    -- | 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.Enums
        (

     -- * Enumerations

    -- ** Align #enum:Align#

        Align(..)                               ,

    -- ** ArrowPlacement #enum:ArrowPlacement#

        ArrowPlacement(..)                      ,

    -- ** ArrowType #enum:ArrowType#

        ArrowType(..)                           ,

    -- ** AssistantPageType #enum:AssistantPageType#

        AssistantPageType(..)                   ,

    -- ** BaselinePosition #enum:BaselinePosition#

        BaselinePosition(..)                    ,

    -- ** BorderStyle #enum:BorderStyle#

        BorderStyle(..)                         ,

    -- ** BuilderError #enum:BuilderError#

        BuilderError(..)                        ,
        catchBuilderError                       ,
        handleBuilderError                      ,

    -- ** ButtonBoxStyle #enum:ButtonBoxStyle#

        ButtonBoxStyle(..)                      ,

    -- ** ButtonRole #enum:ButtonRole#

        ButtonRole(..)                          ,

    -- ** ButtonsType #enum:ButtonsType#

        ButtonsType(..)                         ,

    -- ** CellRendererAccelMode #enum:CellRendererAccelMode#

        CellRendererAccelMode(..)               ,

    -- ** CellRendererMode #enum:CellRendererMode#

        CellRendererMode(..)                    ,

    -- ** CornerType #enum:CornerType#

        CornerType(..)                          ,

    -- ** CssProviderError #enum:CssProviderError#

        CssProviderError(..)                    ,
        catchCssProviderError                   ,
        handleCssProviderError                  ,

    -- ** CssSectionType #enum:CssSectionType#

        CssSectionType(..)                      ,

    -- ** DeleteType #enum:DeleteType#

        DeleteType(..)                          ,

    -- ** DirectionType #enum:DirectionType#

        DirectionType(..)                       ,

    -- ** DragResult #enum:DragResult#

        DragResult(..)                          ,

    -- ** EntryIconPosition #enum:EntryIconPosition#

        EntryIconPosition(..)                   ,

    -- ** EventSequenceState #enum:EventSequenceState#

        EventSequenceState(..)                  ,

    -- ** ExpanderStyle #enum:ExpanderStyle#

        ExpanderStyle(..)                       ,

    -- ** FileChooserAction #enum:FileChooserAction#

        FileChooserAction(..)                   ,

    -- ** FileChooserConfirmation #enum:FileChooserConfirmation#

        FileChooserConfirmation(..)             ,

    -- ** FileChooserError #enum:FileChooserError#

        FileChooserError(..)                    ,
        catchFileChooserError                   ,
        handleFileChooserError                  ,

    -- ** IMPreeditStyle #enum:IMPreeditStyle#

        IMPreeditStyle(..)                      ,

    -- ** IMStatusStyle #enum:IMStatusStyle#

        IMStatusStyle(..)                       ,

    -- ** IconSize #enum:IconSize#

        IconSize(..)                            ,

    -- ** IconThemeError #enum:IconThemeError#

        IconThemeError(..)                      ,
        catchIconThemeError                     ,
        handleIconThemeError                    ,

    -- ** IconViewDropPosition #enum:IconViewDropPosition#

        IconViewDropPosition(..)                ,

    -- ** ImageType #enum:ImageType#

        ImageType(..)                           ,

    -- ** InputPurpose #enum:InputPurpose#

        InputPurpose(..)                        ,

    -- ** Justification #enum:Justification#

        Justification(..)                       ,

    -- ** LevelBarMode #enum:LevelBarMode#

        LevelBarMode(..)                        ,

    -- ** License #enum:License#

        License(..)                             ,

    -- ** MenuDirectionType #enum:MenuDirectionType#

        MenuDirectionType(..)                   ,

    -- ** MessageType #enum:MessageType#

        MessageType(..)                         ,

    -- ** MovementStep #enum:MovementStep#

        MovementStep(..)                        ,

    -- ** NotebookTab #enum:NotebookTab#

        NotebookTab(..)                         ,

    -- ** NumberUpLayout #enum:NumberUpLayout#

        NumberUpLayout(..)                      ,

    -- ** Orientation #enum:Orientation#

        Orientation(..)                         ,

    -- ** PackDirection #enum:PackDirection#

        PackDirection(..)                       ,

    -- ** PackType #enum:PackType#

        PackType(..)                            ,

    -- ** PadActionType #enum:PadActionType#

        PadActionType(..)                       ,

    -- ** PageOrientation #enum:PageOrientation#

        PageOrientation(..)                     ,

    -- ** PageSet #enum:PageSet#

        PageSet(..)                             ,

    -- ** PanDirection #enum:PanDirection#

        PanDirection(..)                        ,

    -- ** PathPriorityType #enum:PathPriorityType#

        PathPriorityType(..)                    ,

    -- ** PathType #enum:PathType#

        PathType(..)                            ,

    -- ** PolicyType #enum:PolicyType#

        PolicyType(..)                          ,

    -- ** PopoverConstraint #enum:PopoverConstraint#

        PopoverConstraint(..)                   ,

    -- ** PositionType #enum:PositionType#

        PositionType(..)                        ,

    -- ** PrintDuplex #enum:PrintDuplex#

        PrintDuplex(..)                         ,

    -- ** PrintError #enum:PrintError#

        PrintError(..)                          ,
        catchPrintError                         ,
        handlePrintError                        ,

    -- ** PrintOperationAction #enum:PrintOperationAction#

        PrintOperationAction(..)                ,

    -- ** PrintOperationResult #enum:PrintOperationResult#

        PrintOperationResult(..)                ,

    -- ** PrintPages #enum:PrintPages#

        PrintPages(..)                          ,

    -- ** PrintQuality #enum:PrintQuality#

        PrintQuality(..)                        ,

    -- ** PrintStatus #enum:PrintStatus#

        PrintStatus(..)                         ,

    -- ** PropagationPhase #enum:PropagationPhase#

        PropagationPhase(..)                    ,

    -- ** RcTokenType #enum:RcTokenType#

        RcTokenType(..)                         ,

    -- ** RecentChooserError #enum:RecentChooserError#

        RecentChooserError(..)                  ,
        catchRecentChooserError                 ,
        handleRecentChooserError                ,

    -- ** RecentManagerError #enum:RecentManagerError#

        RecentManagerError(..)                  ,
        catchRecentManagerError                 ,
        handleRecentManagerError                ,

    -- ** RecentSortType #enum:RecentSortType#

        RecentSortType(..)                      ,

    -- ** ReliefStyle #enum:ReliefStyle#

        ReliefStyle(..)                         ,

    -- ** ResizeMode #enum:ResizeMode#

        ResizeMode(..)                          ,

    -- ** ResponseType #enum:ResponseType#

        ResponseType(..)                        ,

    -- ** RevealerTransitionType #enum:RevealerTransitionType#

        RevealerTransitionType(..)              ,

    -- ** ScrollStep #enum:ScrollStep#

        ScrollStep(..)                          ,

    -- ** ScrollType #enum:ScrollType#

        ScrollType(..)                          ,

    -- ** ScrollablePolicy #enum:ScrollablePolicy#

        ScrollablePolicy(..)                    ,

    -- ** SelectionMode #enum:SelectionMode#

        SelectionMode(..)                       ,

    -- ** SensitivityType #enum:SensitivityType#

        SensitivityType(..)                     ,

    -- ** ShadowType #enum:ShadowType#

        ShadowType(..)                          ,

    -- ** ShortcutType #enum:ShortcutType#

        ShortcutType(..)                        ,

    -- ** SizeGroupMode #enum:SizeGroupMode#

        SizeGroupMode(..)                       ,

    -- ** SizeRequestMode #enum:SizeRequestMode#

        SizeRequestMode(..)                     ,

    -- ** SortType #enum:SortType#

        SortType(..)                            ,

    -- ** SpinButtonUpdatePolicy #enum:SpinButtonUpdatePolicy#

        SpinButtonUpdatePolicy(..)              ,

    -- ** SpinType #enum:SpinType#

        SpinType(..)                            ,

    -- ** StackTransitionType #enum:StackTransitionType#

        StackTransitionType(..)                 ,

    -- ** StateType #enum:StateType#

        StateType(..)                           ,

    -- ** TextBufferTargetInfo #enum:TextBufferTargetInfo#

        TextBufferTargetInfo(..)                ,

    -- ** TextDirection #enum:TextDirection#

        TextDirection(..)                       ,

    -- ** TextExtendSelection #enum:TextExtendSelection#

        TextExtendSelection(..)                 ,

    -- ** TextViewLayer #enum:TextViewLayer#

        TextViewLayer(..)                       ,

    -- ** TextWindowType #enum:TextWindowType#

        TextWindowType(..)                      ,

    -- ** ToolbarSpaceStyle #enum:ToolbarSpaceStyle#

        ToolbarSpaceStyle(..)                   ,

    -- ** ToolbarStyle #enum:ToolbarStyle#

        ToolbarStyle(..)                        ,

    -- ** TreeViewColumnSizing #enum:TreeViewColumnSizing#

        TreeViewColumnSizing(..)                ,

    -- ** TreeViewDropPosition #enum:TreeViewDropPosition#

        TreeViewDropPosition(..)                ,

    -- ** TreeViewGridLines #enum:TreeViewGridLines#

        TreeViewGridLines(..)                   ,

    -- ** Unit #enum:Unit#

        Unit(..)                                ,

    -- ** WidgetHelpType #enum:WidgetHelpType#

        WidgetHelpType(..)                      ,

    -- ** WindowPosition #enum:WindowPosition#

        WindowPosition(..)                      ,

    -- ** WindowType #enum:WindowType#

        WindowType(..)                          ,

    -- ** WrapMode #enum:WrapMode#

        WrapMode(..)                            ,

        ) 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

    -- Enum WrapMode
    -- | Describes a type of line wrapping.
    data WrapMode =
          WrapModeNone
        -- ^ do not wrap lines; just make the text area wider
        | WrapModeChar
        -- ^ wrap text, breaking lines anywhere the cursor can
        --     appear (between characters, usually - if you want to be technical,
        --     between graphemes, see 'GI.Pango.Functions.getLogAttrs')
        | WrapModeWord
        -- ^ wrap text, breaking lines in between words
        | WrapModeWordChar
        -- ^ wrap text, breaking lines in between words, or if
        --     that is not enough, also between graphemes
        | AnotherWrapMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> WrapMode -> ShowS
    [WrapMode] -> ShowS
    WrapMode -> String
    (Int -> WrapMode -> ShowS)
    -> (WrapMode -> String) -> ([WrapMode] -> ShowS) -> Show WrapMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> WrapMode -> ShowS
    showsPrec :: Int -> WrapMode -> ShowS
    $cshow :: WrapMode -> String
    show :: WrapMode -> String
    $cshowList :: [WrapMode] -> ShowS
    showList :: [WrapMode] -> ShowS
    Show, WrapMode -> WrapMode -> Bool
    (WrapMode -> WrapMode -> Bool)
    -> (WrapMode -> WrapMode -> Bool) -> Eq WrapMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WrapMode -> WrapMode -> Bool
    == :: WrapMode -> WrapMode -> Bool
    $c/= :: WrapMode -> WrapMode -> Bool
    /= :: WrapMode -> WrapMode -> Bool
    Eq)

    instance P.Enum WrapMode where
        fromEnum :: WrapMode -> Int
    fromEnum WrapMode
    WrapModeNone = Int
    0
        fromEnum WrapMode
    WrapModeChar = Int
    1
        fromEnum WrapMode
    WrapModeWord = Int
    2
        fromEnum WrapMode
    WrapModeWordChar = Int
    3
        fromEnum (AnotherWrapMode Int
    k) = Int
    k

        toEnum :: Int -> WrapMode
    toEnum Int
    0 = WrapMode
    WrapModeNone
        toEnum Int
    1 = WrapMode
    WrapModeChar
        toEnum Int
    2 = WrapMode
    WrapModeWord
        toEnum Int
    3 = WrapMode
    WrapModeWordChar
        toEnum Int
    k = Int -> WrapMode
    AnotherWrapMode Int
    k

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

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

    foreign import ccall "gtk_wrap_mode_get_type" c_gtk_wrap_mode_get_type ::
        IO GType

    instance B.Types.TypedObject WrapMode where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_wrap_mode_get_type

    instance B.Types.BoxedEnum WrapMode

    -- Enum WindowType
    -- | A t'GI.Gtk.Objects.Window.Window' can be one of these types. Most things you’d consider a
    -- “window” should have type @/GTK_WINDOW_TOPLEVEL/@; windows with this type
    -- are managed by the window manager and have a frame by default (call
    -- 'GI.Gtk.Objects.Window.windowSetDecorated' to toggle the frame).  Windows with type
    -- @/GTK_WINDOW_POPUP/@ are ignored by the window manager; window manager
    -- keybindings won’t work on them, the window manager won’t decorate the
    -- window with a frame, many GTK+ features that rely on the window
    -- manager will not work (e.g. resize grips and
    -- maximization\/minimization). @/GTK_WINDOW_POPUP/@ is used to implement
    -- widgets such as t'GI.Gtk.Objects.Menu.Menu' or tooltips that you normally don’t think of
    -- as windows per se. Nearly all windows should be @/GTK_WINDOW_TOPLEVEL/@.
    -- In particular, do not use @/GTK_WINDOW_POPUP/@ just to turn off
    -- the window borders; use 'GI.Gtk.Objects.Window.windowSetDecorated' for that.
    data WindowType =
          WindowTypeToplevel
        -- ^ A regular window, such as a dialog.
        | WindowTypePopup
        -- ^ A special window such as a tooltip.
        | AnotherWindowType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> WindowType -> ShowS
    [WindowType] -> ShowS
    WindowType -> String
    (Int -> WindowType -> ShowS)
    -> (WindowType -> String)
    -> ([WindowType] -> ShowS)
    -> Show WindowType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> WindowType -> ShowS
    showsPrec :: Int -> WindowType -> ShowS
    $cshow :: WindowType -> String
    show :: WindowType -> String
    $cshowList :: [WindowType] -> ShowS
    showList :: [WindowType] -> ShowS
    Show, WindowType -> WindowType -> Bool
    (WindowType -> WindowType -> Bool)
    -> (WindowType -> WindowType -> Bool) -> Eq WindowType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WindowType -> WindowType -> Bool
    == :: WindowType -> WindowType -> Bool
    $c/= :: WindowType -> WindowType -> Bool
    /= :: WindowType -> WindowType -> Bool
    Eq)

    instance P.Enum WindowType where
        fromEnum :: WindowType -> Int
    fromEnum WindowType
    WindowTypeToplevel = Int
    0
        fromEnum WindowType
    WindowTypePopup = Int
    1
        fromEnum (AnotherWindowType Int
    k) = Int
    k

        toEnum :: Int -> WindowType
    toEnum Int
    0 = WindowType
    WindowTypeToplevel
        toEnum Int
    1 = WindowType
    WindowTypePopup
        toEnum Int
    k = Int -> WindowType
    AnotherWindowType Int
    k

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

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

    foreign import ccall "gtk_window_type_get_type" c_gtk_window_type_get_type ::
        IO GType

    instance B.Types.TypedObject WindowType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_window_type_get_type

    instance B.Types.BoxedEnum WindowType

    -- Enum WindowPosition
    -- | Window placement can be influenced using this enumeration. Note that
    -- using @/GTK_WIN_POS_CENTER_ALWAYS/@ is almost always a bad idea.
    -- It won’t necessarily work well with all window managers or on all windowing systems.
    data WindowPosition =
          WindowPositionNone
        -- ^ No influence is made on placement.
        | WindowPositionCenter
        -- ^ Windows should be placed in the center of the screen.
        | WindowPositionMouse
        -- ^ Windows should be placed at the current mouse position.
        | WindowPositionCenterAlways
        -- ^ Keep window centered as it changes size, etc.
        | WindowPositionCenterOnParent
        -- ^ Center the window on its transient
        --  parent (see 'GI.Gtk.Objects.Window.windowSetTransientFor').
        | AnotherWindowPosition Int
        -- ^ Catch-all for unknown values
        deriving (Int -> WindowPosition -> ShowS
    [WindowPosition] -> ShowS
    WindowPosition -> String
    (Int -> WindowPosition -> ShowS)
    -> (WindowPosition -> String)
    -> ([WindowPosition] -> ShowS)
    -> Show WindowPosition
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> WindowPosition -> ShowS
    showsPrec :: Int -> WindowPosition -> ShowS
    $cshow :: WindowPosition -> String
    show :: WindowPosition -> String
    $cshowList :: [WindowPosition] -> ShowS
    showList :: [WindowPosition] -> ShowS
    Show, WindowPosition -> WindowPosition -> Bool
    (WindowPosition -> WindowPosition -> Bool)
    -> (WindowPosition -> WindowPosition -> Bool) -> Eq WindowPosition
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WindowPosition -> WindowPosition -> Bool
    == :: WindowPosition -> WindowPosition -> Bool
    $c/= :: WindowPosition -> WindowPosition -> Bool
    /= :: WindowPosition -> WindowPosition -> Bool
    Eq)

    instance P.Enum WindowPosition where
        fromEnum :: WindowPosition -> Int
    fromEnum WindowPosition
    WindowPositionNone = Int
    0
        fromEnum WindowPosition
    WindowPositionCenter = Int
    1
        fromEnum WindowPosition
    WindowPositionMouse = Int
    2
        fromEnum WindowPosition
    WindowPositionCenterAlways = Int
    3
        fromEnum WindowPosition
    WindowPositionCenterOnParent = Int
    4
        fromEnum (AnotherWindowPosition Int
    k) = Int
    k

        toEnum :: Int -> WindowPosition
    toEnum Int
    0 = WindowPosition
    WindowPositionNone
        toEnum Int
    1 = WindowPosition
    WindowPositionCenter
        toEnum Int
    2 = WindowPosition
    WindowPositionMouse
        toEnum Int
    3 = WindowPosition
    WindowPositionCenterAlways
        toEnum Int
    4 = WindowPosition
    WindowPositionCenterOnParent
        toEnum Int
    k = Int -> WindowPosition
    AnotherWindowPosition Int
    k

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

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

    foreign import ccall "gtk_window_position_get_type" c_gtk_window_position_get_type ::
        IO GType

    instance B.Types.TypedObject WindowPosition where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_window_position_get_type

    instance B.Types.BoxedEnum WindowPosition

    -- Enum WidgetHelpType
    -- | Kinds of widget-specific help. Used by the [showHelp](#g:signal:showHelp) signal.
    data WidgetHelpType =
          WidgetHelpTypeTooltip
        -- ^ Tooltip.
        | WidgetHelpTypeWhatsThis
        -- ^ What’s this.
        | AnotherWidgetHelpType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> WidgetHelpType -> ShowS
    [WidgetHelpType] -> ShowS
    WidgetHelpType -> String
    (Int -> WidgetHelpType -> ShowS)
    -> (WidgetHelpType -> String)
    -> ([WidgetHelpType] -> ShowS)
    -> Show WidgetHelpType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> WidgetHelpType -> ShowS
    showsPrec :: Int -> WidgetHelpType -> ShowS
    $cshow :: WidgetHelpType -> String
    show :: WidgetHelpType -> String
    $cshowList :: [WidgetHelpType] -> ShowS
    showList :: [WidgetHelpType] -> ShowS
    Show, WidgetHelpType -> WidgetHelpType -> Bool
    (WidgetHelpType -> WidgetHelpType -> Bool)
    -> (WidgetHelpType -> WidgetHelpType -> Bool) -> Eq WidgetHelpType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WidgetHelpType -> WidgetHelpType -> Bool
    == :: WidgetHelpType -> WidgetHelpType -> Bool
    $c/= :: WidgetHelpType -> WidgetHelpType -> Bool
    /= :: WidgetHelpType -> WidgetHelpType -> Bool
    Eq)

    instance P.Enum WidgetHelpType where
        fromEnum :: WidgetHelpType -> Int
    fromEnum WidgetHelpType
    WidgetHelpTypeTooltip = Int
    0
        fromEnum WidgetHelpType
    WidgetHelpTypeWhatsThis = Int
    1
        fromEnum (AnotherWidgetHelpType Int
    k) = Int
    k

        toEnum :: Int -> WidgetHelpType
    toEnum Int
    0 = WidgetHelpType
    WidgetHelpTypeTooltip
        toEnum Int
    1 = WidgetHelpType
    WidgetHelpTypeWhatsThis
        toEnum Int
    k = Int -> WidgetHelpType
    AnotherWidgetHelpType Int
    k

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

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

    foreign import ccall "gtk_widget_help_type_get_type" c_gtk_widget_help_type_get_type ::
        IO GType

    instance B.Types.TypedObject WidgetHelpType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_widget_help_type_get_type

    instance B.Types.BoxedEnum WidgetHelpType

    -- Enum Unit
    -- | See also 'GI.Gtk.Objects.PrintSettings.printSettingsSetPaperWidth'.
    data Unit =
          UnitNone
        -- ^ No units.
        | UnitPoints
        -- ^ Dimensions in points.
        | UnitInch
        -- ^ Dimensions in inches.
        | UnitMm
        -- ^ Dimensions in millimeters
        | AnotherUnit Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Unit -> ShowS
    [Unit] -> ShowS
    Unit -> String
    (Int -> Unit -> ShowS)
    -> (Unit -> String) -> ([Unit] -> ShowS) -> Show Unit
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Unit -> ShowS
    showsPrec :: Int -> Unit -> ShowS
    $cshow :: Unit -> String
    show :: Unit -> String
    $cshowList :: [Unit] -> ShowS
    showList :: [Unit] -> ShowS
    Show, Unit -> Unit -> Bool
    (Unit -> Unit -> Bool) -> (Unit -> Unit -> Bool) -> Eq Unit
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Unit -> Unit -> Bool
    == :: Unit -> Unit -> Bool
    $c/= :: Unit -> Unit -> Bool
    /= :: Unit -> Unit -> Bool
    Eq)

    instance P.Enum Unit where
        fromEnum :: Unit -> Int
    fromEnum Unit
    UnitNone = Int
    0
        fromEnum Unit
    UnitPoints = Int
    1
        fromEnum Unit
    UnitInch = Int
    2
        fromEnum Unit
    UnitMm = Int
    3
        fromEnum (AnotherUnit Int
    k) = Int
    k

        toEnum :: Int -> Unit
    toEnum Int
    0 = Unit
    UnitNone
        toEnum Int
    1 = Unit
    UnitPoints
        toEnum Int
    2 = Unit
    UnitInch
        toEnum Int
    3 = Unit
    UnitMm
        toEnum Int
    k = Int -> Unit
    AnotherUnit Int
    k

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

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

    foreign import ccall "gtk_unit_get_type" c_gtk_unit_get_type ::
        IO GType

    instance B.Types.TypedObject Unit where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_unit_get_type

    instance B.Types.BoxedEnum Unit

    -- Enum TreeViewGridLines
    -- | Used to indicate which grid lines to draw in a tree view.
    data TreeViewGridLines =
          TreeViewGridLinesNone
        -- ^ No grid lines.
        | TreeViewGridLinesHorizontal
        -- ^ Horizontal grid lines.
        | TreeViewGridLinesVertical
        -- ^ Vertical grid lines.
        | TreeViewGridLinesBoth
        -- ^ Horizontal and vertical grid lines.
        | AnotherTreeViewGridLines Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TreeViewGridLines -> ShowS
    [TreeViewGridLines] -> ShowS
    TreeViewGridLines -> String
    (Int -> TreeViewGridLines -> ShowS)
    -> (TreeViewGridLines -> String)
    -> ([TreeViewGridLines] -> ShowS)
    -> Show TreeViewGridLines
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TreeViewGridLines -> ShowS
    showsPrec :: Int -> TreeViewGridLines -> ShowS
    $cshow :: TreeViewGridLines -> String
    show :: TreeViewGridLines -> String
    $cshowList :: [TreeViewGridLines] -> ShowS
    showList :: [TreeViewGridLines] -> ShowS
    Show, TreeViewGridLines -> TreeViewGridLines -> Bool
    (TreeViewGridLines -> TreeViewGridLines -> Bool)
    -> (TreeViewGridLines -> TreeViewGridLines -> Bool)
    -> Eq TreeViewGridLines
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TreeViewGridLines -> TreeViewGridLines -> Bool
    == :: TreeViewGridLines -> TreeViewGridLines -> Bool
    $c/= :: TreeViewGridLines -> TreeViewGridLines -> Bool
    /= :: TreeViewGridLines -> TreeViewGridLines -> Bool
    Eq)

    instance P.Enum TreeViewGridLines where
        fromEnum :: TreeViewGridLines -> Int
    fromEnum TreeViewGridLines
    TreeViewGridLinesNone = Int
    0
        fromEnum TreeViewGridLines
    TreeViewGridLinesHorizontal = Int
    1
        fromEnum TreeViewGridLines
    TreeViewGridLinesVertical = Int
    2
        fromEnum TreeViewGridLines
    TreeViewGridLinesBoth = Int
    3
        fromEnum (AnotherTreeViewGridLines Int
    k) = Int
    k

        toEnum :: Int -> TreeViewGridLines
    toEnum Int
    0 = TreeViewGridLines
    TreeViewGridLinesNone
        toEnum Int
    1 = TreeViewGridLines
    TreeViewGridLinesHorizontal
        toEnum Int
    2 = TreeViewGridLines
    TreeViewGridLinesVertical
        toEnum Int
    3 = TreeViewGridLines
    TreeViewGridLinesBoth
        toEnum Int
    k = Int -> TreeViewGridLines
    AnotherTreeViewGridLines Int
    k

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

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

    foreign import ccall "gtk_tree_view_grid_lines_get_type" c_gtk_tree_view_grid_lines_get_type ::
        IO GType

    instance B.Types.TypedObject TreeViewGridLines where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_tree_view_grid_lines_get_type

    instance B.Types.BoxedEnum TreeViewGridLines

    -- Enum TreeViewDropPosition
    -- | An enum for determining where a dropped row goes.
    data TreeViewDropPosition =
          TreeViewDropPositionBefore
        -- ^ dropped row is inserted before
        | TreeViewDropPositionAfter
        -- ^ dropped row is inserted after
        | TreeViewDropPositionIntoOrBefore
        -- ^ dropped row becomes a child or is inserted before
        | TreeViewDropPositionIntoOrAfter
        -- ^ dropped row becomes a child or is inserted after
        | AnotherTreeViewDropPosition Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TreeViewDropPosition -> ShowS
    [TreeViewDropPosition] -> ShowS
    TreeViewDropPosition -> String
    (Int -> TreeViewDropPosition -> ShowS)
    -> (TreeViewDropPosition -> String)
    -> ([TreeViewDropPosition] -> ShowS)
    -> Show TreeViewDropPosition
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TreeViewDropPosition -> ShowS
    showsPrec :: Int -> TreeViewDropPosition -> ShowS
    $cshow :: TreeViewDropPosition -> String
    show :: TreeViewDropPosition -> String
    $cshowList :: [TreeViewDropPosition] -> ShowS
    showList :: [TreeViewDropPosition] -> ShowS
    Show, TreeViewDropPosition -> TreeViewDropPosition -> Bool
    (TreeViewDropPosition -> TreeViewDropPosition -> Bool)
    -> (TreeViewDropPosition -> TreeViewDropPosition -> Bool)
    -> Eq TreeViewDropPosition
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TreeViewDropPosition -> TreeViewDropPosition -> Bool
    == :: TreeViewDropPosition -> TreeViewDropPosition -> Bool
    $c/= :: TreeViewDropPosition -> TreeViewDropPosition -> Bool
    /= :: TreeViewDropPosition -> TreeViewDropPosition -> Bool
    Eq)

    instance P.Enum TreeViewDropPosition where
        fromEnum :: TreeViewDropPosition -> Int
    fromEnum TreeViewDropPosition
    TreeViewDropPositionBefore = Int
    0
        fromEnum TreeViewDropPosition
    TreeViewDropPositionAfter = Int
    1
        fromEnum TreeViewDropPosition
    TreeViewDropPositionIntoOrBefore = Int
    2
        fromEnum TreeViewDropPosition
    TreeViewDropPositionIntoOrAfter = Int
    3
        fromEnum (AnotherTreeViewDropPosition Int
    k) = Int
    k

        toEnum :: Int -> TreeViewDropPosition
    toEnum Int
    0 = TreeViewDropPosition
    TreeViewDropPositionBefore
        toEnum Int
    1 = TreeViewDropPosition
    TreeViewDropPositionAfter
        toEnum Int
    2 = TreeViewDropPosition
    TreeViewDropPositionIntoOrBefore
        toEnum Int
    3 = TreeViewDropPosition
    TreeViewDropPositionIntoOrAfter
        toEnum Int
    k = Int -> TreeViewDropPosition
    AnotherTreeViewDropPosition Int
    k

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

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

    foreign import ccall "gtk_tree_view_drop_position_get_type" c_gtk_tree_view_drop_position_get_type ::
        IO GType

    instance B.Types.TypedObject TreeViewDropPosition where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_tree_view_drop_position_get_type

    instance B.Types.BoxedEnum TreeViewDropPosition

    -- Enum TreeViewColumnSizing
    -- | The sizing method the column uses to determine its width.  Please note
    -- that /@gTKTREEVIEWCOLUMNAUTOSIZE@/ are inefficient for large views, and
    -- can make columns appear choppy.
    data TreeViewColumnSizing =
          TreeViewColumnSizingGrowOnly
        -- ^ Columns only get bigger in reaction to changes in the model
        | TreeViewColumnSizingAutosize
        -- ^ Columns resize to be the optimal size everytime the model changes.
        | TreeViewColumnSizingFixed
        -- ^ Columns are a fixed numbers of pixels wide.
        | AnotherTreeViewColumnSizing Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TreeViewColumnSizing -> ShowS
    [TreeViewColumnSizing] -> ShowS
    TreeViewColumnSizing -> String
    (Int -> TreeViewColumnSizing -> ShowS)
    -> (TreeViewColumnSizing -> String)
    -> ([TreeViewColumnSizing] -> ShowS)
    -> Show TreeViewColumnSizing
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TreeViewColumnSizing -> ShowS
    showsPrec :: Int -> TreeViewColumnSizing -> ShowS
    $cshow :: TreeViewColumnSizing -> String
    show :: TreeViewColumnSizing -> String
    $cshowList :: [TreeViewColumnSizing] -> ShowS
    showList :: [TreeViewColumnSizing] -> ShowS
    Show, TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
    (TreeViewColumnSizing -> TreeViewColumnSizing -> Bool)
    -> (TreeViewColumnSizing -> TreeViewColumnSizing -> Bool)
    -> Eq TreeViewColumnSizing
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
    == :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
    $c/= :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
    /= :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
    Eq)

    instance P.Enum TreeViewColumnSizing where
        fromEnum :: TreeViewColumnSizing -> Int
    fromEnum TreeViewColumnSizing
    TreeViewColumnSizingGrowOnly = Int
    0
        fromEnum TreeViewColumnSizing
    TreeViewColumnSizingAutosize = Int
    1
        fromEnum TreeViewColumnSizing
    TreeViewColumnSizingFixed = Int
    2
        fromEnum (AnotherTreeViewColumnSizing Int
    k) = Int
    k

        toEnum :: Int -> TreeViewColumnSizing
    toEnum Int
    0 = TreeViewColumnSizing
    TreeViewColumnSizingGrowOnly
        toEnum Int
    1 = TreeViewColumnSizing
    TreeViewColumnSizingAutosize
        toEnum Int
    2 = TreeViewColumnSizing
    TreeViewColumnSizingFixed
        toEnum Int
    k = Int -> TreeViewColumnSizing
    AnotherTreeViewColumnSizing Int
    k

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

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

    foreign import ccall "gtk_tree_view_column_sizing_get_type" c_gtk_tree_view_column_sizing_get_type ::
        IO GType

    instance B.Types.TypedObject TreeViewColumnSizing where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_tree_view_column_sizing_get_type

    instance B.Types.BoxedEnum TreeViewColumnSizing

    -- Enum ToolbarStyle
    -- | Used to customize the appearance of a t'GI.Gtk.Objects.Toolbar.Toolbar'. Note that
    -- setting the toolbar style overrides the user’s preferences
    -- for the default toolbar style.  Note that if the button has only
    -- a label set and GTK_TOOLBAR_ICONS is used, the label will be
    -- visible, and vice versa.
    data ToolbarStyle =
          ToolbarStyleIcons
        -- ^ Buttons display only icons in the toolbar.
        | ToolbarStyleText
        -- ^ Buttons display only text labels in the toolbar.
        | ToolbarStyleBoth
        -- ^ Buttons display text and icons in the toolbar.
        | ToolbarStyleBothHoriz
        -- ^ Buttons display icons and text alongside each
        --  other, rather than vertically stacked
        | AnotherToolbarStyle Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ToolbarStyle -> ShowS
    [ToolbarStyle] -> ShowS
    ToolbarStyle -> String
    (Int -> ToolbarStyle -> ShowS)
    -> (ToolbarStyle -> String)
    -> ([ToolbarStyle] -> ShowS)
    -> Show ToolbarStyle
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ToolbarStyle -> ShowS
    showsPrec :: Int -> ToolbarStyle -> ShowS
    $cshow :: ToolbarStyle -> String
    show :: ToolbarStyle -> String
    $cshowList :: [ToolbarStyle] -> ShowS
    showList :: [ToolbarStyle] -> ShowS
    Show, ToolbarStyle -> ToolbarStyle -> Bool
    (ToolbarStyle -> ToolbarStyle -> Bool)
    -> (ToolbarStyle -> ToolbarStyle -> Bool) -> Eq ToolbarStyle
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ToolbarStyle -> ToolbarStyle -> Bool
    == :: ToolbarStyle -> ToolbarStyle -> Bool
    $c/= :: ToolbarStyle -> ToolbarStyle -> Bool
    /= :: ToolbarStyle -> ToolbarStyle -> Bool
    Eq)

    instance P.Enum ToolbarStyle where
        fromEnum :: ToolbarStyle -> Int
    fromEnum ToolbarStyle
    ToolbarStyleIcons = Int
    0
        fromEnum ToolbarStyle
    ToolbarStyleText = Int
    1
        fromEnum ToolbarStyle
    ToolbarStyleBoth = Int
    2
        fromEnum ToolbarStyle
    ToolbarStyleBothHoriz = Int
    3
        fromEnum (AnotherToolbarStyle Int
    k) = Int
    k

        toEnum :: Int -> ToolbarStyle
    toEnum Int
    0 = ToolbarStyle
    ToolbarStyleIcons
        toEnum Int
    1 = ToolbarStyle
    ToolbarStyleText
        toEnum Int
    2 = ToolbarStyle
    ToolbarStyleBoth
        toEnum Int
    3 = ToolbarStyle
    ToolbarStyleBothHoriz
        toEnum Int
    k = Int -> ToolbarStyle
    AnotherToolbarStyle Int
    k

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

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

    foreign import ccall "gtk_toolbar_style_get_type" c_gtk_toolbar_style_get_type ::
        IO GType

    instance B.Types.TypedObject ToolbarStyle where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_toolbar_style_get_type

    instance B.Types.BoxedEnum ToolbarStyle

    -- Enum ToolbarSpaceStyle
    {-# DEPRECATED ToolbarSpaceStyle ["(Since version 3.20)"] #-}
    -- | Whether spacers are vertical lines or just blank.
    data ToolbarSpaceStyle =
          ToolbarSpaceStyleEmpty
        -- ^ Use blank spacers.
        | ToolbarSpaceStyleLine
        -- ^ Use vertical lines for spacers.
        | AnotherToolbarSpaceStyle Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ToolbarSpaceStyle -> ShowS
    [ToolbarSpaceStyle] -> ShowS
    ToolbarSpaceStyle -> String
    (Int -> ToolbarSpaceStyle -> ShowS)
    -> (ToolbarSpaceStyle -> String)
    -> ([ToolbarSpaceStyle] -> ShowS)
    -> Show ToolbarSpaceStyle
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ToolbarSpaceStyle -> ShowS
    showsPrec :: Int -> ToolbarSpaceStyle -> ShowS
    $cshow :: ToolbarSpaceStyle -> String
    show :: ToolbarSpaceStyle -> String
    $cshowList :: [ToolbarSpaceStyle] -> ShowS
    showList :: [ToolbarSpaceStyle] -> ShowS
    Show, ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool
    (ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool)
    -> (ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool)
    -> Eq ToolbarSpaceStyle
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool
    == :: ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool
    $c/= :: ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool
    /= :: ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool
    Eq)

    instance P.Enum ToolbarSpaceStyle where
        fromEnum :: ToolbarSpaceStyle -> Int
    fromEnum ToolbarSpaceStyle
    ToolbarSpaceStyleEmpty = Int
    0
        fromEnum ToolbarSpaceStyle
    ToolbarSpaceStyleLine = Int
    1
        fromEnum (AnotherToolbarSpaceStyle Int
    k) = Int
    k

        toEnum :: Int -> ToolbarSpaceStyle
    toEnum Int
    0 = ToolbarSpaceStyle
    ToolbarSpaceStyleEmpty
        toEnum Int
    1 = ToolbarSpaceStyle
    ToolbarSpaceStyleLine
        toEnum Int
    k = Int -> ToolbarSpaceStyle
    AnotherToolbarSpaceStyle Int
    k

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

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

    foreign import ccall "gtk_toolbar_space_style_get_type" c_gtk_toolbar_space_style_get_type ::
        IO GType

    instance B.Types.TypedObject ToolbarSpaceStyle where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_toolbar_space_style_get_type

    instance B.Types.BoxedEnum ToolbarSpaceStyle

    -- Enum TextWindowType
    -- | Used to reference the parts of t'GI.Gtk.Objects.TextView.TextView'.
    data TextWindowType =
          TextWindowTypePrivate
        -- ^ Invalid value, used as a marker
        | TextWindowTypeWidget
        -- ^ Window that floats over scrolling areas.
        | TextWindowTypeText
        -- ^ Scrollable text window.
        | TextWindowTypeLeft
        -- ^ Left side border window.
        | TextWindowTypeRight
        -- ^ Right side border window.
        | TextWindowTypeTop
        -- ^ Top border window.
        | TextWindowTypeBottom
        -- ^ Bottom border window.
        | AnotherTextWindowType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TextWindowType -> ShowS
    [TextWindowType] -> ShowS
    TextWindowType -> String
    (Int -> TextWindowType -> ShowS)
    -> (TextWindowType -> String)
    -> ([TextWindowType] -> ShowS)
    -> Show TextWindowType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TextWindowType -> ShowS
    showsPrec :: Int -> TextWindowType -> ShowS
    $cshow :: TextWindowType -> String
    show :: TextWindowType -> String
    $cshowList :: [TextWindowType] -> ShowS
    showList :: [TextWindowType] -> ShowS
    Show, TextWindowType -> TextWindowType -> Bool
    (TextWindowType -> TextWindowType -> Bool)
    -> (TextWindowType -> TextWindowType -> Bool) -> Eq TextWindowType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TextWindowType -> TextWindowType -> Bool
    == :: TextWindowType -> TextWindowType -> Bool
    $c/= :: TextWindowType -> TextWindowType -> Bool
    /= :: TextWindowType -> TextWindowType -> Bool
    Eq)

    instance P.Enum TextWindowType where
        fromEnum :: TextWindowType -> Int
    fromEnum TextWindowType
    TextWindowTypePrivate = Int
    0
        fromEnum TextWindowType
    TextWindowTypeWidget = Int
    1
        fromEnum TextWindowType
    TextWindowTypeText = Int
    2
        fromEnum TextWindowType
    TextWindowTypeLeft = Int
    3
        fromEnum TextWindowType
    TextWindowTypeRight = Int
    4
        fromEnum TextWindowType
    TextWindowTypeTop = Int
    5
        fromEnum TextWindowType
    TextWindowTypeBottom = Int
    6
        fromEnum (AnotherTextWindowType Int
    k) = Int
    k

        toEnum :: Int -> TextWindowType
    toEnum Int
    0 = TextWindowType
    TextWindowTypePrivate
        toEnum Int
    1 = TextWindowType
    TextWindowTypeWidget
        toEnum Int
    2 = TextWindowType
    TextWindowTypeText
        toEnum Int
    3 = TextWindowType
    TextWindowTypeLeft
        toEnum Int
    4 = TextWindowType
    TextWindowTypeRight
        toEnum Int
    5 = TextWindowType
    TextWindowTypeTop
        toEnum Int
    6 = TextWindowType
    TextWindowTypeBottom
        toEnum Int
    k = Int -> TextWindowType
    AnotherTextWindowType Int
    k

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

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

    foreign import ccall "gtk_text_window_type_get_type" c_gtk_text_window_type_get_type ::
        IO GType

    instance B.Types.TypedObject TextWindowType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_text_window_type_get_type

    instance B.Types.BoxedEnum TextWindowType

    -- Enum TextViewLayer
    -- | Used to reference the layers of t'GI.Gtk.Objects.TextView.TextView' for the purpose of customized
    -- drawing with the [draw_layer](#g:signal:draw_layer) vfunc.
    data TextViewLayer =
          TextViewLayerBelow
        -- ^ Old deprecated layer, use 'GI.Gtk.Enums.TextViewLayerBelowText' instead
        | TextViewLayerAbove
        -- ^ Old deprecated layer, use 'GI.Gtk.Enums.TextViewLayerAboveText' instead
        | TextViewLayerBelowText
        -- ^ The layer rendered below the text (but above the background).  Since: 3.20
        | TextViewLayerAboveText
        -- ^ The layer rendered above the text.  Since: 3.20
        | AnotherTextViewLayer Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TextViewLayer -> ShowS
    [TextViewLayer] -> ShowS
    TextViewLayer -> String
    (Int -> TextViewLayer -> ShowS)
    -> (TextViewLayer -> String)
    -> ([TextViewLayer] -> ShowS)
    -> Show TextViewLayer
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TextViewLayer -> ShowS
    showsPrec :: Int -> TextViewLayer -> ShowS
    $cshow :: TextViewLayer -> String
    show :: TextViewLayer -> String
    $cshowList :: [TextViewLayer] -> ShowS
    showList :: [TextViewLayer] -> ShowS
    Show, TextViewLayer -> TextViewLayer -> Bool
    (TextViewLayer -> TextViewLayer -> Bool)
    -> (TextViewLayer -> TextViewLayer -> Bool) -> Eq TextViewLayer
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TextViewLayer -> TextViewLayer -> Bool
    == :: TextViewLayer -> TextViewLayer -> Bool
    $c/= :: TextViewLayer -> TextViewLayer -> Bool
    /= :: TextViewLayer -> TextViewLayer -> Bool
    Eq)

    instance P.Enum TextViewLayer where
        fromEnum :: TextViewLayer -> Int
    fromEnum TextViewLayer
    TextViewLayerBelow = Int
    0
        fromEnum TextViewLayer
    TextViewLayerAbove = Int
    1
        fromEnum TextViewLayer
    TextViewLayerBelowText = Int
    2
        fromEnum TextViewLayer
    TextViewLayerAboveText = Int
    3
        fromEnum (AnotherTextViewLayer Int
    k) = Int
    k

        toEnum :: Int -> TextViewLayer
    toEnum Int
    0 = TextViewLayer
    TextViewLayerBelow
        toEnum Int
    1 = TextViewLayer
    TextViewLayerAbove
        toEnum Int
    2 = TextViewLayer
    TextViewLayerBelowText
        toEnum Int
    3 = TextViewLayer
    TextViewLayerAboveText
        toEnum Int
    k = Int -> TextViewLayer
    AnotherTextViewLayer Int
    k

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

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

    foreign import ccall "gtk_text_view_layer_get_type" c_gtk_text_view_layer_get_type ::
        IO GType

    instance B.Types.TypedObject TextViewLayer where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_text_view_layer_get_type

    instance B.Types.BoxedEnum TextViewLayer

    -- Enum TextExtendSelection
    -- | Granularity types that extend the text selection. Use the
    -- [TextView::extendSelection]("GI.Gtk.Objects.TextView#g:signal:extendSelection") signal to customize the selection.
    --
    -- /Since: 3.16/
    data TextExtendSelection =
          TextExtendSelectionWord
        -- ^ Selects the current word. It is triggered by
        --   a double-click for example.
        | TextExtendSelectionLine
        -- ^ Selects the current line. It is triggered by
        --   a triple-click for example.
        | AnotherTextExtendSelection Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TextExtendSelection -> ShowS
    [TextExtendSelection] -> ShowS
    TextExtendSelection -> String
    (Int -> TextExtendSelection -> ShowS)
    -> (TextExtendSelection -> String)
    -> ([TextExtendSelection] -> ShowS)
    -> Show TextExtendSelection
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TextExtendSelection -> ShowS
    showsPrec :: Int -> TextExtendSelection -> ShowS
    $cshow :: TextExtendSelection -> String
    show :: TextExtendSelection -> String
    $cshowList :: [TextExtendSelection] -> ShowS
    showList :: [TextExtendSelection] -> ShowS
    Show, TextExtendSelection -> TextExtendSelection -> Bool
    (TextExtendSelection -> TextExtendSelection -> Bool)
    -> (TextExtendSelection -> TextExtendSelection -> Bool)
    -> Eq TextExtendSelection
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TextExtendSelection -> TextExtendSelection -> Bool
    == :: TextExtendSelection -> TextExtendSelection -> Bool
    $c/= :: TextExtendSelection -> TextExtendSelection -> Bool
    /= :: TextExtendSelection -> TextExtendSelection -> Bool
    Eq)

    instance P.Enum TextExtendSelection where
        fromEnum :: TextExtendSelection -> Int
    fromEnum TextExtendSelection
    TextExtendSelectionWord = Int
    0
        fromEnum TextExtendSelection
    TextExtendSelectionLine = Int
    1
        fromEnum (AnotherTextExtendSelection Int
    k) = Int
    k

        toEnum :: Int -> TextExtendSelection
    toEnum Int
    0 = TextExtendSelection
    TextExtendSelectionWord
        toEnum Int
    1 = TextExtendSelection
    TextExtendSelectionLine
        toEnum Int
    k = Int -> TextExtendSelection
    AnotherTextExtendSelection Int
    k

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

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

    foreign import ccall "gtk_text_extend_selection_get_type" c_gtk_text_extend_selection_get_type ::
        IO GType

    instance B.Types.TypedObject TextExtendSelection where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_text_extend_selection_get_type

    instance B.Types.BoxedEnum TextExtendSelection

    -- Enum TextDirection
    -- | Reading directions for text.
    data TextDirection =
          TextDirectionNone
        -- ^ No direction.
        | TextDirectionLtr
        -- ^ Left to right text direction.
        | TextDirectionRtl
        -- ^ Right to left text direction.
        | AnotherTextDirection Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TextDirection -> ShowS
    [TextDirection] -> ShowS
    TextDirection -> String
    (Int -> TextDirection -> ShowS)
    -> (TextDirection -> String)
    -> ([TextDirection] -> ShowS)
    -> Show TextDirection
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TextDirection -> ShowS
    showsPrec :: Int -> TextDirection -> ShowS
    $cshow :: TextDirection -> String
    show :: TextDirection -> String
    $cshowList :: [TextDirection] -> ShowS
    showList :: [TextDirection] -> ShowS
    Show, TextDirection -> TextDirection -> Bool
    (TextDirection -> TextDirection -> Bool)
    -> (TextDirection -> TextDirection -> Bool) -> Eq TextDirection
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TextDirection -> TextDirection -> Bool
    == :: TextDirection -> TextDirection -> Bool
    $c/= :: TextDirection -> TextDirection -> Bool
    /= :: TextDirection -> TextDirection -> Bool
    Eq)

    instance P.Enum TextDirection where
        fromEnum :: TextDirection -> Int
    fromEnum TextDirection
    TextDirectionNone = Int
    0
        fromEnum TextDirection
    TextDirectionLtr = Int
    1
        fromEnum TextDirection
    TextDirectionRtl = Int
    2
        fromEnum (AnotherTextDirection Int
    k) = Int
    k

        toEnum :: Int -> TextDirection
    toEnum Int
    0 = TextDirection
    TextDirectionNone
        toEnum Int
    1 = TextDirection
    TextDirectionLtr
        toEnum Int
    2 = TextDirection
    TextDirectionRtl
        toEnum Int
    k = Int -> TextDirection
    AnotherTextDirection Int
    k

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

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

    foreign import ccall "gtk_text_direction_get_type" c_gtk_text_direction_get_type ::
        IO GType

    instance B.Types.TypedObject TextDirection where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_text_direction_get_type

    instance B.Types.BoxedEnum TextDirection

    -- Enum TextBufferTargetInfo
    -- | These values are used as “info” for the targets contained in the
    -- lists returned by 'GI.Gtk.Objects.TextBuffer.textBufferGetCopyTargetList' and
    -- 'GI.Gtk.Objects.TextBuffer.textBufferGetPasteTargetList'.
    --
    -- The values counts down from @-1@ to avoid clashes
    -- with application added drag destinations which usually start at 0.
    data TextBufferTargetInfo =
          TextBufferTargetInfoBufferContents
        -- ^ Buffer contents
        | TextBufferTargetInfoRichText
        -- ^ Rich text
        | TextBufferTargetInfoText
        -- ^ Text
        | AnotherTextBufferTargetInfo Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TextBufferTargetInfo -> ShowS
    [TextBufferTargetInfo] -> ShowS
    TextBufferTargetInfo -> String
    (Int -> TextBufferTargetInfo -> ShowS)
    -> (TextBufferTargetInfo -> String)
    -> ([TextBufferTargetInfo] -> ShowS)
    -> Show TextBufferTargetInfo
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TextBufferTargetInfo -> ShowS
    showsPrec :: Int -> TextBufferTargetInfo -> ShowS
    $cshow :: TextBufferTargetInfo -> String
    show :: TextBufferTargetInfo -> String
    $cshowList :: [TextBufferTargetInfo] -> ShowS
    showList :: [TextBufferTargetInfo] -> ShowS
    Show, TextBufferTargetInfo -> TextBufferTargetInfo -> Bool
    (TextBufferTargetInfo -> TextBufferTargetInfo -> Bool)
    -> (TextBufferTargetInfo -> TextBufferTargetInfo -> Bool)
    -> Eq TextBufferTargetInfo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TextBufferTargetInfo -> TextBufferTargetInfo -> Bool
    == :: TextBufferTargetInfo -> TextBufferTargetInfo -> Bool
    $c/= :: TextBufferTargetInfo -> TextBufferTargetInfo -> Bool
    /= :: TextBufferTargetInfo -> TextBufferTargetInfo -> Bool
    Eq)

    instance P.Enum TextBufferTargetInfo where
        fromEnum :: TextBufferTargetInfo -> Int
    fromEnum TextBufferTargetInfo
    TextBufferTargetInfoBufferContents = Int
    -1
        fromEnum TextBufferTargetInfo
    TextBufferTargetInfoRichText = Int
    -2
        fromEnum TextBufferTargetInfo
    TextBufferTargetInfoText = Int
    -3
        fromEnum (AnotherTextBufferTargetInfo Int
    k) = Int
    k

        toEnum :: Int -> TextBufferTargetInfo
    toEnum Int
    -1 = TextBufferTargetInfo
    TextBufferTargetInfoBufferContents
        toEnum Int
    -2 = TextBufferTargetInfo
    TextBufferTargetInfoRichText
        toEnum Int
    -3 = TextBufferTargetInfo
    TextBufferTargetInfoText
        toEnum Int
    k = Int -> TextBufferTargetInfo
    AnotherTextBufferTargetInfo Int
    k

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

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

    foreign import ccall "gtk_text_buffer_target_info_get_type" c_gtk_text_buffer_target_info_get_type ::
        IO GType

    instance B.Types.TypedObject TextBufferTargetInfo where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_text_buffer_target_info_get_type

    instance B.Types.BoxedEnum TextBufferTargetInfo

    -- Enum StateType
    {-# DEPRECATED StateType ["(Since version 3.14)","All APIs that are using this enumeration have been deprecated","    in favor of alternatives using t'GI.Gtk.Flags.StateFlags'."] #-}
    -- | This type indicates the current state of a widget; the state determines how
    -- the widget is drawn. The t'GI.Gtk.Enums.StateType' enumeration is also used to
    -- identify different colors in a t'GI.Gtk.Objects.Style.Style' for drawing, so states can be
    -- used for subparts of a widget as well as entire widgets.
    data StateType =
          StateTypeNormal
        -- ^ State during normal operation.
        | StateTypeActive
        -- ^ State of a currently active widget, such as a depressed button.
        | StateTypePrelight
        -- ^ State indicating that the mouse pointer is over
        --                      the widget and the widget will respond to mouse clicks.
        | StateTypeSelected
        -- ^ State of a selected item, such the selected row in a list.
        | StateTypeInsensitive
        -- ^ State indicating that the widget is
        --                         unresponsive to user actions.
        | StateTypeInconsistent
        -- ^ The widget is inconsistent, such as checkbuttons
        --                          or radiobuttons that aren’t either set to 'P.True' nor 'P.False',
        --                          or buttons requiring the user attention.
        | StateTypeFocused
        -- ^ The widget has the keyboard focus.
        | AnotherStateType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> StateType -> ShowS
    [StateType] -> ShowS
    StateType -> String
    (Int -> StateType -> ShowS)
    -> (StateType -> String)
    -> ([StateType] -> ShowS)
    -> Show StateType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> StateType -> ShowS
    showsPrec :: Int -> StateType -> ShowS
    $cshow :: StateType -> String
    show :: StateType -> String
    $cshowList :: [StateType] -> ShowS
    showList :: [StateType] -> ShowS
    Show, StateType -> StateType -> Bool
    (StateType -> StateType -> Bool)
    -> (StateType -> StateType -> Bool) -> Eq StateType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: StateType -> StateType -> Bool
    == :: StateType -> StateType -> Bool
    $c/= :: StateType -> StateType -> Bool
    /= :: StateType -> StateType -> Bool
    Eq)

    instance P.Enum StateType where
        fromEnum :: StateType -> Int
    fromEnum StateType
    StateTypeNormal = Int
    0
        fromEnum StateType
    StateTypeActive = Int
    1
        fromEnum StateType
    StateTypePrelight = Int
    2
        fromEnum StateType
    StateTypeSelected = Int
    3
        fromEnum StateType
    StateTypeInsensitive = Int
    4
        fromEnum StateType
    StateTypeInconsistent = Int
    5
        fromEnum StateType
    StateTypeFocused = Int
    6
        fromEnum (AnotherStateType Int
    k) = Int
    k

        toEnum :: Int -> StateType
    toEnum Int
    0 = StateType
    StateTypeNormal
        toEnum Int
    1 = StateType
    StateTypeActive
        toEnum Int
    2 = StateType
    StateTypePrelight
        toEnum Int
    3 = StateType
    StateTypeSelected
        toEnum Int
    4 = StateType
    StateTypeInsensitive
        toEnum Int
    5 = StateType
    StateTypeInconsistent
        toEnum Int
    6 = StateType
    StateTypeFocused
        toEnum Int
    k = Int -> StateType
    AnotherStateType Int
    k

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

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

    foreign import ccall "gtk_state_type_get_type" c_gtk_state_type_get_type ::
        IO GType

    instance B.Types.TypedObject StateType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_state_type_get_type

    instance B.Types.BoxedEnum StateType

    -- Enum StackTransitionType
    -- | These enumeration values describe the possible transitions
    -- between pages in a t'GI.Gtk.Objects.Stack.Stack' widget.
    --
    -- New values may be added to this enumeration over time.
    data StackTransitionType =
          StackTransitionTypeNone
        -- ^ No transition
        | StackTransitionTypeCrossfade
        -- ^ A cross-fade
        | StackTransitionTypeSlideRight
        -- ^ Slide from left to right
        | StackTransitionTypeSlideLeft
        -- ^ Slide from right to left
        | StackTransitionTypeSlideUp
        -- ^ Slide from bottom up
        | StackTransitionTypeSlideDown
        -- ^ Slide from top down
        | StackTransitionTypeSlideLeftRight
        -- ^ Slide from left or right according to the children order
        | StackTransitionTypeSlideUpDown
        -- ^ Slide from top down or bottom up according to the order
        | StackTransitionTypeOverUp
        -- ^ Cover the old page by sliding up. Since 3.12
        | StackTransitionTypeOverDown
        -- ^ Cover the old page by sliding down. Since: 3.12
        | StackTransitionTypeOverLeft
        -- ^ Cover the old page by sliding to the left. Since: 3.12
        | StackTransitionTypeOverRight
        -- ^ Cover the old page by sliding to the right. Since: 3.12
        | StackTransitionTypeUnderUp
        -- ^ Uncover the new page by sliding up. Since 3.12
        | StackTransitionTypeUnderDown
        -- ^ Uncover the new page by sliding down. Since: 3.12
        | StackTransitionTypeUnderLeft
        -- ^ Uncover the new page by sliding to the left. Since: 3.12
        | StackTransitionTypeUnderRight
        -- ^ Uncover the new page by sliding to the right. Since: 3.12
        | StackTransitionTypeOverUpDown
        -- ^ Cover the old page sliding up or uncover the new page sliding down, according to order. Since: 3.12
        | StackTransitionTypeOverDownUp
        -- ^ Cover the old page sliding down or uncover the new page sliding up, according to order. Since: 3.14
        | StackTransitionTypeOverLeftRight
        -- ^ Cover the old page sliding left or uncover the new page sliding right, according to order. Since: 3.14
        | StackTransitionTypeOverRightLeft
        -- ^ Cover the old page sliding right or uncover the new page sliding left, according to order. Since: 3.14
        | AnotherStackTransitionType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> StackTransitionType -> ShowS
    [StackTransitionType] -> ShowS
    StackTransitionType -> String
    (Int -> StackTransitionType -> ShowS)
    -> (StackTransitionType -> String)
    -> ([StackTransitionType] -> ShowS)
    -> Show StackTransitionType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> StackTransitionType -> ShowS
    showsPrec :: Int -> StackTransitionType -> ShowS
    $cshow :: StackTransitionType -> String
    show :: StackTransitionType -> String
    $cshowList :: [StackTransitionType] -> ShowS
    showList :: [StackTransitionType] -> ShowS
    Show, StackTransitionType -> StackTransitionType -> Bool
    (StackTransitionType -> StackTransitionType -> Bool)
    -> (StackTransitionType -> StackTransitionType -> Bool)
    -> Eq StackTransitionType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: StackTransitionType -> StackTransitionType -> Bool
    == :: StackTransitionType -> StackTransitionType -> Bool
    $c/= :: StackTransitionType -> StackTransitionType -> Bool
    /= :: StackTransitionType -> StackTransitionType -> Bool
    Eq)

    instance P.Enum StackTransitionType where
        fromEnum :: StackTransitionType -> Int
    fromEnum StackTransitionType
    StackTransitionTypeNone = Int
    0
        fromEnum StackTransitionType
    StackTransitionTypeCrossfade = Int
    1
        fromEnum StackTransitionType
    StackTransitionTypeSlideRight = Int
    2
        fromEnum StackTransitionType
    StackTransitionTypeSlideLeft = Int
    3
        fromEnum StackTransitionType
    StackTransitionTypeSlideUp = Int
    4
        fromEnum StackTransitionType
    StackTransitionTypeSlideDown = Int
    5
        fromEnum StackTransitionType
    StackTransitionTypeSlideLeftRight = Int
    6
        fromEnum StackTransitionType
    StackTransitionTypeSlideUpDown = Int
    7
        fromEnum StackTransitionType
    StackTransitionTypeOverUp = Int
    8
        fromEnum StackTransitionType
    StackTransitionTypeOverDown = Int
    9
        fromEnum StackTransitionType
    StackTransitionTypeOverLeft = Int
    10
        fromEnum StackTransitionType
    StackTransitionTypeOverRight = Int
    11
        fromEnum StackTransitionType
    StackTransitionTypeUnderUp = Int
    12
        fromEnum StackTransitionType
    StackTransitionTypeUnderDown = Int
    13
        fromEnum StackTransitionType
    StackTransitionTypeUnderLeft = Int
    14
        fromEnum StackTransitionType
    StackTransitionTypeUnderRight = Int
    15
        fromEnum StackTransitionType
    StackTransitionTypeOverUpDown = Int
    16
        fromEnum StackTransitionType
    StackTransitionTypeOverDownUp = Int
    17
        fromEnum StackTransitionType
    StackTransitionTypeOverLeftRight = Int
    18
        fromEnum StackTransitionType
    StackTransitionTypeOverRightLeft = Int
    19
        fromEnum (AnotherStackTransitionType Int
    k) = Int
    k

        toEnum :: Int -> StackTransitionType
    toEnum Int
    0 = StackTransitionType
    StackTransitionTypeNone
        toEnum Int
    1 = StackTransitionType
    StackTransitionTypeCrossfade
        toEnum Int
    2 = StackTransitionType
    StackTransitionTypeSlideRight
        toEnum Int
    3 = StackTransitionType
    StackTransitionTypeSlideLeft
        toEnum Int
    4 = StackTransitionType
    StackTransitionTypeSlideUp
        toEnum Int
    5 = StackTransitionType
    StackTransitionTypeSlideDown
        toEnum Int
    6 = StackTransitionType
    StackTransitionTypeSlideLeftRight
        toEnum Int
    7 = StackTransitionType
    StackTransitionTypeSlideUpDown
        toEnum Int
    8 = StackTransitionType
    StackTransitionTypeOverUp
        toEnum Int
    9 = StackTransitionType
    StackTransitionTypeOverDown
        toEnum Int
    10 = StackTransitionType
    StackTransitionTypeOverLeft
        toEnum Int
    11 = StackTransitionType
    StackTransitionTypeOverRight
        toEnum Int
    12 = StackTransitionType
    StackTransitionTypeUnderUp
        toEnum Int
    13 = StackTransitionType
    StackTransitionTypeUnderDown
        toEnum Int
    14 = StackTransitionType
    StackTransitionTypeUnderLeft
        toEnum Int
    15 = StackTransitionType
    StackTransitionTypeUnderRight
        toEnum Int
    16 = StackTransitionType
    StackTransitionTypeOverUpDown
        toEnum Int
    17 = StackTransitionType
    StackTransitionTypeOverDownUp
        toEnum Int
    18 = StackTransitionType
    StackTransitionTypeOverLeftRight
        toEnum Int
    19 = StackTransitionType
    StackTransitionTypeOverRightLeft
        toEnum Int
    k = Int -> StackTransitionType
    AnotherStackTransitionType Int
    k

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

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

    foreign import ccall "gtk_stack_transition_type_get_type" c_gtk_stack_transition_type_get_type ::
        IO GType

    instance B.Types.TypedObject StackTransitionType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_stack_transition_type_get_type

    instance B.Types.BoxedEnum StackTransitionType

    -- Enum SpinType
    -- | The values of the GtkSpinType enumeration are used to specify the
    -- change to make in 'GI.Gtk.Objects.SpinButton.spinButtonSpin'.
    data SpinType =
          SpinTypeStepForward
        -- ^ Increment by the adjustments step increment.
        | SpinTypeStepBackward
        -- ^ Decrement by the adjustments step increment.
        | SpinTypePageForward
        -- ^ Increment by the adjustments page increment.
        | SpinTypePageBackward
        -- ^ Decrement by the adjustments page increment.
        | SpinTypeHome
        -- ^ Go to the adjustments lower bound.
        | SpinTypeEnd
        -- ^ Go to the adjustments upper bound.
        | SpinTypeUserDefined
        -- ^ Change by a specified amount.
        | AnotherSpinType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SpinType -> ShowS
    [SpinType] -> ShowS
    SpinType -> String
    (Int -> SpinType -> ShowS)
    -> (SpinType -> String) -> ([SpinType] -> ShowS) -> Show SpinType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SpinType -> ShowS
    showsPrec :: Int -> SpinType -> ShowS
    $cshow :: SpinType -> String
    show :: SpinType -> String
    $cshowList :: [SpinType] -> ShowS
    showList :: [SpinType] -> ShowS
    Show, SpinType -> SpinType -> Bool
    (SpinType -> SpinType -> Bool)
    -> (SpinType -> SpinType -> Bool) -> Eq SpinType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SpinType -> SpinType -> Bool
    == :: SpinType -> SpinType -> Bool
    $c/= :: SpinType -> SpinType -> Bool
    /= :: SpinType -> SpinType -> Bool
    Eq)

    instance P.Enum SpinType where
        fromEnum :: SpinType -> Int
    fromEnum SpinType
    SpinTypeStepForward = Int
    0
        fromEnum SpinType
    SpinTypeStepBackward = Int
    1
        fromEnum SpinType
    SpinTypePageForward = Int
    2
        fromEnum SpinType
    SpinTypePageBackward = Int
    3
        fromEnum SpinType
    SpinTypeHome = Int
    4
        fromEnum SpinType
    SpinTypeEnd = Int
    5
        fromEnum SpinType
    SpinTypeUserDefined = Int
    6
        fromEnum (AnotherSpinType Int
    k) = Int
    k

        toEnum :: Int -> SpinType
    toEnum Int
    0 = SpinType
    SpinTypeStepForward
        toEnum Int
    1 = SpinType
    SpinTypeStepBackward
        toEnum Int
    2 = SpinType
    SpinTypePageForward
        toEnum Int
    3 = SpinType
    SpinTypePageBackward
        toEnum Int
    4 = SpinType
    SpinTypeHome
        toEnum Int
    5 = SpinType
    SpinTypeEnd
        toEnum Int
    6 = SpinType
    SpinTypeUserDefined
        toEnum Int
    k = Int -> SpinType
    AnotherSpinType Int
    k

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

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

    foreign import ccall "gtk_spin_type_get_type" c_gtk_spin_type_get_type ::
        IO GType

    instance B.Types.TypedObject SpinType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_spin_type_get_type

    instance B.Types.BoxedEnum SpinType

    -- Enum SpinButtonUpdatePolicy
    -- | The spin button update policy determines whether the spin button displays
    -- values even if they are outside the bounds of its adjustment.
    -- See 'GI.Gtk.Objects.SpinButton.spinButtonSetUpdatePolicy'.
    data SpinButtonUpdatePolicy =
          SpinButtonUpdatePolicyAlways
        -- ^ When refreshing your t'GI.Gtk.Objects.SpinButton.SpinButton', the value is
        --     always displayed
        | SpinButtonUpdatePolicyIfValid
        -- ^ When refreshing your t'GI.Gtk.Objects.SpinButton.SpinButton', the value is
        --     only displayed if it is valid within the bounds of the spin button\'s
        --     adjustment
        | AnotherSpinButtonUpdatePolicy Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SpinButtonUpdatePolicy -> ShowS
    [SpinButtonUpdatePolicy] -> ShowS
    SpinButtonUpdatePolicy -> String
    (Int -> SpinButtonUpdatePolicy -> ShowS)
    -> (SpinButtonUpdatePolicy -> String)
    -> ([SpinButtonUpdatePolicy] -> ShowS)
    -> Show SpinButtonUpdatePolicy
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SpinButtonUpdatePolicy -> ShowS
    showsPrec :: Int -> SpinButtonUpdatePolicy -> ShowS
    $cshow :: SpinButtonUpdatePolicy -> String
    show :: SpinButtonUpdatePolicy -> String
    $cshowList :: [SpinButtonUpdatePolicy] -> ShowS
    showList :: [SpinButtonUpdatePolicy] -> ShowS
    Show, SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
    (SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool)
    -> (SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool)
    -> Eq SpinButtonUpdatePolicy
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
    == :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
    $c/= :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
    /= :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
    Eq)

    instance P.Enum SpinButtonUpdatePolicy where
        fromEnum :: SpinButtonUpdatePolicy -> Int
    fromEnum SpinButtonUpdatePolicy
    SpinButtonUpdatePolicyAlways = Int
    0
        fromEnum SpinButtonUpdatePolicy
    SpinButtonUpdatePolicyIfValid = Int
    1
        fromEnum (AnotherSpinButtonUpdatePolicy Int
    k) = Int
    k

        toEnum :: Int -> SpinButtonUpdatePolicy
    toEnum Int
    0 = SpinButtonUpdatePolicy
    SpinButtonUpdatePolicyAlways
        toEnum Int
    1 = SpinButtonUpdatePolicy
    SpinButtonUpdatePolicyIfValid
        toEnum Int
    k = Int -> SpinButtonUpdatePolicy
    AnotherSpinButtonUpdatePolicy Int
    k

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

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

    foreign import ccall "gtk_spin_button_update_policy_get_type" c_gtk_spin_button_update_policy_get_type ::
        IO GType

    instance B.Types.TypedObject SpinButtonUpdatePolicy where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_spin_button_update_policy_get_type

    instance B.Types.BoxedEnum SpinButtonUpdatePolicy

    -- Enum SortType
    -- | Determines the direction of a sort.
    data SortType =
          SortTypeAscending
        -- ^ Sorting is in ascending order.
        | SortTypeDescending
        -- ^ Sorting is in descending order.
        | AnotherSortType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SortType -> ShowS
    [SortType] -> ShowS
    SortType -> String
    (Int -> SortType -> ShowS)
    -> (SortType -> String) -> ([SortType] -> ShowS) -> Show SortType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SortType -> ShowS
    showsPrec :: Int -> SortType -> ShowS
    $cshow :: SortType -> String
    show :: SortType -> String
    $cshowList :: [SortType] -> ShowS
    showList :: [SortType] -> ShowS
    Show, SortType -> SortType -> Bool
    (SortType -> SortType -> Bool)
    -> (SortType -> SortType -> Bool) -> Eq SortType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SortType -> SortType -> Bool
    == :: SortType -> SortType -> Bool
    $c/= :: SortType -> SortType -> Bool
    /= :: SortType -> SortType -> Bool
    Eq)

    instance P.Enum SortType where
        fromEnum :: SortType -> Int
    fromEnum SortType
    SortTypeAscending = Int
    0
        fromEnum SortType
    SortTypeDescending = Int
    1
        fromEnum (AnotherSortType Int
    k) = Int
    k

        toEnum :: Int -> SortType
    toEnum Int
    0 = SortType
    SortTypeAscending
        toEnum Int
    1 = SortType
    SortTypeDescending
        toEnum Int
    k = Int -> SortType
    AnotherSortType Int
    k

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

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

    foreign import ccall "gtk_sort_type_get_type" c_gtk_sort_type_get_type ::
        IO GType

    instance B.Types.TypedObject SortType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_sort_type_get_type

    instance B.Types.BoxedEnum SortType

    -- Enum SizeRequestMode
    -- | Specifies a preference for height-for-width or
    -- width-for-height geometry management.
    data SizeRequestMode =
          SizeRequestModeHeightForWidth
        -- ^ Prefer height-for-width geometry management
        | SizeRequestModeWidthForHeight
        -- ^ Prefer width-for-height geometry management
        | SizeRequestModeConstantSize
        -- ^ Don’t trade height-for-width or width-for-height
        | AnotherSizeRequestMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SizeRequestMode -> ShowS
    [SizeRequestMode] -> ShowS
    SizeRequestMode -> String
    (Int -> SizeRequestMode -> ShowS)
    -> (SizeRequestMode -> String)
    -> ([SizeRequestMode] -> ShowS)
    -> Show SizeRequestMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SizeRequestMode -> ShowS
    showsPrec :: Int -> SizeRequestMode -> ShowS
    $cshow :: SizeRequestMode -> String
    show :: SizeRequestMode -> String
    $cshowList :: [SizeRequestMode] -> ShowS
    showList :: [SizeRequestMode] -> ShowS
    Show, SizeRequestMode -> SizeRequestMode -> Bool
    (SizeRequestMode -> SizeRequestMode -> Bool)
    -> (SizeRequestMode -> SizeRequestMode -> Bool)
    -> Eq SizeRequestMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SizeRequestMode -> SizeRequestMode -> Bool
    == :: SizeRequestMode -> SizeRequestMode -> Bool
    $c/= :: SizeRequestMode -> SizeRequestMode -> Bool
    /= :: SizeRequestMode -> SizeRequestMode -> Bool
    Eq)

    instance P.Enum SizeRequestMode where
        fromEnum :: SizeRequestMode -> Int
    fromEnum SizeRequestMode
    SizeRequestModeHeightForWidth = Int
    0
        fromEnum SizeRequestMode
    SizeRequestModeWidthForHeight = Int
    1
        fromEnum SizeRequestMode
    SizeRequestModeConstantSize = Int
    2
        fromEnum (AnotherSizeRequestMode Int
    k) = Int
    k

        toEnum :: Int -> SizeRequestMode
    toEnum Int
    0 = SizeRequestMode
    SizeRequestModeHeightForWidth
        toEnum Int
    1 = SizeRequestMode
    SizeRequestModeWidthForHeight
        toEnum Int
    2 = SizeRequestMode
    SizeRequestModeConstantSize
        toEnum Int
    k = Int -> SizeRequestMode
    AnotherSizeRequestMode Int
    k

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

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

    foreign import ccall "gtk_size_request_mode_get_type" c_gtk_size_request_mode_get_type ::
        IO GType

    instance B.Types.TypedObject SizeRequestMode where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_size_request_mode_get_type

    instance B.Types.BoxedEnum SizeRequestMode

    -- Enum SizeGroupMode
    -- | The mode of the size group determines the directions in which the size
    -- group affects the requested sizes of its component widgets.
    data SizeGroupMode =
          SizeGroupModeNone
        -- ^ group has no effect
        | SizeGroupModeHorizontal
        -- ^ group affects horizontal requisition
        | SizeGroupModeVertical
        -- ^ group affects vertical requisition
        | SizeGroupModeBoth
        -- ^ group affects both horizontal and vertical requisition
        | AnotherSizeGroupMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SizeGroupMode -> ShowS
    [SizeGroupMode] -> ShowS
    SizeGroupMode -> String
    (Int -> SizeGroupMode -> ShowS)
    -> (SizeGroupMode -> String)
    -> ([SizeGroupMode] -> ShowS)
    -> Show SizeGroupMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SizeGroupMode -> ShowS
    showsPrec :: Int -> SizeGroupMode -> ShowS
    $cshow :: SizeGroupMode -> String
    show :: SizeGroupMode -> String
    $cshowList :: [SizeGroupMode] -> ShowS
    showList :: [SizeGroupMode] -> ShowS
    Show, SizeGroupMode -> SizeGroupMode -> Bool
    (SizeGroupMode -> SizeGroupMode -> Bool)
    -> (SizeGroupMode -> SizeGroupMode -> Bool) -> Eq SizeGroupMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SizeGroupMode -> SizeGroupMode -> Bool
    == :: SizeGroupMode -> SizeGroupMode -> Bool
    $c/= :: SizeGroupMode -> SizeGroupMode -> Bool
    /= :: SizeGroupMode -> SizeGroupMode -> Bool
    Eq)

    instance P.Enum SizeGroupMode where
        fromEnum :: SizeGroupMode -> Int
    fromEnum SizeGroupMode
    SizeGroupModeNone = Int
    0
        fromEnum SizeGroupMode
    SizeGroupModeHorizontal = Int
    1
        fromEnum SizeGroupMode
    SizeGroupModeVertical = Int
    2
        fromEnum SizeGroupMode
    SizeGroupModeBoth = Int
    3
        fromEnum (AnotherSizeGroupMode Int
    k) = Int
    k

        toEnum :: Int -> SizeGroupMode
    toEnum Int
    0 = SizeGroupMode
    SizeGroupModeNone
        toEnum Int
    1 = SizeGroupMode
    SizeGroupModeHorizontal
        toEnum Int
    2 = SizeGroupMode
    SizeGroupModeVertical
        toEnum Int
    3 = SizeGroupMode
    SizeGroupModeBoth
        toEnum Int
    k = Int -> SizeGroupMode
    AnotherSizeGroupMode Int
    k

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

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

    foreign import ccall "gtk_size_group_mode_get_type" c_gtk_size_group_mode_get_type ::
        IO GType

    instance B.Types.TypedObject SizeGroupMode where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_size_group_mode_get_type

    instance B.Types.BoxedEnum SizeGroupMode

    -- Enum ShortcutType
    -- | GtkShortcutType specifies the kind of shortcut that is being described.
    -- More values may be added to this enumeration over time.
    --
    -- /Since: 3.20/
    data ShortcutType =
          ShortcutTypeAccelerator
        -- ^ The shortcut is a keyboard accelerator. The [ShortcutsShortcut:accelerator]("GI.Gtk.Objects.ShortcutsShortcut#g:attr:accelerator")
        --   property will be used.
        | ShortcutTypeGesturePinch
        -- ^ The shortcut is a pinch gesture. GTK+ provides an icon and subtitle.
        | ShortcutTypeGestureStretch
        -- ^ The shortcut is a stretch gesture. GTK+ provides an icon and subtitle.
        | ShortcutTypeGestureRotateClockwise
        -- ^ The shortcut is a clockwise rotation gesture. GTK+ provides an icon and subtitle.
        | ShortcutTypeGestureRotateCounterclockwise
        -- ^ The shortcut is a counterclockwise rotation gesture. GTK+ provides an icon and subtitle.
        | ShortcutTypeGestureTwoFingerSwipeLeft
        -- ^ The shortcut is a two-finger swipe gesture. GTK+ provides an icon and subtitle.
        | ShortcutTypeGestureTwoFingerSwipeRight
        -- ^ The shortcut is a two-finger swipe gesture. GTK+ provides an icon and subtitle.
        | ShortcutTypeGesture
        -- ^ The shortcut is a gesture. The [ShortcutsShortcut:icon]("GI.Gtk.Objects.ShortcutsShortcut#g:attr:icon") property will be
        --   used.
        | AnotherShortcutType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ShortcutType -> ShowS
    [ShortcutType] -> ShowS
    ShortcutType -> String
    (Int -> ShortcutType -> ShowS)
    -> (ShortcutType -> String)
    -> ([ShortcutType] -> ShowS)
    -> Show ShortcutType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ShortcutType -> ShowS
    showsPrec :: Int -> ShortcutType -> ShowS
    $cshow :: ShortcutType -> String
    show :: ShortcutType -> String
    $cshowList :: [ShortcutType] -> ShowS
    showList :: [ShortcutType] -> ShowS
    Show, ShortcutType -> ShortcutType -> Bool
    (ShortcutType -> ShortcutType -> Bool)
    -> (ShortcutType -> ShortcutType -> Bool) -> Eq ShortcutType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ShortcutType -> ShortcutType -> Bool
    == :: ShortcutType -> ShortcutType -> Bool
    $c/= :: ShortcutType -> ShortcutType -> Bool
    /= :: ShortcutType -> ShortcutType -> Bool
    Eq)

    instance P.Enum ShortcutType where
        fromEnum :: ShortcutType -> Int
    fromEnum ShortcutType
    ShortcutTypeAccelerator = Int
    0
        fromEnum ShortcutType
    ShortcutTypeGesturePinch = Int
    1
        fromEnum ShortcutType
    ShortcutTypeGestureStretch = Int
    2
        fromEnum ShortcutType
    ShortcutTypeGestureRotateClockwise = Int
    3
        fromEnum ShortcutType
    ShortcutTypeGestureRotateCounterclockwise = Int
    4
        fromEnum ShortcutType
    ShortcutTypeGestureTwoFingerSwipeLeft = Int
    5
        fromEnum ShortcutType
    ShortcutTypeGestureTwoFingerSwipeRight = Int
    6
        fromEnum ShortcutType
    ShortcutTypeGesture = Int
    7
        fromEnum (AnotherShortcutType Int
    k) = Int
    k

        toEnum :: Int -> ShortcutType
    toEnum Int
    0 = ShortcutType
    ShortcutTypeAccelerator
        toEnum Int
    1 = ShortcutType
    ShortcutTypeGesturePinch
        toEnum Int
    2 = ShortcutType
    ShortcutTypeGestureStretch
        toEnum Int
    3 = ShortcutType
    ShortcutTypeGestureRotateClockwise
        toEnum Int
    4 = ShortcutType
    ShortcutTypeGestureRotateCounterclockwise
        toEnum Int
    5 = ShortcutType
    ShortcutTypeGestureTwoFingerSwipeLeft
        toEnum Int
    6 = ShortcutType
    ShortcutTypeGestureTwoFingerSwipeRight
        toEnum Int
    7 = ShortcutType
    ShortcutTypeGesture
        toEnum Int
    k = Int -> ShortcutType
    AnotherShortcutType Int
    k

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

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

    foreign import ccall "gtk_shortcut_type_get_type" c_gtk_shortcut_type_get_type ::
        IO GType

    instance B.Types.TypedObject ShortcutType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_shortcut_type_get_type

    instance B.Types.BoxedEnum ShortcutType

    -- Enum ShadowType
    -- | Used to change the appearance of an outline typically provided by a t'GI.Gtk.Objects.Frame.Frame'.
    --
    -- Note that many themes do not differentiate the appearance of the
    -- various shadow types: Either their is no visible shadow (/@gTKSHADOWNONE@/),
    -- or there is (any other value).
    data ShadowType =
          ShadowTypeNone
        -- ^ No outline.
        | ShadowTypeIn
        -- ^ The outline is bevelled inwards.
        | ShadowTypeOut
        -- ^ The outline is bevelled outwards like a button.
        | ShadowTypeEtchedIn
        -- ^ The outline has a sunken 3d appearance.
        | ShadowTypeEtchedOut
        -- ^ The outline has a raised 3d appearance.
        | AnotherShadowType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ShadowType -> ShowS
    [ShadowType] -> ShowS
    ShadowType -> String
    (Int -> ShadowType -> ShowS)
    -> (ShadowType -> String)
    -> ([ShadowType] -> ShowS)
    -> Show ShadowType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ShadowType -> ShowS
    showsPrec :: Int -> ShadowType -> ShowS
    $cshow :: ShadowType -> String
    show :: ShadowType -> String
    $cshowList :: [ShadowType] -> ShowS
    showList :: [ShadowType] -> ShowS
    Show, ShadowType -> ShadowType -> Bool
    (ShadowType -> ShadowType -> Bool)
    -> (ShadowType -> ShadowType -> Bool) -> Eq ShadowType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ShadowType -> ShadowType -> Bool
    == :: ShadowType -> ShadowType -> Bool
    $c/= :: ShadowType -> ShadowType -> Bool
    /= :: ShadowType -> ShadowType -> Bool
    Eq)

    instance P.Enum ShadowType where
        fromEnum :: ShadowType -> Int
    fromEnum ShadowType
    ShadowTypeNone = Int
    0
        fromEnum ShadowType
    ShadowTypeIn = Int
    1
        fromEnum ShadowType
    ShadowTypeOut = Int
    2
        fromEnum ShadowType
    ShadowTypeEtchedIn = Int
    3
        fromEnum ShadowType
    ShadowTypeEtchedOut = Int
    4
        fromEnum (AnotherShadowType Int
    k) = Int
    k

        toEnum :: Int -> ShadowType
    toEnum Int
    0 = ShadowType
    ShadowTypeNone
        toEnum Int
    1 = ShadowType
    ShadowTypeIn
        toEnum Int
    2 = ShadowType
    ShadowTypeOut
        toEnum Int
    3 = ShadowType
    ShadowTypeEtchedIn
        toEnum Int
    4 = ShadowType
    ShadowTypeEtchedOut
        toEnum Int
    k = Int -> ShadowType
    AnotherShadowType Int
    k

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

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

    foreign import ccall "gtk_shadow_type_get_type" c_gtk_shadow_type_get_type ::
        IO GType

    instance B.Types.TypedObject ShadowType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_shadow_type_get_type

    instance B.Types.BoxedEnum ShadowType

    -- Enum SensitivityType
    -- | Determines how GTK+ handles the sensitivity of stepper arrows
    -- at the end of range widgets.
    data SensitivityType =
          SensitivityTypeAuto
        -- ^ The arrow is made insensitive if the
        --   thumb is at the end
        | SensitivityTypeOn
        -- ^ The arrow is always sensitive
        | SensitivityTypeOff
        -- ^ The arrow is always insensitive
        | AnotherSensitivityType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SensitivityType -> ShowS
    [SensitivityType] -> ShowS
    SensitivityType -> String
    (Int -> SensitivityType -> ShowS)
    -> (SensitivityType -> String)
    -> ([SensitivityType] -> ShowS)
    -> Show SensitivityType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SensitivityType -> ShowS
    showsPrec :: Int -> SensitivityType -> ShowS
    $cshow :: SensitivityType -> String
    show :: SensitivityType -> String
    $cshowList :: [SensitivityType] -> ShowS
    showList :: [SensitivityType] -> ShowS
    Show, SensitivityType -> SensitivityType -> Bool
    (SensitivityType -> SensitivityType -> Bool)
    -> (SensitivityType -> SensitivityType -> Bool)
    -> Eq SensitivityType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SensitivityType -> SensitivityType -> Bool
    == :: SensitivityType -> SensitivityType -> Bool
    $c/= :: SensitivityType -> SensitivityType -> Bool
    /= :: SensitivityType -> SensitivityType -> Bool
    Eq)

    instance P.Enum SensitivityType where
        fromEnum :: SensitivityType -> Int
    fromEnum SensitivityType
    SensitivityTypeAuto = Int
    0
        fromEnum SensitivityType
    SensitivityTypeOn = Int
    1
        fromEnum SensitivityType
    SensitivityTypeOff = Int
    2
        fromEnum (AnotherSensitivityType Int
    k) = Int
    k

        toEnum :: Int -> SensitivityType
    toEnum Int
    0 = SensitivityType
    SensitivityTypeAuto
        toEnum Int
    1 = SensitivityType
    SensitivityTypeOn
        toEnum Int
    2 = SensitivityType
    SensitivityTypeOff
        toEnum Int
    k = Int -> SensitivityType
    AnotherSensitivityType Int
    k

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

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

    foreign import ccall "gtk_sensitivity_type_get_type" c_gtk_sensitivity_type_get_type ::
        IO GType

    instance B.Types.TypedObject SensitivityType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_sensitivity_type_get_type

    instance B.Types.BoxedEnum SensitivityType

    -- Enum SelectionMode
    -- | Used to control what selections users are allowed to make.
    data SelectionMode =
          SelectionModeNone
        -- ^ No selection is possible.
        | SelectionModeSingle
        -- ^ Zero or one element may be selected.
        | SelectionModeBrowse
        -- ^ Exactly one element is selected.
        --     In some circumstances, such as initially or during a search
        --     operation, it’s possible for no element to be selected with
        --     'GI.Gtk.Enums.SelectionModeBrowse'. What is really enforced is that the user
        --     can’t deselect a currently selected element except by selecting
        --     another element.
        | SelectionModeMultiple
        -- ^ Any number of elements may be selected.
        --      The Ctrl key may be used to enlarge the selection, and Shift
        --      key to select between the focus and the child pointed to.
        --      Some widgets may also allow Click-drag to select a range of elements.
        | AnotherSelectionMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SelectionMode -> ShowS
    [SelectionMode] -> ShowS
    SelectionMode -> String
    (Int -> SelectionMode -> ShowS)
    -> (SelectionMode -> String)
    -> ([SelectionMode] -> ShowS)
    -> Show SelectionMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SelectionMode -> ShowS
    showsPrec :: Int -> SelectionMode -> ShowS
    $cshow :: SelectionMode -> String
    show :: SelectionMode -> String
    $cshowList :: [SelectionMode] -> ShowS
    showList :: [SelectionMode] -> ShowS
    Show, SelectionMode -> SelectionMode -> Bool
    (SelectionMode -> SelectionMode -> Bool)
    -> (SelectionMode -> SelectionMode -> Bool) -> Eq SelectionMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SelectionMode -> SelectionMode -> Bool
    == :: SelectionMode -> SelectionMode -> Bool
    $c/= :: SelectionMode -> SelectionMode -> Bool
    /= :: SelectionMode -> SelectionMode -> Bool
    Eq)

    instance P.Enum SelectionMode where
        fromEnum :: SelectionMode -> Int
    fromEnum SelectionMode
    SelectionModeNone = Int
    0
        fromEnum SelectionMode
    SelectionModeSingle = Int
    1
        fromEnum SelectionMode
    SelectionModeBrowse = Int
    2
        fromEnum SelectionMode
    SelectionModeMultiple = Int
    3
        fromEnum (AnotherSelectionMode Int
    k) = Int
    k

        toEnum :: Int -> SelectionMode
    toEnum Int
    0 = SelectionMode
    SelectionModeNone
        toEnum Int
    1 = SelectionMode
    SelectionModeSingle
        toEnum Int
    2 = SelectionMode
    SelectionModeBrowse
        toEnum Int
    3 = SelectionMode
    SelectionModeMultiple
        toEnum Int
    k = Int -> SelectionMode
    AnotherSelectionMode Int
    k

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

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

    foreign import ccall "gtk_selection_mode_get_type" c_gtk_selection_mode_get_type ::
        IO GType

    instance B.Types.TypedObject SelectionMode where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_selection_mode_get_type

    instance B.Types.BoxedEnum SelectionMode

    -- Enum ScrollablePolicy
    -- | Defines the policy to be used in a scrollable widget when updating
    -- the scrolled window adjustments in a given orientation.
    data ScrollablePolicy =
          ScrollablePolicyMinimum
        -- ^ Scrollable adjustments are based on the minimum size
        | ScrollablePolicyNatural
        -- ^ Scrollable adjustments are based on the natural size
        | AnotherScrollablePolicy Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ScrollablePolicy -> ShowS
    [ScrollablePolicy] -> ShowS
    ScrollablePolicy -> String
    (Int -> ScrollablePolicy -> ShowS)
    -> (ScrollablePolicy -> String)
    -> ([ScrollablePolicy] -> ShowS)
    -> Show ScrollablePolicy
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ScrollablePolicy -> ShowS
    showsPrec :: Int -> ScrollablePolicy -> ShowS
    $cshow :: ScrollablePolicy -> String
    show :: ScrollablePolicy -> String
    $cshowList :: [ScrollablePolicy] -> ShowS
    showList :: [ScrollablePolicy] -> ShowS
    Show, ScrollablePolicy -> ScrollablePolicy -> Bool
    (ScrollablePolicy -> ScrollablePolicy -> Bool)
    -> (ScrollablePolicy -> ScrollablePolicy -> Bool)
    -> Eq ScrollablePolicy
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ScrollablePolicy -> ScrollablePolicy -> Bool
    == :: ScrollablePolicy -> ScrollablePolicy -> Bool
    $c/= :: ScrollablePolicy -> ScrollablePolicy -> Bool
    /= :: ScrollablePolicy -> ScrollablePolicy -> Bool
    Eq)

    instance P.Enum ScrollablePolicy where
        fromEnum :: ScrollablePolicy -> Int
    fromEnum ScrollablePolicy
    ScrollablePolicyMinimum = Int
    0
        fromEnum ScrollablePolicy
    ScrollablePolicyNatural = Int
    1
        fromEnum (AnotherScrollablePolicy Int
    k) = Int
    k

        toEnum :: Int -> ScrollablePolicy
    toEnum Int
    0 = ScrollablePolicy
    ScrollablePolicyMinimum
        toEnum Int
    1 = ScrollablePolicy
    ScrollablePolicyNatural
        toEnum Int
    k = Int -> ScrollablePolicy
    AnotherScrollablePolicy Int
    k

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

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

    foreign import ccall "gtk_scrollable_policy_get_type" c_gtk_scrollable_policy_get_type ::
        IO GType

    instance B.Types.TypedObject ScrollablePolicy where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_scrollable_policy_get_type

    instance B.Types.BoxedEnum ScrollablePolicy

    -- Enum ScrollType
    -- | Scrolling types.
    data ScrollType =
          ScrollTypeNone
        -- ^ No scrolling.
        | ScrollTypeJump
        -- ^ Jump to new location.
        | ScrollTypeStepBackward
        -- ^ Step backward.
        | ScrollTypeStepForward
        -- ^ Step forward.
        | ScrollTypePageBackward
        -- ^ Page backward.
        | ScrollTypePageForward
        -- ^ Page forward.
        | ScrollTypeStepUp
        -- ^ Step up.
        | ScrollTypeStepDown
        -- ^ Step down.
        | ScrollTypePageUp
        -- ^ Page up.
        | ScrollTypePageDown
        -- ^ Page down.
        | ScrollTypeStepLeft
        -- ^ Step to the left.
        | ScrollTypeStepRight
        -- ^ Step to the right.
        | ScrollTypePageLeft
        -- ^ Page to the left.
        | ScrollTypePageRight
        -- ^ Page to the right.
        | ScrollTypeStart
        -- ^ Scroll to start.
        | ScrollTypeEnd
        -- ^ Scroll to end.
        | AnotherScrollType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ScrollType -> ShowS
    [ScrollType] -> ShowS
    ScrollType -> String
    (Int -> ScrollType -> ShowS)
    -> (ScrollType -> String)
    -> ([ScrollType] -> ShowS)
    -> Show ScrollType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ScrollType -> ShowS
    showsPrec :: Int -> ScrollType -> ShowS
    $cshow :: ScrollType -> String
    show :: ScrollType -> String
    $cshowList :: [ScrollType] -> ShowS
    showList :: [ScrollType] -> ShowS
    Show, ScrollType -> ScrollType -> Bool
    (ScrollType -> ScrollType -> Bool)
    -> (ScrollType -> ScrollType -> Bool) -> Eq ScrollType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ScrollType -> ScrollType -> Bool
    == :: ScrollType -> ScrollType -> Bool
    $c/= :: ScrollType -> ScrollType -> Bool
    /= :: ScrollType -> ScrollType -> Bool
    Eq)

    instance P.Enum ScrollType where
        fromEnum :: ScrollType -> Int
    fromEnum ScrollType
    ScrollTypeNone = Int
    0
        fromEnum ScrollType
    ScrollTypeJump = Int
    1
        fromEnum ScrollType
    ScrollTypeStepBackward = Int
    2
        fromEnum ScrollType
    ScrollTypeStepForward = Int
    3
        fromEnum ScrollType
    ScrollTypePageBackward = Int
    4
        fromEnum ScrollType
    ScrollTypePageForward = Int
    5
        fromEnum ScrollType
    ScrollTypeStepUp = Int
    6
        fromEnum ScrollType
    ScrollTypeStepDown = Int
    7
        fromEnum ScrollType
    ScrollTypePageUp = Int
    8
        fromEnum ScrollType
    ScrollTypePageDown = Int
    9
        fromEnum ScrollType
    ScrollTypeStepLeft = Int
    10
        fromEnum ScrollType
    ScrollTypeStepRight = Int
    11
        fromEnum ScrollType
    ScrollTypePageLeft = Int
    12
        fromEnum ScrollType
    ScrollTypePageRight = Int
    13
        fromEnum ScrollType
    ScrollTypeStart = Int
    14
        fromEnum ScrollType
    ScrollTypeEnd = Int
    15
        fromEnum (AnotherScrollType Int
    k) = Int
    k

        toEnum :: Int -> ScrollType
    toEnum Int
    0 = ScrollType
    ScrollTypeNone
        toEnum Int
    1 = ScrollType
    ScrollTypeJump
        toEnum Int
    2 = ScrollType
    ScrollTypeStepBackward
        toEnum Int
    3 = ScrollType
    ScrollTypeStepForward
        toEnum Int
    4 = ScrollType
    ScrollTypePageBackward
        toEnum Int
    5 = ScrollType
    ScrollTypePageForward
        toEnum Int
    6 = ScrollType
    ScrollTypeStepUp
        toEnum Int
    7 = ScrollType
    ScrollTypeStepDown
        toEnum Int
    8 = ScrollType
    ScrollTypePageUp
        toEnum Int
    9 = ScrollType
    ScrollTypePageDown
        toEnum Int
    10 = ScrollType
    ScrollTypeStepLeft
        toEnum Int
    11 = ScrollType
    ScrollTypeStepRight
        toEnum Int
    12 = ScrollType
    ScrollTypePageLeft
        toEnum Int
    13 = ScrollType
    ScrollTypePageRight
        toEnum Int
    14 = ScrollType
    ScrollTypeStart
        toEnum Int
    15 = ScrollType
    ScrollTypeEnd
        toEnum Int
    k = Int -> ScrollType
    AnotherScrollType Int
    k

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

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

    foreign import ccall "gtk_scroll_type_get_type" c_gtk_scroll_type_get_type ::
        IO GType

    instance B.Types.TypedObject ScrollType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_scroll_type_get_type

    instance B.Types.BoxedEnum ScrollType

    -- Enum ScrollStep
    -- | /No description available in the introspection data./
    data ScrollStep =
          ScrollStepSteps
        -- ^ Scroll in steps.
        | ScrollStepPages
        -- ^ Scroll by pages.
        | ScrollStepEnds
        -- ^ Scroll to ends.
        | ScrollStepHorizontalSteps
        -- ^ Scroll in horizontal steps.
        | ScrollStepHorizontalPages
        -- ^ Scroll by horizontal pages.
        | ScrollStepHorizontalEnds
        -- ^ Scroll to the horizontal ends.
        | AnotherScrollStep Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ScrollStep -> ShowS
    [ScrollStep] -> ShowS
    ScrollStep -> String
    (Int -> ScrollStep -> ShowS)
    -> (ScrollStep -> String)
    -> ([ScrollStep] -> ShowS)
    -> Show ScrollStep
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ScrollStep -> ShowS
    showsPrec :: Int -> ScrollStep -> ShowS
    $cshow :: ScrollStep -> String
    show :: ScrollStep -> String
    $cshowList :: [ScrollStep] -> ShowS
    showList :: [ScrollStep] -> ShowS
    Show, ScrollStep -> ScrollStep -> Bool
    (ScrollStep -> ScrollStep -> Bool)
    -> (ScrollStep -> ScrollStep -> Bool) -> Eq ScrollStep
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ScrollStep -> ScrollStep -> Bool
    == :: ScrollStep -> ScrollStep -> Bool
    $c/= :: ScrollStep -> ScrollStep -> Bool
    /= :: ScrollStep -> ScrollStep -> Bool
    Eq)

    instance P.Enum ScrollStep where
        fromEnum :: ScrollStep -> Int
    fromEnum ScrollStep
    ScrollStepSteps = Int
    0
        fromEnum ScrollStep
    ScrollStepPages = Int
    1
        fromEnum ScrollStep
    ScrollStepEnds = Int
    2
        fromEnum ScrollStep
    ScrollStepHorizontalSteps = Int
    3
        fromEnum ScrollStep
    ScrollStepHorizontalPages = Int
    4
        fromEnum ScrollStep
    ScrollStepHorizontalEnds = Int
    5
        fromEnum (AnotherScrollStep Int
    k) = Int
    k

        toEnum :: Int -> ScrollStep
    toEnum Int
    0 = ScrollStep
    ScrollStepSteps
        toEnum Int
    1 = ScrollStep
    ScrollStepPages
        toEnum Int
    2 = ScrollStep
    ScrollStepEnds
        toEnum Int
    3 = ScrollStep
    ScrollStepHorizontalSteps
        toEnum Int
    4 = ScrollStep
    ScrollStepHorizontalPages
        toEnum Int
    5 = ScrollStep
    ScrollStepHorizontalEnds
        toEnum Int
    k = Int -> ScrollStep
    AnotherScrollStep Int
    k

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

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

    foreign import ccall "gtk_scroll_step_get_type" c_gtk_scroll_step_get_type ::
        IO GType

    instance B.Types.TypedObject ScrollStep where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_scroll_step_get_type

    instance B.Types.BoxedEnum ScrollStep

    -- Enum RevealerTransitionType
    -- | These enumeration values describe the possible transitions
    -- when the child of a t'GI.Gtk.Objects.Revealer.Revealer' widget is shown or hidden.
    data RevealerTransitionType =
          RevealerTransitionTypeNone
        -- ^ No transition
        | RevealerTransitionTypeCrossfade
        -- ^ Fade in
        | RevealerTransitionTypeSlideRight
        -- ^ Slide in from the left
        | RevealerTransitionTypeSlideLeft
        -- ^ Slide in from the right
        | RevealerTransitionTypeSlideUp
        -- ^ Slide in from the bottom
        | RevealerTransitionTypeSlideDown
        -- ^ Slide in from the top
        | AnotherRevealerTransitionType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> RevealerTransitionType -> ShowS
    [RevealerTransitionType] -> ShowS
    RevealerTransitionType -> String
    (Int -> RevealerTransitionType -> ShowS)
    -> (RevealerTransitionType -> String)
    -> ([RevealerTransitionType] -> ShowS)
    -> Show RevealerTransitionType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RevealerTransitionType -> ShowS
    showsPrec :: Int -> RevealerTransitionType -> ShowS
    $cshow :: RevealerTransitionType -> String
    show :: RevealerTransitionType -> String
    $cshowList :: [RevealerTransitionType] -> ShowS
    showList :: [RevealerTransitionType] -> ShowS
    Show, RevealerTransitionType -> RevealerTransitionType -> Bool
    (RevealerTransitionType -> RevealerTransitionType -> Bool)
    -> (RevealerTransitionType -> RevealerTransitionType -> Bool)
    -> Eq RevealerTransitionType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RevealerTransitionType -> RevealerTransitionType -> Bool
    == :: RevealerTransitionType -> RevealerTransitionType -> Bool
    $c/= :: RevealerTransitionType -> RevealerTransitionType -> Bool
    /= :: RevealerTransitionType -> RevealerTransitionType -> Bool
    Eq)

    instance P.Enum RevealerTransitionType where
        fromEnum :: RevealerTransitionType -> Int
    fromEnum RevealerTransitionType
    RevealerTransitionTypeNone = Int
    0
        fromEnum RevealerTransitionType
    RevealerTransitionTypeCrossfade = Int
    1
        fromEnum RevealerTransitionType
    RevealerTransitionTypeSlideRight = Int
    2
        fromEnum RevealerTransitionType
    RevealerTransitionTypeSlideLeft = Int
    3
        fromEnum RevealerTransitionType
    RevealerTransitionTypeSlideUp = Int
    4
        fromEnum RevealerTransitionType
    RevealerTransitionTypeSlideDown = Int
    5
        fromEnum (AnotherRevealerTransitionType Int
    k) = Int
    k

        toEnum :: Int -> RevealerTransitionType
    toEnum Int
    0 = RevealerTransitionType
    RevealerTransitionTypeNone
        toEnum Int
    1 = RevealerTransitionType
    RevealerTransitionTypeCrossfade
        toEnum Int
    2 = RevealerTransitionType
    RevealerTransitionTypeSlideRight
        toEnum Int
    3 = RevealerTransitionType
    RevealerTransitionTypeSlideLeft
        toEnum Int
    4 = RevealerTransitionType
    RevealerTransitionTypeSlideUp
        toEnum Int
    5 = RevealerTransitionType
    RevealerTransitionTypeSlideDown
        toEnum Int
    k = Int -> RevealerTransitionType
    AnotherRevealerTransitionType Int
    k

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

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

    foreign import ccall "gtk_revealer_transition_type_get_type" c_gtk_revealer_transition_type_get_type ::
        IO GType

    instance B.Types.TypedObject RevealerTransitionType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_revealer_transition_type_get_type

    instance B.Types.BoxedEnum RevealerTransitionType

    -- Enum ResponseType
    -- | Predefined values for use as response ids in 'GI.Gtk.Objects.Dialog.dialogAddButton'.
    -- All predefined values are negative; GTK+ leaves values of 0 or greater for
    -- application-defined response ids.
    data ResponseType =
          ResponseTypeNone
        -- ^ Returned if an action widget has no response id,
        --     or if the dialog gets programmatically hidden or destroyed
        | ResponseTypeReject
        -- ^ Generic response id, not used by GTK+ dialogs
        | ResponseTypeAccept
        -- ^ Generic response id, not used by GTK+ dialogs
        | ResponseTypeDeleteEvent
        -- ^ Returned if the dialog is deleted
        | ResponseTypeOk
        -- ^ Returned by OK buttons in GTK+ dialogs
        | ResponseTypeCancel
        -- ^ Returned by Cancel buttons in GTK+ dialogs
        | ResponseTypeClose
        -- ^ Returned by Close buttons in GTK+ dialogs
        | ResponseTypeYes
        -- ^ Returned by Yes buttons in GTK+ dialogs
        | ResponseTypeNo
        -- ^ Returned by No buttons in GTK+ dialogs
        | ResponseTypeApply
        -- ^ Returned by Apply buttons in GTK+ dialogs
        | ResponseTypeHelp
        -- ^ Returned by Help buttons in GTK+ dialogs
        | AnotherResponseType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ResponseType -> ShowS
    [ResponseType] -> ShowS
    ResponseType -> String
    (Int -> ResponseType -> ShowS)
    -> (ResponseType -> String)
    -> ([ResponseType] -> ShowS)
    -> Show ResponseType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ResponseType -> ShowS
    showsPrec :: Int -> ResponseType -> ShowS
    $cshow :: ResponseType -> String
    show :: ResponseType -> String
    $cshowList :: [ResponseType] -> ShowS
    showList :: [ResponseType] -> ShowS
    Show, ResponseType -> ResponseType -> Bool
    (ResponseType -> ResponseType -> Bool)
    -> (ResponseType -> ResponseType -> Bool) -> Eq ResponseType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ResponseType -> ResponseType -> Bool
    == :: ResponseType -> ResponseType -> Bool
    $c/= :: ResponseType -> ResponseType -> Bool
    /= :: ResponseType -> ResponseType -> Bool
    Eq)

    instance P.Enum ResponseType where
        fromEnum :: ResponseType -> Int
    fromEnum ResponseType
    ResponseTypeNone = Int
    -1
        fromEnum ResponseType
    ResponseTypeReject = Int
    -2
        fromEnum ResponseType
    ResponseTypeAccept = Int
    -3
        fromEnum ResponseType
    ResponseTypeDeleteEvent = Int
    -4
        fromEnum ResponseType
    ResponseTypeOk = Int
    -5
        fromEnum ResponseType
    ResponseTypeCancel = Int
    -6
        fromEnum ResponseType
    ResponseTypeClose = Int
    -7
        fromEnum ResponseType
    ResponseTypeYes = Int
    -8
        fromEnum ResponseType
    ResponseTypeNo = Int
    -9
        fromEnum ResponseType
    ResponseTypeApply = Int
    -10
        fromEnum ResponseType
    ResponseTypeHelp = Int
    -11
        fromEnum (AnotherResponseType Int
    k) = Int
    k

        toEnum :: Int -> ResponseType
    toEnum Int
    -1 = ResponseType
    ResponseTypeNone
        toEnum Int
    -2 = ResponseType
    ResponseTypeReject
        toEnum Int
    -3 = ResponseType
    ResponseTypeAccept
        toEnum Int
    -4 = ResponseType
    ResponseTypeDeleteEvent
        toEnum Int
    -5 = ResponseType
    ResponseTypeOk
        toEnum Int
    -6 = ResponseType
    ResponseTypeCancel
        toEnum Int
    -7 = ResponseType
    ResponseTypeClose
        toEnum Int
    -8 = ResponseType
    ResponseTypeYes
        toEnum Int
    -9 = ResponseType
    ResponseTypeNo
        toEnum Int
    -10 = ResponseType
    ResponseTypeApply
        toEnum Int
    -11 = ResponseType
    ResponseTypeHelp
        toEnum Int
    k = Int -> ResponseType
    AnotherResponseType Int
    k

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

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

    foreign import ccall "gtk_response_type_get_type" c_gtk_response_type_get_type ::
        IO GType

    instance B.Types.TypedObject ResponseType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_response_type_get_type

    instance B.Types.BoxedEnum ResponseType

    -- Enum ResizeMode
    -- | /No description available in the introspection data./
    data ResizeMode =
          ResizeModeParent
        -- ^ Pass resize request to the parent
        | ResizeModeQueue
        -- ^ Queue resizes on this widget
        | ResizeModeImmediate
        -- ^ Resize immediately. Deprecated.
        | AnotherResizeMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ResizeMode -> ShowS
    [ResizeMode] -> ShowS
    ResizeMode -> String
    (Int -> ResizeMode -> ShowS)
    -> (ResizeMode -> String)
    -> ([ResizeMode] -> ShowS)
    -> Show ResizeMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ResizeMode -> ShowS
    showsPrec :: Int -> ResizeMode -> ShowS
    $cshow :: ResizeMode -> String
    show :: ResizeMode -> String
    $cshowList :: [ResizeMode] -> ShowS
    showList :: [ResizeMode] -> ShowS
    Show, ResizeMode -> ResizeMode -> Bool
    (ResizeMode -> ResizeMode -> Bool)
    -> (ResizeMode -> ResizeMode -> Bool) -> Eq ResizeMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ResizeMode -> ResizeMode -> Bool
    == :: ResizeMode -> ResizeMode -> Bool
    $c/= :: ResizeMode -> ResizeMode -> Bool
    /= :: ResizeMode -> ResizeMode -> Bool
    Eq)

    instance P.Enum ResizeMode where
        fromEnum :: ResizeMode -> Int
    fromEnum ResizeMode
    ResizeModeParent = Int
    0
        fromEnum ResizeMode
    ResizeModeQueue = Int
    1
        fromEnum ResizeMode
    ResizeModeImmediate = Int
    2
        fromEnum (AnotherResizeMode Int
    k) = Int
    k

        toEnum :: Int -> ResizeMode
    toEnum Int
    0 = ResizeMode
    ResizeModeParent
        toEnum Int
    1 = ResizeMode
    ResizeModeQueue
        toEnum Int
    2 = ResizeMode
    ResizeModeImmediate
        toEnum Int
    k = Int -> ResizeMode
    AnotherResizeMode Int
    k

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

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

    foreign import ccall "gtk_resize_mode_get_type" c_gtk_resize_mode_get_type ::
        IO GType

    instance B.Types.TypedObject ResizeMode where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_resize_mode_get_type

    instance B.Types.BoxedEnum ResizeMode

    -- Enum ReliefStyle
    -- | Indicated the relief to be drawn around a t'GI.Gtk.Objects.Button.Button'.
    data ReliefStyle =
          ReliefStyleNormal
        -- ^ Draw a normal relief.
        | ReliefStyleHalf
        -- ^ A half relief. Deprecated in 3.14, does the same as /@gTKRELIEFNORMAL@/
        | ReliefStyleNone
        -- ^ No relief.
        | AnotherReliefStyle Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ReliefStyle -> ShowS
    [ReliefStyle] -> ShowS
    ReliefStyle -> String
    (Int -> ReliefStyle -> ShowS)
    -> (ReliefStyle -> String)
    -> ([ReliefStyle] -> ShowS)
    -> Show ReliefStyle
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ReliefStyle -> ShowS
    showsPrec :: Int -> ReliefStyle -> ShowS
    $cshow :: ReliefStyle -> String
    show :: ReliefStyle -> String
    $cshowList :: [ReliefStyle] -> ShowS
    showList :: [ReliefStyle] -> ShowS
    Show, ReliefStyle -> ReliefStyle -> Bool
    (ReliefStyle -> ReliefStyle -> Bool)
    -> (ReliefStyle -> ReliefStyle -> Bool) -> Eq ReliefStyle
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ReliefStyle -> ReliefStyle -> Bool
    == :: ReliefStyle -> ReliefStyle -> Bool
    $c/= :: ReliefStyle -> ReliefStyle -> Bool
    /= :: ReliefStyle -> ReliefStyle -> Bool
    Eq)

    instance P.Enum ReliefStyle where
        fromEnum :: ReliefStyle -> Int
    fromEnum ReliefStyle
    ReliefStyleNormal = Int
    0
        fromEnum ReliefStyle
    ReliefStyleHalf = Int
    1
        fromEnum ReliefStyle
    ReliefStyleNone = Int
    2
        fromEnum (AnotherReliefStyle Int
    k) = Int
    k

        toEnum :: Int -> ReliefStyle
    toEnum Int
    0 = ReliefStyle
    ReliefStyleNormal
        toEnum Int
    1 = ReliefStyle
    ReliefStyleHalf
        toEnum Int
    2 = ReliefStyle
    ReliefStyleNone
        toEnum Int
    k = Int -> ReliefStyle
    AnotherReliefStyle Int
    k

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

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

    foreign import ccall "gtk_relief_style_get_type" c_gtk_relief_style_get_type ::
        IO GType

    instance B.Types.TypedObject ReliefStyle where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_relief_style_get_type

    instance B.Types.BoxedEnum ReliefStyle

    -- Enum RecentSortType
    -- | Used to specify the sorting method to be applyed to the recently
    -- used resource list.
    --
    -- /Since: 2.10/
    data RecentSortType =
          RecentSortTypeNone
        -- ^ Do not sort the returned list of recently used
        --   resources.
        | RecentSortTypeMru
        -- ^ Sort the returned list with the most recently used
        --   items first.
        | RecentSortTypeLru
        -- ^ Sort the returned list with the least recently used
        --   items first.
        | RecentSortTypeCustom
        -- ^ Sort the returned list using a custom sorting
        --   function passed using 'GI.Gtk.Interfaces.RecentChooser.recentChooserSetSortFunc'.
        | AnotherRecentSortType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> RecentSortType -> ShowS
    [RecentSortType] -> ShowS
    RecentSortType -> String
    (Int -> RecentSortType -> ShowS)
    -> (RecentSortType -> String)
    -> ([RecentSortType] -> ShowS)
    -> Show RecentSortType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RecentSortType -> ShowS
    showsPrec :: Int -> RecentSortType -> ShowS
    $cshow :: RecentSortType -> String
    show :: RecentSortType -> String
    $cshowList :: [RecentSortType] -> ShowS
    showList :: [RecentSortType] -> ShowS
    Show, RecentSortType -> RecentSortType -> Bool
    (RecentSortType -> RecentSortType -> Bool)
    -> (RecentSortType -> RecentSortType -> Bool) -> Eq RecentSortType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RecentSortType -> RecentSortType -> Bool
    == :: RecentSortType -> RecentSortType -> Bool
    $c/= :: RecentSortType -> RecentSortType -> Bool
    /= :: RecentSortType -> RecentSortType -> Bool
    Eq)

    instance P.Enum RecentSortType where
        fromEnum :: RecentSortType -> Int
    fromEnum RecentSortType
    RecentSortTypeNone = Int
    0
        fromEnum RecentSortType
    RecentSortTypeMru = Int
    1
        fromEnum RecentSortType
    RecentSortTypeLru = Int
    2
        fromEnum RecentSortType
    RecentSortTypeCustom = Int
    3
        fromEnum (AnotherRecentSortType Int
    k) = Int
    k

        toEnum :: Int -> RecentSortType
    toEnum Int
    0 = RecentSortType
    RecentSortTypeNone
        toEnum Int
    1 = RecentSortType
    RecentSortTypeMru
        toEnum Int
    2 = RecentSortType
    RecentSortTypeLru
        toEnum Int
    3 = RecentSortType
    RecentSortTypeCustom
        toEnum Int
    k = Int -> RecentSortType
    AnotherRecentSortType Int
    k

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

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

    foreign import ccall "gtk_recent_sort_type_get_type" c_gtk_recent_sort_type_get_type ::
        IO GType

    instance B.Types.TypedObject RecentSortType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_recent_sort_type_get_type

    instance B.Types.BoxedEnum RecentSortType

    -- Enum RecentManagerError
    -- | Error codes for t'GI.Gtk.Objects.RecentManager.RecentManager' operations
    --
    -- /Since: 2.10/
    data RecentManagerError =
          RecentManagerErrorNotFound
        -- ^ the URI specified does not exists in
        --   the recently used resources list.
        | RecentManagerErrorInvalidUri
        -- ^ the URI specified is not valid.
        | RecentManagerErrorInvalidEncoding
        -- ^ the supplied string is not
        --   UTF-8 encoded.
        | RecentManagerErrorNotRegistered
        -- ^ no application has registered
        --   the specified item.
        | RecentManagerErrorRead
        -- ^ failure while reading the recently used
        --   resources file.
        | RecentManagerErrorWrite
        -- ^ failure while writing the recently used
        --   resources file.
        | RecentManagerErrorUnknown
        -- ^ unspecified error.
        | AnotherRecentManagerError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> RecentManagerError -> ShowS
    [RecentManagerError] -> ShowS
    RecentManagerError -> String
    (Int -> RecentManagerError -> ShowS)
    -> (RecentManagerError -> String)
    -> ([RecentManagerError] -> ShowS)
    -> Show RecentManagerError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RecentManagerError -> ShowS
    showsPrec :: Int -> RecentManagerError -> ShowS
    $cshow :: RecentManagerError -> String
    show :: RecentManagerError -> String
    $cshowList :: [RecentManagerError] -> ShowS
    showList :: [RecentManagerError] -> ShowS
    Show, RecentManagerError -> RecentManagerError -> Bool
    (RecentManagerError -> RecentManagerError -> Bool)
    -> (RecentManagerError -> RecentManagerError -> Bool)
    -> Eq RecentManagerError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RecentManagerError -> RecentManagerError -> Bool
    == :: RecentManagerError -> RecentManagerError -> Bool
    $c/= :: RecentManagerError -> RecentManagerError -> Bool
    /= :: RecentManagerError -> RecentManagerError -> Bool
    Eq)

    instance P.Enum RecentManagerError where
        fromEnum :: RecentManagerError -> Int
    fromEnum RecentManagerError
    RecentManagerErrorNotFound = Int
    0
        fromEnum RecentManagerError
    RecentManagerErrorInvalidUri = Int
    1
        fromEnum RecentManagerError
    RecentManagerErrorInvalidEncoding = Int
    2
        fromEnum RecentManagerError
    RecentManagerErrorNotRegistered = Int
    3
        fromEnum RecentManagerError
    RecentManagerErrorRead = Int
    4
        fromEnum RecentManagerError
    RecentManagerErrorWrite = Int
    5
        fromEnum RecentManagerError
    RecentManagerErrorUnknown = Int
    6
        fromEnum (AnotherRecentManagerError Int
    k) = Int
    k

        toEnum :: Int -> RecentManagerError
    toEnum Int
    0 = RecentManagerError
    RecentManagerErrorNotFound
        toEnum Int
    1 = RecentManagerError
    RecentManagerErrorInvalidUri
        toEnum Int
    2 = RecentManagerError
    RecentManagerErrorInvalidEncoding
        toEnum Int
    3 = RecentManagerError
    RecentManagerErrorNotRegistered
        toEnum Int
    4 = RecentManagerError
    RecentManagerErrorRead
        toEnum Int
    5 = RecentManagerError
    RecentManagerErrorWrite
        toEnum Int
    6 = RecentManagerError
    RecentManagerErrorUnknown
        toEnum Int
    k = Int -> RecentManagerError
    AnotherRecentManagerError Int
    k

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

    instance GErrorClass RecentManagerError where
        gerrorClassDomain :: RecentManagerError -> Text
    gerrorClassDomain RecentManagerError
    _ = Text
    "gtk-recent-manager-error-quark"

    -- | Catch exceptions of type `RecentManagerError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
    catchRecentManagerError ::
        IO a ->
        (RecentManagerError -> GErrorMessage -> IO a) ->
        IO a
    catchRecentManagerError :: forall a. IO a -> (RecentManagerError -> Text -> IO a) -> IO a
    catchRecentManagerError = IO a -> (RecentManagerError -> Text -> IO a) -> IO a
    forall err a.
    GErrorClass err =>
    IO a -> (err -> Text -> IO a) -> IO a
    catchGErrorJustDomain

    -- | Handle exceptions of type `RecentManagerError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
    handleRecentManagerError ::
        (RecentManagerError -> GErrorMessage -> IO a) ->
        IO a ->
        IO a
    handleRecentManagerError :: forall a. (RecentManagerError -> Text -> IO a) -> IO a -> IO a
    handleRecentManagerError = (RecentManagerError -> Text -> IO a) -> IO a -> IO a
    forall err a.
    GErrorClass err =>
    (err -> Text -> IO a) -> IO a -> IO a
    handleGErrorJustDomain

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

    foreign import ccall "gtk_recent_manager_error_get_type" c_gtk_recent_manager_error_get_type ::
        IO GType

    instance B.Types.TypedObject RecentManagerError where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_recent_manager_error_get_type

    instance B.Types.BoxedEnum RecentManagerError

    -- Enum RecentChooserError
    -- | These identify the various errors that can occur while calling
    -- t'GI.Gtk.Interfaces.RecentChooser.RecentChooser' functions.
    --
    -- /Since: 2.10/
    data RecentChooserError =
          RecentChooserErrorNotFound
        -- ^ Indicates that a file does not exist
        | RecentChooserErrorInvalidUri
        -- ^ Indicates a malformed URI
        | AnotherRecentChooserError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> RecentChooserError -> ShowS
    [RecentChooserError] -> ShowS
    RecentChooserError -> String
    (Int -> RecentChooserError -> ShowS)
    -> (RecentChooserError -> String)
    -> ([RecentChooserError] -> ShowS)
    -> Show RecentChooserError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RecentChooserError -> ShowS
    showsPrec :: Int -> RecentChooserError -> ShowS
    $cshow :: RecentChooserError -> String
    show :: RecentChooserError -> String
    $cshowList :: [RecentChooserError] -> ShowS
    showList :: [RecentChooserError] -> ShowS
    Show, RecentChooserError -> RecentChooserError -> Bool
    (RecentChooserError -> RecentChooserError -> Bool)
    -> (RecentChooserError -> RecentChooserError -> Bool)
    -> Eq RecentChooserError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RecentChooserError -> RecentChooserError -> Bool
    == :: RecentChooserError -> RecentChooserError -> Bool
    $c/= :: RecentChooserError -> RecentChooserError -> Bool
    /= :: RecentChooserError -> RecentChooserError -> Bool
    Eq)

    instance P.Enum RecentChooserError where
        fromEnum :: RecentChooserError -> Int
    fromEnum RecentChooserError
    RecentChooserErrorNotFound = Int
    0
        fromEnum RecentChooserError
    RecentChooserErrorInvalidUri = Int
    1
        fromEnum (AnotherRecentChooserError Int
    k) = Int
    k

        toEnum :: Int -> RecentChooserError
    toEnum Int
    0 = RecentChooserError
    RecentChooserErrorNotFound
        toEnum Int
    1 = RecentChooserError
    RecentChooserErrorInvalidUri
        toEnum Int
    k = Int -> RecentChooserError
    AnotherRecentChooserError Int
    k

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

    instance GErrorClass RecentChooserError where
        gerrorClassDomain :: RecentChooserError -> Text
    gerrorClassDomain RecentChooserError
    _ = Text
    "gtk-recent-chooser-error-quark"

    -- | Catch exceptions of type `RecentChooserError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
    catchRecentChooserError ::
        IO a ->
        (RecentChooserError -> GErrorMessage -> IO a) ->
        IO a
    catchRecentChooserError :: forall a. IO a -> (RecentChooserError -> Text -> IO a) -> IO a
    catchRecentChooserError = IO a -> (RecentChooserError -> Text -> IO a) -> IO a
    forall err a.
    GErrorClass err =>
    IO a -> (err -> Text -> IO a) -> IO a
    catchGErrorJustDomain

    -- | Handle exceptions of type `RecentChooserError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
    handleRecentChooserError ::
        (RecentChooserError -> GErrorMessage -> IO a) ->
        IO a ->
        IO a
    handleRecentChooserError :: forall a. (RecentChooserError -> Text -> IO a) -> IO a -> IO a
    handleRecentChooserError = (RecentChooserError -> Text -> IO a) -> IO a -> IO a
    forall err a.
    GErrorClass err =>
    (err -> Text -> IO a) -> IO a -> IO a
    handleGErrorJustDomain

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

    foreign import ccall "gtk_recent_chooser_error_get_type" c_gtk_recent_chooser_error_get_type ::
        IO GType

    instance B.Types.TypedObject RecentChooserError where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_recent_chooser_error_get_type

    instance B.Types.BoxedEnum RecentChooserError

    -- Enum RcTokenType
    {-# DEPRECATED RcTokenType ["(Since version 3.0)","Use t'GI.Gtk.Objects.CssProvider.CssProvider' instead."] #-}
    -- | The t'GI.Gtk.Enums.RcTokenType' enumeration represents the tokens
    -- in the RC file. It is exposed so that theme engines
    -- can reuse these tokens when parsing the theme-engine
    -- specific portions of a RC file.
    data RcTokenType =
          RcTokenTypeInvalid
        -- ^ Deprecated
        | RcTokenTypeInclude
        -- ^ Deprecated
        | RcTokenTypeNormal
        -- ^ Deprecated
        | RcTokenTypeActive
        -- ^ Deprecated
        | RcTokenTypePrelight
        -- ^ Deprecated
        | RcTokenTypeSelected
        -- ^ Deprecated
        | RcTokenTypeInsensitive
        -- ^ Deprecated
        | RcTokenTypeFg
        -- ^ Deprecated
        | RcTokenTypeBg
        -- ^ Deprecated
        | RcTokenTypeText
        -- ^ Deprecated
        | RcTokenTypeBase
        -- ^ Deprecated
        | RcTokenTypeXthickness
        -- ^ Deprecated
        | RcTokenTypeYthickness
        -- ^ Deprecated
        | RcTokenTypeFont
        -- ^ Deprecated
        | RcTokenTypeFontset
        -- ^ Deprecated
        | RcTokenTypeFontName
        -- ^ Deprecated
        | RcTokenTypeBgPixmap
        -- ^ Deprecated
        | RcTokenTypePixmapPath
        -- ^ Deprecated
        | RcTokenTypeStyle
        -- ^ Deprecated
        | RcTokenTypeBinding
        -- ^ Deprecated
        | RcTokenTypeBind
        -- ^ Deprecated
        | RcTokenTypeWidget
        -- ^ Deprecated
        | RcTokenTypeWidgetClass
        -- ^ Deprecated
        | RcTokenTypeClass
        -- ^ Deprecated
        | RcTokenTypeLowest
        -- ^ Deprecated
        | RcTokenTypeGtk
        -- ^ Deprecated
        | RcTokenTypeApplication
        -- ^ Deprecated
        | RcTokenTypeTheme
        -- ^ Deprecated
        | RcTokenTypeRc
        -- ^ Deprecated
        | RcTokenTypeHighest
        -- ^ Deprecated
        | RcTokenTypeEngine
        -- ^ Deprecated
        | RcTokenTypeModulePath
        -- ^ Deprecated
        | RcTokenTypeImModulePath
        -- ^ Deprecated
        | RcTokenTypeImModuleFile
        -- ^ Deprecated
        | RcTokenTypeStock
        -- ^ Deprecated
        | RcTokenTypeLtr
        -- ^ Deprecated
        | RcTokenTypeRtl
        -- ^ Deprecated
        | RcTokenTypeColor
        -- ^ Deprecated
        | RcTokenTypeUnbind
        -- ^ Deprecated
        | RcTokenTypeLast
        -- ^ Deprecated
        | AnotherRcTokenType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> RcTokenType -> ShowS
    [RcTokenType] -> ShowS
    RcTokenType -> String
    (Int -> RcTokenType -> ShowS)
    -> (RcTokenType -> String)
    -> ([RcTokenType] -> ShowS)
    -> Show RcTokenType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RcTokenType -> ShowS
    showsPrec :: Int -> RcTokenType -> ShowS
    $cshow :: RcTokenType -> String
    show :: RcTokenType -> String
    $cshowList :: [RcTokenType] -> ShowS
    showList :: [RcTokenType] -> ShowS
    Show, RcTokenType -> RcTokenType -> Bool
    (RcTokenType -> RcTokenType -> Bool)
    -> (RcTokenType -> RcTokenType -> Bool) -> Eq RcTokenType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RcTokenType -> RcTokenType -> Bool
    == :: RcTokenType -> RcTokenType -> Bool
    $c/= :: RcTokenType -> RcTokenType -> Bool
    /= :: RcTokenType -> RcTokenType -> Bool
    Eq)

    instance P.Enum RcTokenType where
        fromEnum :: RcTokenType -> Int
    fromEnum RcTokenType
    RcTokenTypeInvalid = Int
    270
        fromEnum RcTokenType
    RcTokenTypeInclude = Int
    271
        fromEnum RcTokenType
    RcTokenTypeNormal = Int
    272
        fromEnum RcTokenType
    RcTokenTypeActive = Int
    273
        fromEnum RcTokenType
    RcTokenTypePrelight = Int
    274
        fromEnum RcTokenType
    RcTokenTypeSelected = Int
    275
        fromEnum RcTokenType
    RcTokenTypeInsensitive = Int
    276
        fromEnum RcTokenType
    RcTokenTypeFg = Int
    277
        fromEnum RcTokenType
    RcTokenTypeBg = Int
    278
        fromEnum RcTokenType
    RcTokenTypeText = Int
    279
        fromEnum RcTokenType
    RcTokenTypeBase = Int
    280
        fromEnum RcTokenType
    RcTokenTypeXthickness = Int
    281
        fromEnum RcTokenType
    RcTokenTypeYthickness = Int
    282
        fromEnum RcTokenType
    RcTokenTypeFont = Int
    283
        fromEnum RcTokenType
    RcTokenTypeFontset = Int
    284
        fromEnum RcTokenType
    RcTokenTypeFontName = Int
    285
        fromEnum RcTokenType
    RcTokenTypeBgPixmap = Int
    286
        fromEnum RcTokenType
    RcTokenTypePixmapPath = Int
    287
        fromEnum RcTokenType
    RcTokenTypeStyle = Int
    288
        fromEnum RcTokenType
    RcTokenTypeBinding = Int
    289
        fromEnum RcTokenType
    RcTokenTypeBind = Int
    290
        fromEnum RcTokenType
    RcTokenTypeWidget = Int
    291
        fromEnum RcTokenType
    RcTokenTypeWidgetClass = Int
    292
        fromEnum RcTokenType
    RcTokenTypeClass = Int
    293
        fromEnum RcTokenType
    RcTokenTypeLowest = Int
    294
        fromEnum RcTokenType
    RcTokenTypeGtk = Int
    295
        fromEnum RcTokenType
    RcTokenTypeApplication = Int
    296
        fromEnum RcTokenType
    RcTokenTypeTheme = Int
    297
        fromEnum RcTokenType
    RcTokenTypeRc = Int
    298
        fromEnum RcTokenType
    RcTokenTypeHighest = Int
    299
        fromEnum RcTokenType
    RcTokenTypeEngine = Int
    300
        fromEnum RcTokenType
    RcTokenTypeModulePath = Int
    301
        fromEnum RcTokenType
    RcTokenTypeImModulePath = Int
    302
        fromEnum RcTokenType
    RcTokenTypeImModuleFile = Int
    303
        fromEnum RcTokenType
    RcTokenTypeStock = Int
    304
        fromEnum RcTokenType
    RcTokenTypeLtr = Int
    305
        fromEnum RcTokenType
    RcTokenTypeRtl = Int
    306
        fromEnum RcTokenType
    RcTokenTypeColor = Int
    307
        fromEnum RcTokenType
    RcTokenTypeUnbind = Int
    308
        fromEnum RcTokenType
    RcTokenTypeLast = Int
    309
        fromEnum (AnotherRcTokenType Int
    k) = Int
    k

        toEnum :: Int -> RcTokenType
    toEnum Int
    270 = RcTokenType
    RcTokenTypeInvalid
        toEnum Int
    271 = RcTokenType
    RcTokenTypeInclude
        toEnum Int
    272 = RcTokenType
    RcTokenTypeNormal
        toEnum Int
    273 = RcTokenType
    RcTokenTypeActive
        toEnum Int
    274 = RcTokenType
    RcTokenTypePrelight
        toEnum Int
    275 = RcTokenType
    RcTokenTypeSelected
        toEnum Int
    276 = RcTokenType
    RcTokenTypeInsensitive
        toEnum Int
    277 = RcTokenType
    RcTokenTypeFg
        toEnum Int
    278 = RcTokenType
    RcTokenTypeBg
        toEnum Int
    279 = RcTokenType
    RcTokenTypeText
        toEnum Int
    280 = RcTokenType
    RcTokenTypeBase
        toEnum Int
    281 = RcTokenType
    RcTokenTypeXthickness
        toEnum Int
    282 = RcTokenType
    RcTokenTypeYthickness
        toEnum Int
    283 = RcTokenType
    RcTokenTypeFont
        toEnum Int
    284 = RcTokenType
    RcTokenTypeFontset
        toEnum Int
    285 = RcTokenType
    RcTokenTypeFontName
        toEnum Int
    286 = RcTokenType
    RcTokenTypeBgPixmap
        toEnum Int
    287 = RcTokenType
    RcTokenTypePixmapPath
        toEnum Int
    288 = RcTokenType
    RcTokenTypeStyle
        toEnum Int
    289 = RcTokenType
    RcTokenTypeBinding
        toEnum Int
    290 = RcTokenType
    RcTokenTypeBind
        toEnum Int
    291 = RcTokenType
    RcTokenTypeWidget
        toEnum Int
    292 = RcTokenType
    RcTokenTypeWidgetClass
        toEnum Int
    293 = RcTokenType
    RcTokenTypeClass
        toEnum Int
    294 = RcTokenType
    RcTokenTypeLowest
        toEnum Int
    295 = RcTokenType
    RcTokenTypeGtk
        toEnum Int
    296 = RcTokenType
    RcTokenTypeApplication
        toEnum Int
    297 = RcTokenType
    RcTokenTypeTheme
        toEnum Int
    298 = RcTokenType
    RcTokenTypeRc
        toEnum Int
    299 = RcTokenType
    RcTokenTypeHighest
        toEnum Int
    300 = RcTokenType
    RcTokenTypeEngine
        toEnum Int
    301 = RcTokenType
    RcTokenTypeModulePath
        toEnum Int
    302 = RcTokenType
    RcTokenTypeImModulePath
        toEnum Int
    303 = RcTokenType
    RcTokenTypeImModuleFile
        toEnum Int
    304 = RcTokenType
    RcTokenTypeStock
        toEnum Int
    305 = RcTokenType
    RcTokenTypeLtr
        toEnum Int
    306 = RcTokenType
    RcTokenTypeRtl
        toEnum Int
    307 = RcTokenType
    RcTokenTypeColor
        toEnum Int
    308 = RcTokenType
    RcTokenTypeUnbind
        toEnum Int
    309 = RcTokenType
    RcTokenTypeLast
        toEnum Int
    k = Int -> RcTokenType
    AnotherRcTokenType Int
    k

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

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

    foreign import ccall "gtk_rc_token_type_get_type" c_gtk_rc_token_type_get_type ::
        IO GType

    instance B.Types.TypedObject RcTokenType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_rc_token_type_get_type

    instance B.Types.BoxedEnum RcTokenType

    -- Enum PropagationPhase
    -- | Describes the stage at which events are fed into a t'GI.Gtk.Objects.EventController.EventController'.
    --
    -- /Since: 3.14/
    data PropagationPhase =
          PropagationPhaseNone
        -- ^ Events are not delivered automatically. Those can be
        --   manually fed through 'GI.Gtk.Objects.EventController.eventControllerHandleEvent'. This should
        --   only be used when full control about when, or whether the controller
        --   handles the event is needed.
        | PropagationPhaseCapture
        -- ^ Events are delivered in the capture phase. The
        --   capture phase happens before the bubble phase, runs from the toplevel down
        --   to the event widget. This option should only be used on containers that
        --   might possibly handle events before their children do.
        | PropagationPhaseBubble
        -- ^ Events are delivered in the bubble phase. The bubble
        --   phase happens after the capture phase, and before the default handlers
        --   are run. This phase runs from the event widget, up to the toplevel.
        | PropagationPhaseTarget
        -- ^ Events are delivered in the default widget event handlers,
        --   note that widget implementations must chain up on button, motion, touch and
        --   grab broken handlers for controllers in this phase to be run.
        | AnotherPropagationPhase Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PropagationPhase -> ShowS
    [PropagationPhase] -> ShowS
    PropagationPhase -> String
    (Int -> PropagationPhase -> ShowS)
    -> (PropagationPhase -> String)
    -> ([PropagationPhase] -> ShowS)
    -> Show PropagationPhase
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PropagationPhase -> ShowS
    showsPrec :: Int -> PropagationPhase -> ShowS
    $cshow :: PropagationPhase -> String
    show :: PropagationPhase -> String
    $cshowList :: [PropagationPhase] -> ShowS
    showList :: [PropagationPhase] -> ShowS
    Show, PropagationPhase -> PropagationPhase -> Bool
    (PropagationPhase -> PropagationPhase -> Bool)
    -> (PropagationPhase -> PropagationPhase -> Bool)
    -> Eq PropagationPhase
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PropagationPhase -> PropagationPhase -> Bool
    == :: PropagationPhase -> PropagationPhase -> Bool
    $c/= :: PropagationPhase -> PropagationPhase -> Bool
    /= :: PropagationPhase -> PropagationPhase -> Bool
    Eq)

    instance P.Enum PropagationPhase where
        fromEnum :: PropagationPhase -> Int
    fromEnum PropagationPhase
    PropagationPhaseNone = Int
    0
        fromEnum PropagationPhase
    PropagationPhaseCapture = Int
    1
        fromEnum PropagationPhase
    PropagationPhaseBubble = Int
    2
        fromEnum PropagationPhase
    PropagationPhaseTarget = Int
    3
        fromEnum (AnotherPropagationPhase Int
    k) = Int
    k

        toEnum :: Int -> PropagationPhase
    toEnum Int
    0 = PropagationPhase
    PropagationPhaseNone
        toEnum Int
    1 = PropagationPhase
    PropagationPhaseCapture
        toEnum Int
    2 = PropagationPhase
    PropagationPhaseBubble
        toEnum Int
    3 = PropagationPhase
    PropagationPhaseTarget
        toEnum Int
    k = Int -> PropagationPhase
    AnotherPropagationPhase Int
    k

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

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

    foreign import ccall "gtk_propagation_phase_get_type" c_gtk_propagation_phase_get_type ::
        IO GType

    instance B.Types.TypedObject PropagationPhase where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_propagation_phase_get_type

    instance B.Types.BoxedEnum PropagationPhase

    -- Enum PrintStatus
    -- | The status gives a rough indication of the completion of a running
    -- print operation.
    data PrintStatus =
          PrintStatusInitial
        -- ^ The printing has not started yet; this
        --     status is set initially, and while the print dialog is shown.
        | PrintStatusPreparing
        -- ^ This status is set while the begin-print
        --     signal is emitted and during pagination.
        | PrintStatusGeneratingData
        -- ^ This status is set while the
        --     pages are being rendered.
        | PrintStatusSendingData
        -- ^ The print job is being sent off to the
        --     printer.
        | PrintStatusPending
        -- ^ The print job has been sent to the printer,
        --     but is not printed for some reason, e.g. the printer may be stopped.
        | PrintStatusPendingIssue
        -- ^ Some problem has occurred during
        --     printing, e.g. a paper jam.
        | PrintStatusPrinting
        -- ^ The printer is processing the print job.
        | PrintStatusFinished
        -- ^ The printing has been completed successfully.
        | PrintStatusFinishedAborted
        -- ^ The printing has been aborted.
        | AnotherPrintStatus Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PrintStatus -> ShowS
    [PrintStatus] -> ShowS
    PrintStatus -> String
    (Int -> PrintStatus -> ShowS)
    -> (PrintStatus -> String)
    -> ([PrintStatus] -> ShowS)
    -> Show PrintStatus
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PrintStatus -> ShowS
    showsPrec :: Int -> PrintStatus -> ShowS
    $cshow :: PrintStatus -> String
    show :: PrintStatus -> String
    $cshowList :: [PrintStatus] -> ShowS
    showList :: [PrintStatus] -> ShowS
    Show, PrintStatus -> PrintStatus -> Bool
    (PrintStatus -> PrintStatus -> Bool)
    -> (PrintStatus -> PrintStatus -> Bool) -> Eq PrintStatus
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PrintStatus -> PrintStatus -> Bool
    == :: PrintStatus -> PrintStatus -> Bool
    $c/= :: PrintStatus -> PrintStatus -> Bool
    /= :: PrintStatus -> PrintStatus -> Bool
    Eq)

    instance P.Enum PrintStatus where
        fromEnum :: PrintStatus -> Int
    fromEnum PrintStatus
    PrintStatusInitial = Int
    0
        fromEnum PrintStatus
    PrintStatusPreparing = Int
    1
        fromEnum PrintStatus
    PrintStatusGeneratingData = Int
    2
        fromEnum PrintStatus
    PrintStatusSendingData = Int
    3
        fromEnum PrintStatus
    PrintStatusPending = Int
    4
        fromEnum PrintStatus
    PrintStatusPendingIssue = Int
    5
        fromEnum PrintStatus
    PrintStatusPrinting = Int
    6
        fromEnum PrintStatus
    PrintStatusFinished = Int
    7
        fromEnum PrintStatus
    PrintStatusFinishedAborted = Int
    8
        fromEnum (AnotherPrintStatus Int
    k) = Int
    k

        toEnum :: Int -> PrintStatus
    toEnum Int
    0 = PrintStatus
    PrintStatusInitial
        toEnum Int
    1 = PrintStatus
    PrintStatusPreparing
        toEnum Int
    2 = PrintStatus
    PrintStatusGeneratingData
        toEnum Int
    3 = PrintStatus
    PrintStatusSendingData
        toEnum Int
    4 = PrintStatus
    PrintStatusPending
        toEnum Int
    5 = PrintStatus
    PrintStatusPendingIssue
        toEnum Int
    6 = PrintStatus
    PrintStatusPrinting
        toEnum Int
    7 = PrintStatus
    PrintStatusFinished
        toEnum Int
    8 = PrintStatus
    PrintStatusFinishedAborted
        toEnum Int
    k = Int -> PrintStatus
    AnotherPrintStatus Int
    k

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

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

    foreign import ccall "gtk_print_status_get_type" c_gtk_print_status_get_type ::
        IO GType

    instance B.Types.TypedObject PrintStatus where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_print_status_get_type

    instance B.Types.BoxedEnum PrintStatus

    -- Enum PrintQuality
    -- | See also 'GI.Gtk.Objects.PrintSettings.printSettingsSetQuality'.
    data PrintQuality =
          PrintQualityLow
        -- ^ Low quality.
        | PrintQualityNormal
        -- ^ Normal quality.
        | PrintQualityHigh
        -- ^ High quality.
        | PrintQualityDraft
        -- ^ Draft quality.
        | AnotherPrintQuality Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PrintQuality -> ShowS
    [PrintQuality] -> ShowS
    PrintQuality -> String
    (Int -> PrintQuality -> ShowS)
    -> (PrintQuality -> String)
    -> ([PrintQuality] -> ShowS)
    -> Show PrintQuality
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PrintQuality -> ShowS
    showsPrec :: Int -> PrintQuality -> ShowS
    $cshow :: PrintQuality -> String
    show :: PrintQuality -> String
    $cshowList :: [PrintQuality] -> ShowS
    showList :: [PrintQuality] -> ShowS
    Show, PrintQuality -> PrintQuality -> Bool
    (PrintQuality -> PrintQuality -> Bool)
    -> (PrintQuality -> PrintQuality -> Bool) -> Eq PrintQuality
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PrintQuality -> PrintQuality -> Bool
    == :: PrintQuality -> PrintQuality -> Bool
    $c/= :: PrintQuality -> PrintQuality -> Bool
    /= :: PrintQuality -> PrintQuality -> Bool
    Eq)

    instance P.Enum PrintQuality where
        fromEnum :: PrintQuality -> Int
    fromEnum PrintQuality
    PrintQualityLow = Int
    0
        fromEnum PrintQuality
    PrintQualityNormal = Int
    1
        fromEnum PrintQuality
    PrintQualityHigh = Int
    2
        fromEnum PrintQuality
    PrintQualityDraft = Int
    3
        fromEnum (AnotherPrintQuality Int
    k) = Int
    k

        toEnum :: Int -> PrintQuality
    toEnum Int
    0 = PrintQuality
    PrintQualityLow
        toEnum Int
    1 = PrintQuality
    PrintQualityNormal
        toEnum Int
    2 = PrintQuality
    PrintQualityHigh
        toEnum Int
    3 = PrintQuality
    PrintQualityDraft
        toEnum Int
    k = Int -> PrintQuality
    AnotherPrintQuality Int
    k

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

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

    foreign import ccall "gtk_print_quality_get_type" c_gtk_print_quality_get_type ::
        IO GType

    instance B.Types.TypedObject PrintQuality where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_print_quality_get_type

    instance B.Types.BoxedEnum PrintQuality

    -- Enum PrintPages
    -- | See also @/gtk_print_job_set_pages()/@
    data PrintPages =
          PrintPagesAll
        -- ^ All pages.
        | PrintPagesCurrent
        -- ^ Current page.
        | PrintPagesRanges
        -- ^ Range of pages.
        | PrintPagesSelection
        -- ^ Selected pages.
        | AnotherPrintPages Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PrintPages -> ShowS
    [PrintPages] -> ShowS
    PrintPages -> String
    (Int -> PrintPages -> ShowS)
    -> (PrintPages -> String)
    -> ([PrintPages] -> ShowS)
    -> Show PrintPages
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PrintPages -> ShowS
    showsPrec :: Int -> PrintPages -> ShowS
    $cshow :: PrintPages -> String
    show :: PrintPages -> String
    $cshowList :: [PrintPages] -> ShowS
    showList :: [PrintPages] -> ShowS
    Show, PrintPages -> PrintPages -> Bool
    (PrintPages -> PrintPages -> Bool)
    -> (PrintPages -> PrintPages -> Bool) -> Eq PrintPages
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PrintPages -> PrintPages -> Bool
    == :: PrintPages -> PrintPages -> Bool
    $c/= :: PrintPages -> PrintPages -> Bool
    /= :: PrintPages -> PrintPages -> Bool
    Eq)

    instance P.Enum PrintPages where
        fromEnum :: PrintPages -> Int
    fromEnum PrintPages
    PrintPagesAll = Int
    0
        fromEnum PrintPages
    PrintPagesCurrent = Int
    1
        fromEnum PrintPages
    PrintPagesRanges = Int
    2
        fromEnum PrintPages
    PrintPagesSelection = Int
    3
        fromEnum (AnotherPrintPages Int
    k) = Int
    k

        toEnum :: Int -> PrintPages
    toEnum Int
    0 = PrintPages
    PrintPagesAll
        toEnum Int
    1 = PrintPages
    PrintPagesCurrent
        toEnum Int
    2 = PrintPages
    PrintPagesRanges
        toEnum Int
    3 = PrintPages
    PrintPagesSelection
        toEnum Int
    k = Int -> PrintPages
    AnotherPrintPages Int
    k

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

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

    foreign import ccall "gtk_print_pages_get_type" c_gtk_print_pages_get_type ::
        IO GType

    instance B.Types.TypedObject PrintPages where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_print_pages_get_type

    instance B.Types.BoxedEnum PrintPages

    -- Enum PrintOperationResult
    -- | A value of this type is returned by 'GI.Gtk.Objects.PrintOperation.printOperationRun'.
    data PrintOperationResult =
          PrintOperationResultError
        -- ^ An error has occurred.
        | PrintOperationResultApply
        -- ^ The print settings should be stored.
        | PrintOperationResultCancel
        -- ^ The print operation has been canceled,
        --     the print settings should not be stored.
        | PrintOperationResultInProgress
        -- ^ The print operation is not complete
        --     yet. This value will only be returned when running asynchronously.
        | AnotherPrintOperationResult Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PrintOperationResult -> ShowS
    [PrintOperationResult] -> ShowS
    PrintOperationResult -> String
    (Int -> PrintOperationResult -> ShowS)
    -> (PrintOperationResult -> String)
    -> ([PrintOperationResult] -> ShowS)
    -> Show PrintOperationResult
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PrintOperationResult -> ShowS
    showsPrec :: Int -> PrintOperationResult -> ShowS
    $cshow :: PrintOperationResult -> String
    show :: PrintOperationResult -> String
    $cshowList :: [PrintOperationResult] -> ShowS
    showList :: [PrintOperationResult] -> ShowS
    Show, PrintOperationResult -> PrintOperationResult -> Bool
    (PrintOperationResult -> PrintOperationResult -> Bool)
    -> (PrintOperationResult -> PrintOperationResult -> Bool)
    -> Eq PrintOperationResult
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PrintOperationResult -> PrintOperationResult -> Bool
    == :: PrintOperationResult -> PrintOperationResult -> Bool
    $c/= :: PrintOperationResult -> PrintOperationResult -> Bool
    /= :: PrintOperationResult -> PrintOperationResult -> Bool
    Eq)

    instance P.Enum PrintOperationResult where
        fromEnum :: PrintOperationResult -> Int
    fromEnum PrintOperationResult
    PrintOperationResultError = Int
    0
        fromEnum PrintOperationResult
    PrintOperationResultApply = Int
    1
        fromEnum PrintOperationResult
    PrintOperationResultCancel = Int
    2
        fromEnum PrintOperationResult
    PrintOperationResultInProgress = Int
    3
        fromEnum (AnotherPrintOperationResult Int
    k) = Int
    k

        toEnum :: Int -> PrintOperationResult
    toEnum Int
    0 = PrintOperationResult
    PrintOperationResultError
        toEnum Int
    1 = PrintOperationResult
    PrintOperationResultApply
        toEnum Int
    2 = PrintOperationResult
    PrintOperationResultCancel
        toEnum Int
    3 = PrintOperationResult
    PrintOperationResultInProgress
        toEnum Int
    k = Int -> PrintOperationResult
    AnotherPrintOperationResult Int
    k

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

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

    foreign import ccall "gtk_print_operation_result_get_type" c_gtk_print_operation_result_get_type ::
        IO GType

    instance B.Types.TypedObject PrintOperationResult where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_print_operation_result_get_type

    instance B.Types.BoxedEnum PrintOperationResult

    -- Enum PrintOperationAction
    -- | The /@action@/ parameter to 'GI.Gtk.Objects.PrintOperation.printOperationRun'
    -- determines what action the print operation should perform.
    data PrintOperationAction =
          PrintOperationActionPrintDialog
        -- ^ Show the print dialog.
        | PrintOperationActionPrint
        -- ^ Start to print without showing
        --     the print dialog, based on the current print settings.
        | PrintOperationActionPreview
        -- ^ Show the print preview.
        | PrintOperationActionExport
        -- ^ Export to a file. This requires
        --     the export-filename property to be set.
        | AnotherPrintOperationAction Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PrintOperationAction -> ShowS
    [PrintOperationAction] -> ShowS
    PrintOperationAction -> String
    (Int -> PrintOperationAction -> ShowS)
    -> (PrintOperationAction -> String)
    -> ([PrintOperationAction] -> ShowS)
    -> Show PrintOperationAction
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PrintOperationAction -> ShowS
    showsPrec :: Int -> PrintOperationAction -> ShowS
    $cshow :: PrintOperationAction -> String
    show :: PrintOperationAction -> String
    $cshowList :: [PrintOperationAction] -> ShowS
    showList :: [PrintOperationAction] -> ShowS
    Show, PrintOperationAction -> PrintOperationAction -> Bool
    (PrintOperationAction -> PrintOperationAction -> Bool)
    -> (PrintOperationAction -> PrintOperationAction -> Bool)
    -> Eq PrintOperationAction
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PrintOperationAction -> PrintOperationAction -> Bool
    == :: PrintOperationAction -> PrintOperationAction -> Bool
    $c/= :: PrintOperationAction -> PrintOperationAction -> Bool
    /= :: PrintOperationAction -> PrintOperationAction -> Bool
    Eq)

    instance P.Enum PrintOperationAction where
        fromEnum :: PrintOperationAction -> Int
    fromEnum PrintOperationAction
    PrintOperationActionPrintDialog = Int
    0
        fromEnum PrintOperationAction
    PrintOperationActionPrint = Int
    1
        fromEnum PrintOperationAction
    PrintOperationActionPreview = Int
    2
        fromEnum PrintOperationAction
    PrintOperationActionExport = Int
    3
        fromEnum (AnotherPrintOperationAction Int
    k) = Int
    k

        toEnum :: Int -> PrintOperationAction
    toEnum Int
    0 = PrintOperationAction
    PrintOperationActionPrintDialog
        toEnum Int
    1 = PrintOperationAction
    PrintOperationActionPrint
        toEnum Int
    2 = PrintOperationAction
    PrintOperationActionPreview
        toEnum Int
    3 = PrintOperationAction
    PrintOperationActionExport
        toEnum Int
    k = Int -> PrintOperationAction
    AnotherPrintOperationAction Int
    k

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

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

    foreign import ccall "gtk_print_operation_action_get_type" c_gtk_print_operation_action_get_type ::
        IO GType

    instance B.Types.TypedObject PrintOperationAction where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_print_operation_action_get_type

    instance B.Types.BoxedEnum PrintOperationAction

    -- Enum PrintError
    -- | Error codes that identify various errors that can occur while
    -- using the GTK+ printing support.
    data PrintError =
          PrintErrorGeneral
        -- ^ An unspecified error occurred.
        | PrintErrorInternalError
        -- ^ An internal error occurred.
        | PrintErrorNomem
        -- ^ A memory allocation failed.
        | PrintErrorInvalidFile
        -- ^ An error occurred while loading a page setup
        --     or paper size from a key file.
        | AnotherPrintError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PrintError -> ShowS
    [PrintError] -> ShowS
    PrintError -> String
    (Int -> PrintError -> ShowS)
    -> (PrintError -> String)
    -> ([PrintError] -> ShowS)
    -> Show PrintError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PrintError -> ShowS
    showsPrec :: Int -> PrintError -> ShowS
    $cshow :: PrintError -> String
    show :: PrintError -> String
    $cshowList :: [PrintError] -> ShowS
    showList :: [PrintError] -> ShowS
    Show, PrintError -> PrintError -> Bool
    (PrintError -> PrintError -> Bool)
    -> (PrintError -> PrintError -> Bool) -> Eq PrintError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PrintError -> PrintError -> Bool
    == :: PrintError -> PrintError -> Bool
    $c/= :: PrintError -> PrintError -> Bool
    /= :: PrintError -> PrintError -> Bool
    Eq)

    instance P.Enum PrintError where
        fromEnum :: PrintError -> Int
    fromEnum PrintError
    PrintErrorGeneral = Int
    0
        fromEnum PrintError
    PrintErrorInternalError = Int
    1
        fromEnum PrintError
    PrintErrorNomem = Int
    2
        fromEnum PrintError
    PrintErrorInvalidFile = Int
    3
        fromEnum (AnotherPrintError Int
    k) = Int
    k

        toEnum :: Int -> PrintError
    toEnum Int
    0 = PrintError
    PrintErrorGeneral
        toEnum Int
    1 = PrintError
    PrintErrorInternalError
        toEnum Int
    2 = PrintError
    PrintErrorNomem
        toEnum Int
    3 = PrintError
    PrintErrorInvalidFile
        toEnum Int
    k = Int -> PrintError
    AnotherPrintError Int
    k

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

    instance GErrorClass PrintError where
        gerrorClassDomain :: PrintError -> Text
    gerrorClassDomain PrintError
    _ = Text
    "gtk-print-error-quark"

    -- | Catch exceptions of type `PrintError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
    catchPrintError ::
        IO a ->
        (PrintError -> GErrorMessage -> IO a) ->
        IO a
    catchPrintError :: forall a. IO a -> (PrintError -> Text -> IO a) -> IO a
    catchPrintError = IO a -> (PrintError -> Text -> IO a) -> IO a
    forall err a.
    GErrorClass err =>
    IO a -> (err -> Text -> IO a) -> IO a
    catchGErrorJustDomain

    -- | Handle exceptions of type `PrintError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
    handlePrintError ::
        (PrintError -> GErrorMessage -> IO a) ->
        IO a ->
        IO a
    handlePrintError :: forall a. (PrintError -> Text -> IO a) -> IO a -> IO a
    handlePrintError = (PrintError -> Text -> IO a) -> IO a -> IO a
    forall err a.
    GErrorClass err =>
    (err -> Text -> IO a) -> IO a -> IO a
    handleGErrorJustDomain

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

    foreign import ccall "gtk_print_error_get_type" c_gtk_print_error_get_type ::
        IO GType

    instance B.Types.TypedObject PrintError where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_print_error_get_type

    instance B.Types.BoxedEnum PrintError

    -- Enum PrintDuplex
    -- | See also 'GI.Gtk.Objects.PrintSettings.printSettingsSetDuplex'.
    data PrintDuplex =
          PrintDuplexSimplex
        -- ^ No duplex.
        | PrintDuplexHorizontal
        -- ^ Horizontal duplex.
        | PrintDuplexVertical
        -- ^ Vertical duplex.
        | AnotherPrintDuplex Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PrintDuplex -> ShowS
    [PrintDuplex] -> ShowS
    PrintDuplex -> String
    (Int -> PrintDuplex -> ShowS)
    -> (PrintDuplex -> String)
    -> ([PrintDuplex] -> ShowS)
    -> Show PrintDuplex
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PrintDuplex -> ShowS
    showsPrec :: Int -> PrintDuplex -> ShowS
    $cshow :: PrintDuplex -> String
    show :: PrintDuplex -> String
    $cshowList :: [PrintDuplex] -> ShowS
    showList :: [PrintDuplex] -> ShowS
    Show, PrintDuplex -> PrintDuplex -> Bool
    (PrintDuplex -> PrintDuplex -> Bool)
    -> (PrintDuplex -> PrintDuplex -> Bool) -> Eq PrintDuplex
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PrintDuplex -> PrintDuplex -> Bool
    == :: PrintDuplex -> PrintDuplex -> Bool
    $c/= :: PrintDuplex -> PrintDuplex -> Bool
    /= :: PrintDuplex -> PrintDuplex -> Bool
    Eq)

    instance P.Enum PrintDuplex where
        fromEnum :: PrintDuplex -> Int
    fromEnum PrintDuplex
    PrintDuplexSimplex = Int
    0
        fromEnum PrintDuplex
    PrintDuplexHorizontal = Int
    1
        fromEnum PrintDuplex
    PrintDuplexVertical = Int
    2
        fromEnum (AnotherPrintDuplex Int
    k) = Int
    k

        toEnum :: Int -> PrintDuplex
    toEnum Int
    0 = PrintDuplex
    PrintDuplexSimplex
        toEnum Int
    1 = PrintDuplex
    PrintDuplexHorizontal
        toEnum Int
    2 = PrintDuplex
    PrintDuplexVertical
        toEnum Int
    k = Int -> PrintDuplex
    AnotherPrintDuplex Int
    k

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

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

    foreign import ccall "gtk_print_duplex_get_type" c_gtk_print_duplex_get_type ::
        IO GType

    instance B.Types.TypedObject PrintDuplex where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_print_duplex_get_type

    instance B.Types.BoxedEnum PrintDuplex

    -- Enum PositionType
    -- | Describes which edge of a widget a certain feature is positioned at, e.g. the
    -- tabs of a t'GI.Gtk.Objects.Notebook.Notebook', the handle of a t'GI.Gtk.Objects.HandleBox.HandleBox' or the label of a
    -- t'GI.Gtk.Objects.Scale.Scale'.
    data PositionType =
          PositionTypeLeft
        -- ^ The feature is at the left edge.
        | PositionTypeRight
        -- ^ The feature is at the right edge.
        | PositionTypeTop
        -- ^ The feature is at the top edge.
        | PositionTypeBottom
        -- ^ The feature is at the bottom edge.
        | AnotherPositionType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PositionType -> ShowS
    [PositionType] -> ShowS
    PositionType -> String
    (Int -> PositionType -> ShowS)
    -> (PositionType -> String)
    -> ([PositionType] -> ShowS)
    -> Show PositionType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PositionType -> ShowS
    showsPrec :: Int -> PositionType -> ShowS
    $cshow :: PositionType -> String
    show :: PositionType -> String
    $cshowList :: [PositionType] -> ShowS
    showList :: [PositionType] -> ShowS
    Show, PositionType -> PositionType -> Bool
    (PositionType -> PositionType -> Bool)
    -> (PositionType -> PositionType -> Bool) -> Eq PositionType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PositionType -> PositionType -> Bool
    == :: PositionType -> PositionType -> Bool
    $c/= :: PositionType -> PositionType -> Bool
    /= :: PositionType -> PositionType -> Bool
    Eq)

    instance P.Enum PositionType where
        fromEnum :: PositionType -> Int
    fromEnum PositionType
    PositionTypeLeft = Int
    0
        fromEnum PositionType
    PositionTypeRight = Int
    1
        fromEnum PositionType
    PositionTypeTop = Int
    2
        fromEnum PositionType
    PositionTypeBottom = Int
    3
        fromEnum (AnotherPositionType Int
    k) = Int
    k

        toEnum :: Int -> PositionType
    toEnum Int
    0 = PositionType
    PositionTypeLeft
        toEnum Int
    1 = PositionType
    PositionTypeRight
        toEnum Int
    2 = PositionType
    PositionTypeTop
        toEnum Int
    3 = PositionType
    PositionTypeBottom
        toEnum Int
    k = Int -> PositionType
    AnotherPositionType Int
    k

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

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

    foreign import ccall "gtk_position_type_get_type" c_gtk_position_type_get_type ::
        IO GType

    instance B.Types.TypedObject PositionType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_position_type_get_type

    instance B.Types.BoxedEnum PositionType

    -- Enum PopoverConstraint
    -- | Describes constraints to positioning of popovers. More values
    -- may be added to this enumeration in the future.
    --
    -- /Since: 3.20/
    data PopoverConstraint =
          PopoverConstraintNone
        -- ^ Don\'t constrain the popover position
        --   beyond what is imposed by the implementation
        | PopoverConstraintWindow
        -- ^ Constrain the popover to the boundaries
        --   of the window that it is attached to
        | AnotherPopoverConstraint Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PopoverConstraint -> ShowS
    [PopoverConstraint] -> ShowS
    PopoverConstraint -> String
    (Int -> PopoverConstraint -> ShowS)
    -> (PopoverConstraint -> String)
    -> ([PopoverConstraint] -> ShowS)
    -> Show PopoverConstraint
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PopoverConstraint -> ShowS
    showsPrec :: Int -> PopoverConstraint -> ShowS
    $cshow :: PopoverConstraint -> String
    show :: PopoverConstraint -> String
    $cshowList :: [PopoverConstraint] -> ShowS
    showList :: [PopoverConstraint] -> ShowS
    Show, PopoverConstraint -> PopoverConstraint -> Bool
    (PopoverConstraint -> PopoverConstraint -> Bool)
    -> (PopoverConstraint -> PopoverConstraint -> Bool)
    -> Eq PopoverConstraint
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PopoverConstraint -> PopoverConstraint -> Bool
    == :: PopoverConstraint -> PopoverConstraint -> Bool
    $c/= :: PopoverConstraint -> PopoverConstraint -> Bool
    /= :: PopoverConstraint -> PopoverConstraint -> Bool
    Eq)

    instance P.Enum PopoverConstraint where
        fromEnum :: PopoverConstraint -> Int
    fromEnum PopoverConstraint
    PopoverConstraintNone = Int
    0
        fromEnum PopoverConstraint
    PopoverConstraintWindow = Int
    1
        fromEnum (AnotherPopoverConstraint Int
    k) = Int
    k

        toEnum :: Int -> PopoverConstraint
    toEnum Int
    0 = PopoverConstraint
    PopoverConstraintNone
        toEnum Int
    1 = PopoverConstraint
    PopoverConstraintWindow
        toEnum Int
    k = Int -> PopoverConstraint
    AnotherPopoverConstraint Int
    k

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

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

    foreign import ccall "gtk_popover_constraint_get_type" c_gtk_popover_constraint_get_type ::
        IO GType

    instance B.Types.TypedObject PopoverConstraint where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_popover_constraint_get_type

    instance B.Types.BoxedEnum PopoverConstraint

    -- Enum PolicyType
    -- | Determines how the size should be computed to achieve the one of the
    -- visibility mode for the scrollbars.
    data PolicyType =
          PolicyTypeAlways
        -- ^ The scrollbar is always visible. The view size is
        --  independent of the content.
        | PolicyTypeAutomatic
        -- ^ The scrollbar will appear and disappear as necessary.
        --  For example, when all of a t'GI.Gtk.Objects.TreeView.TreeView' can not be seen.
        | PolicyTypeNever
        -- ^ The scrollbar should never appear. In this mode the
        --  content determines the size.
        | PolicyTypeExternal
        -- ^ Don\'t show a scrollbar, but don\'t force the
        --  size to follow the content. This can be used e.g. to make multiple
        --  scrolled windows share a scrollbar. Since: 3.16
        | AnotherPolicyType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PolicyType -> ShowS
    [PolicyType] -> ShowS
    PolicyType -> String
    (Int -> PolicyType -> ShowS)
    -> (PolicyType -> String)
    -> ([PolicyType] -> ShowS)
    -> Show PolicyType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PolicyType -> ShowS
    showsPrec :: Int -> PolicyType -> ShowS
    $cshow :: PolicyType -> String
    show :: PolicyType -> String
    $cshowList :: [PolicyType] -> ShowS
    showList :: [PolicyType] -> ShowS
    Show, PolicyType -> PolicyType -> Bool
    (PolicyType -> PolicyType -> Bool)
    -> (PolicyType -> PolicyType -> Bool) -> Eq PolicyType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PolicyType -> PolicyType -> Bool
    == :: PolicyType -> PolicyType -> Bool
    $c/= :: PolicyType -> PolicyType -> Bool
    /= :: PolicyType -> PolicyType -> Bool
    Eq)

    instance P.Enum PolicyType where
        fromEnum :: PolicyType -> Int
    fromEnum PolicyType
    PolicyTypeAlways = Int
    0
        fromEnum PolicyType
    PolicyTypeAutomatic = Int
    1
        fromEnum PolicyType
    PolicyTypeNever = Int
    2
        fromEnum PolicyType
    PolicyTypeExternal = Int
    3
        fromEnum (AnotherPolicyType Int
    k) = Int
    k

        toEnum :: Int -> PolicyType
    toEnum Int
    0 = PolicyType
    PolicyTypeAlways
        toEnum Int
    1 = PolicyType
    PolicyTypeAutomatic
        toEnum Int
    2 = PolicyType
    PolicyTypeNever
        toEnum Int
    3 = PolicyType
    PolicyTypeExternal
        toEnum Int
    k = Int -> PolicyType
    AnotherPolicyType Int
    k

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

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

    foreign import ccall "gtk_policy_type_get_type" c_gtk_policy_type_get_type ::
        IO GType

    instance B.Types.TypedObject PolicyType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_policy_type_get_type

    instance B.Types.BoxedEnum PolicyType

    -- Enum PathType
    {-# DEPRECATED PathType ["(Since version 3.0)"] #-}
    -- | Widget path types.
    -- See also 'GI.Gtk.Structs.BindingSet.bindingSetAddPath'.
    data PathType =
          PathTypeWidget
        -- ^ Deprecated
        | PathTypeWidgetClass
        -- ^ Deprecated
        | PathTypeClass
        -- ^ Deprecated
        | AnotherPathType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PathType -> ShowS
    [PathType] -> ShowS
    PathType -> String
    (Int -> PathType -> ShowS)
    -> (PathType -> String) -> ([PathType] -> ShowS) -> Show PathType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PathType -> ShowS
    showsPrec :: Int -> PathType -> ShowS
    $cshow :: PathType -> String
    show :: PathType -> String
    $cshowList :: [PathType] -> ShowS
    showList :: [PathType] -> ShowS
    Show, PathType -> PathType -> Bool
    (PathType -> PathType -> Bool)
    -> (PathType -> PathType -> Bool) -> Eq PathType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PathType -> PathType -> Bool
    == :: PathType -> PathType -> Bool
    $c/= :: PathType -> PathType -> Bool
    /= :: PathType -> PathType -> Bool
    Eq)

    instance P.Enum PathType where
        fromEnum :: PathType -> Int
    fromEnum PathType
    PathTypeWidget = Int
    0
        fromEnum PathType
    PathTypeWidgetClass = Int
    1
        fromEnum PathType
    PathTypeClass = Int
    2
        fromEnum (AnotherPathType Int
    k) = Int
    k

        toEnum :: Int -> PathType
    toEnum Int
    0 = PathType
    PathTypeWidget
        toEnum Int
    1 = PathType
    PathTypeWidgetClass
        toEnum Int
    2 = PathType
    PathTypeClass
        toEnum Int
    k = Int -> PathType
    AnotherPathType Int
    k

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

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

    foreign import ccall "gtk_path_type_get_type" c_gtk_path_type_get_type ::
        IO GType

    instance B.Types.TypedObject PathType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_path_type_get_type

    instance B.Types.BoxedEnum PathType

    -- Enum PathPriorityType
    {-# DEPRECATED PathPriorityType ["(Since version 3.0)"] #-}
    -- | Priorities for path lookups.
    -- See also 'GI.Gtk.Structs.BindingSet.bindingSetAddPath'.
    data PathPriorityType =
          PathPriorityTypeLowest
        -- ^ Deprecated
        | PathPriorityTypeGtk
        -- ^ Deprecated
        | PathPriorityTypeApplication
        -- ^ Deprecated
        | PathPriorityTypeTheme
        -- ^ Deprecated
        | PathPriorityTypeRc
        -- ^ Deprecated
        | PathPriorityTypeHighest
        -- ^ Deprecated
        | AnotherPathPriorityType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PathPriorityType -> ShowS
    [PathPriorityType] -> ShowS
    PathPriorityType -> String
    (Int -> PathPriorityType -> ShowS)
    -> (PathPriorityType -> String)
    -> ([PathPriorityType] -> ShowS)
    -> Show PathPriorityType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PathPriorityType -> ShowS
    showsPrec :: Int -> PathPriorityType -> ShowS
    $cshow :: PathPriorityType -> String
    show :: PathPriorityType -> String
    $cshowList :: [PathPriorityType] -> ShowS
    showList :: [PathPriorityType] -> ShowS
    Show, PathPriorityType -> PathPriorityType -> Bool
    (PathPriorityType -> PathPriorityType -> Bool)
    -> (PathPriorityType -> PathPriorityType -> Bool)
    -> Eq PathPriorityType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PathPriorityType -> PathPriorityType -> Bool
    == :: PathPriorityType -> PathPriorityType -> Bool
    $c/= :: PathPriorityType -> PathPriorityType -> Bool
    /= :: PathPriorityType -> PathPriorityType -> Bool
    Eq)

    instance P.Enum PathPriorityType where
        fromEnum :: PathPriorityType -> Int
    fromEnum PathPriorityType
    PathPriorityTypeLowest = Int
    0
        fromEnum PathPriorityType
    PathPriorityTypeGtk = Int
    4
        fromEnum PathPriorityType
    PathPriorityTypeApplication = Int
    8
        fromEnum PathPriorityType
    PathPriorityTypeTheme = Int
    10
        fromEnum PathPriorityType
    PathPriorityTypeRc = Int
    12
        fromEnum PathPriorityType
    PathPriorityTypeHighest = Int
    15
        fromEnum (AnotherPathPriorityType Int
    k) = Int
    k

        toEnum :: Int -> PathPriorityType
    toEnum Int
    0 = PathPriorityType
    PathPriorityTypeLowest
        toEnum Int
    4 = PathPriorityType
    PathPriorityTypeGtk
        toEnum Int
    8 = PathPriorityType
    PathPriorityTypeApplication
        toEnum Int
    10 = PathPriorityType
    PathPriorityTypeTheme
        toEnum Int
    12 = PathPriorityType
    PathPriorityTypeRc
        toEnum Int
    15 = PathPriorityType
    PathPriorityTypeHighest
        toEnum Int
    k = Int -> PathPriorityType
    AnotherPathPriorityType Int
    k

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

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

    foreign import ccall "gtk_path_priority_type_get_type" c_gtk_path_priority_type_get_type ::
        IO GType

    instance B.Types.TypedObject PathPriorityType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_path_priority_type_get_type

    instance B.Types.BoxedEnum PathPriorityType

    -- Enum PanDirection
    -- | Describes the panning direction of a t'GI.Gtk.Objects.GesturePan.GesturePan'
    --
    -- /Since: 3.14/
    data PanDirection =
          PanDirectionLeft
        -- ^ panned towards the left
        | PanDirectionRight
        -- ^ panned towards the right
        | PanDirectionUp
        -- ^ panned upwards
        | PanDirectionDown
        -- ^ panned downwards
        | AnotherPanDirection Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PanDirection -> ShowS
    [PanDirection] -> ShowS
    PanDirection -> String
    (Int -> PanDirection -> ShowS)
    -> (PanDirection -> String)
    -> ([PanDirection] -> ShowS)
    -> Show PanDirection
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PanDirection -> ShowS
    showsPrec :: Int -> PanDirection -> ShowS
    $cshow :: PanDirection -> String
    show :: PanDirection -> String
    $cshowList :: [PanDirection] -> ShowS
    showList :: [PanDirection] -> ShowS
    Show, PanDirection -> PanDirection -> Bool
    (PanDirection -> PanDirection -> Bool)
    -> (PanDirection -> PanDirection -> Bool) -> Eq PanDirection
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PanDirection -> PanDirection -> Bool
    == :: PanDirection -> PanDirection -> Bool
    $c/= :: PanDirection -> PanDirection -> Bool
    /= :: PanDirection -> PanDirection -> Bool
    Eq)

    instance P.Enum PanDirection where
        fromEnum :: PanDirection -> Int
    fromEnum PanDirection
    PanDirectionLeft = Int
    0
        fromEnum PanDirection
    PanDirectionRight = Int
    1
        fromEnum PanDirection
    PanDirectionUp = Int
    2
        fromEnum PanDirection
    PanDirectionDown = Int
    3
        fromEnum (AnotherPanDirection Int
    k) = Int
    k

        toEnum :: Int -> PanDirection
    toEnum Int
    0 = PanDirection
    PanDirectionLeft
        toEnum Int
    1 = PanDirection
    PanDirectionRight
        toEnum Int
    2 = PanDirection
    PanDirectionUp
        toEnum Int
    3 = PanDirection
    PanDirectionDown
        toEnum Int
    k = Int -> PanDirection
    AnotherPanDirection Int
    k

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

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

    foreign import ccall "gtk_pan_direction_get_type" c_gtk_pan_direction_get_type ::
        IO GType

    instance B.Types.TypedObject PanDirection where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_pan_direction_get_type

    instance B.Types.BoxedEnum PanDirection

    -- Enum PageSet
    -- | See also @/gtk_print_job_set_page_set()/@.
    data PageSet =
          PageSetAll
        -- ^ All pages.
        | PageSetEven
        -- ^ Even pages.
        | PageSetOdd
        -- ^ Odd pages.
        | AnotherPageSet Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PageSet -> ShowS
    [PageSet] -> ShowS
    PageSet -> String
    (Int -> PageSet -> ShowS)
    -> (PageSet -> String) -> ([PageSet] -> ShowS) -> Show PageSet
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PageSet -> ShowS
    showsPrec :: Int -> PageSet -> ShowS
    $cshow :: PageSet -> String
    show :: PageSet -> String
    $cshowList :: [PageSet] -> ShowS
    showList :: [PageSet] -> ShowS
    Show, PageSet -> PageSet -> Bool
    (PageSet -> PageSet -> Bool)
    -> (PageSet -> PageSet -> Bool) -> Eq PageSet
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PageSet -> PageSet -> Bool
    == :: PageSet -> PageSet -> Bool
    $c/= :: PageSet -> PageSet -> Bool
    /= :: PageSet -> PageSet -> Bool
    Eq)

    instance P.Enum PageSet where
        fromEnum :: PageSet -> Int
    fromEnum PageSet
    PageSetAll = Int
    0
        fromEnum PageSet
    PageSetEven = Int
    1
        fromEnum PageSet
    PageSetOdd = Int
    2
        fromEnum (AnotherPageSet Int
    k) = Int
    k

        toEnum :: Int -> PageSet
    toEnum Int
    0 = PageSet
    PageSetAll
        toEnum Int
    1 = PageSet
    PageSetEven
        toEnum Int
    2 = PageSet
    PageSetOdd
        toEnum Int
    k = Int -> PageSet
    AnotherPageSet Int
    k

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

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

    foreign import ccall "gtk_page_set_get_type" c_gtk_page_set_get_type ::
        IO GType

    instance B.Types.TypedObject PageSet where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_page_set_get_type

    instance B.Types.BoxedEnum PageSet

    -- Enum PageOrientation
    -- | See also 'GI.Gtk.Objects.PrintSettings.printSettingsSetOrientation'.
    data PageOrientation =
          PageOrientationPortrait
        -- ^ Portrait mode.
        | PageOrientationLandscape
        -- ^ Landscape mode.
        | PageOrientationReversePortrait
        -- ^ Reverse portrait mode.
        | PageOrientationReverseLandscape
        -- ^ Reverse landscape mode.
        | AnotherPageOrientation Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PageOrientation -> ShowS
    [PageOrientation] -> ShowS
    PageOrientation -> String
    (Int -> PageOrientation -> ShowS)
    -> (PageOrientation -> String)
    -> ([PageOrientation] -> ShowS)
    -> Show PageOrientation
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PageOrientation -> ShowS
    showsPrec :: Int -> PageOrientation -> ShowS
    $cshow :: PageOrientation -> String
    show :: PageOrientation -> String
    $cshowList :: [PageOrientation] -> ShowS
    showList :: [PageOrientation] -> ShowS
    Show, PageOrientation -> PageOrientation -> Bool
    (PageOrientation -> PageOrientation -> Bool)
    -> (PageOrientation -> PageOrientation -> Bool)
    -> Eq PageOrientation
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PageOrientation -> PageOrientation -> Bool
    == :: PageOrientation -> PageOrientation -> Bool
    $c/= :: PageOrientation -> PageOrientation -> Bool
    /= :: PageOrientation -> PageOrientation -> Bool
    Eq)

    instance P.Enum PageOrientation where
        fromEnum :: PageOrientation -> Int
    fromEnum PageOrientation
    PageOrientationPortrait = Int
    0
        fromEnum PageOrientation
    PageOrientationLandscape = Int
    1
        fromEnum PageOrientation
    PageOrientationReversePortrait = Int
    2
        fromEnum PageOrientation
    PageOrientationReverseLandscape = Int
    3
        fromEnum (AnotherPageOrientation Int
    k) = Int
    k

        toEnum :: Int -> PageOrientation
    toEnum Int
    0 = PageOrientation
    PageOrientationPortrait
        toEnum Int
    1 = PageOrientation
    PageOrientationLandscape
        toEnum Int
    2 = PageOrientation
    PageOrientationReversePortrait
        toEnum Int
    3 = PageOrientation
    PageOrientationReverseLandscape
        toEnum Int
    k = Int -> PageOrientation
    AnotherPageOrientation Int
    k

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

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

    foreign import ccall "gtk_page_orientation_get_type" c_gtk_page_orientation_get_type ::
        IO GType

    instance B.Types.TypedObject PageOrientation where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_page_orientation_get_type

    instance B.Types.BoxedEnum PageOrientation

    -- Enum PadActionType
    -- | The type of a pad action.
    data PadActionType =
          PadActionTypeButton
        -- ^ Action is triggered by a pad button
        | PadActionTypeRing
        -- ^ Action is triggered by a pad ring
        | PadActionTypeStrip
        -- ^ Action is triggered by a pad strip
        | AnotherPadActionType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PadActionType -> ShowS
    [PadActionType] -> ShowS
    PadActionType -> String
    (Int -> PadActionType -> ShowS)
    -> (PadActionType -> String)
    -> ([PadActionType] -> ShowS)
    -> Show PadActionType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PadActionType -> ShowS
    showsPrec :: Int -> PadActionType -> ShowS
    $cshow :: PadActionType -> String
    show :: PadActionType -> String
    $cshowList :: [PadActionType] -> ShowS
    showList :: [PadActionType] -> ShowS
    Show, PadActionType -> PadActionType -> Bool
    (PadActionType -> PadActionType -> Bool)
    -> (PadActionType -> PadActionType -> Bool) -> Eq PadActionType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PadActionType -> PadActionType -> Bool
    == :: PadActionType -> PadActionType -> Bool
    $c/= :: PadActionType -> PadActionType -> Bool
    /= :: PadActionType -> PadActionType -> Bool
    Eq)

    instance P.Enum PadActionType where
        fromEnum :: PadActionType -> Int
    fromEnum PadActionType
    PadActionTypeButton = Int
    0
        fromEnum PadActionType
    PadActionTypeRing = Int
    1
        fromEnum PadActionType
    PadActionTypeStrip = Int
    2
        fromEnum (AnotherPadActionType Int
    k) = Int
    k

        toEnum :: Int -> PadActionType
    toEnum Int
    0 = PadActionType
    PadActionTypeButton
        toEnum Int
    1 = PadActionType
    PadActionTypeRing
        toEnum Int
    2 = PadActionType
    PadActionTypeStrip
        toEnum Int
    k = Int -> PadActionType
    AnotherPadActionType Int
    k

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

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

    foreign import ccall "gtk_pad_action_type_get_type" c_gtk_pad_action_type_get_type ::
        IO GType

    instance B.Types.TypedObject PadActionType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_pad_action_type_get_type

    instance B.Types.BoxedEnum PadActionType

    -- Enum PackType
    -- | Represents the packing location t'GI.Gtk.Objects.Box.Box' children. (See: t'GI.Gtk.Objects.VBox.VBox',
    -- t'GI.Gtk.Objects.HBox.HBox', and t'GI.Gtk.Objects.ButtonBox.ButtonBox').
    data PackType =
          PackTypeStart
        -- ^ The child is packed into the start of the box
        | PackTypeEnd
        -- ^ The child is packed into the end of the box
        | AnotherPackType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PackType -> ShowS
    [PackType] -> ShowS
    PackType -> String
    (Int -> PackType -> ShowS)
    -> (PackType -> String) -> ([PackType] -> ShowS) -> Show PackType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PackType -> ShowS
    showsPrec :: Int -> PackType -> ShowS
    $cshow :: PackType -> String
    show :: PackType -> String
    $cshowList :: [PackType] -> ShowS
    showList :: [PackType] -> ShowS
    Show, PackType -> PackType -> Bool
    (PackType -> PackType -> Bool)
    -> (PackType -> PackType -> Bool) -> Eq PackType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PackType -> PackType -> Bool
    == :: PackType -> PackType -> Bool
    $c/= :: PackType -> PackType -> Bool
    /= :: PackType -> PackType -> Bool
    Eq)

    instance P.Enum PackType where
        fromEnum :: PackType -> Int
    fromEnum PackType
    PackTypeStart = Int
    0
        fromEnum PackType
    PackTypeEnd = Int
    1
        fromEnum (AnotherPackType Int
    k) = Int
    k

        toEnum :: Int -> PackType
    toEnum Int
    0 = PackType
    PackTypeStart
        toEnum Int
    1 = PackType
    PackTypeEnd
        toEnum Int
    k = Int -> PackType
    AnotherPackType Int
    k

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

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

    foreign import ccall "gtk_pack_type_get_type" c_gtk_pack_type_get_type ::
        IO GType

    instance B.Types.TypedObject PackType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_pack_type_get_type

    instance B.Types.BoxedEnum PackType

    -- Enum PackDirection
    -- | Determines how widgets should be packed inside menubars
    -- and menuitems contained in menubars.
    data PackDirection =
          PackDirectionLtr
        -- ^ Widgets are packed left-to-right
        | PackDirectionRtl
        -- ^ Widgets are packed right-to-left
        | PackDirectionTtb
        -- ^ Widgets are packed top-to-bottom
        | PackDirectionBtt
        -- ^ Widgets are packed bottom-to-top
        | AnotherPackDirection Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PackDirection -> ShowS
    [PackDirection] -> ShowS
    PackDirection -> String
    (Int -> PackDirection -> ShowS)
    -> (PackDirection -> String)
    -> ([PackDirection] -> ShowS)
    -> Show PackDirection
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PackDirection -> ShowS
    showsPrec :: Int -> PackDirection -> ShowS
    $cshow :: PackDirection -> String
    show :: PackDirection -> String
    $cshowList :: [PackDirection] -> ShowS
    showList :: [PackDirection] -> ShowS
    Show, PackDirection -> PackDirection -> Bool
    (PackDirection -> PackDirection -> Bool)
    -> (PackDirection -> PackDirection -> Bool) -> Eq PackDirection
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PackDirection -> PackDirection -> Bool
    == :: PackDirection -> PackDirection -> Bool
    $c/= :: PackDirection -> PackDirection -> Bool
    /= :: PackDirection -> PackDirection -> Bool
    Eq)

    instance P.Enum PackDirection where
        fromEnum :: PackDirection -> Int
    fromEnum PackDirection
    PackDirectionLtr = Int
    0
        fromEnum PackDirection
    PackDirectionRtl = Int
    1
        fromEnum PackDirection
    PackDirectionTtb = Int
    2
        fromEnum PackDirection
    PackDirectionBtt = Int
    3
        fromEnum (AnotherPackDirection Int
    k) = Int
    k

        toEnum :: Int -> PackDirection
    toEnum Int
    0 = PackDirection
    PackDirectionLtr
        toEnum Int
    1 = PackDirection
    PackDirectionRtl
        toEnum Int
    2 = PackDirection
    PackDirectionTtb
        toEnum Int
    3 = PackDirection
    PackDirectionBtt
        toEnum Int
    k = Int -> PackDirection
    AnotherPackDirection Int
    k

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

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

    foreign import ccall "gtk_pack_direction_get_type" c_gtk_pack_direction_get_type ::
        IO GType

    instance B.Types.TypedObject PackDirection where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_pack_direction_get_type

    instance B.Types.BoxedEnum PackDirection

    -- Enum Orientation
    -- | Represents the orientation of widgets and other objects which can be switched
    -- between horizontal and vertical orientation on the fly, like t'GI.Gtk.Objects.Toolbar.Toolbar' or
    -- t'GI.Gtk.Objects.GesturePan.GesturePan'.
    data Orientation =
          OrientationHorizontal
        -- ^ The element is in horizontal orientation.
        | OrientationVertical
        -- ^ The element is in vertical orientation.
        | AnotherOrientation Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Orientation -> ShowS
    [Orientation] -> ShowS
    Orientation -> String
    (Int -> Orientation -> ShowS)
    -> (Orientation -> String)
    -> ([Orientation] -> ShowS)
    -> Show Orientation
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Orientation -> ShowS
    showsPrec :: Int -> Orientation -> ShowS
    $cshow :: Orientation -> String
    show :: Orientation -> String
    $cshowList :: [Orientation] -> ShowS
    showList :: [Orientation] -> ShowS
    Show, Orientation -> Orientation -> Bool
    (Orientation -> Orientation -> Bool)
    -> (Orientation -> Orientation -> Bool) -> Eq Orientation
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Orientation -> Orientation -> Bool
    == :: Orientation -> Orientation -> Bool
    $c/= :: Orientation -> Orientation -> Bool
    /= :: Orientation -> Orientation -> Bool
    Eq)

    instance P.Enum Orientation where
        fromEnum :: Orientation -> Int
    fromEnum Orientation
    OrientationHorizontal = Int
    0
        fromEnum Orientation
    OrientationVertical = Int
    1
        fromEnum (AnotherOrientation Int
    k) = Int
    k

        toEnum :: Int -> Orientation
    toEnum Int
    0 = Orientation
    OrientationHorizontal
        toEnum Int
    1 = Orientation
    OrientationVertical
        toEnum Int
    k = Int -> Orientation
    AnotherOrientation Int
    k

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

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

    foreign import ccall "gtk_orientation_get_type" c_gtk_orientation_get_type ::
        IO GType

    instance B.Types.TypedObject Orientation where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_orientation_get_type

    instance B.Types.BoxedEnum Orientation

    -- Enum NumberUpLayout
    -- | Used to determine the layout of pages on a sheet when printing
    -- multiple pages per sheet.
    data NumberUpLayout =
          NumberUpLayoutLrtb
        -- ^ <<https://developer.gnome.org/gtk3/stable/layout-lrtb.png>>
        | NumberUpLayoutLrbt
        -- ^ <<https://developer.gnome.org/gtk3/stable/layout-lrbt.png>>
        | NumberUpLayoutRltb
        -- ^ <<https://developer.gnome.org/gtk3/stable/layout-rltb.png>>
        | NumberUpLayoutRlbt
        -- ^ <<https://developer.gnome.org/gtk3/stable/layout-rlbt.png>>
        | NumberUpLayoutTblr
        -- ^ <<https://developer.gnome.org/gtk3/stable/layout-tblr.png>>
        | NumberUpLayoutTbrl
        -- ^ <<https://developer.gnome.org/gtk3/stable/layout-tbrl.png>>
        | NumberUpLayoutBtlr
        -- ^ <<https://developer.gnome.org/gtk3/stable/layout-btlr.png>>
        | NumberUpLayoutBtrl
        -- ^ <<https://developer.gnome.org/gtk3/stable/layout-btrl.png>>
        | AnotherNumberUpLayout Int
        -- ^ Catch-all for unknown values
        deriving (Int -> NumberUpLayout -> ShowS
    [NumberUpLayout] -> ShowS
    NumberUpLayout -> String
    (Int -> NumberUpLayout -> ShowS)
    -> (NumberUpLayout -> String)
    -> ([NumberUpLayout] -> ShowS)
    -> Show NumberUpLayout
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> NumberUpLayout -> ShowS
    showsPrec :: Int -> NumberUpLayout -> ShowS
    $cshow :: NumberUpLayout -> String
    show :: NumberUpLayout -> String
    $cshowList :: [NumberUpLayout] -> ShowS
    showList :: [NumberUpLayout] -> ShowS
    Show, NumberUpLayout -> NumberUpLayout -> Bool
    (NumberUpLayout -> NumberUpLayout -> Bool)
    -> (NumberUpLayout -> NumberUpLayout -> Bool) -> Eq NumberUpLayout
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: NumberUpLayout -> NumberUpLayout -> Bool
    == :: NumberUpLayout -> NumberUpLayout -> Bool
    $c/= :: NumberUpLayout -> NumberUpLayout -> Bool
    /= :: NumberUpLayout -> NumberUpLayout -> Bool
    Eq)

    instance P.Enum NumberUpLayout where
        fromEnum :: NumberUpLayout -> Int
    fromEnum NumberUpLayout
    NumberUpLayoutLrtb = Int
    0
        fromEnum NumberUpLayout
    NumberUpLayoutLrbt = Int
    1
        fromEnum NumberUpLayout
    NumberUpLayoutRltb = Int
    2
        fromEnum NumberUpLayout
    NumberUpLayoutRlbt = Int
    3
        fromEnum NumberUpLayout
    NumberUpLayoutTblr = Int
    4
        fromEnum NumberUpLayout
    NumberUpLayoutTbrl = Int
    5
        fromEnum NumberUpLayout
    NumberUpLayoutBtlr = Int
    6
        fromEnum NumberUpLayout
    NumberUpLayoutBtrl = Int
    7
        fromEnum (AnotherNumberUpLayout Int
    k) = Int
    k

        toEnum :: Int -> NumberUpLayout
    toEnum Int
    0 = NumberUpLayout
    NumberUpLayoutLrtb
        toEnum Int
    1 = NumberUpLayout
    NumberUpLayoutLrbt
        toEnum Int
    2 = NumberUpLayout
    NumberUpLayoutRltb
        toEnum Int
    3 = NumberUpLayout
    NumberUpLayoutRlbt
        toEnum Int
    4 = NumberUpLayout
    NumberUpLayoutTblr
        toEnum Int
    5 = NumberUpLayout
    NumberUpLayoutTbrl
        toEnum Int
    6 = NumberUpLayout
    NumberUpLayoutBtlr
        toEnum Int
    7 = NumberUpLayout
    NumberUpLayoutBtrl
        toEnum Int
    k = Int -> NumberUpLayout
    AnotherNumberUpLayout Int
    k

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

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

    foreign import ccall "gtk_number_up_layout_get_type" c_gtk_number_up_layout_get_type ::
        IO GType

    instance B.Types.TypedObject NumberUpLayout where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_number_up_layout_get_type

    instance B.Types.BoxedEnum NumberUpLayout

    -- Enum NotebookTab
    -- | /No description available in the introspection data./
    data NotebookTab =
          NotebookTabFirst
        -- ^ /No description available in the introspection data./
        | NotebookTabLast
        -- ^ /No description available in the introspection data./
        | AnotherNotebookTab Int
        -- ^ Catch-all for unknown values
        deriving (Int -> NotebookTab -> ShowS
    [NotebookTab] -> ShowS
    NotebookTab -> String
    (Int -> NotebookTab -> ShowS)
    -> (NotebookTab -> String)
    -> ([NotebookTab] -> ShowS)
    -> Show NotebookTab
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> NotebookTab -> ShowS
    showsPrec :: Int -> NotebookTab -> ShowS
    $cshow :: NotebookTab -> String
    show :: NotebookTab -> String
    $cshowList :: [NotebookTab] -> ShowS
    showList :: [NotebookTab] -> ShowS
    Show, NotebookTab -> NotebookTab -> Bool
    (NotebookTab -> NotebookTab -> Bool)
    -> (NotebookTab -> NotebookTab -> Bool) -> Eq NotebookTab
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: NotebookTab -> NotebookTab -> Bool
    == :: NotebookTab -> NotebookTab -> Bool
    $c/= :: NotebookTab -> NotebookTab -> Bool
    /= :: NotebookTab -> NotebookTab -> Bool
    Eq)

    instance P.Enum NotebookTab where
        fromEnum :: NotebookTab -> Int
    fromEnum NotebookTab
    NotebookTabFirst = Int
    0
        fromEnum NotebookTab
    NotebookTabLast = Int
    1
        fromEnum (AnotherNotebookTab Int
    k) = Int
    k

        toEnum :: Int -> NotebookTab
    toEnum Int
    0 = NotebookTab
    NotebookTabFirst
        toEnum Int
    1 = NotebookTab
    NotebookTabLast
        toEnum Int
    k = Int -> NotebookTab
    AnotherNotebookTab Int
    k

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

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

    foreign import ccall "gtk_notebook_tab_get_type" c_gtk_notebook_tab_get_type ::
        IO GType

    instance B.Types.TypedObject NotebookTab where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_notebook_tab_get_type

    instance B.Types.BoxedEnum NotebookTab

    -- Enum MovementStep
    -- | /No description available in the introspection data./
    data MovementStep =
          MovementStepLogicalPositions
        -- ^ Move forward or back by graphemes
        | MovementStepVisualPositions
        -- ^ Move left or right by graphemes
        | MovementStepWords
        -- ^ Move forward or back by words
        | MovementStepDisplayLines
        -- ^ Move up or down lines (wrapped lines)
        | MovementStepDisplayLineEnds
        -- ^ Move to either end of a line
        | MovementStepParagraphs
        -- ^ Move up or down paragraphs (newline-ended lines)
        | MovementStepParagraphEnds
        -- ^ Move to either end of a paragraph
        | MovementStepPages
        -- ^ Move by pages
        | MovementStepBufferEnds
        -- ^ Move to ends of the buffer
        | MovementStepHorizontalPages
        -- ^ Move horizontally by pages
        | AnotherMovementStep Int
        -- ^ Catch-all for unknown values
        deriving (Int -> MovementStep -> ShowS
    [MovementStep] -> ShowS
    MovementStep -> String
    (Int -> MovementStep -> ShowS)
    -> (MovementStep -> String)
    -> ([MovementStep] -> ShowS)
    -> Show MovementStep
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MovementStep -> ShowS
    showsPrec :: Int -> MovementStep -> ShowS
    $cshow :: MovementStep -> String
    show :: MovementStep -> String
    $cshowList :: [MovementStep] -> ShowS
    showList :: [MovementStep] -> ShowS
    Show, MovementStep -> MovementStep -> Bool
    (MovementStep -> MovementStep -> Bool)
    -> (MovementStep -> MovementStep -> Bool) -> Eq MovementStep
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MovementStep -> MovementStep -> Bool
    == :: MovementStep -> MovementStep -> Bool
    $c/= :: MovementStep -> MovementStep -> Bool
    /= :: MovementStep -> MovementStep -> Bool
    Eq)

    instance P.Enum MovementStep where
        fromEnum :: MovementStep -> Int
    fromEnum MovementStep
    MovementStepLogicalPositions = Int
    0
        fromEnum MovementStep
    MovementStepVisualPositions = Int
    1
        fromEnum MovementStep
    MovementStepWords = Int
    2
        fromEnum MovementStep
    MovementStepDisplayLines = Int
    3
        fromEnum MovementStep
    MovementStepDisplayLineEnds = Int
    4
        fromEnum MovementStep
    MovementStepParagraphs = Int
    5
        fromEnum MovementStep
    MovementStepParagraphEnds = Int
    6
        fromEnum MovementStep
    MovementStepPages = Int
    7
        fromEnum MovementStep
    MovementStepBufferEnds = Int
    8
        fromEnum MovementStep
    MovementStepHorizontalPages = Int
    9
        fromEnum (AnotherMovementStep Int
    k) = Int
    k

        toEnum :: Int -> MovementStep
    toEnum Int
    0 = MovementStep
    MovementStepLogicalPositions
        toEnum Int
    1 = MovementStep
    MovementStepVisualPositions
        toEnum Int
    2 = MovementStep
    MovementStepWords
        toEnum Int
    3 = MovementStep
    MovementStepDisplayLines
        toEnum Int
    4 = MovementStep
    MovementStepDisplayLineEnds
        toEnum Int
    5 = MovementStep
    MovementStepParagraphs
        toEnum Int
    6 = MovementStep
    MovementStepParagraphEnds
        toEnum Int
    7 = MovementStep
    MovementStepPages
        toEnum Int
    8 = MovementStep
    MovementStepBufferEnds
        toEnum Int
    9 = MovementStep
    MovementStepHorizontalPages
        toEnum Int
    k = Int -> MovementStep
    AnotherMovementStep Int
    k

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

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

    foreign import ccall "gtk_movement_step_get_type" c_gtk_movement_step_get_type ::
        IO GType

    instance B.Types.TypedObject MovementStep where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_movement_step_get_type

    instance B.Types.BoxedEnum MovementStep

    -- Enum MessageType
    -- | The type of message being displayed in the dialog.
    data MessageType =
          MessageTypeInfo
        -- ^ Informational message
        | MessageTypeWarning
        -- ^ Non-fatal warning message
        | MessageTypeQuestion
        -- ^ Question requiring a choice
        | MessageTypeError
        -- ^ Fatal error message
        | MessageTypeOther
        -- ^ None of the above
        | AnotherMessageType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> MessageType -> ShowS
    [MessageType] -> ShowS
    MessageType -> String
    (Int -> MessageType -> ShowS)
    -> (MessageType -> String)
    -> ([MessageType] -> ShowS)
    -> Show MessageType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MessageType -> ShowS
    showsPrec :: Int -> MessageType -> ShowS
    $cshow :: MessageType -> String
    show :: MessageType -> String
    $cshowList :: [MessageType] -> ShowS
    showList :: [MessageType] -> ShowS
    Show, MessageType -> MessageType -> Bool
    (MessageType -> MessageType -> Bool)
    -> (MessageType -> MessageType -> Bool) -> Eq MessageType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MessageType -> MessageType -> Bool
    == :: MessageType -> MessageType -> Bool
    $c/= :: MessageType -> MessageType -> Bool
    /= :: MessageType -> MessageType -> Bool
    Eq)

    instance P.Enum MessageType where
        fromEnum :: MessageType -> Int
    fromEnum MessageType
    MessageTypeInfo = Int
    0
        fromEnum MessageType
    MessageTypeWarning = Int
    1
        fromEnum MessageType
    MessageTypeQuestion = Int
    2
        fromEnum MessageType
    MessageTypeError = Int
    3
        fromEnum MessageType
    MessageTypeOther = Int
    4
        fromEnum (AnotherMessageType Int
    k) = Int
    k

        toEnum :: Int -> MessageType
    toEnum Int
    0 = MessageType
    MessageTypeInfo
        toEnum Int
    1 = MessageType
    MessageTypeWarning
        toEnum Int
    2 = MessageType
    MessageTypeQuestion
        toEnum Int
    3 = MessageType
    MessageTypeError
        toEnum Int
    4 = MessageType
    MessageTypeOther
        toEnum Int
    k = Int -> MessageType
    AnotherMessageType Int
    k

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

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

    foreign import ccall "gtk_message_type_get_type" c_gtk_message_type_get_type ::
        IO GType

    instance B.Types.TypedObject MessageType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_message_type_get_type

    instance B.Types.BoxedEnum MessageType

    -- Enum MenuDirectionType
    -- | An enumeration representing directional movements within a menu.
    data MenuDirectionType =
          MenuDirectionTypeParent
        -- ^ To the parent menu shell
        | MenuDirectionTypeChild
        -- ^ To the submenu, if any, associated with the item
        | MenuDirectionTypeNext
        -- ^ To the next menu item
        | MenuDirectionTypePrev
        -- ^ To the previous menu item
        | AnotherMenuDirectionType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> MenuDirectionType -> ShowS
    [MenuDirectionType] -> ShowS
    MenuDirectionType -> String
    (Int -> MenuDirectionType -> ShowS)
    -> (MenuDirectionType -> String)
    -> ([MenuDirectionType] -> ShowS)
    -> Show MenuDirectionType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MenuDirectionType -> ShowS
    showsPrec :: Int -> MenuDirectionType -> ShowS
    $cshow :: MenuDirectionType -> String
    show :: MenuDirectionType -> String
    $cshowList :: [MenuDirectionType] -> ShowS
    showList :: [MenuDirectionType] -> ShowS
    Show, MenuDirectionType -> MenuDirectionType -> Bool
    (MenuDirectionType -> MenuDirectionType -> Bool)
    -> (MenuDirectionType -> MenuDirectionType -> Bool)
    -> Eq MenuDirectionType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MenuDirectionType -> MenuDirectionType -> Bool
    == :: MenuDirectionType -> MenuDirectionType -> Bool
    $c/= :: MenuDirectionType -> MenuDirectionType -> Bool
    /= :: MenuDirectionType -> MenuDirectionType -> Bool
    Eq)

    instance P.Enum MenuDirectionType where
        fromEnum :: MenuDirectionType -> Int
    fromEnum MenuDirectionType
    MenuDirectionTypeParent = Int
    0
        fromEnum MenuDirectionType
    MenuDirectionTypeChild = Int
    1
        fromEnum MenuDirectionType
    MenuDirectionTypeNext = Int
    2
        fromEnum MenuDirectionType
    MenuDirectionTypePrev = Int
    3
        fromEnum (AnotherMenuDirectionType Int
    k) = Int
    k

        toEnum :: Int -> MenuDirectionType
    toEnum Int
    0 = MenuDirectionType
    MenuDirectionTypeParent
        toEnum Int
    1 = MenuDirectionType
    MenuDirectionTypeChild
        toEnum Int
    2 = MenuDirectionType
    MenuDirectionTypeNext
        toEnum Int
    3 = MenuDirectionType
    MenuDirectionTypePrev
        toEnum Int
    k = Int -> MenuDirectionType
    AnotherMenuDirectionType Int
    k

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

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

    foreign import ccall "gtk_menu_direction_type_get_type" c_gtk_menu_direction_type_get_type ::
        IO GType

    instance B.Types.TypedObject MenuDirectionType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_menu_direction_type_get_type

    instance B.Types.BoxedEnum MenuDirectionType

    -- Enum License
    -- | The type of license for an application.
    --
    -- This enumeration can be expanded at later date.
    --
    -- /Since: 3.0/
    data License =
          LicenseUnknown
        -- ^ No license specified
        | LicenseCustom
        -- ^ A license text is going to be specified by the
        --   developer
        | LicenseGpl20
        -- ^ The GNU General Public License, version 2.0 or later
        | LicenseGpl30
        -- ^ The GNU General Public License, version 3.0 or later
        | LicenseLgpl21
        -- ^ The GNU Lesser General Public License, version 2.1 or later
        | LicenseLgpl30
        -- ^ The GNU Lesser General Public License, version 3.0 or later
        | LicenseBsd
        -- ^ The BSD standard license
        | LicenseMitX11
        -- ^ The MIT\/X11 standard license
        | LicenseArtistic
        -- ^ The Artistic License, version 2.0
        | LicenseGpl20Only
        -- ^ The GNU General Public License, version 2.0 only. Since 3.12.
        | LicenseGpl30Only
        -- ^ The GNU General Public License, version 3.0 only. Since 3.12.
        | LicenseLgpl21Only
        -- ^ The GNU Lesser General Public License, version 2.1 only. Since 3.12.
        | LicenseLgpl30Only
        -- ^ The GNU Lesser General Public License, version 3.0 only. Since 3.12.
        | LicenseAgpl30
        -- ^ The GNU Affero General Public License, version 3.0 or later. Since: 3.22.
        | LicenseAgpl30Only
        -- ^ The GNU Affero General Public License, version 3.0 only. Since: 3.22.27.
        | LicenseBsd3
        -- ^ The 3-clause BSD licence. Since: 3.24.20.
        | LicenseApache20
        -- ^ The Apache License, version 2.0. Since: 3.24.20.
        | LicenseMpl20
        -- ^ The Mozilla Public License, version 2.0. Since: 3.24.20.
        | AnotherLicense Int
        -- ^ Catch-all for unknown values
        deriving (Int -> License -> ShowS
    [License] -> ShowS
    License -> String
    (Int -> License -> ShowS)
    -> (License -> String) -> ([License] -> ShowS) -> Show License
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> License -> ShowS
    showsPrec :: Int -> License -> ShowS
    $cshow :: License -> String
    show :: License -> String
    $cshowList :: [License] -> ShowS
    showList :: [License] -> ShowS
    Show, License -> License -> Bool
    (License -> License -> Bool)
    -> (License -> License -> Bool) -> Eq License
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: License -> License -> Bool
    == :: License -> License -> Bool
    $c/= :: License -> License -> Bool
    /= :: License -> License -> Bool
    Eq)

    instance P.Enum License where
        fromEnum :: License -> Int
    fromEnum License
    LicenseUnknown = Int
    0
        fromEnum License
    LicenseCustom = Int
    1
        fromEnum License
    LicenseGpl20 = Int
    2
        fromEnum License
    LicenseGpl30 = Int
    3
        fromEnum License
    LicenseLgpl21 = Int
    4
        fromEnum License
    LicenseLgpl30 = Int
    5
        fromEnum License
    LicenseBsd = Int
    6
        fromEnum License
    LicenseMitX11 = Int
    7
        fromEnum License
    LicenseArtistic = Int
    8
        fromEnum License
    LicenseGpl20Only = Int
    9
        fromEnum License
    LicenseGpl30Only = Int
    10
        fromEnum License
    LicenseLgpl21Only = Int
    11
        fromEnum License
    LicenseLgpl30Only = Int
    12
        fromEnum License
    LicenseAgpl30 = Int
    13
        fromEnum License
    LicenseAgpl30Only = Int
    14
        fromEnum License
    LicenseBsd3 = Int
    15
        fromEnum License
    LicenseApache20 = Int
    16
        fromEnum License
    LicenseMpl20 = Int
    17
        fromEnum (AnotherLicense Int
    k) = Int
    k

        toEnum :: Int -> License
    toEnum Int
    0 = License
    LicenseUnknown
        toEnum Int
    1 = License
    LicenseCustom
        toEnum Int
    2 = License
    LicenseGpl20
        toEnum Int
    3 = License
    LicenseGpl30
        toEnum Int
    4 = License
    LicenseLgpl21
        toEnum Int
    5 = License
    LicenseLgpl30
        toEnum Int
    6 = License
    LicenseBsd
        toEnum Int
    7 = License
    LicenseMitX11
        toEnum Int
    8 = License
    LicenseArtistic
        toEnum Int
    9 = License
    LicenseGpl20Only
        toEnum Int
    10 = License
    LicenseGpl30Only
        toEnum Int
    11 = License
    LicenseLgpl21Only
        toEnum Int
    12 = License
    LicenseLgpl30Only
        toEnum Int
    13 = License
    LicenseAgpl30
        toEnum Int
    14 = License
    LicenseAgpl30Only
        toEnum Int
    15 = License
    LicenseBsd3
        toEnum Int
    16 = License
    LicenseApache20
        toEnum Int
    17 = License
    LicenseMpl20
        toEnum Int
    k = Int -> License
    AnotherLicense Int
    k

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

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

    foreign import ccall "gtk_license_get_type" c_gtk_license_get_type ::
        IO GType

    instance B.Types.TypedObject License where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_license_get_type

    instance B.Types.BoxedEnum License

    -- Enum LevelBarMode
    -- | Describes how t'GI.Gtk.Objects.LevelBar.LevelBar' contents should be rendered.
    -- Note that this enumeration could be extended with additional modes
    -- in the future.
    --
    -- /Since: 3.6/
    data LevelBarMode =
          LevelBarModeContinuous
        -- ^ the bar has a continuous mode
        | LevelBarModeDiscrete
        -- ^ the bar has a discrete mode
        | AnotherLevelBarMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> LevelBarMode -> ShowS
    [LevelBarMode] -> ShowS
    LevelBarMode -> String
    (Int -> LevelBarMode -> ShowS)
    -> (LevelBarMode -> String)
    -> ([LevelBarMode] -> ShowS)
    -> Show LevelBarMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> LevelBarMode -> ShowS
    showsPrec :: Int -> LevelBarMode -> ShowS
    $cshow :: LevelBarMode -> String
    show :: LevelBarMode -> String
    $cshowList :: [LevelBarMode] -> ShowS
    showList :: [LevelBarMode] -> ShowS
    Show, LevelBarMode -> LevelBarMode -> Bool
    (LevelBarMode -> LevelBarMode -> Bool)
    -> (LevelBarMode -> LevelBarMode -> Bool) -> Eq LevelBarMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: LevelBarMode -> LevelBarMode -> Bool
    == :: LevelBarMode -> LevelBarMode -> Bool
    $c/= :: LevelBarMode -> LevelBarMode -> Bool
    /= :: LevelBarMode -> LevelBarMode -> Bool
    Eq)

    instance P.Enum LevelBarMode where
        fromEnum :: LevelBarMode -> Int
    fromEnum LevelBarMode
    LevelBarModeContinuous = Int
    0
        fromEnum LevelBarMode
    LevelBarModeDiscrete = Int
    1
        fromEnum (AnotherLevelBarMode Int
    k) = Int
    k

        toEnum :: Int -> LevelBarMode
    toEnum Int
    0 = LevelBarMode
    LevelBarModeContinuous
        toEnum Int
    1 = LevelBarMode
    LevelBarModeDiscrete
        toEnum Int
    k = Int -> LevelBarMode
    AnotherLevelBarMode Int
    k

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

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

    foreign import ccall "gtk_level_bar_mode_get_type" c_gtk_level_bar_mode_get_type ::
        IO GType

    instance B.Types.TypedObject LevelBarMode where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_level_bar_mode_get_type

    instance B.Types.BoxedEnum LevelBarMode

    -- Enum Justification
    -- | Used for justifying the text inside a t'GI.Gtk.Objects.Label.Label' widget. (See also
    -- t'GI.Gtk.Objects.Alignment.Alignment').
    data Justification =
          JustificationLeft
        -- ^ The text is placed at the left edge of the label.
        | JustificationRight
        -- ^ The text is placed at the right edge of the label.
        | JustificationCenter
        -- ^ The text is placed in the center of the label.
        | JustificationFill
        -- ^ The text is placed is distributed across the label.
        | AnotherJustification Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Justification -> ShowS
    [Justification] -> ShowS
    Justification -> String
    (Int -> Justification -> ShowS)
    -> (Justification -> String)
    -> ([Justification] -> ShowS)
    -> Show Justification
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Justification -> ShowS
    showsPrec :: Int -> Justification -> ShowS
    $cshow :: Justification -> String
    show :: Justification -> String
    $cshowList :: [Justification] -> ShowS
    showList :: [Justification] -> ShowS
    Show, Justification -> Justification -> Bool
    (Justification -> Justification -> Bool)
    -> (Justification -> Justification -> Bool) -> Eq Justification
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Justification -> Justification -> Bool
    == :: Justification -> Justification -> Bool
    $c/= :: Justification -> Justification -> Bool
    /= :: Justification -> Justification -> Bool
    Eq)

    instance P.Enum Justification where
        fromEnum :: Justification -> Int
    fromEnum Justification
    JustificationLeft = Int
    0
        fromEnum Justification
    JustificationRight = Int
    1
        fromEnum Justification
    JustificationCenter = Int
    2
        fromEnum Justification
    JustificationFill = Int
    3
        fromEnum (AnotherJustification Int
    k) = Int
    k

        toEnum :: Int -> Justification
    toEnum Int
    0 = Justification
    JustificationLeft
        toEnum Int
    1 = Justification
    JustificationRight
        toEnum Int
    2 = Justification
    JustificationCenter
        toEnum Int
    3 = Justification
    JustificationFill
        toEnum Int
    k = Int -> Justification
    AnotherJustification Int
    k

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

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

    foreign import ccall "gtk_justification_get_type" c_gtk_justification_get_type ::
        IO GType

    instance B.Types.TypedObject Justification where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_justification_get_type

    instance B.Types.BoxedEnum Justification

    -- Enum InputPurpose
    -- | Describes primary purpose of the input widget. This information is
    -- useful for on-screen keyboards and similar input methods to decide
    -- which keys should be presented to the user.
    --
    -- Note that the purpose is not meant to impose a totally strict rule
    -- about allowed characters, and does not replace input validation.
    -- It is fine for an on-screen keyboard to let the user override the
    -- character set restriction that is expressed by the purpose. The
    -- application is expected to validate the entry contents, even if
    -- it specified a purpose.
    --
    -- The difference between /@gTKINPUTPURPOSEDIGITS@/ and
    -- /@gTKINPUTPURPOSENUMBER@/ is that the former accepts only digits
    -- while the latter also some punctuation (like commas or points, plus,
    -- minus) and “e” or “E” as in 3.14E+000.
    --
    -- This enumeration may be extended in the future; input methods should
    -- interpret unknown values as “free form”.
    --
    -- /Since: 3.6/
    data InputPurpose =
          InputPurposeFreeForm
        -- ^ Allow any character
        | InputPurposeAlpha
        -- ^ Allow only alphabetic characters
        | InputPurposeDigits
        -- ^ Allow only digits
        | InputPurposeNumber
        -- ^ Edited field expects numbers
        | InputPurposePhone
        -- ^ Edited field expects phone number
        | InputPurposeUrl
        -- ^ Edited field expects URL
        | InputPurposeEmail
        -- ^ Edited field expects email address
        | InputPurposeName
        -- ^ Edited field expects the name of a person
        | InputPurposePassword
        -- ^ Like /@gTKINPUTPURPOSEFREEFORM@/, but characters are hidden
        | InputPurposePin
        -- ^ Like /@gTKINPUTPURPOSEDIGITS@/, but characters are hidden
        | InputPurposeTerminal
        -- ^ Allow any character, in addition to control codes
        | AnotherInputPurpose Int
        -- ^ Catch-all for unknown values
        deriving (Int -> InputPurpose -> ShowS
    [InputPurpose] -> ShowS
    InputPurpose -> String
    (Int -> InputPurpose -> ShowS)
    -> (InputPurpose -> String)
    -> ([InputPurpose] -> ShowS)
    -> Show InputPurpose
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> InputPurpose -> ShowS
    showsPrec :: Int -> InputPurpose -> ShowS
    $cshow :: InputPurpose -> String
    show :: InputPurpose -> String
    $cshowList :: [InputPurpose] -> ShowS
    showList :: [InputPurpose] -> ShowS
    Show, InputPurpose -> InputPurpose -> Bool
    (InputPurpose -> InputPurpose -> Bool)
    -> (InputPurpose -> InputPurpose -> Bool) -> Eq InputPurpose
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: InputPurpose -> InputPurpose -> Bool
    == :: InputPurpose -> InputPurpose -> Bool
    $c/= :: InputPurpose -> InputPurpose -> Bool
    /= :: InputPurpose -> InputPurpose -> Bool
    Eq)

    instance P.Enum InputPurpose where
        fromEnum :: InputPurpose -> Int
    fromEnum InputPurpose
    InputPurposeFreeForm = Int
    0
        fromEnum InputPurpose
    InputPurposeAlpha = Int
    1
        fromEnum InputPurpose
    InputPurposeDigits = Int
    2
        fromEnum InputPurpose
    InputPurposeNumber = Int
    3
        fromEnum InputPurpose
    InputPurposePhone = Int
    4
        fromEnum InputPurpose
    InputPurposeUrl = Int
    5
        fromEnum InputPurpose
    InputPurposeEmail = Int
    6
        fromEnum InputPurpose
    InputPurposeName = Int
    7
        fromEnum InputPurpose
    InputPurposePassword = Int
    8
        fromEnum InputPurpose
    InputPurposePin = Int
    9
        fromEnum InputPurpose
    InputPurposeTerminal = Int
    10
        fromEnum (AnotherInputPurpose Int
    k) = Int
    k

        toEnum :: Int -> InputPurpose
    toEnum Int
    0 = InputPurpose
    InputPurposeFreeForm
        toEnum Int
    1 = InputPurpose
    InputPurposeAlpha
        toEnum Int
    2 = InputPurpose
    InputPurposeDigits
        toEnum Int
    3 = InputPurpose
    InputPurposeNumber
        toEnum Int
    4 = InputPurpose
    InputPurposePhone
        toEnum Int
    5 = InputPurpose
    InputPurposeUrl
        toEnum Int
    6 = InputPurpose
    InputPurposeEmail
        toEnum Int
    7 = InputPurpose
    InputPurposeName
        toEnum Int
    8 = InputPurpose
    InputPurposePassword
        toEnum Int
    9 = InputPurpose
    InputPurposePin
        toEnum Int
    10 = InputPurpose
    InputPurposeTerminal
        toEnum Int
    k = Int -> InputPurpose
    AnotherInputPurpose Int
    k

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

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

    foreign import ccall "gtk_input_purpose_get_type" c_gtk_input_purpose_get_type ::
        IO GType

    instance B.Types.TypedObject InputPurpose where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_input_purpose_get_type

    instance B.Types.BoxedEnum InputPurpose

    -- Enum ImageType
    -- | Describes the image data representation used by a t'GI.Gtk.Objects.Image.Image'. If you
    -- want to get the image from the widget, you can only get the
    -- currently-stored representation. e.g.  if the
    -- 'GI.Gtk.Objects.Image.imageGetStorageType' returns @/GTK_IMAGE_PIXBUF/@, then you can
    -- call 'GI.Gtk.Objects.Image.imageGetPixbuf' but not 'GI.Gtk.Objects.Image.imageGetStock'.  For empty
    -- images, you can request any storage type (call any of the \"get\"
    -- functions), but they will all return 'P.Nothing' values.
    data ImageType =
          ImageTypeEmpty
        -- ^ there is no image displayed by the widget
        | ImageTypePixbuf
        -- ^ the widget contains a t'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf'
        | ImageTypeStock
        -- ^ the widget contains a [stock item name][gtkstock]
        | ImageTypeIconSet
        -- ^ the widget contains a t'GI.Gtk.Structs.IconSet.IconSet'
        | ImageTypeAnimation
        -- ^ the widget contains a t'GI.GdkPixbuf.Objects.PixbufAnimation.PixbufAnimation'
        | ImageTypeIconName
        -- ^ the widget contains a named icon.
        --  This image type was added in GTK+ 2.6
        | ImageTypeGicon
        -- ^ the widget contains a t'GI.Gio.Interfaces.Icon.Icon'.
        --  This image type was added in GTK+ 2.14
        | ImageTypeSurface
        -- ^ the widget contains a t'GI.Cairo.Structs.Surface.Surface'.
        --  This image type was added in GTK+ 3.10
        | AnotherImageType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ImageType -> ShowS
    [ImageType] -> ShowS
    ImageType -> String
    (Int -> ImageType -> ShowS)
    -> (ImageType -> String)
    -> ([ImageType] -> ShowS)
    -> Show ImageType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ImageType -> ShowS
    showsPrec :: Int -> ImageType -> ShowS
    $cshow :: ImageType -> String
    show :: ImageType -> String
    $cshowList :: [ImageType] -> ShowS
    showList :: [ImageType] -> ShowS
    Show, ImageType -> ImageType -> Bool
    (ImageType -> ImageType -> Bool)
    -> (ImageType -> ImageType -> Bool) -> Eq ImageType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ImageType -> ImageType -> Bool
    == :: ImageType -> ImageType -> Bool
    $c/= :: ImageType -> ImageType -> Bool
    /= :: ImageType -> ImageType -> Bool
    Eq)

    instance P.Enum ImageType where
        fromEnum :: ImageType -> Int
    fromEnum ImageType
    ImageTypeEmpty = Int
    0
        fromEnum ImageType
    ImageTypePixbuf = Int
    1
        fromEnum ImageType
    ImageTypeStock = Int
    2
        fromEnum ImageType
    ImageTypeIconSet = Int
    3
        fromEnum ImageType
    ImageTypeAnimation = Int
    4
        fromEnum ImageType
    ImageTypeIconName = Int
    5
        fromEnum ImageType
    ImageTypeGicon = Int
    6
        fromEnum ImageType
    ImageTypeSurface = Int
    7
        fromEnum (AnotherImageType Int
    k) = Int
    k

        toEnum :: Int -> ImageType
    toEnum Int
    0 = ImageType
    ImageTypeEmpty
        toEnum Int
    1 = ImageType
    ImageTypePixbuf
        toEnum Int
    2 = ImageType
    ImageTypeStock
        toEnum Int
    3 = ImageType
    ImageTypeIconSet
        toEnum Int
    4 = ImageType
    ImageTypeAnimation
        toEnum Int
    5 = ImageType
    ImageTypeIconName
        toEnum Int
    6 = ImageType
    ImageTypeGicon
        toEnum Int
    7 = ImageType
    ImageTypeSurface
        toEnum Int
    k = Int -> ImageType
    AnotherImageType Int
    k

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

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

    foreign import ccall "gtk_image_type_get_type" c_gtk_image_type_get_type ::
        IO GType

    instance B.Types.TypedObject ImageType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_image_type_get_type

    instance B.Types.BoxedEnum ImageType

    -- Enum IconViewDropPosition
    -- | An enum for determining where a dropped item goes.
    data IconViewDropPosition =
          IconViewDropPositionNoDrop
        -- ^ no drop possible
        | IconViewDropPositionDropInto
        -- ^ dropped item replaces the item
        | IconViewDropPositionDropLeft
        -- ^ droppped item is inserted to the left
        | IconViewDropPositionDropRight
        -- ^ dropped item is inserted to the right
        | IconViewDropPositionDropAbove
        -- ^ dropped item is inserted above
        | IconViewDropPositionDropBelow
        -- ^ dropped item is inserted below
        | AnotherIconViewDropPosition Int
        -- ^ Catch-all for unknown values
        deriving (Int -> IconViewDropPosition -> ShowS
    [IconViewDropPosition] -> ShowS
    IconViewDropPosition -> String
    (Int -> IconViewDropPosition -> ShowS)
    -> (IconViewDropPosition -> String)
    -> ([IconViewDropPosition] -> ShowS)
    -> Show IconViewDropPosition
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IconViewDropPosition -> ShowS
    showsPrec :: Int -> IconViewDropPosition -> ShowS
    $cshow :: IconViewDropPosition -> String
    show :: IconViewDropPosition -> String
    $cshowList :: [IconViewDropPosition] -> ShowS
    showList :: [IconViewDropPosition] -> ShowS
    Show, IconViewDropPosition -> IconViewDropPosition -> Bool
    (IconViewDropPosition -> IconViewDropPosition -> Bool)
    -> (IconViewDropPosition -> IconViewDropPosition -> Bool)
    -> Eq IconViewDropPosition
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IconViewDropPosition -> IconViewDropPosition -> Bool
    == :: IconViewDropPosition -> IconViewDropPosition -> Bool
    $c/= :: IconViewDropPosition -> IconViewDropPosition -> Bool
    /= :: IconViewDropPosition -> IconViewDropPosition -> Bool
    Eq)

    instance P.Enum IconViewDropPosition where
        fromEnum :: IconViewDropPosition -> Int
    fromEnum IconViewDropPosition
    IconViewDropPositionNoDrop = Int
    0
        fromEnum IconViewDropPosition
    IconViewDropPositionDropInto = Int
    1
        fromEnum IconViewDropPosition
    IconViewDropPositionDropLeft = Int
    2
        fromEnum IconViewDropPosition
    IconViewDropPositionDropRight = Int
    3
        fromEnum IconViewDropPosition
    IconViewDropPositionDropAbove = Int
    4
        fromEnum IconViewDropPosition
    IconViewDropPositionDropBelow = Int
    5
        fromEnum (AnotherIconViewDropPosition Int
    k) = Int
    k

        toEnum :: Int -> IconViewDropPosition
    toEnum Int
    0 = IconViewDropPosition
    IconViewDropPositionNoDrop
        toEnum Int
    1 = IconViewDropPosition
    IconViewDropPositionDropInto
        toEnum Int
    2 = IconViewDropPosition
    IconViewDropPositionDropLeft
        toEnum Int
    3 = IconViewDropPosition
    IconViewDropPositionDropRight
        toEnum Int
    4 = IconViewDropPosition
    IconViewDropPositionDropAbove
        toEnum Int
    5 = IconViewDropPosition
    IconViewDropPositionDropBelow
        toEnum Int
    k = Int -> IconViewDropPosition
    AnotherIconViewDropPosition Int
    k

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

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

    foreign import ccall "gtk_icon_view_drop_position_get_type" c_gtk_icon_view_drop_position_get_type ::
        IO GType

    instance B.Types.TypedObject IconViewDropPosition where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_icon_view_drop_position_get_type

    instance B.Types.BoxedEnum IconViewDropPosition

    -- Enum IconThemeError
    -- | Error codes for GtkIconTheme operations.
    data IconThemeError =
          IconThemeErrorNotFound
        -- ^ The icon specified does not exist in the theme
        | IconThemeErrorFailed
        -- ^ An unspecified error occurred.
        | AnotherIconThemeError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> IconThemeError -> ShowS
    [IconThemeError] -> ShowS
    IconThemeError -> String
    (Int -> IconThemeError -> ShowS)
    -> (IconThemeError -> String)
    -> ([IconThemeError] -> ShowS)
    -> Show IconThemeError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IconThemeError -> ShowS
    showsPrec :: Int -> IconThemeError -> ShowS
    $cshow :: IconThemeError -> String
    show :: IconThemeError -> String
    $cshowList :: [IconThemeError] -> ShowS
    showList :: [IconThemeError] -> ShowS
    Show, IconThemeError -> IconThemeError -> Bool
    (IconThemeError -> IconThemeError -> Bool)
    -> (IconThemeError -> IconThemeError -> Bool) -> Eq IconThemeError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IconThemeError -> IconThemeError -> Bool
    == :: IconThemeError -> IconThemeError -> Bool
    $c/= :: IconThemeError -> IconThemeError -> Bool
    /= :: IconThemeError -> IconThemeError -> Bool
    Eq)

    instance P.Enum IconThemeError where
        fromEnum :: IconThemeError -> Int
    fromEnum IconThemeError
    IconThemeErrorNotFound = Int
    0
        fromEnum IconThemeError
    IconThemeErrorFailed = Int
    1
        fromEnum (AnotherIconThemeError Int
    k) = Int
    k

        toEnum :: Int -> IconThemeError
    toEnum Int
    0 = IconThemeError
    IconThemeErrorNotFound
        toEnum Int
    1 = IconThemeError
    IconThemeErrorFailed
        toEnum Int
    k = Int -> IconThemeError
    AnotherIconThemeError Int
    k

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

    instance GErrorClass IconThemeError where
        gerrorClassDomain :: IconThemeError -> Text
    gerrorClassDomain IconThemeError
    _ = Text
    "gtk-icon-theme-error-quark"

    -- | Catch exceptions of type `IconThemeError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
    catchIconThemeError ::
        IO a ->
        (IconThemeError -> GErrorMessage -> IO a) ->
        IO a
    catchIconThemeError :: forall a. IO a -> (IconThemeError -> Text -> IO a) -> IO a
    catchIconThemeError = IO a -> (IconThemeError -> Text -> IO a) -> IO a
    forall err a.
    GErrorClass err =>
    IO a -> (err -> Text -> IO a) -> IO a
    catchGErrorJustDomain

    -- | Handle exceptions of type `IconThemeError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
    handleIconThemeError ::
        (IconThemeError -> GErrorMessage -> IO a) ->
        IO a ->
        IO a
    handleIconThemeError :: forall a. (IconThemeError -> Text -> IO a) -> IO a -> IO a
    handleIconThemeError = (IconThemeError -> Text -> IO a) -> IO a -> IO a
    forall err a.
    GErrorClass err =>
    (err -> Text -> IO a) -> IO a -> IO a
    handleGErrorJustDomain

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

    foreign import ccall "gtk_icon_theme_error_get_type" c_gtk_icon_theme_error_get_type ::
        IO GType

    instance B.Types.TypedObject IconThemeError where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_icon_theme_error_get_type

    instance B.Types.BoxedEnum IconThemeError

    -- Enum IconSize
    -- | Built-in stock icon sizes.
    data IconSize =
          IconSizeInvalid
        -- ^ Invalid size.
        | IconSizeMenu
        -- ^ Size appropriate for menus (16px).
        | IconSizeSmallToolbar
        -- ^ Size appropriate for small toolbars (16px).
        | IconSizeLargeToolbar
        -- ^ Size appropriate for large toolbars (24px)
        | IconSizeButton
        -- ^ Size appropriate for buttons (16px)
        | IconSizeDnd
        -- ^ Size appropriate for drag and drop (32px)
        | IconSizeDialog
        -- ^ Size appropriate for dialogs (48px)
        | AnotherIconSize Int
        -- ^ Catch-all for unknown values
        deriving (Int -> IconSize -> ShowS
    [IconSize] -> ShowS
    IconSize -> String
    (Int -> IconSize -> ShowS)
    -> (IconSize -> String) -> ([IconSize] -> ShowS) -> Show IconSize
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IconSize -> ShowS
    showsPrec :: Int -> IconSize -> ShowS
    $cshow :: IconSize -> String
    show :: IconSize -> String
    $cshowList :: [IconSize] -> ShowS
    showList :: [IconSize] -> ShowS
    Show, IconSize -> IconSize -> Bool
    (IconSize -> IconSize -> Bool)
    -> (IconSize -> IconSize -> Bool) -> Eq IconSize
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IconSize -> IconSize -> Bool
    == :: IconSize -> IconSize -> Bool
    $c/= :: IconSize -> IconSize -> Bool
    /= :: IconSize -> IconSize -> Bool
    Eq)

    instance P.Enum IconSize where
        fromEnum :: IconSize -> Int
    fromEnum IconSize
    IconSizeInvalid = Int
    0
        fromEnum IconSize
    IconSizeMenu = Int
    1
        fromEnum IconSize
    IconSizeSmallToolbar = Int
    2
        fromEnum IconSize
    IconSizeLargeToolbar = Int
    3
        fromEnum IconSize
    IconSizeButton = Int
    4
        fromEnum IconSize
    IconSizeDnd = Int
    5
        fromEnum IconSize
    IconSizeDialog = Int
    6
        fromEnum (AnotherIconSize Int
    k) = Int
    k

        toEnum :: Int -> IconSize
    toEnum Int
    0 = IconSize
    IconSizeInvalid
        toEnum Int
    1 = IconSize
    IconSizeMenu
        toEnum Int
    2 = IconSize
    IconSizeSmallToolbar
        toEnum Int
    3 = IconSize
    IconSizeLargeToolbar
        toEnum Int
    4 = IconSize
    IconSizeButton
        toEnum Int
    5 = IconSize
    IconSizeDnd
        toEnum Int
    6 = IconSize
    IconSizeDialog
        toEnum Int
    k = Int -> IconSize
    AnotherIconSize Int
    k

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

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

    foreign import ccall "gtk_icon_size_get_type" c_gtk_icon_size_get_type ::
        IO GType

    instance B.Types.TypedObject IconSize where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_icon_size_get_type

    instance B.Types.BoxedEnum IconSize

    -- Enum IMStatusStyle
    {-# DEPRECATED IMStatusStyle ["(Since version 3.10)"] #-}
    -- | Style for input method status. See also
    -- [Settings:gtkImStatusStyle]("GI.Gtk.Objects.Settings#g:attr:gtkImStatusStyle")
    data IMStatusStyle =
          IMStatusStyleNothing
        -- ^ Deprecated
        | IMStatusStyleCallback
        -- ^ Deprecated
        | IMStatusStyleNone
        -- ^ Deprecated
        | AnotherIMStatusStyle Int
        -- ^ Catch-all for unknown values
        deriving (Int -> IMStatusStyle -> ShowS
    [IMStatusStyle] -> ShowS
    IMStatusStyle -> String
    (Int -> IMStatusStyle -> ShowS)
    -> (IMStatusStyle -> String)
    -> ([IMStatusStyle] -> ShowS)
    -> Show IMStatusStyle
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IMStatusStyle -> ShowS
    showsPrec :: Int -> IMStatusStyle -> ShowS
    $cshow :: IMStatusStyle -> String
    show :: IMStatusStyle -> String
    $cshowList :: [IMStatusStyle] -> ShowS
    showList :: [IMStatusStyle] -> ShowS
    Show, IMStatusStyle -> IMStatusStyle -> Bool
    (IMStatusStyle -> IMStatusStyle -> Bool)
    -> (IMStatusStyle -> IMStatusStyle -> Bool) -> Eq IMStatusStyle
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IMStatusStyle -> IMStatusStyle -> Bool
    == :: IMStatusStyle -> IMStatusStyle -> Bool
    $c/= :: IMStatusStyle -> IMStatusStyle -> Bool
    /= :: IMStatusStyle -> IMStatusStyle -> Bool
    Eq)

    instance P.Enum IMStatusStyle where
        fromEnum :: IMStatusStyle -> Int
    fromEnum IMStatusStyle
    IMStatusStyleNothing = Int
    0
        fromEnum IMStatusStyle
    IMStatusStyleCallback = Int
    1
        fromEnum IMStatusStyle
    IMStatusStyleNone = Int
    2
        fromEnum (AnotherIMStatusStyle Int
    k) = Int
    k

        toEnum :: Int -> IMStatusStyle
    toEnum Int
    0 = IMStatusStyle
    IMStatusStyleNothing
        toEnum Int
    1 = IMStatusStyle
    IMStatusStyleCallback
        toEnum Int
    2 = IMStatusStyle
    IMStatusStyleNone
        toEnum Int
    k = Int -> IMStatusStyle
    AnotherIMStatusStyle Int
    k

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

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

    foreign import ccall "gtk_im_status_style_get_type" c_gtk_im_status_style_get_type ::
        IO GType

    instance B.Types.TypedObject IMStatusStyle where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_im_status_style_get_type

    instance B.Types.BoxedEnum IMStatusStyle

    -- Enum IMPreeditStyle
    {-# DEPRECATED IMPreeditStyle ["(Since version 3.10)"] #-}
    -- | Style for input method preedit. See also
    -- [Settings:gtkImPreeditStyle]("GI.Gtk.Objects.Settings#g:attr:gtkImPreeditStyle")
    data IMPreeditStyle =
          IMPreeditStyleNothing
        -- ^ Deprecated
        | IMPreeditStyleCallback
        -- ^ Deprecated
        | IMPreeditStyleNone
        -- ^ Deprecated
        | AnotherIMPreeditStyle Int
        -- ^ Catch-all for unknown values
        deriving (Int -> IMPreeditStyle -> ShowS
    [IMPreeditStyle] -> ShowS
    IMPreeditStyle -> String
    (Int -> IMPreeditStyle -> ShowS)
    -> (IMPreeditStyle -> String)
    -> ([IMPreeditStyle] -> ShowS)
    -> Show IMPreeditStyle
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IMPreeditStyle -> ShowS
    showsPrec :: Int -> IMPreeditStyle -> ShowS
    $cshow :: IMPreeditStyle -> String
    show :: IMPreeditStyle -> String
    $cshowList :: [IMPreeditStyle] -> ShowS
    showList :: [IMPreeditStyle] -> ShowS
    Show, IMPreeditStyle -> IMPreeditStyle -> Bool
    (IMPreeditStyle -> IMPreeditStyle -> Bool)
    -> (IMPreeditStyle -> IMPreeditStyle -> Bool) -> Eq IMPreeditStyle
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IMPreeditStyle -> IMPreeditStyle -> Bool
    == :: IMPreeditStyle -> IMPreeditStyle -> Bool
    $c/= :: IMPreeditStyle -> IMPreeditStyle -> Bool
    /= :: IMPreeditStyle -> IMPreeditStyle -> Bool
    Eq)

    instance P.Enum IMPreeditStyle where
        fromEnum :: IMPreeditStyle -> Int
    fromEnum IMPreeditStyle
    IMPreeditStyleNothing = Int
    0
        fromEnum IMPreeditStyle
    IMPreeditStyleCallback = Int
    1
        fromEnum IMPreeditStyle
    IMPreeditStyleNone = Int
    2
        fromEnum (AnotherIMPreeditStyle Int
    k) = Int
    k

        toEnum :: Int -> IMPreeditStyle
    toEnum Int
    0 = IMPreeditStyle
    IMPreeditStyleNothing
        toEnum Int
    1 = IMPreeditStyle
    IMPreeditStyleCallback
        toEnum Int
    2 = IMPreeditStyle
    IMPreeditStyleNone
        toEnum Int
    k = Int -> IMPreeditStyle
    AnotherIMPreeditStyle Int
    k

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

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

    foreign import ccall "gtk_im_preedit_style_get_type" c_gtk_im_preedit_style_get_type ::
        IO GType

    instance B.Types.TypedObject IMPreeditStyle where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_im_preedit_style_get_type

    instance B.Types.BoxedEnum IMPreeditStyle

    -- Enum FileChooserError
    -- | These identify the various errors that can occur while calling
    -- t'GI.Gtk.Interfaces.FileChooser.FileChooser' functions.
    data FileChooserError =
          FileChooserErrorNonexistent
        -- ^ Indicates that a file does not exist.
        | FileChooserErrorBadFilename
        -- ^ Indicates a malformed filename.
        | FileChooserErrorAlreadyExists
        -- ^ Indicates a duplicate path (e.g. when
        --  adding a bookmark).
        | FileChooserErrorIncompleteHostname
        -- ^ Indicates an incomplete hostname (e.g. \"http:\/\/foo\" without a slash after that).
        | AnotherFileChooserError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> FileChooserError -> ShowS
    [FileChooserError] -> ShowS
    FileChooserError -> String
    (Int -> FileChooserError -> ShowS)
    -> (FileChooserError -> String)
    -> ([FileChooserError] -> ShowS)
    -> Show FileChooserError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FileChooserError -> ShowS
    showsPrec :: Int -> FileChooserError -> ShowS
    $cshow :: FileChooserError -> String
    show :: FileChooserError -> String
    $cshowList :: [FileChooserError] -> ShowS
    showList :: [FileChooserError] -> ShowS
    Show, FileChooserError -> FileChooserError -> Bool
    (FileChooserError -> FileChooserError -> Bool)
    -> (FileChooserError -> FileChooserError -> Bool)
    -> Eq FileChooserError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FileChooserError -> FileChooserError -> Bool
    == :: FileChooserError -> FileChooserError -> Bool
    $c/= :: FileChooserError -> FileChooserError -> Bool
    /= :: FileChooserError -> FileChooserError -> Bool
    Eq)

    instance P.Enum FileChooserError where
        fromEnum :: FileChooserError -> Int
    fromEnum FileChooserError
    FileChooserErrorNonexistent = Int
    0
        fromEnum FileChooserError
    FileChooserErrorBadFilename = Int
    1
        fromEnum FileChooserError
    FileChooserErrorAlreadyExists = Int
    2
        fromEnum FileChooserError
    FileChooserErrorIncompleteHostname = Int
    3
        fromEnum (AnotherFileChooserError Int
    k) = Int
    k

        toEnum :: Int -> FileChooserError
    toEnum Int
    0 = FileChooserError
    FileChooserErrorNonexistent
        toEnum Int
    1 = FileChooserError
    FileChooserErrorBadFilename
        toEnum Int
    2 = FileChooserError
    FileChooserErrorAlreadyExists
        toEnum Int
    3 = FileChooserError
    FileChooserErrorIncompleteHostname
        toEnum Int
    k = Int -> FileChooserError
    AnotherFileChooserError Int
    k

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

    instance GErrorClass FileChooserError where
        gerrorClassDomain :: FileChooserError -> Text
    gerrorClassDomain FileChooserError
    _ = Text
    "gtk-file-chooser-error-quark"

    -- | Catch exceptions of type `FileChooserError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
    catchFileChooserError ::
        IO a ->
        (FileChooserError -> GErrorMessage -> IO a) ->
        IO a
    catchFileChooserError :: forall a. IO a -> (FileChooserError -> Text -> IO a) -> IO a
    catchFileChooserError = IO a -> (FileChooserError -> Text -> IO a) -> IO a
    forall err a.
    GErrorClass err =>
    IO a -> (err -> Text -> IO a) -> IO a
    catchGErrorJustDomain

    -- | Handle exceptions of type `FileChooserError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
    handleFileChooserError ::
        (FileChooserError -> GErrorMessage -> IO a) ->
        IO a ->
        IO a
    handleFileChooserError :: forall a. (FileChooserError -> Text -> IO a) -> IO a -> IO a
    handleFileChooserError = (FileChooserError -> Text -> IO a) -> IO a -> IO a
    forall err a.
    GErrorClass err =>
    (err -> Text -> IO a) -> IO a -> IO a
    handleGErrorJustDomain

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

    foreign import ccall "gtk_file_chooser_error_get_type" c_gtk_file_chooser_error_get_type ::
        IO GType

    instance B.Types.TypedObject FileChooserError where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_file_chooser_error_get_type

    instance B.Types.BoxedEnum FileChooserError

    -- Enum FileChooserConfirmation
    -- | Used as a return value of handlers for the
    -- [FileChooser::confirmOverwrite]("GI.Gtk.Interfaces.FileChooser#g:signal:confirmOverwrite") signal of a t'GI.Gtk.Interfaces.FileChooser.FileChooser'. This
    -- value determines whether the file chooser will present the stock
    -- confirmation dialog, accept the user’s choice of a filename, or
    -- let the user choose another filename.
    --
    -- /Since: 2.8/
    data FileChooserConfirmation =
          FileChooserConfirmationConfirm
        -- ^ The file chooser will present
        --  its stock dialog to confirm about overwriting an existing file.
        | FileChooserConfirmationAcceptFilename
        -- ^ The file chooser will
        --  terminate and accept the user’s choice of a file name.
        | FileChooserConfirmationSelectAgain
        -- ^ The file chooser will
        --  continue running, so as to let the user select another file name.
        | AnotherFileChooserConfirmation Int
        -- ^ Catch-all for unknown values
        deriving (Int -> FileChooserConfirmation -> ShowS
    [FileChooserConfirmation] -> ShowS
    FileChooserConfirmation -> String
    (Int -> FileChooserConfirmation -> ShowS)
    -> (FileChooserConfirmation -> String)
    -> ([FileChooserConfirmation] -> ShowS)
    -> Show FileChooserConfirmation
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FileChooserConfirmation -> ShowS
    showsPrec :: Int -> FileChooserConfirmation -> ShowS
    $cshow :: FileChooserConfirmation -> String
    show :: FileChooserConfirmation -> String
    $cshowList :: [FileChooserConfirmation] -> ShowS
    showList :: [FileChooserConfirmation] -> ShowS
    Show, FileChooserConfirmation -> FileChooserConfirmation -> Bool
    (FileChooserConfirmation -> FileChooserConfirmation -> Bool)
    -> (FileChooserConfirmation -> FileChooserConfirmation -> Bool)
    -> Eq FileChooserConfirmation
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FileChooserConfirmation -> FileChooserConfirmation -> Bool
    == :: FileChooserConfirmation -> FileChooserConfirmation -> Bool
    $c/= :: FileChooserConfirmation -> FileChooserConfirmation -> Bool
    /= :: FileChooserConfirmation -> FileChooserConfirmation -> Bool
    Eq)

    instance P.Enum FileChooserConfirmation where
        fromEnum :: FileChooserConfirmation -> Int
    fromEnum FileChooserConfirmation
    FileChooserConfirmationConfirm = Int
    0
        fromEnum FileChooserConfirmation
    FileChooserConfirmationAcceptFilename = Int
    1
        fromEnum FileChooserConfirmation
    FileChooserConfirmationSelectAgain = Int
    2
        fromEnum (AnotherFileChooserConfirmation Int
    k) = Int
    k

        toEnum :: Int -> FileChooserConfirmation
    toEnum Int
    0 = FileChooserConfirmation
    FileChooserConfirmationConfirm
        toEnum Int
    1 = FileChooserConfirmation
    FileChooserConfirmationAcceptFilename
        toEnum Int
    2 = FileChooserConfirmation
    FileChooserConfirmationSelectAgain
        toEnum Int
    k = Int -> FileChooserConfirmation
    AnotherFileChooserConfirmation Int
    k

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

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

    foreign import ccall "gtk_file_chooser_confirmation_get_type" c_gtk_file_chooser_confirmation_get_type ::
        IO GType

    instance B.Types.TypedObject FileChooserConfirmation where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_file_chooser_confirmation_get_type

    instance B.Types.BoxedEnum FileChooserConfirmation

    -- Enum FileChooserAction
    -- | Describes whether a t'GI.Gtk.Interfaces.FileChooser.FileChooser' is being used to open existing files
    -- or to save to a possibly new file.
    data FileChooserAction =
          FileChooserActionOpen
        -- ^ Indicates open mode.  The file chooser
        --  will only let the user pick an existing file.
        | FileChooserActionSave
        -- ^ Indicates save mode.  The file chooser
        --  will let the user pick an existing file, or type in a new
        --  filename.
        | FileChooserActionSelectFolder
        -- ^ Indicates an Open mode for
        --  selecting folders.  The file chooser will let the user pick an
        --  existing folder.
        | FileChooserActionCreateFolder
        -- ^ Indicates a mode for creating a
        --  new folder.  The file chooser will let the user name an existing or
        --  new folder.
        | AnotherFileChooserAction Int
        -- ^ Catch-all for unknown values
        deriving (Int -> FileChooserAction -> ShowS
    [FileChooserAction] -> ShowS
    FileChooserAction -> String
    (Int -> FileChooserAction -> ShowS)
    -> (FileChooserAction -> String)
    -> ([FileChooserAction] -> ShowS)
    -> Show FileChooserAction
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FileChooserAction -> ShowS
    showsPrec :: Int -> FileChooserAction -> ShowS
    $cshow :: FileChooserAction -> String
    show :: FileChooserAction -> String
    $cshowList :: [FileChooserAction] -> ShowS
    showList :: [FileChooserAction] -> ShowS
    Show, FileChooserAction -> FileChooserAction -> Bool
    (FileChooserAction -> FileChooserAction -> Bool)
    -> (FileChooserAction -> FileChooserAction -> Bool)
    -> Eq FileChooserAction
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FileChooserAction -> FileChooserAction -> Bool
    == :: FileChooserAction -> FileChooserAction -> Bool
    $c/= :: FileChooserAction -> FileChooserAction -> Bool
    /= :: FileChooserAction -> FileChooserAction -> Bool
    Eq)

    instance P.Enum FileChooserAction where
        fromEnum :: FileChooserAction -> Int
    fromEnum FileChooserAction
    FileChooserActionOpen = Int
    0
        fromEnum FileChooserAction
    FileChooserActionSave = Int
    1
        fromEnum FileChooserAction
    FileChooserActionSelectFolder = Int
    2
        fromEnum FileChooserAction
    FileChooserActionCreateFolder = Int
    3
        fromEnum (AnotherFileChooserAction Int
    k) = Int
    k

        toEnum :: Int -> FileChooserAction
    toEnum Int
    0 = FileChooserAction
    FileChooserActionOpen
        toEnum Int
    1 = FileChooserAction
    FileChooserActionSave
        toEnum Int
    2 = FileChooserAction
    FileChooserActionSelectFolder
        toEnum Int
    3 = FileChooserAction
    FileChooserActionCreateFolder
        toEnum Int
    k = Int -> FileChooserAction
    AnotherFileChooserAction Int
    k

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

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

    foreign import ccall "gtk_file_chooser_action_get_type" c_gtk_file_chooser_action_get_type ::
        IO GType

    instance B.Types.TypedObject FileChooserAction where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_file_chooser_action_get_type

    instance B.Types.BoxedEnum FileChooserAction

    -- Enum ExpanderStyle
    -- | Used to specify the style of the expanders drawn by a t'GI.Gtk.Objects.TreeView.TreeView'.
    data ExpanderStyle =
          ExpanderStyleCollapsed
        -- ^ The style used for a collapsed subtree.
        | ExpanderStyleSemiCollapsed
        -- ^ Intermediate style used during animation.
        | ExpanderStyleSemiExpanded
        -- ^ Intermediate style used during animation.
        | ExpanderStyleExpanded
        -- ^ The style used for an expanded subtree.
        | AnotherExpanderStyle Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ExpanderStyle -> ShowS
    [ExpanderStyle] -> ShowS
    ExpanderStyle -> String
    (Int -> ExpanderStyle -> ShowS)
    -> (ExpanderStyle -> String)
    -> ([ExpanderStyle] -> ShowS)
    -> Show ExpanderStyle
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ExpanderStyle -> ShowS
    showsPrec :: Int -> ExpanderStyle -> ShowS
    $cshow :: ExpanderStyle -> String
    show :: ExpanderStyle -> String
    $cshowList :: [ExpanderStyle] -> ShowS
    showList :: [ExpanderStyle] -> ShowS
    Show, ExpanderStyle -> ExpanderStyle -> Bool
    (ExpanderStyle -> ExpanderStyle -> Bool)
    -> (ExpanderStyle -> ExpanderStyle -> Bool) -> Eq ExpanderStyle
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ExpanderStyle -> ExpanderStyle -> Bool
    == :: ExpanderStyle -> ExpanderStyle -> Bool
    $c/= :: ExpanderStyle -> ExpanderStyle -> Bool
    /= :: ExpanderStyle -> ExpanderStyle -> Bool
    Eq)

    instance P.Enum ExpanderStyle where
        fromEnum :: ExpanderStyle -> Int
    fromEnum ExpanderStyle
    ExpanderStyleCollapsed = Int
    0
        fromEnum ExpanderStyle
    ExpanderStyleSemiCollapsed = Int
    1
        fromEnum ExpanderStyle
    ExpanderStyleSemiExpanded = Int
    2
        fromEnum ExpanderStyle
    ExpanderStyleExpanded = Int
    3
        fromEnum (AnotherExpanderStyle Int
    k) = Int
    k

        toEnum :: Int -> ExpanderStyle
    toEnum Int
    0 = ExpanderStyle
    ExpanderStyleCollapsed
        toEnum Int
    1 = ExpanderStyle
    ExpanderStyleSemiCollapsed
        toEnum Int
    2 = ExpanderStyle
    ExpanderStyleSemiExpanded
        toEnum Int
    3 = ExpanderStyle
    ExpanderStyleExpanded
        toEnum Int
    k = Int -> ExpanderStyle
    AnotherExpanderStyle Int
    k

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

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

    foreign import ccall "gtk_expander_style_get_type" c_gtk_expander_style_get_type ::
        IO GType

    instance B.Types.TypedObject ExpanderStyle where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_expander_style_get_type

    instance B.Types.BoxedEnum ExpanderStyle

    -- Enum EventSequenceState
    -- | Describes the state of a t'GI.Gdk.Structs.EventSequence.EventSequence' in a t'GI.Gtk.Objects.Gesture.Gesture'.
    --
    -- /Since: 3.14/
    data EventSequenceState =
          EventSequenceStateNone
        -- ^ The sequence is handled, but not grabbed.
        | EventSequenceStateClaimed
        -- ^ The sequence is handled and grabbed.
        | EventSequenceStateDenied
        -- ^ The sequence is denied.
        | AnotherEventSequenceState Int
        -- ^ Catch-all for unknown values
        deriving (Int -> EventSequenceState -> ShowS
    [EventSequenceState] -> ShowS
    EventSequenceState -> String
    (Int -> EventSequenceState -> ShowS)
    -> (EventSequenceState -> String)
    -> ([EventSequenceState] -> ShowS)
    -> Show EventSequenceState
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EventSequenceState -> ShowS
    showsPrec :: Int -> EventSequenceState -> ShowS
    $cshow :: EventSequenceState -> String
    show :: EventSequenceState -> String
    $cshowList :: [EventSequenceState] -> ShowS
    showList :: [EventSequenceState] -> ShowS
    Show, EventSequenceState -> EventSequenceState -> Bool
    (EventSequenceState -> EventSequenceState -> Bool)
    -> (EventSequenceState -> EventSequenceState -> Bool)
    -> Eq EventSequenceState
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EventSequenceState -> EventSequenceState -> Bool
    == :: EventSequenceState -> EventSequenceState -> Bool
    $c/= :: EventSequenceState -> EventSequenceState -> Bool
    /= :: EventSequenceState -> EventSequenceState -> Bool
    Eq)

    instance P.Enum EventSequenceState where
        fromEnum :: EventSequenceState -> Int
    fromEnum EventSequenceState
    EventSequenceStateNone = Int
    0
        fromEnum EventSequenceState
    EventSequenceStateClaimed = Int
    1
        fromEnum EventSequenceState
    EventSequenceStateDenied = Int
    2
        fromEnum (AnotherEventSequenceState Int
    k) = Int
    k

        toEnum :: Int -> EventSequenceState
    toEnum Int
    0 = EventSequenceState
    EventSequenceStateNone
        toEnum Int
    1 = EventSequenceState
    EventSequenceStateClaimed
        toEnum Int
    2 = EventSequenceState
    EventSequenceStateDenied
        toEnum Int
    k = Int -> EventSequenceState
    AnotherEventSequenceState Int
    k

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

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

    foreign import ccall "gtk_event_sequence_state_get_type" c_gtk_event_sequence_state_get_type ::
        IO GType

    instance B.Types.TypedObject EventSequenceState where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_event_sequence_state_get_type

    instance B.Types.BoxedEnum EventSequenceState

    -- Enum EntryIconPosition
    -- | Specifies the side of the entry at which an icon is placed.
    --
    -- /Since: 2.16/
    data EntryIconPosition =
          EntryIconPositionPrimary
        -- ^ At the beginning of the entry (depending on the text direction).
        | EntryIconPositionSecondary
        -- ^ At the end of the entry (depending on the text direction).
        | AnotherEntryIconPosition Int
        -- ^ Catch-all for unknown values
        deriving (Int -> EntryIconPosition -> ShowS
    [EntryIconPosition] -> ShowS
    EntryIconPosition -> String
    (Int -> EntryIconPosition -> ShowS)
    -> (EntryIconPosition -> String)
    -> ([EntryIconPosition] -> ShowS)
    -> Show EntryIconPosition
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EntryIconPosition -> ShowS
    showsPrec :: Int -> EntryIconPosition -> ShowS
    $cshow :: EntryIconPosition -> String
    show :: EntryIconPosition -> String
    $cshowList :: [EntryIconPosition] -> ShowS
    showList :: [EntryIconPosition] -> ShowS
    Show, EntryIconPosition -> EntryIconPosition -> Bool
    (EntryIconPosition -> EntryIconPosition -> Bool)
    -> (EntryIconPosition -> EntryIconPosition -> Bool)
    -> Eq EntryIconPosition
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EntryIconPosition -> EntryIconPosition -> Bool
    == :: EntryIconPosition -> EntryIconPosition -> Bool
    $c/= :: EntryIconPosition -> EntryIconPosition -> Bool
    /= :: EntryIconPosition -> EntryIconPosition -> Bool
    Eq)

    instance P.Enum EntryIconPosition where
        fromEnum :: EntryIconPosition -> Int
    fromEnum EntryIconPosition
    EntryIconPositionPrimary = Int
    0
        fromEnum EntryIconPosition
    EntryIconPositionSecondary = Int
    1
        fromEnum (AnotherEntryIconPosition Int
    k) = Int
    k

        toEnum :: Int -> EntryIconPosition
    toEnum Int
    0 = EntryIconPosition
    EntryIconPositionPrimary
        toEnum Int
    1 = EntryIconPosition
    EntryIconPositionSecondary
        toEnum Int
    k = Int -> EntryIconPosition
    AnotherEntryIconPosition Int
    k

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

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

    foreign import ccall "gtk_entry_icon_position_get_type" c_gtk_entry_icon_position_get_type ::
        IO GType

    instance B.Types.TypedObject EntryIconPosition where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_entry_icon_position_get_type

    instance B.Types.BoxedEnum EntryIconPosition

    -- Enum DragResult
    -- | Gives an indication why a drag operation failed.
    -- The value can by obtained by connecting to the
    -- [Widget::dragFailed]("GI.Gtk.Objects.Widget#g:signal:dragFailed") signal.
    data DragResult =
          DragResultSuccess
        -- ^ The drag operation was successful.
        | DragResultNoTarget
        -- ^ No suitable drag target.
        | DragResultUserCancelled
        -- ^ The user cancelled the drag operation.
        | DragResultTimeoutExpired
        -- ^ The drag operation timed out.
        | DragResultGrabBroken
        -- ^ The pointer or keyboard grab used
        --  for the drag operation was broken.
        | DragResultError
        -- ^ The drag operation failed due to some
        --  unspecified error.
        | AnotherDragResult Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DragResult -> ShowS
    [DragResult] -> ShowS
    DragResult -> String
    (Int -> DragResult -> ShowS)
    -> (DragResult -> String)
    -> ([DragResult] -> ShowS)
    -> Show DragResult
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DragResult -> ShowS
    showsPrec :: Int -> DragResult -> ShowS
    $cshow :: DragResult -> String
    show :: DragResult -> String
    $cshowList :: [DragResult] -> ShowS
    showList :: [DragResult] -> ShowS
    Show, DragResult -> DragResult -> Bool
    (DragResult -> DragResult -> Bool)
    -> (DragResult -> DragResult -> Bool) -> Eq DragResult
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DragResult -> DragResult -> Bool
    == :: DragResult -> DragResult -> Bool
    $c/= :: DragResult -> DragResult -> Bool
    /= :: DragResult -> DragResult -> Bool
    Eq)

    instance P.Enum DragResult where
        fromEnum :: DragResult -> Int
    fromEnum DragResult
    DragResultSuccess = Int
    0
        fromEnum DragResult
    DragResultNoTarget = Int
    1
        fromEnum DragResult
    DragResultUserCancelled = Int
    2
        fromEnum DragResult
    DragResultTimeoutExpired = Int
    3
        fromEnum DragResult
    DragResultGrabBroken = Int
    4
        fromEnum DragResult
    DragResultError = Int
    5
        fromEnum (AnotherDragResult Int
    k) = Int
    k

        toEnum :: Int -> DragResult
    toEnum Int
    0 = DragResult
    DragResultSuccess
        toEnum Int
    1 = DragResult
    DragResultNoTarget
        toEnum Int
    2 = DragResult
    DragResultUserCancelled
        toEnum Int
    3 = DragResult
    DragResultTimeoutExpired
        toEnum Int
    4 = DragResult
    DragResultGrabBroken
        toEnum Int
    5 = DragResult
    DragResultError
        toEnum Int
    k = Int -> DragResult
    AnotherDragResult Int
    k

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

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

    foreign import ccall "gtk_drag_result_get_type" c_gtk_drag_result_get_type ::
        IO GType

    instance B.Types.TypedObject DragResult where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_drag_result_get_type

    instance B.Types.BoxedEnum DragResult

    -- Enum DirectionType
    -- | Focus movement types.
    data DirectionType =
          DirectionTypeTabForward
        -- ^ Move forward.
        | DirectionTypeTabBackward
        -- ^ Move backward.
        | DirectionTypeUp
        -- ^ Move up.
        | DirectionTypeDown
        -- ^ Move down.
        | DirectionTypeLeft
        -- ^ Move left.
        | DirectionTypeRight
        -- ^ Move right.
        | AnotherDirectionType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DirectionType -> ShowS
    [DirectionType] -> ShowS
    DirectionType -> String
    (Int -> DirectionType -> ShowS)
    -> (DirectionType -> String)
    -> ([DirectionType] -> ShowS)
    -> Show DirectionType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DirectionType -> ShowS
    showsPrec :: Int -> DirectionType -> ShowS
    $cshow :: DirectionType -> String
    show :: DirectionType -> String
    $cshowList :: [DirectionType] -> ShowS
    showList :: [DirectionType] -> ShowS
    Show, DirectionType -> DirectionType -> Bool
    (DirectionType -> DirectionType -> Bool)
    -> (DirectionType -> DirectionType -> Bool) -> Eq DirectionType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DirectionType -> DirectionType -> Bool
    == :: DirectionType -> DirectionType -> Bool
    $c/= :: DirectionType -> DirectionType -> Bool
    /= :: DirectionType -> DirectionType -> Bool
    Eq)

    instance P.Enum DirectionType where
        fromEnum :: DirectionType -> Int
    fromEnum DirectionType
    DirectionTypeTabForward = Int
    0
        fromEnum DirectionType
    DirectionTypeTabBackward = Int
    1
        fromEnum DirectionType
    DirectionTypeUp = Int
    2
        fromEnum DirectionType
    DirectionTypeDown = Int
    3
        fromEnum DirectionType
    DirectionTypeLeft = Int
    4
        fromEnum DirectionType
    DirectionTypeRight = Int
    5
        fromEnum (AnotherDirectionType Int
    k) = Int
    k

        toEnum :: Int -> DirectionType
    toEnum Int
    0 = DirectionType
    DirectionTypeTabForward
        toEnum Int
    1 = DirectionType
    DirectionTypeTabBackward
        toEnum Int
    2 = DirectionType
    DirectionTypeUp
        toEnum Int
    3 = DirectionType
    DirectionTypeDown
        toEnum Int
    4 = DirectionType
    DirectionTypeLeft
        toEnum Int
    5 = DirectionType
    DirectionTypeRight
        toEnum Int
    k = Int -> DirectionType
    AnotherDirectionType Int
    k

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

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

    foreign import ccall "gtk_direction_type_get_type" c_gtk_direction_type_get_type ::
        IO GType

    instance B.Types.TypedObject DirectionType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_direction_type_get_type

    instance B.Types.BoxedEnum DirectionType

    -- Enum DeleteType
    -- | See also: [Entry::deleteFromCursor]("GI.Gtk.Objects.Entry#g:signal:deleteFromCursor").
    data DeleteType =
          DeleteTypeChars
        -- ^ Delete characters.
        | DeleteTypeWordEnds
        -- ^ Delete only the portion of the word to the
        --   left\/right of cursor if we’re in the middle of a word.
        | DeleteTypeWords
        -- ^ Delete words.
        | DeleteTypeDisplayLines
        -- ^ Delete display-lines. Display-lines
        --   refers to the visible lines, with respect to to the current line
        --   breaks. As opposed to paragraphs, which are defined by line
        --   breaks in the input.
        | DeleteTypeDisplayLineEnds
        -- ^ Delete only the portion of the
        --   display-line to the left\/right of cursor.
        | DeleteTypeParagraphEnds
        -- ^ Delete to the end of the
        --   paragraph. Like C-k in Emacs (or its reverse).
        | DeleteTypeParagraphs
        -- ^ Delete entire line. Like C-k in pico.
        | DeleteTypeWhitespace
        -- ^ Delete only whitespace. Like M-\\ in Emacs.
        | AnotherDeleteType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DeleteType -> ShowS
    [DeleteType] -> ShowS
    DeleteType -> String
    (Int -> DeleteType -> ShowS)
    -> (DeleteType -> String)
    -> ([DeleteType] -> ShowS)
    -> Show DeleteType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DeleteType -> ShowS
    showsPrec :: Int -> DeleteType -> ShowS
    $cshow :: DeleteType -> String
    show :: DeleteType -> String
    $cshowList :: [DeleteType] -> ShowS
    showList :: [DeleteType] -> ShowS
    Show, DeleteType -> DeleteType -> Bool
    (DeleteType -> DeleteType -> Bool)
    -> (DeleteType -> DeleteType -> Bool) -> Eq DeleteType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DeleteType -> DeleteType -> Bool
    == :: DeleteType -> DeleteType -> Bool
    $c/= :: DeleteType -> DeleteType -> Bool
    /= :: DeleteType -> DeleteType -> Bool
    Eq)

    instance P.Enum DeleteType where
        fromEnum :: DeleteType -> Int
    fromEnum DeleteType
    DeleteTypeChars = Int
    0
        fromEnum DeleteType
    DeleteTypeWordEnds = Int
    1
        fromEnum DeleteType
    DeleteTypeWords = Int
    2
        fromEnum DeleteType
    DeleteTypeDisplayLines = Int
    3
        fromEnum DeleteType
    DeleteTypeDisplayLineEnds = Int
    4
        fromEnum DeleteType
    DeleteTypeParagraphEnds = Int
    5
        fromEnum DeleteType
    DeleteTypeParagraphs = Int
    6
        fromEnum DeleteType
    DeleteTypeWhitespace = Int
    7
        fromEnum (AnotherDeleteType Int
    k) = Int
    k

        toEnum :: Int -> DeleteType
    toEnum Int
    0 = DeleteType
    DeleteTypeChars
        toEnum Int
    1 = DeleteType
    DeleteTypeWordEnds
        toEnum Int
    2 = DeleteType
    DeleteTypeWords
        toEnum Int
    3 = DeleteType
    DeleteTypeDisplayLines
        toEnum Int
    4 = DeleteType
    DeleteTypeDisplayLineEnds
        toEnum Int
    5 = DeleteType
    DeleteTypeParagraphEnds
        toEnum Int
    6 = DeleteType
    DeleteTypeParagraphs
        toEnum Int
    7 = DeleteType
    DeleteTypeWhitespace
        toEnum Int
    k = Int -> DeleteType
    AnotherDeleteType Int
    k

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

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

    foreign import ccall "gtk_delete_type_get_type" c_gtk_delete_type_get_type ::
        IO GType

    instance B.Types.TypedObject DeleteType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_delete_type_get_type

    instance B.Types.BoxedEnum DeleteType

    -- Enum CssSectionType
    -- | The different types of sections indicate parts of a CSS document as
    -- parsed by GTK’s CSS parser. They are oriented towards the
    -- <http://www.w3.org/TR/CSS21/grammar.html CSS Grammar>,
    -- but may contain extensions.
    --
    -- More types might be added in the future as the parser incorporates
    -- more features.
    --
    -- /Since: 3.2/
    data CssSectionType =
          CssSectionTypeDocument
        -- ^ The section describes a complete document.
        --   This section time is the only one where 'GI.Gtk.Structs.CssSection.cssSectionGetParent'
        --   might return 'P.Nothing'.
        | CssSectionTypeImport
        -- ^ The section defines an import rule.
        | CssSectionTypeColorDefinition
        -- ^ The section defines a color. This
        --   is a GTK extension to CSS.
        | CssSectionTypeBindingSet
        -- ^ The section defines a binding set. This
        --   is a GTK extension to CSS.
        | CssSectionTypeRuleset
        -- ^ The section defines a CSS ruleset.
        | CssSectionTypeSelector
        -- ^ The section defines a CSS selector.
        | CssSectionTypeDeclaration
        -- ^ The section defines the declaration of
        --   a CSS variable.
        | CssSectionTypeValue
        -- ^ The section defines the value of a CSS declaration.
        | CssSectionTypeKeyframes
        -- ^ The section defines keyframes. See <http://dev.w3.org/csswg/css3-animations/#keyframes CSS
        --   Animations> for details. Since 3.6
        | AnotherCssSectionType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> CssSectionType -> ShowS
    [CssSectionType] -> ShowS
    CssSectionType -> String
    (Int -> CssSectionType -> ShowS)
    -> (CssSectionType -> String)
    -> ([CssSectionType] -> ShowS)
    -> Show CssSectionType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CssSectionType -> ShowS
    showsPrec :: Int -> CssSectionType -> ShowS
    $cshow :: CssSectionType -> String
    show :: CssSectionType -> String
    $cshowList :: [CssSectionType] -> ShowS
    showList :: [CssSectionType] -> ShowS
    Show, CssSectionType -> CssSectionType -> Bool
    (CssSectionType -> CssSectionType -> Bool)
    -> (CssSectionType -> CssSectionType -> Bool) -> Eq CssSectionType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CssSectionType -> CssSectionType -> Bool
    == :: CssSectionType -> CssSectionType -> Bool
    $c/= :: CssSectionType -> CssSectionType -> Bool
    /= :: CssSectionType -> CssSectionType -> Bool
    Eq)

    instance P.Enum CssSectionType where
        fromEnum :: CssSectionType -> Int
    fromEnum CssSectionType
    CssSectionTypeDocument = Int
    0
        fromEnum CssSectionType
    CssSectionTypeImport = Int
    1
        fromEnum CssSectionType
    CssSectionTypeColorDefinition = Int
    2
        fromEnum CssSectionType
    CssSectionTypeBindingSet = Int
    3
        fromEnum CssSectionType
    CssSectionTypeRuleset = Int
    4
        fromEnum CssSectionType
    CssSectionTypeSelector = Int
    5
        fromEnum CssSectionType
    CssSectionTypeDeclaration = Int
    6
        fromEnum CssSectionType
    CssSectionTypeValue = Int
    7
        fromEnum CssSectionType
    CssSectionTypeKeyframes = Int
    8
        fromEnum (AnotherCssSectionType Int
    k) = Int
    k

        toEnum :: Int -> CssSectionType
    toEnum Int
    0 = CssSectionType
    CssSectionTypeDocument
        toEnum Int
    1 = CssSectionType
    CssSectionTypeImport
        toEnum Int
    2 = CssSectionType
    CssSectionTypeColorDefinition
        toEnum Int
    3 = CssSectionType
    CssSectionTypeBindingSet
        toEnum Int
    4 = CssSectionType
    CssSectionTypeRuleset
        toEnum Int
    5 = CssSectionType
    CssSectionTypeSelector
        toEnum Int
    6 = CssSectionType
    CssSectionTypeDeclaration
        toEnum Int
    7 = CssSectionType
    CssSectionTypeValue
        toEnum Int
    8 = CssSectionType
    CssSectionTypeKeyframes
        toEnum Int
    k = Int -> CssSectionType
    AnotherCssSectionType Int
    k

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

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

    foreign import ccall "gtk_css_section_type_get_type" c_gtk_css_section_type_get_type ::
        IO GType

    instance B.Types.TypedObject CssSectionType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_css_section_type_get_type

    instance B.Types.BoxedEnum CssSectionType

    -- Enum CssProviderError
    -- | Error codes for @/GTK_CSS_PROVIDER_ERROR/@.
    data CssProviderError =
          CssProviderErrorFailed
        -- ^ Failed.
        | CssProviderErrorSyntax
        -- ^ Syntax error.
        | CssProviderErrorImport
        -- ^ Import error.
        | CssProviderErrorName
        -- ^ Name error.
        | CssProviderErrorDeprecated
        -- ^ Deprecation error.
        | CssProviderErrorUnknownValue
        -- ^ Unknown value.
        | AnotherCssProviderError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> CssProviderError -> ShowS
    [CssProviderError] -> ShowS
    CssProviderError -> String
    (Int -> CssProviderError -> ShowS)
    -> (CssProviderError -> String)
    -> ([CssProviderError] -> ShowS)
    -> Show CssProviderError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CssProviderError -> ShowS
    showsPrec :: Int -> CssProviderError -> ShowS
    $cshow :: CssProviderError -> String
    show :: CssProviderError -> String
    $cshowList :: [CssProviderError] -> ShowS
    showList :: [CssProviderError] -> ShowS
    Show, CssProviderError -> CssProviderError -> Bool
    (CssProviderError -> CssProviderError -> Bool)
    -> (CssProviderError -> CssProviderError -> Bool)
    -> Eq CssProviderError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CssProviderError -> CssProviderError -> Bool
    == :: CssProviderError -> CssProviderError -> Bool
    $c/= :: CssProviderError -> CssProviderError -> Bool
    /= :: CssProviderError -> CssProviderError -> Bool
    Eq)

    instance P.Enum CssProviderError where
        fromEnum :: CssProviderError -> Int
    fromEnum CssProviderError
    CssProviderErrorFailed = Int
    0
        fromEnum CssProviderError
    CssProviderErrorSyntax = Int
    1
        fromEnum CssProviderError
    CssProviderErrorImport = Int
    2
        fromEnum CssProviderError
    CssProviderErrorName = Int
    3
        fromEnum CssProviderError
    CssProviderErrorDeprecated = Int
    4
        fromEnum CssProviderError
    CssProviderErrorUnknownValue = Int
    5
        fromEnum (AnotherCssProviderError Int
    k) = Int
    k

        toEnum :: Int -> CssProviderError
    toEnum Int
    0 = CssProviderError
    CssProviderErrorFailed
        toEnum Int
    1 = CssProviderError
    CssProviderErrorSyntax
        toEnum Int
    2 = CssProviderError
    CssProviderErrorImport
        toEnum Int
    3 = CssProviderError
    CssProviderErrorName
        toEnum Int
    4 = CssProviderError
    CssProviderErrorDeprecated
        toEnum Int
    5 = CssProviderError
    CssProviderErrorUnknownValue
        toEnum Int
    k = Int -> CssProviderError
    AnotherCssProviderError Int
    k

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

    instance GErrorClass CssProviderError where
        gerrorClassDomain :: CssProviderError -> Text
    gerrorClassDomain CssProviderError
    _ = Text
    "gtk-css-provider-error-quark"

    -- | Catch exceptions of type `CssProviderError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
    catchCssProviderError ::
        IO a ->
        (CssProviderError -> GErrorMessage -> IO a) ->
        IO a
    catchCssProviderError :: forall a. IO a -> (CssProviderError -> Text -> IO a) -> IO a
    catchCssProviderError = IO a -> (CssProviderError -> Text -> IO a) -> IO a
    forall err a.
    GErrorClass err =>
    IO a -> (err -> Text -> IO a) -> IO a
    catchGErrorJustDomain

    -- | Handle exceptions of type `CssProviderError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
    handleCssProviderError ::
        (CssProviderError -> GErrorMessage -> IO a) ->
        IO a ->
        IO a
    handleCssProviderError :: forall a. (CssProviderError -> Text -> IO a) -> IO a -> IO a
    handleCssProviderError = (CssProviderError -> Text -> IO a) -> IO a -> IO a
    forall err a.
    GErrorClass err =>
    (err -> Text -> IO a) -> IO a -> IO a
    handleGErrorJustDomain

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

    foreign import ccall "gtk_css_provider_error_get_type" c_gtk_css_provider_error_get_type ::
        IO GType

    instance B.Types.TypedObject CssProviderError where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_css_provider_error_get_type

    instance B.Types.BoxedEnum CssProviderError

    -- Enum CornerType
    -- | Specifies which corner a child widget should be placed in when packed into
    -- a t'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow'. This is effectively the opposite of where the scroll
    -- bars are placed.
    data CornerType =
          CornerTypeTopLeft
        -- ^ Place the scrollbars on the right and bottom of the
        --  widget (default behaviour).
        | CornerTypeBottomLeft
        -- ^ Place the scrollbars on the top and right of the
        --  widget.
        | CornerTypeTopRight
        -- ^ Place the scrollbars on the left and bottom of the
        --  widget.
        | CornerTypeBottomRight
        -- ^ Place the scrollbars on the top and left of the
        --  widget.
        | AnotherCornerType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> CornerType -> ShowS
    [CornerType] -> ShowS
    CornerType -> String
    (Int -> CornerType -> ShowS)
    -> (CornerType -> String)
    -> ([CornerType] -> ShowS)
    -> Show CornerType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CornerType -> ShowS
    showsPrec :: Int -> CornerType -> ShowS
    $cshow :: CornerType -> String
    show :: CornerType -> String
    $cshowList :: [CornerType] -> ShowS
    showList :: [CornerType] -> ShowS
    Show, CornerType -> CornerType -> Bool
    (CornerType -> CornerType -> Bool)
    -> (CornerType -> CornerType -> Bool) -> Eq CornerType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CornerType -> CornerType -> Bool
    == :: CornerType -> CornerType -> Bool
    $c/= :: CornerType -> CornerType -> Bool
    /= :: CornerType -> CornerType -> Bool
    Eq)

    instance P.Enum CornerType where
        fromEnum :: CornerType -> Int
    fromEnum CornerType
    CornerTypeTopLeft = Int
    0
        fromEnum CornerType
    CornerTypeBottomLeft = Int
    1
        fromEnum CornerType
    CornerTypeTopRight = Int
    2
        fromEnum CornerType
    CornerTypeBottomRight = Int
    3
        fromEnum (AnotherCornerType Int
    k) = Int
    k

        toEnum :: Int -> CornerType
    toEnum Int
    0 = CornerType
    CornerTypeTopLeft
        toEnum Int
    1 = CornerType
    CornerTypeBottomLeft
        toEnum Int
    2 = CornerType
    CornerTypeTopRight
        toEnum Int
    3 = CornerType
    CornerTypeBottomRight
        toEnum Int
    k = Int -> CornerType
    AnotherCornerType Int
    k

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

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

    foreign import ccall "gtk_corner_type_get_type" c_gtk_corner_type_get_type ::
        IO GType

    instance B.Types.TypedObject CornerType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_corner_type_get_type

    instance B.Types.BoxedEnum CornerType

    -- Enum CellRendererMode
    -- | Identifies how the user can interact with a particular cell.
    data CellRendererMode =
          CellRendererModeInert
        -- ^ The cell is just for display
        --  and cannot be interacted with.  Note that this doesn’t mean that eg. the
        --  row being drawn can’t be selected -- just that a particular element of
        --  it cannot be individually modified.
        | CellRendererModeActivatable
        -- ^ The cell can be clicked.
        | CellRendererModeEditable
        -- ^ The cell can be edited or otherwise modified.
        | AnotherCellRendererMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> CellRendererMode -> ShowS
    [CellRendererMode] -> ShowS
    CellRendererMode -> String
    (Int -> CellRendererMode -> ShowS)
    -> (CellRendererMode -> String)
    -> ([CellRendererMode] -> ShowS)
    -> Show CellRendererMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CellRendererMode -> ShowS
    showsPrec :: Int -> CellRendererMode -> ShowS
    $cshow :: CellRendererMode -> String
    show :: CellRendererMode -> String
    $cshowList :: [CellRendererMode] -> ShowS
    showList :: [CellRendererMode] -> ShowS
    Show, CellRendererMode -> CellRendererMode -> Bool
    (CellRendererMode -> CellRendererMode -> Bool)
    -> (CellRendererMode -> CellRendererMode -> Bool)
    -> Eq CellRendererMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CellRendererMode -> CellRendererMode -> Bool
    == :: CellRendererMode -> CellRendererMode -> Bool
    $c/= :: CellRendererMode -> CellRendererMode -> Bool
    /= :: CellRendererMode -> CellRendererMode -> Bool
    Eq)

    instance P.Enum CellRendererMode where
        fromEnum :: CellRendererMode -> Int
    fromEnum CellRendererMode
    CellRendererModeInert = Int
    0
        fromEnum CellRendererMode
    CellRendererModeActivatable = Int
    1
        fromEnum CellRendererMode
    CellRendererModeEditable = Int
    2
        fromEnum (AnotherCellRendererMode Int
    k) = Int
    k

        toEnum :: Int -> CellRendererMode
    toEnum Int
    0 = CellRendererMode
    CellRendererModeInert
        toEnum Int
    1 = CellRendererMode
    CellRendererModeActivatable
        toEnum Int
    2 = CellRendererMode
    CellRendererModeEditable
        toEnum Int
    k = Int -> CellRendererMode
    AnotherCellRendererMode Int
    k

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

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

    foreign import ccall "gtk_cell_renderer_mode_get_type" c_gtk_cell_renderer_mode_get_type ::
        IO GType

    instance B.Types.TypedObject CellRendererMode where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_cell_renderer_mode_get_type

    instance B.Types.BoxedEnum CellRendererMode

    -- Enum CellRendererAccelMode
    -- | Determines if the edited accelerators are GTK+ accelerators. If
    -- they are, consumed modifiers are suppressed, only accelerators
    -- accepted by GTK+ are allowed, and the accelerators are rendered
    -- in the same way as they are in menus.
    data CellRendererAccelMode =
          CellRendererAccelModeGtk
        -- ^ GTK+ accelerators mode
        | CellRendererAccelModeOther
        -- ^ Other accelerator mode
        -- GTK_CELL_RENDERER_ACCEL_MODE_MODIFIER_TAP: Bare modifiers mode
        | CellRendererAccelModeModifierTap
        -- ^ /No description available in the introspection data./
        | AnotherCellRendererAccelMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> CellRendererAccelMode -> ShowS
    [CellRendererAccelMode] -> ShowS
    CellRendererAccelMode -> String
    (Int -> CellRendererAccelMode -> ShowS)
    -> (CellRendererAccelMode -> String)
    -> ([CellRendererAccelMode] -> ShowS)
    -> Show CellRendererAccelMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CellRendererAccelMode -> ShowS
    showsPrec :: Int -> CellRendererAccelMode -> ShowS
    $cshow :: CellRendererAccelMode -> String
    show :: CellRendererAccelMode -> String
    $cshowList :: [CellRendererAccelMode] -> ShowS
    showList :: [CellRendererAccelMode] -> ShowS
    Show, CellRendererAccelMode -> CellRendererAccelMode -> Bool
    (CellRendererAccelMode -> CellRendererAccelMode -> Bool)
    -> (CellRendererAccelMode -> CellRendererAccelMode -> Bool)
    -> Eq CellRendererAccelMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CellRendererAccelMode -> CellRendererAccelMode -> Bool
    == :: CellRendererAccelMode -> CellRendererAccelMode -> Bool
    $c/= :: CellRendererAccelMode -> CellRendererAccelMode -> Bool
    /= :: CellRendererAccelMode -> CellRendererAccelMode -> Bool
    Eq)

    instance P.Enum CellRendererAccelMode where
        fromEnum :: CellRendererAccelMode -> Int
    fromEnum CellRendererAccelMode
    CellRendererAccelModeGtk = Int
    0
        fromEnum CellRendererAccelMode
    CellRendererAccelModeOther = Int
    1
        fromEnum CellRendererAccelMode
    CellRendererAccelModeModifierTap = Int
    2
        fromEnum (AnotherCellRendererAccelMode Int
    k) = Int
    k

        toEnum :: Int -> CellRendererAccelMode
    toEnum Int
    0 = CellRendererAccelMode
    CellRendererAccelModeGtk
        toEnum Int
    1 = CellRendererAccelMode
    CellRendererAccelModeOther
        toEnum Int
    2 = CellRendererAccelMode
    CellRendererAccelModeModifierTap
        toEnum Int
    k = Int -> CellRendererAccelMode
    AnotherCellRendererAccelMode Int
    k

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

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

    foreign import ccall "gtk_cell_renderer_accel_mode_get_type" c_gtk_cell_renderer_accel_mode_get_type ::
        IO GType

    instance B.Types.TypedObject CellRendererAccelMode where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_cell_renderer_accel_mode_get_type

    instance B.Types.BoxedEnum CellRendererAccelMode

    -- Enum ButtonsType
    -- | Prebuilt sets of buttons for the dialog. If
    -- none of these choices are appropriate, simply use 'GI.Gtk.Enums.ButtonsTypeNone'
    -- then call @/gtk_dialog_add_buttons()/@.
    --
    -- > Please note that 'GI.Gtk.Enums.ButtonsTypeOk', 'GI.Gtk.Enums.ButtonsTypeYesNo'
    -- > and 'GI.Gtk.Enums.ButtonsTypeOkCancel' are discouraged by the
    -- > <http://library.gnome.org/devel/hig-book/stable/ GNOME Human Interface Guidelines>.
    data ButtonsType =
          ButtonsTypeNone
        -- ^ no buttons at all
        | ButtonsTypeOk
        -- ^ an OK button
        | ButtonsTypeClose
        -- ^ a Close button
        | ButtonsTypeCancel
        -- ^ a Cancel button
        | ButtonsTypeYesNo
        -- ^ Yes and No buttons
        | ButtonsTypeOkCancel
        -- ^ OK and Cancel buttons
        | AnotherButtonsType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ButtonsType -> ShowS
    [ButtonsType] -> ShowS
    ButtonsType -> String
    (Int -> ButtonsType -> ShowS)
    -> (ButtonsType -> String)
    -> ([ButtonsType] -> ShowS)
    -> Show ButtonsType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ButtonsType -> ShowS
    showsPrec :: Int -> ButtonsType -> ShowS
    $cshow :: ButtonsType -> String
    show :: ButtonsType -> String
    $cshowList :: [ButtonsType] -> ShowS
    showList :: [ButtonsType] -> ShowS
    Show, ButtonsType -> ButtonsType -> Bool
    (ButtonsType -> ButtonsType -> Bool)
    -> (ButtonsType -> ButtonsType -> Bool) -> Eq ButtonsType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ButtonsType -> ButtonsType -> Bool
    == :: ButtonsType -> ButtonsType -> Bool
    $c/= :: ButtonsType -> ButtonsType -> Bool
    /= :: ButtonsType -> ButtonsType -> Bool
    Eq)

    instance P.Enum ButtonsType where
        fromEnum :: ButtonsType -> Int
    fromEnum ButtonsType
    ButtonsTypeNone = Int
    0
        fromEnum ButtonsType
    ButtonsTypeOk = Int
    1
        fromEnum ButtonsType
    ButtonsTypeClose = Int
    2
        fromEnum ButtonsType
    ButtonsTypeCancel = Int
    3
        fromEnum ButtonsType
    ButtonsTypeYesNo = Int
    4
        fromEnum ButtonsType
    ButtonsTypeOkCancel = Int
    5
        fromEnum (AnotherButtonsType Int
    k) = Int
    k

        toEnum :: Int -> ButtonsType
    toEnum Int
    0 = ButtonsType
    ButtonsTypeNone
        toEnum Int
    1 = ButtonsType
    ButtonsTypeOk
        toEnum Int
    2 = ButtonsType
    ButtonsTypeClose
        toEnum Int
    3 = ButtonsType
    ButtonsTypeCancel
        toEnum Int
    4 = ButtonsType
    ButtonsTypeYesNo
        toEnum Int
    5 = ButtonsType
    ButtonsTypeOkCancel
        toEnum Int
    k = Int -> ButtonsType
    AnotherButtonsType Int
    k

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

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

    foreign import ccall "gtk_buttons_type_get_type" c_gtk_buttons_type_get_type ::
        IO GType

    instance B.Types.TypedObject ButtonsType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_buttons_type_get_type

    instance B.Types.BoxedEnum ButtonsType

    -- Enum ButtonRole
    -- | The role specifies the desired appearance of a t'GI.Gtk.Objects.ModelButton.ModelButton'.
    data ButtonRole =
          ButtonRoleNormal
        -- ^ A plain button
        | ButtonRoleCheck
        -- ^ A check button
        | ButtonRoleRadio
        -- ^ A radio button
        | AnotherButtonRole Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ButtonRole -> ShowS
    [ButtonRole] -> ShowS
    ButtonRole -> String
    (Int -> ButtonRole -> ShowS)
    -> (ButtonRole -> String)
    -> ([ButtonRole] -> ShowS)
    -> Show ButtonRole
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ButtonRole -> ShowS
    showsPrec :: Int -> ButtonRole -> ShowS
    $cshow :: ButtonRole -> String
    show :: ButtonRole -> String
    $cshowList :: [ButtonRole] -> ShowS
    showList :: [ButtonRole] -> ShowS
    Show, ButtonRole -> ButtonRole -> Bool
    (ButtonRole -> ButtonRole -> Bool)
    -> (ButtonRole -> ButtonRole -> Bool) -> Eq ButtonRole
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ButtonRole -> ButtonRole -> Bool
    == :: ButtonRole -> ButtonRole -> Bool
    $c/= :: ButtonRole -> ButtonRole -> Bool
    /= :: ButtonRole -> ButtonRole -> Bool
    Eq)

    instance P.Enum ButtonRole where
        fromEnum :: ButtonRole -> Int
    fromEnum ButtonRole
    ButtonRoleNormal = Int
    0
        fromEnum ButtonRole
    ButtonRoleCheck = Int
    1
        fromEnum ButtonRole
    ButtonRoleRadio = Int
    2
        fromEnum (AnotherButtonRole Int
    k) = Int
    k

        toEnum :: Int -> ButtonRole
    toEnum Int
    0 = ButtonRole
    ButtonRoleNormal
        toEnum Int
    1 = ButtonRole
    ButtonRoleCheck
        toEnum Int
    2 = ButtonRole
    ButtonRoleRadio
        toEnum Int
    k = Int -> ButtonRole
    AnotherButtonRole Int
    k

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

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

    foreign import ccall "gtk_button_role_get_type" c_gtk_button_role_get_type ::
        IO GType

    instance B.Types.TypedObject ButtonRole where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_button_role_get_type

    instance B.Types.BoxedEnum ButtonRole

    -- Enum ButtonBoxStyle
    -- | Used to dictate the style that a t'GI.Gtk.Objects.ButtonBox.ButtonBox' uses to layout the buttons it
    -- contains.
    data ButtonBoxStyle =
          ButtonBoxStyleSpread
        -- ^ Buttons are evenly spread across the box.
        | ButtonBoxStyleEdge
        -- ^ Buttons are placed at the edges of the box.
        | ButtonBoxStyleStart
        -- ^ Buttons are grouped towards the start of the box,
        --   (on the left for a HBox, or the top for a VBox).
        | ButtonBoxStyleEnd
        -- ^ Buttons are grouped towards the end of the box,
        --   (on the right for a HBox, or the bottom for a VBox).
        | ButtonBoxStyleCenter
        -- ^ Buttons are centered in the box. Since 2.12.
        | ButtonBoxStyleExpand
        -- ^ Buttons expand to fill the box. This entails giving
        --   buttons a \"linked\" appearance, making button sizes homogeneous, and
        --   setting spacing to 0 (same as calling 'GI.Gtk.Objects.Box.boxSetHomogeneous' and
        --   'GI.Gtk.Objects.Box.boxSetSpacing' manually). Since 3.12.
        | AnotherButtonBoxStyle Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ButtonBoxStyle -> ShowS
    [ButtonBoxStyle] -> ShowS
    ButtonBoxStyle -> String
    (Int -> ButtonBoxStyle -> ShowS)
    -> (ButtonBoxStyle -> String)
    -> ([ButtonBoxStyle] -> ShowS)
    -> Show ButtonBoxStyle
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ButtonBoxStyle -> ShowS
    showsPrec :: Int -> ButtonBoxStyle -> ShowS
    $cshow :: ButtonBoxStyle -> String
    show :: ButtonBoxStyle -> String
    $cshowList :: [ButtonBoxStyle] -> ShowS
    showList :: [ButtonBoxStyle] -> ShowS
    Show, ButtonBoxStyle -> ButtonBoxStyle -> Bool
    (ButtonBoxStyle -> ButtonBoxStyle -> Bool)
    -> (ButtonBoxStyle -> ButtonBoxStyle -> Bool) -> Eq ButtonBoxStyle
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ButtonBoxStyle -> ButtonBoxStyle -> Bool
    == :: ButtonBoxStyle -> ButtonBoxStyle -> Bool
    $c/= :: ButtonBoxStyle -> ButtonBoxStyle -> Bool
    /= :: ButtonBoxStyle -> ButtonBoxStyle -> Bool
    Eq)

    instance P.Enum ButtonBoxStyle where
        fromEnum :: ButtonBoxStyle -> Int
    fromEnum ButtonBoxStyle
    ButtonBoxStyleSpread = Int
    1
        fromEnum ButtonBoxStyle
    ButtonBoxStyleEdge = Int
    2
        fromEnum ButtonBoxStyle
    ButtonBoxStyleStart = Int
    3
        fromEnum ButtonBoxStyle
    ButtonBoxStyleEnd = Int
    4
        fromEnum ButtonBoxStyle
    ButtonBoxStyleCenter = Int
    5
        fromEnum ButtonBoxStyle
    ButtonBoxStyleExpand = Int
    6
        fromEnum (AnotherButtonBoxStyle Int
    k) = Int
    k

        toEnum :: Int -> ButtonBoxStyle
    toEnum Int
    1 = ButtonBoxStyle
    ButtonBoxStyleSpread
        toEnum Int
    2 = ButtonBoxStyle
    ButtonBoxStyleEdge
        toEnum Int
    3 = ButtonBoxStyle
    ButtonBoxStyleStart
        toEnum Int
    4 = ButtonBoxStyle
    ButtonBoxStyleEnd
        toEnum Int
    5 = ButtonBoxStyle
    ButtonBoxStyleCenter
        toEnum Int
    6 = ButtonBoxStyle
    ButtonBoxStyleExpand
        toEnum Int
    k = Int -> ButtonBoxStyle
    AnotherButtonBoxStyle Int
    k

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

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

    foreign import ccall "gtk_button_box_style_get_type" c_gtk_button_box_style_get_type ::
        IO GType

    instance B.Types.TypedObject ButtonBoxStyle where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_button_box_style_get_type

    instance B.Types.BoxedEnum ButtonBoxStyle

    -- Enum BuilderError
    -- | Error codes that identify various errors that can occur while using
    -- t'GI.Gtk.Objects.Builder.Builder'.
    data BuilderError =
          BuilderErrorInvalidTypeFunction
        -- ^ A type-func attribute didn’t name
        --  a function that returns a t'GType'.
        | BuilderErrorUnhandledTag
        -- ^ The input contained a tag that t'GI.Gtk.Objects.Builder.Builder'
        --  can’t handle.
        | BuilderErrorMissingAttribute
        -- ^ An attribute that is required by
        --  t'GI.Gtk.Objects.Builder.Builder' was missing.
        | BuilderErrorInvalidAttribute
        -- ^ t'GI.Gtk.Objects.Builder.Builder' found an attribute that
        --  it doesn’t understand.
        | BuilderErrorInvalidTag
        -- ^ t'GI.Gtk.Objects.Builder.Builder' found a tag that
        --  it doesn’t understand.
        | BuilderErrorMissingPropertyValue
        -- ^ A required property value was
        --  missing.
        | BuilderErrorInvalidValue
        -- ^ t'GI.Gtk.Objects.Builder.Builder' couldn’t parse
        --  some attribute value.
        | BuilderErrorVersionMismatch
        -- ^ The input file requires a newer version
        --  of GTK+.
        | BuilderErrorDuplicateId
        -- ^ An object id occurred twice.
        | BuilderErrorObjectTypeRefused
        -- ^ A specified object type is of the same type or
        --  derived from the type of the composite class being extended with builder XML.
        | BuilderErrorTemplateMismatch
        -- ^ The wrong type was specified in a composite class’s template XML
        | BuilderErrorInvalidProperty
        -- ^ The specified property is unknown for the object class.
        | BuilderErrorInvalidSignal
        -- ^ The specified signal is unknown for the object class.
        | BuilderErrorInvalidId
        -- ^ An object id is unknown
        | AnotherBuilderError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> BuilderError -> ShowS
    [BuilderError] -> ShowS
    BuilderError -> String
    (Int -> BuilderError -> ShowS)
    -> (BuilderError -> String)
    -> ([BuilderError] -> ShowS)
    -> Show BuilderError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BuilderError -> ShowS
    showsPrec :: Int -> BuilderError -> ShowS
    $cshow :: BuilderError -> String
    show :: BuilderError -> String
    $cshowList :: [BuilderError] -> ShowS
    showList :: [BuilderError] -> ShowS
    Show, BuilderError -> BuilderError -> Bool
    (BuilderError -> BuilderError -> Bool)
    -> (BuilderError -> BuilderError -> Bool) -> Eq BuilderError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BuilderError -> BuilderError -> Bool
    == :: BuilderError -> BuilderError -> Bool
    $c/= :: BuilderError -> BuilderError -> Bool
    /= :: BuilderError -> BuilderError -> Bool
    Eq)

    instance P.Enum BuilderError where
        fromEnum :: BuilderError -> Int
    fromEnum BuilderError
    BuilderErrorInvalidTypeFunction = Int
    0
        fromEnum BuilderError
    BuilderErrorUnhandledTag = Int
    1
        fromEnum BuilderError
    BuilderErrorMissingAttribute = Int
    2
        fromEnum BuilderError
    BuilderErrorInvalidAttribute = Int
    3
        fromEnum BuilderError
    BuilderErrorInvalidTag = Int
    4
        fromEnum BuilderError
    BuilderErrorMissingPropertyValue = Int
    5
        fromEnum BuilderError
    BuilderErrorInvalidValue = Int
    6
        fromEnum BuilderError
    BuilderErrorVersionMismatch = Int
    7
        fromEnum BuilderError
    BuilderErrorDuplicateId = Int
    8
        fromEnum BuilderError
    BuilderErrorObjectTypeRefused = Int
    9
        fromEnum BuilderError
    BuilderErrorTemplateMismatch = Int
    10
        fromEnum BuilderError
    BuilderErrorInvalidProperty = Int
    11
        fromEnum BuilderError
    BuilderErrorInvalidSignal = Int
    12
        fromEnum BuilderError
    BuilderErrorInvalidId = Int
    13
        fromEnum (AnotherBuilderError Int
    k) = Int
    k

        toEnum :: Int -> BuilderError
    toEnum Int
    0 = BuilderError
    BuilderErrorInvalidTypeFunction
        toEnum Int
    1 = BuilderError
    BuilderErrorUnhandledTag
        toEnum Int
    2 = BuilderError
    BuilderErrorMissingAttribute
        toEnum Int
    3 = BuilderError
    BuilderErrorInvalidAttribute
        toEnum Int
    4 = BuilderError
    BuilderErrorInvalidTag
        toEnum Int
    5 = BuilderError
    BuilderErrorMissingPropertyValue
        toEnum Int
    6 = BuilderError
    BuilderErrorInvalidValue
        toEnum Int
    7 = BuilderError
    BuilderErrorVersionMismatch
        toEnum Int
    8 = BuilderError
    BuilderErrorDuplicateId
        toEnum Int
    9 = BuilderError
    BuilderErrorObjectTypeRefused
        toEnum Int
    10 = BuilderError
    BuilderErrorTemplateMismatch
        toEnum Int
    11 = BuilderError
    BuilderErrorInvalidProperty
        toEnum Int
    12 = BuilderError
    BuilderErrorInvalidSignal
        toEnum Int
    13 = BuilderError
    BuilderErrorInvalidId
        toEnum Int
    k = Int -> BuilderError
    AnotherBuilderError Int
    k

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

    instance GErrorClass BuilderError where
        gerrorClassDomain :: BuilderError -> Text
    gerrorClassDomain BuilderError
    _ = Text
    "gtk-builder-error-quark"

    -- | Catch exceptions of type `BuilderError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
    catchBuilderError ::
        IO a ->
        (BuilderError -> GErrorMessage -> IO a) ->
        IO a
    catchBuilderError :: forall a. IO a -> (BuilderError -> Text -> IO a) -> IO a
    catchBuilderError = IO a -> (BuilderError -> Text -> IO a) -> IO a
    forall err a.
    GErrorClass err =>
    IO a -> (err -> Text -> IO a) -> IO a
    catchGErrorJustDomain

    -- | Handle exceptions of type `BuilderError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
    handleBuilderError ::
        (BuilderError -> GErrorMessage -> IO a) ->
        IO a ->
        IO a
    handleBuilderError :: forall a. (BuilderError -> Text -> IO a) -> IO a -> IO a
    handleBuilderError = (BuilderError -> Text -> IO a) -> IO a -> IO a
    forall err a.
    GErrorClass err =>
    (err -> Text -> IO a) -> IO a -> IO a
    handleGErrorJustDomain

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

    foreign import ccall "gtk_builder_error_get_type" c_gtk_builder_error_get_type ::
        IO GType

    instance B.Types.TypedObject BuilderError where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_builder_error_get_type

    instance B.Types.BoxedEnum BuilderError

    -- Enum BorderStyle
    -- | Describes how the border of a UI element should be rendered.
    data BorderStyle =
          BorderStyleNone
        -- ^ No visible border
        | BorderStyleSolid
        -- ^ A single line segment
        | BorderStyleInset
        -- ^ Looks as if the content is sunken into the canvas
        | BorderStyleOutset
        -- ^ Looks as if the content is coming out of the canvas
        | BorderStyleHidden
        -- ^ Same as /@gTKBORDERSTYLENONE@/
        | BorderStyleDotted
        -- ^ A series of round dots
        | BorderStyleDashed
        -- ^ A series of square-ended dashes
        | BorderStyleDouble
        -- ^ Two parallel lines with some space between them
        | BorderStyleGroove
        -- ^ Looks as if it were carved in the canvas
        | BorderStyleRidge
        -- ^ Looks as if it were coming out of the canvas
        | AnotherBorderStyle Int
        -- ^ Catch-all for unknown values
        deriving (Int -> BorderStyle -> ShowS
    [BorderStyle] -> ShowS
    BorderStyle -> String
    (Int -> BorderStyle -> ShowS)
    -> (BorderStyle -> String)
    -> ([BorderStyle] -> ShowS)
    -> Show BorderStyle
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BorderStyle -> ShowS
    showsPrec :: Int -> BorderStyle -> ShowS
    $cshow :: BorderStyle -> String
    show :: BorderStyle -> String
    $cshowList :: [BorderStyle] -> ShowS
    showList :: [BorderStyle] -> ShowS
    Show, BorderStyle -> BorderStyle -> Bool
    (BorderStyle -> BorderStyle -> Bool)
    -> (BorderStyle -> BorderStyle -> Bool) -> Eq BorderStyle
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BorderStyle -> BorderStyle -> Bool
    == :: BorderStyle -> BorderStyle -> Bool
    $c/= :: BorderStyle -> BorderStyle -> Bool
    /= :: BorderStyle -> BorderStyle -> Bool
    Eq)

    instance P.Enum BorderStyle where
        fromEnum :: BorderStyle -> Int
    fromEnum BorderStyle
    BorderStyleNone = Int
    0
        fromEnum BorderStyle
    BorderStyleSolid = Int
    1
        fromEnum BorderStyle
    BorderStyleInset = Int
    2
        fromEnum BorderStyle
    BorderStyleOutset = Int
    3
        fromEnum BorderStyle
    BorderStyleHidden = Int
    4
        fromEnum BorderStyle
    BorderStyleDotted = Int
    5
        fromEnum BorderStyle
    BorderStyleDashed = Int
    6
        fromEnum BorderStyle
    BorderStyleDouble = Int
    7
        fromEnum BorderStyle
    BorderStyleGroove = Int
    8
        fromEnum BorderStyle
    BorderStyleRidge = Int
    9
        fromEnum (AnotherBorderStyle Int
    k) = Int
    k

        toEnum :: Int -> BorderStyle
    toEnum Int
    0 = BorderStyle
    BorderStyleNone
        toEnum Int
    1 = BorderStyle
    BorderStyleSolid
        toEnum Int
    2 = BorderStyle
    BorderStyleInset
        toEnum Int
    3 = BorderStyle
    BorderStyleOutset
        toEnum Int
    4 = BorderStyle
    BorderStyleHidden
        toEnum Int
    5 = BorderStyle
    BorderStyleDotted
        toEnum Int
    6 = BorderStyle
    BorderStyleDashed
        toEnum Int
    7 = BorderStyle
    BorderStyleDouble
        toEnum Int
    8 = BorderStyle
    BorderStyleGroove
        toEnum Int
    9 = BorderStyle
    BorderStyleRidge
        toEnum Int
    k = Int -> BorderStyle
    AnotherBorderStyle Int
    k

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

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

    foreign import ccall "gtk_border_style_get_type" c_gtk_border_style_get_type ::
        IO GType

    instance B.Types.TypedObject BorderStyle where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_border_style_get_type

    instance B.Types.BoxedEnum BorderStyle

    -- Enum BaselinePosition
    -- | Whenever a container has some form of natural row it may align
    -- children in that row along a common typographical baseline. If
    -- the amount of verical space in the row is taller than the total
    -- requested height of the baseline-aligned children then it can use a
    -- t'GI.Gtk.Enums.BaselinePosition' to select where to put the baseline inside the
    -- extra availible space.
    --
    -- /Since: 3.10/
    data BaselinePosition =
          BaselinePositionTop
        -- ^ Align the baseline at the top
        | BaselinePositionCenter
        -- ^ Center the baseline
        | BaselinePositionBottom
        -- ^ Align the baseline at the bottom
        | AnotherBaselinePosition Int
        -- ^ Catch-all for unknown values
        deriving (Int -> BaselinePosition -> ShowS
    [BaselinePosition] -> ShowS
    BaselinePosition -> String
    (Int -> BaselinePosition -> ShowS)
    -> (BaselinePosition -> String)
    -> ([BaselinePosition] -> ShowS)
    -> Show BaselinePosition
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BaselinePosition -> ShowS
    showsPrec :: Int -> BaselinePosition -> ShowS
    $cshow :: BaselinePosition -> String
    show :: BaselinePosition -> String
    $cshowList :: [BaselinePosition] -> ShowS
    showList :: [BaselinePosition] -> ShowS
    Show, BaselinePosition -> BaselinePosition -> Bool
    (BaselinePosition -> BaselinePosition -> Bool)
    -> (BaselinePosition -> BaselinePosition -> Bool)
    -> Eq BaselinePosition
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BaselinePosition -> BaselinePosition -> Bool
    == :: BaselinePosition -> BaselinePosition -> Bool
    $c/= :: BaselinePosition -> BaselinePosition -> Bool
    /= :: BaselinePosition -> BaselinePosition -> Bool
    Eq)

    instance P.Enum BaselinePosition where
        fromEnum :: BaselinePosition -> Int
    fromEnum BaselinePosition
    BaselinePositionTop = Int
    0
        fromEnum BaselinePosition
    BaselinePositionCenter = Int
    1
        fromEnum BaselinePosition
    BaselinePositionBottom = Int
    2
        fromEnum (AnotherBaselinePosition Int
    k) = Int
    k

        toEnum :: Int -> BaselinePosition
    toEnum Int
    0 = BaselinePosition
    BaselinePositionTop
        toEnum Int
    1 = BaselinePosition
    BaselinePositionCenter
        toEnum Int
    2 = BaselinePosition
    BaselinePositionBottom
        toEnum Int
    k = Int -> BaselinePosition
    AnotherBaselinePosition Int
    k

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

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

    foreign import ccall "gtk_baseline_position_get_type" c_gtk_baseline_position_get_type ::
        IO GType

    instance B.Types.TypedObject BaselinePosition where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_baseline_position_get_type

    instance B.Types.BoxedEnum BaselinePosition

    -- Enum AssistantPageType
    -- | An enum for determining the page role inside the t'GI.Gtk.Objects.Assistant.Assistant'. It\'s
    -- used to handle buttons sensitivity and visibility.
    --
    -- Note that an assistant needs to end its page flow with a page of type
    -- 'GI.Gtk.Enums.AssistantPageTypeConfirm', 'GI.Gtk.Enums.AssistantPageTypeSummary' or
    -- 'GI.Gtk.Enums.AssistantPageTypeProgress' to be correct.
    --
    -- The Cancel button will only be shown if the page isn’t “committed”.
    -- See 'GI.Gtk.Objects.Assistant.assistantCommit' for details.
    data AssistantPageType =
          AssistantPageTypeContent
        -- ^ The page has regular contents. Both the
        --  Back and forward buttons will be shown.
        | AssistantPageTypeIntro
        -- ^ The page contains an introduction to the
        --  assistant task. Only the Forward button will be shown if there is a
        --   next page.
        | AssistantPageTypeConfirm
        -- ^ The page lets the user confirm or deny the
        --  changes. The Back and Apply buttons will be shown.
        | AssistantPageTypeSummary
        -- ^ The page informs the user of the changes
        --  done. Only the Close button will be shown.
        | AssistantPageTypeProgress
        -- ^ Used for tasks that take a long time to
        --  complete, blocks the assistant until the page is marked as complete.
        --   Only the back button will be shown.
        | AssistantPageTypeCustom
        -- ^ Used for when other page types are not
        --  appropriate. No buttons will be shown, and the application must
        --  add its own buttons through 'GI.Gtk.Objects.Assistant.assistantAddActionWidget'.
        | AnotherAssistantPageType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AssistantPageType -> ShowS
    [AssistantPageType] -> ShowS
    AssistantPageType -> String
    (Int -> AssistantPageType -> ShowS)
    -> (AssistantPageType -> String)
    -> ([AssistantPageType] -> ShowS)
    -> Show AssistantPageType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AssistantPageType -> ShowS
    showsPrec :: Int -> AssistantPageType -> ShowS
    $cshow :: AssistantPageType -> String
    show :: AssistantPageType -> String
    $cshowList :: [AssistantPageType] -> ShowS
    showList :: [AssistantPageType] -> ShowS
    Show, AssistantPageType -> AssistantPageType -> Bool
    (AssistantPageType -> AssistantPageType -> Bool)
    -> (AssistantPageType -> AssistantPageType -> Bool)
    -> Eq AssistantPageType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AssistantPageType -> AssistantPageType -> Bool
    == :: AssistantPageType -> AssistantPageType -> Bool
    $c/= :: AssistantPageType -> AssistantPageType -> Bool
    /= :: AssistantPageType -> AssistantPageType -> Bool
    Eq)

    instance P.Enum AssistantPageType where
        fromEnum :: AssistantPageType -> Int
    fromEnum AssistantPageType
    AssistantPageTypeContent = Int
    0
        fromEnum AssistantPageType
    AssistantPageTypeIntro = Int
    1
        fromEnum AssistantPageType
    AssistantPageTypeConfirm = Int
    2
        fromEnum AssistantPageType
    AssistantPageTypeSummary = Int
    3
        fromEnum AssistantPageType
    AssistantPageTypeProgress = Int
    4
        fromEnum AssistantPageType
    AssistantPageTypeCustom = Int
    5
        fromEnum (AnotherAssistantPageType Int
    k) = Int
    k

        toEnum :: Int -> AssistantPageType
    toEnum Int
    0 = AssistantPageType
    AssistantPageTypeContent
        toEnum Int
    1 = AssistantPageType
    AssistantPageTypeIntro
        toEnum Int
    2 = AssistantPageType
    AssistantPageTypeConfirm
        toEnum Int
    3 = AssistantPageType
    AssistantPageTypeSummary
        toEnum Int
    4 = AssistantPageType
    AssistantPageTypeProgress
        toEnum Int
    5 = AssistantPageType
    AssistantPageTypeCustom
        toEnum Int
    k = Int -> AssistantPageType
    AnotherAssistantPageType Int
    k

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

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

    foreign import ccall "gtk_assistant_page_type_get_type" c_gtk_assistant_page_type_get_type ::
        IO GType

    instance B.Types.TypedObject AssistantPageType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_assistant_page_type_get_type

    instance B.Types.BoxedEnum AssistantPageType

    -- Enum ArrowType
    -- | Used to indicate the direction in which an arrow should point.
    data ArrowType =
          ArrowTypeUp
        -- ^ Represents an upward pointing arrow.
        | ArrowTypeDown
        -- ^ Represents a downward pointing arrow.
        | ArrowTypeLeft
        -- ^ Represents a left pointing arrow.
        | ArrowTypeRight
        -- ^ Represents a right pointing arrow.
        | ArrowTypeNone
        -- ^ No arrow. Since 2.10.
        | AnotherArrowType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ArrowType -> ShowS
    [ArrowType] -> ShowS
    ArrowType -> String
    (Int -> ArrowType -> ShowS)
    -> (ArrowType -> String)
    -> ([ArrowType] -> ShowS)
    -> Show ArrowType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ArrowType -> ShowS
    showsPrec :: Int -> ArrowType -> ShowS
    $cshow :: ArrowType -> String
    show :: ArrowType -> String
    $cshowList :: [ArrowType] -> ShowS
    showList :: [ArrowType] -> ShowS
    Show, ArrowType -> ArrowType -> Bool
    (ArrowType -> ArrowType -> Bool)
    -> (ArrowType -> ArrowType -> Bool) -> Eq ArrowType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ArrowType -> ArrowType -> Bool
    == :: ArrowType -> ArrowType -> Bool
    $c/= :: ArrowType -> ArrowType -> Bool
    /= :: ArrowType -> ArrowType -> Bool
    Eq)

    instance P.Enum ArrowType where
        fromEnum :: ArrowType -> Int
    fromEnum ArrowType
    ArrowTypeUp = Int
    0
        fromEnum ArrowType
    ArrowTypeDown = Int
    1
        fromEnum ArrowType
    ArrowTypeLeft = Int
    2
        fromEnum ArrowType
    ArrowTypeRight = Int
    3
        fromEnum ArrowType
    ArrowTypeNone = Int
    4
        fromEnum (AnotherArrowType Int
    k) = Int
    k

        toEnum :: Int -> ArrowType
    toEnum Int
    0 = ArrowType
    ArrowTypeUp
        toEnum Int
    1 = ArrowType
    ArrowTypeDown
        toEnum Int
    2 = ArrowType
    ArrowTypeLeft
        toEnum Int
    3 = ArrowType
    ArrowTypeRight
        toEnum Int
    4 = ArrowType
    ArrowTypeNone
        toEnum Int
    k = Int -> ArrowType
    AnotherArrowType Int
    k

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

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

    foreign import ccall "gtk_arrow_type_get_type" c_gtk_arrow_type_get_type ::
        IO GType

    instance B.Types.TypedObject ArrowType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_arrow_type_get_type

    instance B.Types.BoxedEnum ArrowType

    -- Enum ArrowPlacement
    -- | Used to specify the placement of scroll arrows in scrolling menus.
    data ArrowPlacement =
          ArrowPlacementBoth
        -- ^ Place one arrow on each end of the menu.
        | ArrowPlacementStart
        -- ^ Place both arrows at the top of the menu.
        | ArrowPlacementEnd
        -- ^ Place both arrows at the bottom of the menu.
        | AnotherArrowPlacement Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ArrowPlacement -> ShowS
    [ArrowPlacement] -> ShowS
    ArrowPlacement -> String
    (Int -> ArrowPlacement -> ShowS)
    -> (ArrowPlacement -> String)
    -> ([ArrowPlacement] -> ShowS)
    -> Show ArrowPlacement
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ArrowPlacement -> ShowS
    showsPrec :: Int -> ArrowPlacement -> ShowS
    $cshow :: ArrowPlacement -> String
    show :: ArrowPlacement -> String
    $cshowList :: [ArrowPlacement] -> ShowS
    showList :: [ArrowPlacement] -> ShowS
    Show, ArrowPlacement -> ArrowPlacement -> Bool
    (ArrowPlacement -> ArrowPlacement -> Bool)
    -> (ArrowPlacement -> ArrowPlacement -> Bool) -> Eq ArrowPlacement
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ArrowPlacement -> ArrowPlacement -> Bool
    == :: ArrowPlacement -> ArrowPlacement -> Bool
    $c/= :: ArrowPlacement -> ArrowPlacement -> Bool
    /= :: ArrowPlacement -> ArrowPlacement -> Bool
    Eq)

    instance P.Enum ArrowPlacement where
        fromEnum :: ArrowPlacement -> Int
    fromEnum ArrowPlacement
    ArrowPlacementBoth = Int
    0
        fromEnum ArrowPlacement
    ArrowPlacementStart = Int
    1
        fromEnum ArrowPlacement
    ArrowPlacementEnd = Int
    2
        fromEnum (AnotherArrowPlacement Int
    k) = Int
    k

        toEnum :: Int -> ArrowPlacement
    toEnum Int
    0 = ArrowPlacement
    ArrowPlacementBoth
        toEnum Int
    1 = ArrowPlacement
    ArrowPlacementStart
        toEnum Int
    2 = ArrowPlacement
    ArrowPlacementEnd
        toEnum Int
    k = Int -> ArrowPlacement
    AnotherArrowPlacement Int
    k

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

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

    foreign import ccall "gtk_arrow_placement_get_type" c_gtk_arrow_placement_get_type ::
        IO GType

    instance B.Types.TypedObject ArrowPlacement where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_arrow_placement_get_type

    instance B.Types.BoxedEnum ArrowPlacement

    -- Enum Align
    -- | Controls how a widget deals with extra space in a single (x or y)
    -- dimension.
    --
    -- Alignment only matters if the widget receives a “too large” allocation,
    -- for example if you packed the widget with the [Widget:expand]("GI.Gtk.Objects.Widget#g:attr:expand")
    -- flag inside a t'GI.Gtk.Objects.Box.Box', then the widget might get extra space.  If
    -- you have for example a 16x16 icon inside a 32x32 space, the icon
    -- could be scaled and stretched, it could be centered, or it could be
    -- positioned to one side of the space.
    --
    -- Note that in horizontal context /@gTKALIGNSTART@/ and /@gTKALIGNEND@/
    -- are interpreted relative to text direction.
    --
    -- GTK_ALIGN_BASELINE support for it is optional for containers and widgets, and
    -- it is only supported for vertical alignment.  When its not supported by
    -- a child or a container it is treated as /@gTKALIGNFILL@/.
    data Align =
          AlignFill
        -- ^ stretch to fill all space if possible, center if
        --     no meaningful way to stretch
        | AlignStart
        -- ^ snap to left or top side, leaving space on right
        --     or bottom
        | AlignEnd
        -- ^ snap to right or bottom side, leaving space on left
        --     or top
        | AlignCenter
        -- ^ center natural width of widget inside the
        --     allocation
        | AlignBaseline
        -- ^ align the widget according to the baseline. Since 3.10.
        | AnotherAlign Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Align -> ShowS
    [Align] -> ShowS
    Align -> String
    (Int -> Align -> ShowS)
    -> (Align -> String) -> ([Align] -> ShowS) -> Show Align
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Align -> ShowS
    showsPrec :: Int -> Align -> ShowS
    $cshow :: Align -> String
    show :: Align -> String
    $cshowList :: [Align] -> ShowS
    showList :: [Align] -> ShowS
    Show, Align -> Align -> Bool
    (Align -> Align -> Bool) -> (Align -> Align -> Bool) -> Eq Align
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Align -> Align -> Bool
    == :: Align -> Align -> Bool
    $c/= :: Align -> Align -> Bool
    /= :: Align -> Align -> Bool
    Eq)

    instance P.Enum Align where
        fromEnum :: Align -> Int
    fromEnum Align
    AlignFill = Int
    0
        fromEnum Align
    AlignStart = Int
    1
        fromEnum Align
    AlignEnd = Int
    2
        fromEnum Align
    AlignCenter = Int
    3
        fromEnum Align
    AlignBaseline = Int
    4
        fromEnum (AnotherAlign Int
    k) = Int
    k

        toEnum :: Int -> Align
    toEnum Int
    0 = Align
    AlignFill
        toEnum Int
    1 = Align
    AlignStart
        toEnum Int
    2 = Align
    AlignEnd
        toEnum Int
    3 = Align
    AlignCenter
        toEnum Int
    4 = Align
    AlignBaseline
        toEnum Int
    k = Int -> Align
    AnotherAlign Int
    k

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

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

    foreign import ccall "gtk_align_get_type" c_gtk_align_get_type ::
        IO GType

    instance B.Types.TypedObject Align where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_align_get_type

    instance B.Types.BoxedEnum Align