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

    -- ** AccessibleAnnouncementPriority #enum:AccessibleAnnouncementPriority#

        AccessibleAnnouncementPriority(..)      ,

    -- ** AccessibleAutocomplete #enum:AccessibleAutocomplete#

        AccessibleAutocomplete(..)              ,

    -- ** AccessibleInvalidState #enum:AccessibleInvalidState#

        AccessibleInvalidState(..)              ,

    -- ** AccessiblePlatformState #enum:AccessiblePlatformState#

        AccessiblePlatformState(..)             ,

    -- ** AccessibleProperty #enum:AccessibleProperty#

        AccessibleProperty(..)                  ,

    -- ** AccessibleRelation #enum:AccessibleRelation#

        AccessibleRelation(..)                  ,

    -- ** AccessibleRole #enum:AccessibleRole#

        AccessibleRole(..)                      ,

    -- ** AccessibleSort #enum:AccessibleSort#

        AccessibleSort(..)                      ,

    -- ** AccessibleState #enum:AccessibleState#

        AccessibleState(..)                     ,

    -- ** AccessibleTextContentChange #enum:AccessibleTextContentChange#

        AccessibleTextContentChange(..)         ,

    -- ** AccessibleTextGranularity #enum:AccessibleTextGranularity#

        AccessibleTextGranularity(..)           ,

    -- ** AccessibleTristate #enum:AccessibleTristate#

        AccessibleTristate(..)                  ,

    -- ** Align #enum:Align#

        Align(..)                               ,

    -- ** ArrowType #enum:ArrowType#

        ArrowType(..)                           ,

    -- ** AssistantPageType #enum:AssistantPageType#

        AssistantPageType(..)                   ,

    -- ** BaselinePosition #enum:BaselinePosition#

        BaselinePosition(..)                    ,

    -- ** BorderStyle #enum:BorderStyle#

        BorderStyle(..)                         ,

    -- ** BuilderError #enum:BuilderError#

        BuilderError(..)                        ,
        catchBuilderError                       ,
        handleBuilderError                      ,

    -- ** ButtonsType #enum:ButtonsType#

        ButtonsType(..)                         ,

    -- ** CellRendererAccelMode #enum:CellRendererAccelMode#

        CellRendererAccelMode(..)               ,

    -- ** CellRendererMode #enum:CellRendererMode#

        CellRendererMode(..)                    ,

    -- ** Collation #enum:Collation#

        Collation(..)                           ,

    -- ** ConstraintAttribute #enum:ConstraintAttribute#

        ConstraintAttribute(..)                 ,

    -- ** ConstraintRelation #enum:ConstraintRelation#

        ConstraintRelation(..)                  ,

    -- ** ConstraintStrength #enum:ConstraintStrength#

        ConstraintStrength(..)                  ,

    -- ** ConstraintVflParserError #enum:ConstraintVflParserError#

        ConstraintVflParserError(..)            ,
        catchConstraintVflParserError           ,
        handleConstraintVflParserError          ,

    -- ** ContentFit #enum:ContentFit#

        ContentFit(..)                          ,

    -- ** CornerType #enum:CornerType#

        CornerType(..)                          ,

    -- ** CssParserError #enum:CssParserError#

        CssParserError(..)                      ,
        catchCssParserError                     ,
        handleCssParserError                    ,

    -- ** CssParserWarning #enum:CssParserWarning#

        CssParserWarning(..)                    ,

    -- ** DeleteType #enum:DeleteType#

        DeleteType(..)                          ,

    -- ** DialogError #enum:DialogError#

        DialogError(..)                         ,
        catchDialogError                        ,
        handleDialogError                       ,

    -- ** DirectionType #enum:DirectionType#

        DirectionType(..)                       ,

    -- ** EditableProperties #enum:EditableProperties#

        EditableProperties(..)                  ,

    -- ** EntryIconPosition #enum:EntryIconPosition#

        EntryIconPosition(..)                   ,

    -- ** EventSequenceState #enum:EventSequenceState#

        EventSequenceState(..)                  ,

    -- ** FileChooserAction #enum:FileChooserAction#

        FileChooserAction(..)                   ,

    -- ** FileChooserError #enum:FileChooserError#

        FileChooserError(..)                    ,
        catchFileChooserError                   ,
        handleFileChooserError                  ,

    -- ** FilterChange #enum:FilterChange#

        FilterChange(..)                        ,

    -- ** FilterMatch #enum:FilterMatch#

        FilterMatch(..)                         ,

    -- ** FontLevel #enum:FontLevel#

        FontLevel(..)                           ,

    -- ** FontRendering #enum:FontRendering#

        FontRendering(..)                       ,

    -- ** GraphicsOffloadEnabled #enum:GraphicsOffloadEnabled#

        GraphicsOffloadEnabled(..)              ,

    -- ** IconSize #enum:IconSize#

        IconSize(..)                            ,

    -- ** IconThemeError #enum:IconThemeError#

        IconThemeError(..)                      ,
        catchIconThemeError                     ,
        handleIconThemeError                    ,

    -- ** IconViewDropPosition #enum:IconViewDropPosition#

        IconViewDropPosition(..)                ,

    -- ** ImageType #enum:ImageType#

        ImageType(..)                           ,

    -- ** InputPurpose #enum:InputPurpose#

        InputPurpose(..)                        ,

    -- ** InscriptionOverflow #enum:InscriptionOverflow#

        InscriptionOverflow(..)                 ,

    -- ** InterfaceColorScheme #enum:InterfaceColorScheme#

        InterfaceColorScheme(..)                ,

    -- ** InterfaceContrast #enum:InterfaceContrast#

        InterfaceContrast(..)                   ,

    -- ** Justification #enum:Justification#

        Justification(..)                       ,

    -- ** LevelBarMode #enum:LevelBarMode#

        LevelBarMode(..)                        ,

    -- ** License #enum:License#

        License(..)                             ,

    -- ** ListTabBehavior #enum:ListTabBehavior#

        ListTabBehavior(..)                     ,

    -- ** MessageType #enum:MessageType#

        MessageType(..)                         ,

    -- ** MovementStep #enum:MovementStep#

        MovementStep(..)                        ,

    -- ** NaturalWrapMode #enum:NaturalWrapMode#

        NaturalWrapMode(..)                     ,

    -- ** NotebookTab #enum:NotebookTab#

        NotebookTab(..)                         ,

    -- ** NumberUpLayout #enum:NumberUpLayout#

        NumberUpLayout(..)                      ,

    -- ** Ordering #enum:Ordering#

        Ordering(..)                            ,

    -- ** Orientation #enum:Orientation#

        Orientation(..)                         ,

    -- ** Overflow #enum:Overflow#

        Overflow(..)                            ,

    -- ** PackType #enum:PackType#

        PackType(..)                            ,

    -- ** PadActionType #enum:PadActionType#

        PadActionType(..)                       ,

    -- ** PageOrientation #enum:PageOrientation#

        PageOrientation(..)                     ,

    -- ** PageSet #enum:PageSet#

        PageSet(..)                             ,

    -- ** PanDirection #enum:PanDirection#

        PanDirection(..)                        ,

    -- ** PolicyType #enum:PolicyType#

        PolicyType(..)                          ,

    -- ** 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(..)                         ,

    -- ** PropagationLimit #enum:PropagationLimit#

        PropagationLimit(..)                    ,

    -- ** PropagationPhase #enum:PropagationPhase#

        PropagationPhase(..)                    ,

    -- ** RecentManagerError #enum:RecentManagerError#

        RecentManagerError(..)                  ,
        catchRecentManagerError                 ,
        handleRecentManagerError                ,

    -- ** ReducedMotion #enum:ReducedMotion#

        ReducedMotion(..)                       ,

    -- ** ResponseType #enum:ResponseType#

        ResponseType(..)                        ,

    -- ** RestoreReason #enum:RestoreReason#

        RestoreReason(..)                       ,

    -- ** RevealerTransitionType #enum:RevealerTransitionType#

        RevealerTransitionType(..)              ,

    -- ** ScrollStep #enum:ScrollStep#

        ScrollStep(..)                          ,

    -- ** ScrollType #enum:ScrollType#

        ScrollType(..)                          ,

    -- ** ScrollablePolicy #enum:ScrollablePolicy#

        ScrollablePolicy(..)                    ,

    -- ** SelectionMode #enum:SelectionMode#

        SelectionMode(..)                       ,

    -- ** SensitivityType #enum:SensitivityType#

        SensitivityType(..)                     ,

    -- ** ShortcutScope #enum:ShortcutScope#

        ShortcutScope(..)                       ,

    -- ** ShortcutType #enum:ShortcutType#

        ShortcutType(..)                        ,

    -- ** SizeGroupMode #enum:SizeGroupMode#

        SizeGroupMode(..)                       ,

    -- ** SizeRequestMode #enum:SizeRequestMode#

        SizeRequestMode(..)                     ,

    -- ** SortType #enum:SortType#

        SortType(..)                            ,

    -- ** SorterChange #enum:SorterChange#

        SorterChange(..)                        ,

    -- ** SorterOrder #enum:SorterOrder#

        SorterOrder(..)                         ,

    -- ** SpinButtonUpdatePolicy #enum:SpinButtonUpdatePolicy#

        SpinButtonUpdatePolicy(..)              ,

    -- ** SpinType #enum:SpinType#

        SpinType(..)                            ,

    -- ** StackTransitionType #enum:StackTransitionType#

        StackTransitionType(..)                 ,

    -- ** StringFilterMatchMode #enum:StringFilterMatchMode#

        StringFilterMatchMode(..)               ,

    -- ** SvgError #enum:SvgError#

        SvgError(..)                            ,
        catchSvgError                           ,
        handleSvgError                          ,

    -- ** SymbolicColor #enum:SymbolicColor#

        SymbolicColor(..)                       ,

    -- ** SystemSetting #enum:SystemSetting#

        SystemSetting(..)                       ,

    -- ** TextDirection #enum:TextDirection#

        TextDirection(..)                       ,

    -- ** TextExtendSelection #enum:TextExtendSelection#

        TextExtendSelection(..)                 ,

    -- ** TextViewLayer #enum:TextViewLayer#

        TextViewLayer(..)                       ,

    -- ** TextWindowType #enum:TextWindowType#

        TextWindowType(..)                      ,

    -- ** TreeViewColumnSizing #enum:TreeViewColumnSizing#

        TreeViewColumnSizing(..)                ,

    -- ** TreeViewDropPosition #enum:TreeViewDropPosition#

        TreeViewDropPosition(..)                ,

    -- ** TreeViewGridLines #enum:TreeViewGridLines#

        TreeViewGridLines(..)                   ,

    -- ** Unit #enum:Unit#

        Unit(..)                                ,

    -- ** WindowGravity #enum:WindowGravity#

        WindowGravity(..)                       ,

    -- ** 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 WindowGravity
    -- | Determines which point or edge of a window is meant to remain fixed
    -- when a window changes size.
    --
    -- /Since: 4.20/
    data WindowGravity =
          WindowGravityTopLeft
        -- ^ The top left corner
        | WindowGravityTop
        -- ^ The top edge
        | WindowGravityTopRight
        -- ^ The top right corner
        | WindowGravityLeft
        -- ^ The left edge
        | WindowGravityCenter
        -- ^ The center pointer
        | WindowGravityRight
        -- ^ The right edge
        | WindowGravityBottomLeft
        -- ^ The bottom left corner
        | WindowGravityBottom
        -- ^ the bottom edge
        | WindowGravityBottomRight
        -- ^ The bottom right corner
        | WindowGravityTopStart
        -- ^ The top left or top right corner,
        --   depending on the text direction
        | WindowGravityTopEnd
        -- ^ The top right or top left corner,
        --   depending on the text direction
        | WindowGravityStart
        -- ^ The left or right edge,
        --   depending on the text direction
        | WindowGravityEnd
        -- ^ The right or left edge,
        --   depending on the text direction
        | WindowGravityBottomStart
        -- ^ The bottom left or top right corner,
        --   depending on the text direction
        | WindowGravityBottomEnd
        -- ^ The bottom right or top left corner,
        --   depending on the text direction
        | AnotherWindowGravity Int
        -- ^ Catch-all for unknown values
        deriving (Int -> WindowGravity -> ShowS
    [WindowGravity] -> ShowS
    WindowGravity -> String
    (Int -> WindowGravity -> ShowS)
    -> (WindowGravity -> String)
    -> ([WindowGravity] -> ShowS)
    -> Show WindowGravity
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> WindowGravity -> ShowS
    showsPrec :: Int -> WindowGravity -> ShowS
    $cshow :: WindowGravity -> String
    show :: WindowGravity -> String
    $cshowList :: [WindowGravity] -> ShowS
    showList :: [WindowGravity] -> ShowS
    Show, WindowGravity -> WindowGravity -> Bool
    (WindowGravity -> WindowGravity -> Bool)
    -> (WindowGravity -> WindowGravity -> Bool) -> Eq WindowGravity
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WindowGravity -> WindowGravity -> Bool
    == :: WindowGravity -> WindowGravity -> Bool
    $c/= :: WindowGravity -> WindowGravity -> Bool
    /= :: WindowGravity -> WindowGravity -> Bool
    Eq)

    instance P.Enum WindowGravity where
        fromEnum :: WindowGravity -> Int
    fromEnum WindowGravity
    WindowGravityTopLeft = Int
    0
        fromEnum WindowGravity
    WindowGravityTop = Int
    1
        fromEnum WindowGravity
    WindowGravityTopRight = Int
    2
        fromEnum WindowGravity
    WindowGravityLeft = Int
    3
        fromEnum WindowGravity
    WindowGravityCenter = Int
    4
        fromEnum WindowGravity
    WindowGravityRight = Int
    5
        fromEnum WindowGravity
    WindowGravityBottomLeft = Int
    6
        fromEnum WindowGravity
    WindowGravityBottom = Int
    7
        fromEnum WindowGravity
    WindowGravityBottomRight = Int
    8
        fromEnum WindowGravity
    WindowGravityTopStart = Int
    9
        fromEnum WindowGravity
    WindowGravityTopEnd = Int
    10
        fromEnum WindowGravity
    WindowGravityStart = Int
    11
        fromEnum WindowGravity
    WindowGravityEnd = Int
    12
        fromEnum WindowGravity
    WindowGravityBottomStart = Int
    13
        fromEnum WindowGravity
    WindowGravityBottomEnd = Int
    14
        fromEnum (AnotherWindowGravity Int
    k) = Int
    k

        toEnum :: Int -> WindowGravity
    toEnum Int
    0 = WindowGravity
    WindowGravityTopLeft
        toEnum Int
    1 = WindowGravity
    WindowGravityTop
        toEnum Int
    2 = WindowGravity
    WindowGravityTopRight
        toEnum Int
    3 = WindowGravity
    WindowGravityLeft
        toEnum Int
    4 = WindowGravity
    WindowGravityCenter
        toEnum Int
    5 = WindowGravity
    WindowGravityRight
        toEnum Int
    6 = WindowGravity
    WindowGravityBottomLeft
        toEnum Int
    7 = WindowGravity
    WindowGravityBottom
        toEnum Int
    8 = WindowGravity
    WindowGravityBottomRight
        toEnum Int
    9 = WindowGravity
    WindowGravityTopStart
        toEnum Int
    10 = WindowGravity
    WindowGravityTopEnd
        toEnum Int
    11 = WindowGravity
    WindowGravityStart
        toEnum Int
    12 = WindowGravity
    WindowGravityEnd
        toEnum Int
    13 = WindowGravity
    WindowGravityBottomStart
        toEnum Int
    14 = WindowGravity
    WindowGravityBottomEnd
        toEnum Int
    k = Int -> WindowGravity
    AnotherWindowGravity Int
    k

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

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

    foreign import ccall "gtk_window_gravity_get_type" c_gtk_window_gravity_get_type ::
        IO GType

    instance B.Types.TypedObject WindowGravity where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_window_gravity_get_type

    instance B.Types.BoxedEnum WindowGravity

    -- 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
    {-# DEPRECATED TreeViewGridLines ["(Since version 4.20)","There is no replacement"] #-}
    -- | 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
    {-# DEPRECATED TreeViewDropPosition ["(Since version 4.20)","There is no replacement."] #-}
    -- | 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
    {-# DEPRECATED TreeViewColumnSizing ["(Since version 4.20)","There is no replacement."] #-}
    -- | The sizing method the column uses to determine its width.  Please note
    -- that 'GI.Gtk.Enums.TreeViewColumnSizingAutosize' 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 every time 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 TextWindowType
    -- | Used to reference the parts of @GtkTextView@.
    data TextWindowType =
          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
    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
    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 @GtkTextView@ for the purpose of customized
    -- drawing with the [snapshot_layer](#g:signal:snapshot_layer) vfunc.
    data TextViewLayer =
          TextViewLayerBelowText
        -- ^ The layer rendered below the text (but above the background).
        | TextViewLayerAboveText
        -- ^ The layer rendered above the text.
        | 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
    TextViewLayerBelowText = Int
    0
        fromEnum TextViewLayer
    TextViewLayerAboveText = Int
    1
        fromEnum (AnotherTextViewLayer Int
    k) = Int
    k

        toEnum :: Int -> TextViewLayer
    toEnum Int
    0 = TextViewLayer
    TextViewLayerBelowText
        toEnum Int
    1 = 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
    -- @GtkTextView::extend-selection@ signal to customize the selection.
    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 SystemSetting
    -- | Values that can be passed to the t'GI.Gtk.Objects.Widget.Widget'.@/system_setting_changed/@()
    -- vfunc.
    --
    -- The values indicate which system setting has changed.
    -- Widgets may need to drop caches, or react otherwise.
    --
    -- Most of the values correspond to [class/@settings@/] properties.
    --
    -- More values may be added over time.
    data SystemSetting =
          SystemSettingDpi
        -- ^ the [Settings:gtkXftDpi]("GI.Gtk.Objects.Settings#g:attr:gtkXftDpi") setting has changed
        | SystemSettingFontName
        -- ^ The [Settings:gtkFontName]("GI.Gtk.Objects.Settings#g:attr:gtkFontName") setting has changed
        | SystemSettingFontConfig
        -- ^ The font configuration has changed in a way that
        --   requires text to be redrawn. This can be any of the
        --   [Settings:gtkXftAntialias]("GI.Gtk.Objects.Settings#g:attr:gtkXftAntialias"),
        --   [Settings:gtkXftHinting]("GI.Gtk.Objects.Settings#g:attr:gtkXftHinting"),
        --   [Settings:gtkXftHintstyle]("GI.Gtk.Objects.Settings#g:attr:gtkXftHintstyle"),
        --   [Settings:gtkXftRgba]("GI.Gtk.Objects.Settings#g:attr:gtkXftRgba") or
        --   [Settings:gtkFontconfigTimestamp]("GI.Gtk.Objects.Settings#g:attr:gtkFontconfigTimestamp") settings
        | SystemSettingDisplay
        -- ^ The display has changed
        | SystemSettingIconTheme
        -- ^ The icon theme has changed in a way that requires
        --   icons to be looked up again
        | AnotherSystemSetting Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SystemSetting -> ShowS
    [SystemSetting] -> ShowS
    SystemSetting -> String
    (Int -> SystemSetting -> ShowS)
    -> (SystemSetting -> String)
    -> ([SystemSetting] -> ShowS)
    -> Show SystemSetting
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SystemSetting -> ShowS
    showsPrec :: Int -> SystemSetting -> ShowS
    $cshow :: SystemSetting -> String
    show :: SystemSetting -> String
    $cshowList :: [SystemSetting] -> ShowS
    showList :: [SystemSetting] -> ShowS
    Show, SystemSetting -> SystemSetting -> Bool
    (SystemSetting -> SystemSetting -> Bool)
    -> (SystemSetting -> SystemSetting -> Bool) -> Eq SystemSetting
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SystemSetting -> SystemSetting -> Bool
    == :: SystemSetting -> SystemSetting -> Bool
    $c/= :: SystemSetting -> SystemSetting -> Bool
    /= :: SystemSetting -> SystemSetting -> Bool
    Eq)

    instance P.Enum SystemSetting where
        fromEnum :: SystemSetting -> Int
    fromEnum SystemSetting
    SystemSettingDpi = Int
    0
        fromEnum SystemSetting
    SystemSettingFontName = Int
    1
        fromEnum SystemSetting
    SystemSettingFontConfig = Int
    2
        fromEnum SystemSetting
    SystemSettingDisplay = Int
    3
        fromEnum SystemSetting
    SystemSettingIconTheme = Int
    4
        fromEnum (AnotherSystemSetting Int
    k) = Int
    k

        toEnum :: Int -> SystemSetting
    toEnum Int
    0 = SystemSetting
    SystemSettingDpi
        toEnum Int
    1 = SystemSetting
    SystemSettingFontName
        toEnum Int
    2 = SystemSetting
    SystemSettingFontConfig
        toEnum Int
    3 = SystemSetting
    SystemSettingDisplay
        toEnum Int
    4 = SystemSetting
    SystemSettingIconTheme
        toEnum Int
    k = Int -> SystemSetting
    AnotherSystemSetting Int
    k

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

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

    foreign import ccall "gtk_system_setting_get_type" c_gtk_system_setting_get_type ::
        IO GType

    instance B.Types.TypedObject SystemSetting where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_system_setting_get_type

    instance B.Types.BoxedEnum SystemSetting

    -- Enum SymbolicColor
    -- | The indexes of colors passed to symbolic color rendering, such as
    -- t'GI.Gtk.Interfaces.SymbolicPaintable.SymbolicPaintable'.@/snapshot_symbolic/@().
    --
    -- More values may be added over time.
    --
    -- /Since: 4.6/
    data SymbolicColor =
          SymbolicColorForeground
        -- ^ The default foreground color
        | SymbolicColorError
        -- ^ Indication color for errors
        | SymbolicColorWarning
        -- ^ Indication color for warnings
        | SymbolicColorSuccess
        -- ^ Indication color for success
        | SymbolicColorAccent
        -- ^ The system accent color.
        --
        -- /Since: 4.22/
        | AnotherSymbolicColor Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SymbolicColor -> ShowS
    [SymbolicColor] -> ShowS
    SymbolicColor -> String
    (Int -> SymbolicColor -> ShowS)
    -> (SymbolicColor -> String)
    -> ([SymbolicColor] -> ShowS)
    -> Show SymbolicColor
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SymbolicColor -> ShowS
    showsPrec :: Int -> SymbolicColor -> ShowS
    $cshow :: SymbolicColor -> String
    show :: SymbolicColor -> String
    $cshowList :: [SymbolicColor] -> ShowS
    showList :: [SymbolicColor] -> ShowS
    Show, SymbolicColor -> SymbolicColor -> Bool
    (SymbolicColor -> SymbolicColor -> Bool)
    -> (SymbolicColor -> SymbolicColor -> Bool) -> Eq SymbolicColor
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SymbolicColor -> SymbolicColor -> Bool
    == :: SymbolicColor -> SymbolicColor -> Bool
    $c/= :: SymbolicColor -> SymbolicColor -> Bool
    /= :: SymbolicColor -> SymbolicColor -> Bool
    Eq)

    instance P.Enum SymbolicColor where
        fromEnum :: SymbolicColor -> Int
    fromEnum SymbolicColor
    SymbolicColorForeground = Int
    0
        fromEnum SymbolicColor
    SymbolicColorError = Int
    1
        fromEnum SymbolicColor
    SymbolicColorWarning = Int
    2
        fromEnum SymbolicColor
    SymbolicColorSuccess = Int
    3
        fromEnum SymbolicColor
    SymbolicColorAccent = Int
    4
        fromEnum (AnotherSymbolicColor Int
    k) = Int
    k

        toEnum :: Int -> SymbolicColor
    toEnum Int
    0 = SymbolicColor
    SymbolicColorForeground
        toEnum Int
    1 = SymbolicColor
    SymbolicColorError
        toEnum Int
    2 = SymbolicColor
    SymbolicColorWarning
        toEnum Int
    3 = SymbolicColor
    SymbolicColorSuccess
        toEnum Int
    4 = SymbolicColor
    SymbolicColorAccent
        toEnum Int
    k = Int -> SymbolicColor
    AnotherSymbolicColor Int
    k

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

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

    foreign import ccall "gtk_symbolic_color_get_type" c_gtk_symbolic_color_get_type ::
        IO GType

    instance B.Types.TypedObject SymbolicColor where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_symbolic_color_get_type

    instance B.Types.BoxedEnum SymbolicColor

    -- Enum SvgError
    -- | Error codes in the @GTK_SVG_ERROR@ domain for errors
    -- that happen during parsing or rendering of SVG.
    --
    -- /Since: 4.22/
    data SvgError =
          SvgErrorInvalidSyntax
        -- ^ The XML syntax is broken
        --   in some way
        | SvgErrorInvalidElement
        -- ^ An XML element is invalid
        --   (either because it is not part of SVG, or because it is
        --   in the wrong place, or because it not implemented in GTK)
        | SvgErrorInvalidAttribute
        -- ^ An attribute is invalid
        --   (either because it is not part of SVG, or because it is
        --   not implemented in GTK, or its value is problematic)
        | SvgErrorMissingAttribute
        -- ^ A required attribute is missing
        | SvgErrorInvalidReference
        -- ^ A reference does not point to
        --   a suitable element
        | SvgErrorFailedUpdate
        -- ^ An animation could not be updated
        | SvgErrorFailedRendering
        -- ^ Rendering is not according to
        --   expecations
        | SvgErrorIgnoredElement
        -- ^ An XML element is ignored,
        --   but it should not affect rendering (this error code is used
        --   for metadata and exension elements)
        | SvgErrorLimitsExceeded
        -- ^ An implementation limit has
        --   been hit, such as the number of loaded shapes.
        | SvgErrorNotImplemented
        -- ^ The SVG uses features that
        --   are not supported by @GtkSvg@. It may be advisable to use
        --   a different SVG renderer.
        | SvgErrorFeatureDisabled
        -- ^ /No description available in the introspection data./
        | AnotherSvgError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SvgError -> ShowS
    [SvgError] -> ShowS
    SvgError -> String
    (Int -> SvgError -> ShowS)
    -> (SvgError -> String) -> ([SvgError] -> ShowS) -> Show SvgError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SvgError -> ShowS
    showsPrec :: Int -> SvgError -> ShowS
    $cshow :: SvgError -> String
    show :: SvgError -> String
    $cshowList :: [SvgError] -> ShowS
    showList :: [SvgError] -> ShowS
    Show, SvgError -> SvgError -> Bool
    (SvgError -> SvgError -> Bool)
    -> (SvgError -> SvgError -> Bool) -> Eq SvgError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SvgError -> SvgError -> Bool
    == :: SvgError -> SvgError -> Bool
    $c/= :: SvgError -> SvgError -> Bool
    /= :: SvgError -> SvgError -> Bool
    Eq)

    instance P.Enum SvgError where
        fromEnum :: SvgError -> Int
    fromEnum SvgError
    SvgErrorInvalidSyntax = Int
    0
        fromEnum SvgError
    SvgErrorInvalidElement = Int
    1
        fromEnum SvgError
    SvgErrorInvalidAttribute = Int
    2
        fromEnum SvgError
    SvgErrorMissingAttribute = Int
    3
        fromEnum SvgError
    SvgErrorInvalidReference = Int
    4
        fromEnum SvgError
    SvgErrorFailedUpdate = Int
    5
        fromEnum SvgError
    SvgErrorFailedRendering = Int
    6
        fromEnum SvgError
    SvgErrorIgnoredElement = Int
    7
        fromEnum SvgError
    SvgErrorLimitsExceeded = Int
    8
        fromEnum SvgError
    SvgErrorNotImplemented = Int
    9
        fromEnum SvgError
    SvgErrorFeatureDisabled = Int
    10
        fromEnum (AnotherSvgError Int
    k) = Int
    k

        toEnum :: Int -> SvgError
    toEnum Int
    0 = SvgError
    SvgErrorInvalidSyntax
        toEnum Int
    1 = SvgError
    SvgErrorInvalidElement
        toEnum Int
    2 = SvgError
    SvgErrorInvalidAttribute
        toEnum Int
    3 = SvgError
    SvgErrorMissingAttribute
        toEnum Int
    4 = SvgError
    SvgErrorInvalidReference
        toEnum Int
    5 = SvgError
    SvgErrorFailedUpdate
        toEnum Int
    6 = SvgError
    SvgErrorFailedRendering
        toEnum Int
    7 = SvgError
    SvgErrorIgnoredElement
        toEnum Int
    8 = SvgError
    SvgErrorLimitsExceeded
        toEnum Int
    9 = SvgError
    SvgErrorNotImplemented
        toEnum Int
    10 = SvgError
    SvgErrorFeatureDisabled
        toEnum Int
    k = Int -> SvgError
    AnotherSvgError Int
    k

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

    instance GErrorClass SvgError where
        gerrorClassDomain :: SvgError -> Text
    gerrorClassDomain SvgError
    _ = Text
    "GtkSvgError"

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

    -- | Handle exceptions of type `SvgError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
    handleSvgError ::
        (SvgError -> GErrorMessage -> IO a) ->
        IO a ->
        IO a
    handleSvgError :: forall a. (SvgError -> Text -> IO a) -> IO a -> IO a
    handleSvgError = (SvgError -> 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 SvgError = '[]
    instance O.HasParentTypes SvgError

    foreign import ccall "gtk_svg_error_get_type" c_gtk_svg_error_get_type ::
        IO GType

    instance B.Types.TypedObject SvgError where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_svg_error_get_type

    instance B.Types.BoxedEnum SvgError

    -- Enum StringFilterMatchMode
    -- | Specifies how search strings are matched inside text.
    data StringFilterMatchMode =
          StringFilterMatchModeExact
        -- ^ The search string and
        --   text must match exactly
        | StringFilterMatchModeSubstring
        -- ^ The search string
        --   must be contained as a substring inside the text
        | StringFilterMatchModePrefix
        -- ^ The text must begin
        --   with the search string
        | AnotherStringFilterMatchMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> StringFilterMatchMode -> ShowS
    [StringFilterMatchMode] -> ShowS
    StringFilterMatchMode -> String
    (Int -> StringFilterMatchMode -> ShowS)
    -> (StringFilterMatchMode -> String)
    -> ([StringFilterMatchMode] -> ShowS)
    -> Show StringFilterMatchMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> StringFilterMatchMode -> ShowS
    showsPrec :: Int -> StringFilterMatchMode -> ShowS
    $cshow :: StringFilterMatchMode -> String
    show :: StringFilterMatchMode -> String
    $cshowList :: [StringFilterMatchMode] -> ShowS
    showList :: [StringFilterMatchMode] -> ShowS
    Show, StringFilterMatchMode -> StringFilterMatchMode -> Bool
    (StringFilterMatchMode -> StringFilterMatchMode -> Bool)
    -> (StringFilterMatchMode -> StringFilterMatchMode -> Bool)
    -> Eq StringFilterMatchMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: StringFilterMatchMode -> StringFilterMatchMode -> Bool
    == :: StringFilterMatchMode -> StringFilterMatchMode -> Bool
    $c/= :: StringFilterMatchMode -> StringFilterMatchMode -> Bool
    /= :: StringFilterMatchMode -> StringFilterMatchMode -> Bool
    Eq)

    instance P.Enum StringFilterMatchMode where
        fromEnum :: StringFilterMatchMode -> Int
    fromEnum StringFilterMatchMode
    StringFilterMatchModeExact = Int
    0
        fromEnum StringFilterMatchMode
    StringFilterMatchModeSubstring = Int
    1
        fromEnum StringFilterMatchMode
    StringFilterMatchModePrefix = Int
    2
        fromEnum (AnotherStringFilterMatchMode Int
    k) = Int
    k

        toEnum :: Int -> StringFilterMatchMode
    toEnum Int
    0 = StringFilterMatchMode
    StringFilterMatchModeExact
        toEnum Int
    1 = StringFilterMatchMode
    StringFilterMatchModeSubstring
        toEnum Int
    2 = StringFilterMatchMode
    StringFilterMatchModePrefix
        toEnum Int
    k = Int -> StringFilterMatchMode
    AnotherStringFilterMatchMode Int
    k

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

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

    foreign import ccall "gtk_string_filter_match_mode_get_type" c_gtk_string_filter_match_mode_get_type ::
        IO GType

    instance B.Types.TypedObject StringFilterMatchMode where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_string_filter_match_mode_get_type

    instance B.Types.BoxedEnum StringFilterMatchMode

    -- Enum StackTransitionType
    -- | Possible transitions between pages in a @GtkStack@ 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
        | StackTransitionTypeOverDown
        -- ^ Cover the old page by sliding down
        | StackTransitionTypeOverLeft
        -- ^ Cover the old page by sliding to the left
        | StackTransitionTypeOverRight
        -- ^ Cover the old page by sliding to the right
        | StackTransitionTypeUnderUp
        -- ^ Uncover the new page by sliding up
        | StackTransitionTypeUnderDown
        -- ^ Uncover the new page by sliding down
        | StackTransitionTypeUnderLeft
        -- ^ Uncover the new page by sliding to the left
        | StackTransitionTypeUnderRight
        -- ^ Uncover the new page by sliding to the right
        | StackTransitionTypeOverUpDown
        -- ^ Cover the old page sliding up or uncover the new page sliding down, according to order
        | StackTransitionTypeOverDownUp
        -- ^ Cover the old page sliding down or uncover the new page sliding up, according to order
        | StackTransitionTypeOverLeftRight
        -- ^ Cover the old page sliding left or uncover the new page sliding right, according to order
        | StackTransitionTypeOverRightLeft
        -- ^ Cover the old page sliding right or uncover the new page sliding left, according to order
        | StackTransitionTypeRotateLeft
        -- ^ Pretend the pages are sides of a cube and rotate that cube to the left
        | StackTransitionTypeRotateRight
        -- ^ Pretend the pages are sides of a cube and rotate that cube to the right
        | StackTransitionTypeRotateLeftRight
        -- ^ Pretend the pages are sides of a cube and rotate that cube to the left or right according to the children order
        | 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 StackTransitionType
    StackTransitionTypeRotateLeft = Int
    20
        fromEnum StackTransitionType
    StackTransitionTypeRotateRight = Int
    21
        fromEnum StackTransitionType
    StackTransitionTypeRotateLeftRight = Int
    22
        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
    20 = StackTransitionType
    StackTransitionTypeRotateLeft
        toEnum Int
    21 = StackTransitionType
    StackTransitionTypeRotateRight
        toEnum Int
    22 = StackTransitionType
    StackTransitionTypeRotateLeftRight
        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
    -- | Determines whether the spin button displays values outside the adjustment
    -- bounds.
    --
    -- See 'GI.Gtk.Objects.SpinButton.spinButtonSetUpdatePolicy'.
    data SpinButtonUpdatePolicy =
          SpinButtonUpdatePolicyAlways
        -- ^ When refreshing your @GtkSpinButton@, the value is
        --   always displayed
        | SpinButtonUpdatePolicyIfValid
        -- ^ When refreshing your @GtkSpinButton@, 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 SorterOrder
    -- | Describes the type of order that a @GtkSorter@ may produce.
    data SorterOrder =
          SorterOrderPartial
        -- ^ A partial order. Any @GtkOrdering@ is possible.
        | SorterOrderNone
        -- ^ No order, all elements are considered equal.
        --   'GI.Gtk.Objects.Sorter.sorterCompare' will only return 'GI.Gtk.Enums.OrderingEqual'.
        | SorterOrderTotal
        -- ^ A total order. 'GI.Gtk.Objects.Sorter.sorterCompare' will only
        --   return 'GI.Gtk.Enums.OrderingEqual' if an item is compared with itself. Two
        --   different items will never cause this value to be returned.
        | AnotherSorterOrder Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SorterOrder -> ShowS
    [SorterOrder] -> ShowS
    SorterOrder -> String
    (Int -> SorterOrder -> ShowS)
    -> (SorterOrder -> String)
    -> ([SorterOrder] -> ShowS)
    -> Show SorterOrder
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SorterOrder -> ShowS
    showsPrec :: Int -> SorterOrder -> ShowS
    $cshow :: SorterOrder -> String
    show :: SorterOrder -> String
    $cshowList :: [SorterOrder] -> ShowS
    showList :: [SorterOrder] -> ShowS
    Show, SorterOrder -> SorterOrder -> Bool
    (SorterOrder -> SorterOrder -> Bool)
    -> (SorterOrder -> SorterOrder -> Bool) -> Eq SorterOrder
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SorterOrder -> SorterOrder -> Bool
    == :: SorterOrder -> SorterOrder -> Bool
    $c/= :: SorterOrder -> SorterOrder -> Bool
    /= :: SorterOrder -> SorterOrder -> Bool
    Eq)

    instance P.Enum SorterOrder where
        fromEnum :: SorterOrder -> Int
    fromEnum SorterOrder
    SorterOrderPartial = Int
    0
        fromEnum SorterOrder
    SorterOrderNone = Int
    1
        fromEnum SorterOrder
    SorterOrderTotal = Int
    2
        fromEnum (AnotherSorterOrder Int
    k) = Int
    k

        toEnum :: Int -> SorterOrder
    toEnum Int
    0 = SorterOrder
    SorterOrderPartial
        toEnum Int
    1 = SorterOrder
    SorterOrderNone
        toEnum Int
    2 = SorterOrder
    SorterOrderTotal
        toEnum Int
    k = Int -> SorterOrder
    AnotherSorterOrder Int
    k

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

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

    foreign import ccall "gtk_sorter_order_get_type" c_gtk_sorter_order_get_type ::
        IO GType

    instance B.Types.TypedObject SorterOrder where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_sorter_order_get_type

    instance B.Types.BoxedEnum SorterOrder

    -- Enum SorterChange
    -- | Describes changes in a sorter in more detail and allows users
    -- to optimize resorting.
    data SorterChange =
          SorterChangeDifferent
        -- ^ The sorter change cannot be described
        --   by any of the other enumeration values
        | SorterChangeInverted
        -- ^ The sort order was inverted. Comparisons
        --   that returned 'GI.Gtk.Enums.OrderingSmaller' now return 'GI.Gtk.Enums.OrderingLarger'
        --   and vice versa. Other comparisons return the same values as before.
        | SorterChangeLessStrict
        -- ^ The sorter is less strict: Comparisons
        --   may now return 'GI.Gtk.Enums.OrderingEqual' that did not do so before.
        | SorterChangeMoreStrict
        -- ^ The sorter is more strict: Comparisons
        --   that did return 'GI.Gtk.Enums.OrderingEqual' may not do so anymore.
        | AnotherSorterChange Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SorterChange -> ShowS
    [SorterChange] -> ShowS
    SorterChange -> String
    (Int -> SorterChange -> ShowS)
    -> (SorterChange -> String)
    -> ([SorterChange] -> ShowS)
    -> Show SorterChange
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SorterChange -> ShowS
    showsPrec :: Int -> SorterChange -> ShowS
    $cshow :: SorterChange -> String
    show :: SorterChange -> String
    $cshowList :: [SorterChange] -> ShowS
    showList :: [SorterChange] -> ShowS
    Show, SorterChange -> SorterChange -> Bool
    (SorterChange -> SorterChange -> Bool)
    -> (SorterChange -> SorterChange -> Bool) -> Eq SorterChange
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SorterChange -> SorterChange -> Bool
    == :: SorterChange -> SorterChange -> Bool
    $c/= :: SorterChange -> SorterChange -> Bool
    /= :: SorterChange -> SorterChange -> Bool
    Eq)

    instance P.Enum SorterChange where
        fromEnum :: SorterChange -> Int
    fromEnum SorterChange
    SorterChangeDifferent = Int
    0
        fromEnum SorterChange
    SorterChangeInverted = Int
    1
        fromEnum SorterChange
    SorterChangeLessStrict = Int
    2
        fromEnum SorterChange
    SorterChangeMoreStrict = Int
    3
        fromEnum (AnotherSorterChange Int
    k) = Int
    k

        toEnum :: Int -> SorterChange
    toEnum Int
    0 = SorterChange
    SorterChangeDifferent
        toEnum Int
    1 = SorterChange
    SorterChangeInverted
        toEnum Int
    2 = SorterChange
    SorterChangeLessStrict
        toEnum Int
    3 = SorterChange
    SorterChangeMoreStrict
        toEnum Int
    k = Int -> SorterChange
    AnotherSorterChange Int
    k

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

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

    foreign import ccall "gtk_sorter_change_get_type" c_gtk_sorter_change_get_type ::
        IO GType

    instance B.Types.TypedObject SorterChange where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_sorter_change_get_type

    instance B.Types.BoxedEnum SorterChange

    -- 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.
    data ShortcutType =
          ShortcutTypeAccelerator
        -- ^ The shortcut is a keyboard accelerator. The GtkShortcutsShortcut: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 GtkShortcutsShortcut:icon property will be
        --   used.
        | ShortcutTypeGestureSwipeLeft
        -- ^ The shortcut is a swipe gesture. GTK provides an icon and subtitle.
        | ShortcutTypeGestureSwipeRight
        -- ^ The shortcut is a swipe gesture. GTK provides an icon and subtitle.
        | 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 ShortcutType
    ShortcutTypeGestureSwipeLeft = Int
    8
        fromEnum ShortcutType
    ShortcutTypeGestureSwipeRight = Int
    9
        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
    8 = ShortcutType
    ShortcutTypeGestureSwipeLeft
        toEnum Int
    9 = ShortcutType
    ShortcutTypeGestureSwipeRight
        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 ShortcutScope
    -- | Describes where [class/@shortcut@/]s added to a
    -- [class/@shortcutController@/] get handled.
    data ShortcutScope =
          ShortcutScopeLocal
        -- ^ Shortcuts are handled inside
        --   the widget the controller belongs to.
        | ShortcutScopeManaged
        -- ^ Shortcuts are handled by
        --   the first ancestor that is a [iface/@shortcutManager@/]
        | ShortcutScopeGlobal
        -- ^ Shortcuts are handled by
        --   the root widget.
        | AnotherShortcutScope Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ShortcutScope -> ShowS
    [ShortcutScope] -> ShowS
    ShortcutScope -> String
    (Int -> ShortcutScope -> ShowS)
    -> (ShortcutScope -> String)
    -> ([ShortcutScope] -> ShowS)
    -> Show ShortcutScope
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ShortcutScope -> ShowS
    showsPrec :: Int -> ShortcutScope -> ShowS
    $cshow :: ShortcutScope -> String
    show :: ShortcutScope -> String
    $cshowList :: [ShortcutScope] -> ShowS
    showList :: [ShortcutScope] -> ShowS
    Show, ShortcutScope -> ShortcutScope -> Bool
    (ShortcutScope -> ShortcutScope -> Bool)
    -> (ShortcutScope -> ShortcutScope -> Bool) -> Eq ShortcutScope
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ShortcutScope -> ShortcutScope -> Bool
    == :: ShortcutScope -> ShortcutScope -> Bool
    $c/= :: ShortcutScope -> ShortcutScope -> Bool
    /= :: ShortcutScope -> ShortcutScope -> Bool
    Eq)

    instance P.Enum ShortcutScope where
        fromEnum :: ShortcutScope -> Int
    fromEnum ShortcutScope
    ShortcutScopeLocal = Int
    0
        fromEnum ShortcutScope
    ShortcutScopeManaged = Int
    1
        fromEnum ShortcutScope
    ShortcutScopeGlobal = Int
    2
        fromEnum (AnotherShortcutScope Int
    k) = Int
    k

        toEnum :: Int -> ShortcutScope
    toEnum Int
    0 = ShortcutScope
    ShortcutScopeLocal
        toEnum Int
    1 = ShortcutScope
    ShortcutScopeManaged
        toEnum Int
    2 = ShortcutScope
    ShortcutScopeGlobal
        toEnum Int
    k = Int -> ShortcutScope
    AnotherShortcutScope Int
    k

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

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

    foreign import ccall "gtk_shortcut_scope_get_type" c_gtk_shortcut_scope_get_type ::
        IO GType

    instance B.Types.TypedObject ShortcutScope where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_shortcut_scope_get_type

    instance B.Types.BoxedEnum ShortcutScope

    -- Enum SensitivityType
    -- | Determines how GTK handles the sensitivity of various controls,
    -- such as combo box buttons.
    data SensitivityType =
          SensitivityTypeAuto
        -- ^ The control is made insensitive if no
        --   action can be triggered
        | SensitivityTypeOn
        -- ^ The control is always sensitive
        | SensitivityTypeOff
        -- ^ The control 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
    -- | Passed as argument to various keybinding signals.
    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 @GtkRevealer@ 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
        | RevealerTransitionTypeSwingRight
        -- ^ Floop in from the left
        | RevealerTransitionTypeSwingLeft
        -- ^ Floop in from the right
        | RevealerTransitionTypeSwingUp
        -- ^ Floop in from the bottom
        | RevealerTransitionTypeSwingDown
        -- ^ Floop in from the top
        | RevealerTransitionTypeFadeSlideRight
        -- ^ Combination of 'GI.Gtk.Enums.RevealerTransitionTypeCrossfade'
        -- and 'GI.Gtk.Enums.RevealerTransitionTypeSlideRight'.
        --
        -- /Since: 4.22/
        | RevealerTransitionTypeFadeSlideLeft
        -- ^ Combination of 'GI.Gtk.Enums.RevealerTransitionTypeCrossfade'
        -- and 'GI.Gtk.Enums.RevealerTransitionTypeSlideLeft'.
        --
        -- /Since: 4.22/
        | RevealerTransitionTypeFadeSlideUp
        -- ^ Combination of 'GI.Gtk.Enums.RevealerTransitionTypeCrossfade'
        -- and 'GI.Gtk.Enums.RevealerTransitionTypeSlideUp'.
        --
        -- /Since: 4.22/
        | RevealerTransitionTypeFadeSlideDown
        -- ^ Combination of 'GI.Gtk.Enums.RevealerTransitionTypeCrossfade'
        -- and 'GI.Gtk.Enums.RevealerTransitionTypeSlideDown'.
        --
        -- /Since: 4.22/
        | 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 RevealerTransitionType
    RevealerTransitionTypeSwingRight = Int
    6
        fromEnum RevealerTransitionType
    RevealerTransitionTypeSwingLeft = Int
    7
        fromEnum RevealerTransitionType
    RevealerTransitionTypeSwingUp = Int
    8
        fromEnum RevealerTransitionType
    RevealerTransitionTypeSwingDown = Int
    9
        fromEnum RevealerTransitionType
    RevealerTransitionTypeFadeSlideRight = Int
    10
        fromEnum RevealerTransitionType
    RevealerTransitionTypeFadeSlideLeft = Int
    11
        fromEnum RevealerTransitionType
    RevealerTransitionTypeFadeSlideUp = Int
    12
        fromEnum RevealerTransitionType
    RevealerTransitionTypeFadeSlideDown = Int
    13
        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
    6 = RevealerTransitionType
    RevealerTransitionTypeSwingRight
        toEnum Int
    7 = RevealerTransitionType
    RevealerTransitionTypeSwingLeft
        toEnum Int
    8 = RevealerTransitionType
    RevealerTransitionTypeSwingUp
        toEnum Int
    9 = RevealerTransitionType
    RevealerTransitionTypeSwingDown
        toEnum Int
    10 = RevealerTransitionType
    RevealerTransitionTypeFadeSlideRight
        toEnum Int
    11 = RevealerTransitionType
    RevealerTransitionTypeFadeSlideLeft
        toEnum Int
    12 = RevealerTransitionType
    RevealerTransitionTypeFadeSlideUp
        toEnum Int
    13 = RevealerTransitionType
    RevealerTransitionTypeFadeSlideDown
        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 RestoreReason
    -- | Enumerates possible reasons for an application to restore saved state.
    --
    -- See [Application::restoreState]("GI.Gtk.Objects.Application#g:signal:restoreState").
    --
    -- /Since: 4.24/
    data RestoreReason =
          RestoreReasonPristine
        -- ^ Don\'t restore anything
        | RestoreReasonLaunch
        -- ^ This is normal launch. Restore as little as is reasonable
        | RestoreReasonRecover
        -- ^ The application has crashed before. Try to restore the previous state
        | RestoreReasonRestore
        -- ^ This is a session restore. Restore the previous state as far as possible
        | AnotherRestoreReason Int
        -- ^ Catch-all for unknown values
        deriving (Int -> RestoreReason -> ShowS
    [RestoreReason] -> ShowS
    RestoreReason -> String
    (Int -> RestoreReason -> ShowS)
    -> (RestoreReason -> String)
    -> ([RestoreReason] -> ShowS)
    -> Show RestoreReason
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RestoreReason -> ShowS
    showsPrec :: Int -> RestoreReason -> ShowS
    $cshow :: RestoreReason -> String
    show :: RestoreReason -> String
    $cshowList :: [RestoreReason] -> ShowS
    showList :: [RestoreReason] -> ShowS
    Show, RestoreReason -> RestoreReason -> Bool
    (RestoreReason -> RestoreReason -> Bool)
    -> (RestoreReason -> RestoreReason -> Bool) -> Eq RestoreReason
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RestoreReason -> RestoreReason -> Bool
    == :: RestoreReason -> RestoreReason -> Bool
    $c/= :: RestoreReason -> RestoreReason -> Bool
    /= :: RestoreReason -> RestoreReason -> Bool
    Eq)

    instance P.Enum RestoreReason where
        fromEnum :: RestoreReason -> Int
    fromEnum RestoreReason
    RestoreReasonPristine = Int
    0
        fromEnum RestoreReason
    RestoreReasonLaunch = Int
    1
        fromEnum RestoreReason
    RestoreReasonRecover = Int
    2
        fromEnum RestoreReason
    RestoreReasonRestore = Int
    3
        fromEnum (AnotherRestoreReason Int
    k) = Int
    k

        toEnum :: Int -> RestoreReason
    toEnum Int
    0 = RestoreReason
    RestoreReasonPristine
        toEnum Int
    1 = RestoreReason
    RestoreReasonLaunch
        toEnum Int
    2 = RestoreReason
    RestoreReasonRecover
        toEnum Int
    3 = RestoreReason
    RestoreReasonRestore
        toEnum Int
    k = Int -> RestoreReason
    AnotherRestoreReason Int
    k

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

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

    foreign import ccall "gtk_restore_reason_get_type" c_gtk_restore_reason_get_type ::
        IO GType

    instance B.Types.TypedObject RestoreReason where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_restore_reason_get_type

    instance B.Types.BoxedEnum RestoreReason

    -- Enum ResponseType
    {-# DEPRECATED ResponseType ["(Since version 4.20)","There is no replacement."] #-}
    -- | 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 ReducedMotion
    -- | Values for the [Settings:gtkInterfaceReducedMotion]("GI.Gtk.Objects.Settings#g:attr:gtkInterfaceReducedMotion")
    -- and [CssProvider:prefersReducedMotion]("GI.Gtk.Objects.CssProvider#g:attr:prefersReducedMotion") properties
    -- that indicates the preferred level of motion animations.
    --
    -- This information can be used inside CSS via media queries.
    --
    -- /Since: 4.22/
    data ReducedMotion =
          ReducedMotionNoPreference
        -- ^ The user has made no preference known to the system
        | ReducedMotionReduce
        -- ^ The user has notified the system that they
        --   prefer an interface that removes or replaces the types of motion-based
        --   animation that either trigger discomfort for those with vestibular
        --   motion sensitivity, or distraction for those with attention deficits
        | AnotherReducedMotion Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ReducedMotion -> ShowS
    [ReducedMotion] -> ShowS
    ReducedMotion -> String
    (Int -> ReducedMotion -> ShowS)
    -> (ReducedMotion -> String)
    -> ([ReducedMotion] -> ShowS)
    -> Show ReducedMotion
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ReducedMotion -> ShowS
    showsPrec :: Int -> ReducedMotion -> ShowS
    $cshow :: ReducedMotion -> String
    show :: ReducedMotion -> String
    $cshowList :: [ReducedMotion] -> ShowS
    showList :: [ReducedMotion] -> ShowS
    Show, ReducedMotion -> ReducedMotion -> Bool
    (ReducedMotion -> ReducedMotion -> Bool)
    -> (ReducedMotion -> ReducedMotion -> Bool) -> Eq ReducedMotion
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ReducedMotion -> ReducedMotion -> Bool
    == :: ReducedMotion -> ReducedMotion -> Bool
    $c/= :: ReducedMotion -> ReducedMotion -> Bool
    /= :: ReducedMotion -> ReducedMotion -> Bool
    Eq)

    instance P.Enum ReducedMotion where
        fromEnum :: ReducedMotion -> Int
    fromEnum ReducedMotion
    ReducedMotionNoPreference = Int
    0
        fromEnum ReducedMotion
    ReducedMotionReduce = Int
    1
        fromEnum (AnotherReducedMotion Int
    k) = Int
    k

        toEnum :: Int -> ReducedMotion
    toEnum Int
    0 = ReducedMotion
    ReducedMotionNoPreference
        toEnum Int
    1 = ReducedMotion
    ReducedMotionReduce
        toEnum Int
    k = Int -> ReducedMotion
    AnotherReducedMotion Int
    k

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

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

    foreign import ccall "gtk_reduced_motion_get_type" c_gtk_reduced_motion_get_type ::
        IO GType

    instance B.Types.TypedObject ReducedMotion where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_reduced_motion_get_type

    instance B.Types.BoxedEnum ReducedMotion

    -- Enum RecentManagerError
    -- | Error codes for @GtkRecentManager@ operations
    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 PropagationPhase
    -- | Describes the stage at which events are fed into a [class/@eventController@/].
    data PropagationPhase =
          PropagationPhaseNone
        -- ^ Events are not delivered.
        | 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 PropagationLimit
    -- | Describes limits of a [class/@eventController@/] for handling events
    -- targeting other widgets.
    data PropagationLimit =
          PropagationLimitNone
        -- ^ Events are handled regardless of what their
        --   target is.
        | PropagationLimitSameNative
        -- ^ Events are only handled if their target is in
        --   the same [iface/@native@/] (or widget with [Widget:limitEvents]("GI.Gtk.Objects.Widget#g:attr:limitEvents")
        --   set) as the event controllers widget.
        --   Note that some event types have two targets (origin and destination).
        | AnotherPropagationLimit Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PropagationLimit -> ShowS
    [PropagationLimit] -> ShowS
    PropagationLimit -> String
    (Int -> PropagationLimit -> ShowS)
    -> (PropagationLimit -> String)
    -> ([PropagationLimit] -> ShowS)
    -> Show PropagationLimit
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PropagationLimit -> ShowS
    showsPrec :: Int -> PropagationLimit -> ShowS
    $cshow :: PropagationLimit -> String
    show :: PropagationLimit -> String
    $cshowList :: [PropagationLimit] -> ShowS
    showList :: [PropagationLimit] -> ShowS
    Show, PropagationLimit -> PropagationLimit -> Bool
    (PropagationLimit -> PropagationLimit -> Bool)
    -> (PropagationLimit -> PropagationLimit -> Bool)
    -> Eq PropagationLimit
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PropagationLimit -> PropagationLimit -> Bool
    == :: PropagationLimit -> PropagationLimit -> Bool
    $c/= :: PropagationLimit -> PropagationLimit -> Bool
    /= :: PropagationLimit -> PropagationLimit -> Bool
    Eq)

    instance P.Enum PropagationLimit where
        fromEnum :: PropagationLimit -> Int
    fromEnum PropagationLimit
    PropagationLimitNone = Int
    0
        fromEnum PropagationLimit
    PropagationLimitSameNative = Int
    1
        fromEnum (AnotherPropagationLimit Int
    k) = Int
    k

        toEnum :: Int -> PropagationLimit
    toEnum Int
    0 = PropagationLimit
    PropagationLimitNone
        toEnum Int
    1 = PropagationLimit
    PropagationLimitSameNative
        toEnum Int
    k = Int -> PropagationLimit
    AnotherPropagationLimit Int
    k

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

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

    foreign import ccall "gtk_propagation_limit_get_type" c_gtk_propagation_limit_get_type ::
        IO GType

    instance B.Types.TypedObject PropagationLimit where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_propagation_limit_get_type

    instance B.Types.BoxedEnum PropagationLimit

    -- 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 'GI.Gtk.Objects.PrintJob.printJobSetPages'
    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
    -- | The result of a print operation.
    --
    -- 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
    -- | Determines what action the print operation should perform.
    --
    -- A parameter of this typs is passed to 'GI.Gtk.Objects.PrintOperation.printOperationRun'.
    data PrintOperationAction =
          PrintOperationActionPrintDialog
        -- ^ Show the print dialog.
        | PrintOperationActionPrint
        -- ^ Start to print without showing
        --   the print dialog, based on the current print settings, if possible.
        --   Depending on the platform, a print dialog might appear anyway.
        | 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.
    --
    -- For examples, see the tabs of a [class/@notebook@/], or the label
    -- of a [class/@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 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 @GtkTreeView@ 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.
        | 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 PanDirection
    -- | Describes the panning direction of a [class/@gesturePan@/].
    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 'GI.Gtk.Objects.PrintJob.printJobSetPageSet'.
    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
        | PadActionTypeDial
        -- ^ Action is triggered by a pad dial
        | 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 PadActionType
    PadActionTypeDial = Int
    3
        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
    3 = PadActionType
    PadActionTypeDial
        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 of a children in its parent.
    --
    -- See [class/@windowControls@/] for example.
    data PackType =
          PackTypeStart
        -- ^ The child is packed into the start of the widget
        | PackTypeEnd
        -- ^ The child is packed into the end of the widget
        | 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 Overflow
    -- | Defines how content overflowing a given area should be handled.
    --
    -- This is used in 'GI.Gtk.Objects.Widget.widgetSetOverflow'. The
    -- [Widget:overflow]("GI.Gtk.Objects.Widget#g:attr:overflow") property is modeled after the
    -- CSS overflow property, but implements it only partially.
    data Overflow =
          OverflowVisible
        -- ^ No change is applied. Content is drawn at the specified
        --   position.
        | OverflowHidden
        -- ^ Content is clipped to the bounds of the area. Content
        --   outside the area is not drawn and cannot be interacted with.
        | AnotherOverflow Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Overflow -> ShowS
    [Overflow] -> ShowS
    Overflow -> String
    (Int -> Overflow -> ShowS)
    -> (Overflow -> String) -> ([Overflow] -> ShowS) -> Show Overflow
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Overflow -> ShowS
    showsPrec :: Int -> Overflow -> ShowS
    $cshow :: Overflow -> String
    show :: Overflow -> String
    $cshowList :: [Overflow] -> ShowS
    showList :: [Overflow] -> ShowS
    Show, Overflow -> Overflow -> Bool
    (Overflow -> Overflow -> Bool)
    -> (Overflow -> Overflow -> Bool) -> Eq Overflow
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Overflow -> Overflow -> Bool
    == :: Overflow -> Overflow -> Bool
    $c/= :: Overflow -> Overflow -> Bool
    /= :: Overflow -> Overflow -> Bool
    Eq)

    instance P.Enum Overflow where
        fromEnum :: Overflow -> Int
    fromEnum Overflow
    OverflowVisible = Int
    0
        fromEnum Overflow
    OverflowHidden = Int
    1
        fromEnum (AnotherOverflow Int
    k) = Int
    k

        toEnum :: Int -> Overflow
    toEnum Int
    0 = Overflow
    OverflowVisible
        toEnum Int
    1 = Overflow
    OverflowHidden
        toEnum Int
    k = Int -> Overflow
    AnotherOverflow Int
    k

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

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

    foreign import ccall "gtk_overflow_get_type" c_gtk_overflow_get_type ::
        IO GType

    instance B.Types.TypedObject Overflow where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_overflow_get_type

    instance B.Types.BoxedEnum Overflow

    -- Enum Orientation
    -- | Represents the orientation of widgets and other objects.
    --
    -- Typical examples are [class/@box@/] or [class/@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 Ordering
    -- | Describes the way two values can be compared.
    --
    -- These values can be used with a [callback/@gLib@/.CompareFunc]. However,
    -- a @GCompareFunc@ is allowed to return any integer values.
    -- For converting such a value to a @GtkOrdering@ value, use
    -- t'GI.Gtk.Enums.Ordering'.@/from_cmpfunc/@().
    data Ordering =
          OrderingSmaller
        -- ^ the first value is smaller than the second
        | OrderingEqual
        -- ^ the two values are equal
        | OrderingLarger
        -- ^ the first value is larger than the second
        | AnotherOrdering Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Ordering -> ShowS
    [Ordering] -> ShowS
    Ordering -> String
    (Int -> Ordering -> ShowS)
    -> (Ordering -> String) -> ([Ordering] -> ShowS) -> Show Ordering
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Ordering -> ShowS
    showsPrec :: Int -> Ordering -> ShowS
    $cshow :: Ordering -> String
    show :: Ordering -> String
    $cshowList :: [Ordering] -> ShowS
    showList :: [Ordering] -> ShowS
    Show, Ordering -> Ordering -> Bool
    (Ordering -> Ordering -> Bool)
    -> (Ordering -> Ordering -> Bool) -> Eq Ordering
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Ordering -> Ordering -> Bool
    == :: Ordering -> Ordering -> Bool
    $c/= :: Ordering -> Ordering -> Bool
    /= :: Ordering -> Ordering -> Bool
    Eq)

    instance P.Enum Ordering where
        fromEnum :: Ordering -> Int
    fromEnum Ordering
    OrderingSmaller = Int
    -1
        fromEnum Ordering
    OrderingEqual = Int
    0
        fromEnum Ordering
    OrderingLarger = Int
    1
        fromEnum (AnotherOrdering Int
    k) = Int
    k

        toEnum :: Int -> Ordering
    toEnum Int
    -1 = Ordering
    OrderingSmaller
        toEnum Int
    0 = Ordering
    OrderingEqual
        toEnum Int
    1 = Ordering
    OrderingLarger
        toEnum Int
    k = Int -> Ordering
    AnotherOrdering Int
    k

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

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

    foreign import ccall "gtk_ordering_get_type" c_gtk_ordering_get_type ::
        IO GType

    instance B.Types.TypedObject Ordering where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_ordering_get_type

    instance B.Types.BoxedEnum Ordering

    -- Enum NumberUpLayout
    -- | Used to determine the layout of pages on a sheet when printing
    -- multiple pages per sheet.
    data NumberUpLayout =
          NumberUpLayoutLrtb
        -- ^ <<https://docs.gtk.org/gtk4/layout-lrtb.png>>
        | NumberUpLayoutLrbt
        -- ^ <<https://docs.gtk.org/gtk4/layout-lrbt.png>>
        | NumberUpLayoutRltb
        -- ^ <<https://docs.gtk.org/gtk4/layout-rltb.png>>
        | NumberUpLayoutRlbt
        -- ^ <<https://docs.gtk.org/gtk4/layout-rlbt.png>>
        | NumberUpLayoutTblr
        -- ^ <<https://docs.gtk.org/gtk4/layout-tblr.png>>
        | NumberUpLayoutTbrl
        -- ^ <<https://docs.gtk.org/gtk4/layout-tbrl.png>>
        | NumberUpLayoutBtlr
        -- ^ <<https://docs.gtk.org/gtk4/layout-btlr.png>>
        | NumberUpLayoutBtrl
        -- ^ <<https://docs.gtk.org/gtk4/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
    -- | The parameter used in the action signals of @GtkNotebook@.
    data NotebookTab =
          NotebookTabFirst
        -- ^ the first tab in the notebook
        | NotebookTabLast
        -- ^ the last tab in the notebook
        | 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 NaturalWrapMode
    -- | Options for selecting a different wrap mode for natural size
    -- requests.
    --
    -- See for example the [Label:naturalWrapMode]("GI.Gtk.Objects.Label#g:attr:naturalWrapMode") property.
    --
    -- /Since: 4.6/
    data NaturalWrapMode =
          NaturalWrapModeInherit
        -- ^ Inherit the minimum size request.
        --   In particular, this should be used with 'GI.Pango.Enums.WrapModeChar'.
        | NaturalWrapModeNone
        -- ^ Try not to wrap the text. This mode is the
        --   closest to GTK3\'s behavior but can lead to a wide label leaving
        --   lots of empty space below the text.
        | NaturalWrapModeWord
        -- ^ Attempt to wrap at word boundaries. This
        --   is useful in particular when using 'GI.Pango.Enums.WrapModeWordChar' as the
        --   wrap mode.
        | AnotherNaturalWrapMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> NaturalWrapMode -> ShowS
    [NaturalWrapMode] -> ShowS
    NaturalWrapMode -> String
    (Int -> NaturalWrapMode -> ShowS)
    -> (NaturalWrapMode -> String)
    -> ([NaturalWrapMode] -> ShowS)
    -> Show NaturalWrapMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> NaturalWrapMode -> ShowS
    showsPrec :: Int -> NaturalWrapMode -> ShowS
    $cshow :: NaturalWrapMode -> String
    show :: NaturalWrapMode -> String
    $cshowList :: [NaturalWrapMode] -> ShowS
    showList :: [NaturalWrapMode] -> ShowS
    Show, NaturalWrapMode -> NaturalWrapMode -> Bool
    (NaturalWrapMode -> NaturalWrapMode -> Bool)
    -> (NaturalWrapMode -> NaturalWrapMode -> Bool)
    -> Eq NaturalWrapMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: NaturalWrapMode -> NaturalWrapMode -> Bool
    == :: NaturalWrapMode -> NaturalWrapMode -> Bool
    $c/= :: NaturalWrapMode -> NaturalWrapMode -> Bool
    /= :: NaturalWrapMode -> NaturalWrapMode -> Bool
    Eq)

    instance P.Enum NaturalWrapMode where
        fromEnum :: NaturalWrapMode -> Int
    fromEnum NaturalWrapMode
    NaturalWrapModeInherit = Int
    0
        fromEnum NaturalWrapMode
    NaturalWrapModeNone = Int
    1
        fromEnum NaturalWrapMode
    NaturalWrapModeWord = Int
    2
        fromEnum (AnotherNaturalWrapMode Int
    k) = Int
    k

        toEnum :: Int -> NaturalWrapMode
    toEnum Int
    0 = NaturalWrapMode
    NaturalWrapModeInherit
        toEnum Int
    1 = NaturalWrapMode
    NaturalWrapModeNone
        toEnum Int
    2 = NaturalWrapMode
    NaturalWrapModeWord
        toEnum Int
    k = Int -> NaturalWrapMode
    AnotherNaturalWrapMode Int
    k

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

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

    foreign import ccall "gtk_natural_wrap_mode_get_type" c_gtk_natural_wrap_mode_get_type ::
        IO GType

    instance B.Types.TypedObject NaturalWrapMode where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_natural_wrap_mode_get_type

    instance B.Types.BoxedEnum NaturalWrapMode

    -- Enum MovementStep
    -- | Passed as argument to various keybinding signals for moving the
    -- cursor position.
    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 a [class/@messageDialog@/].
    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 ListTabBehavior
    -- | Used to configure the focus behavior in the @GTK_DIR_TAB_FORWARD@
    -- and @GTK_DIR_TAB_BACKWARD@ direction, like the \<kbd>Tab\<\/kbd> key
    -- in a t'GI.Gtk.Objects.ListView.ListView'.
    --
    -- /Since: 4.12/
    data ListTabBehavior =
          ListTabBehaviorAll
        -- ^ Cycle through all focusable items of the list
        | ListTabBehaviorItem
        -- ^ Cycle through a single list element, then move
        --   focus out of the list. Moving focus between items needs to be
        --   done with the arrow keys.
        | ListTabBehaviorCell
        -- ^ Cycle only through a single cell, then
        --   move focus out of the list. Moving focus between cells needs to
        --   be done with the arrow keys. This is only relevant for
        --   cell-based widgets like t'GI.Gtk.Objects.ColumnView.ColumnView', otherwise it behaves
        --   like @GTK_LIST_TAB_ITEM@.
        | AnotherListTabBehavior Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ListTabBehavior -> ShowS
    [ListTabBehavior] -> ShowS
    ListTabBehavior -> String
    (Int -> ListTabBehavior -> ShowS)
    -> (ListTabBehavior -> String)
    -> ([ListTabBehavior] -> ShowS)
    -> Show ListTabBehavior
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ListTabBehavior -> ShowS
    showsPrec :: Int -> ListTabBehavior -> ShowS
    $cshow :: ListTabBehavior -> String
    show :: ListTabBehavior -> String
    $cshowList :: [ListTabBehavior] -> ShowS
    showList :: [ListTabBehavior] -> ShowS
    Show, ListTabBehavior -> ListTabBehavior -> Bool
    (ListTabBehavior -> ListTabBehavior -> Bool)
    -> (ListTabBehavior -> ListTabBehavior -> Bool)
    -> Eq ListTabBehavior
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ListTabBehavior -> ListTabBehavior -> Bool
    == :: ListTabBehavior -> ListTabBehavior -> Bool
    $c/= :: ListTabBehavior -> ListTabBehavior -> Bool
    /= :: ListTabBehavior -> ListTabBehavior -> Bool
    Eq)

    instance P.Enum ListTabBehavior where
        fromEnum :: ListTabBehavior -> Int
    fromEnum ListTabBehavior
    ListTabBehaviorAll = Int
    0
        fromEnum ListTabBehavior
    ListTabBehaviorItem = Int
    1
        fromEnum ListTabBehavior
    ListTabBehaviorCell = Int
    2
        fromEnum (AnotherListTabBehavior Int
    k) = Int
    k

        toEnum :: Int -> ListTabBehavior
    toEnum Int
    0 = ListTabBehavior
    ListTabBehaviorAll
        toEnum Int
    1 = ListTabBehavior
    ListTabBehaviorItem
        toEnum Int
    2 = ListTabBehavior
    ListTabBehaviorCell
        toEnum Int
    k = Int -> ListTabBehavior
    AnotherListTabBehavior Int
    k

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

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

    foreign import ccall "gtk_list_tab_behavior_get_type" c_gtk_list_tab_behavior_get_type ::
        IO GType

    instance B.Types.TypedObject ListTabBehavior where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_list_tab_behavior_get_type

    instance B.Types.BoxedEnum ListTabBehavior

    -- Enum License
    -- | The type of license for an application.
    --
    -- This enumeration can be expanded at later date.
    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
        | LicenseGpl30Only
        -- ^ The GNU General Public License, version 3.0 only
        | LicenseLgpl21Only
        -- ^ The GNU Lesser General Public License, version 2.1 only
        | LicenseLgpl30Only
        -- ^ The GNU Lesser General Public License, version 3.0 only
        | LicenseAgpl30
        -- ^ The GNU Affero General Public License, version 3.0 or later
        | LicenseAgpl30Only
        -- ^ The GNU Affero General Public License, version 3.0 only
        | LicenseBsd3
        -- ^ The 3-clause BSD licence
        | LicenseApache20
        -- ^ The Apache License, version 2.0
        | LicenseMpl20
        -- ^ The Mozilla Public License, version 2.0
        | License0bsd
        -- ^ Zero-Clause BSD license
        | 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 License
    License0bsd = Int
    18
        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
    18 = License
    License0bsd
        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 [class/@levelBar@/] contents should be rendered.
    --
    -- Note that this enumeration could be extended with additional modes
    -- in the future.
    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 [class/@label@/] widget.
    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 InterfaceContrast
    -- | Values for the [Settings:gtkInterfaceContrast]("GI.Gtk.Objects.Settings#g:attr:gtkInterfaceContrast")
    -- and [CssProvider:prefersContrast]("GI.Gtk.Objects.CssProvider#g:attr:prefersContrast") properties
    -- that indicates the preferred level of contrast.
    --
    -- This information can be used inside CSS via media queries.
    --
    -- More values may be added to this enumeration. Unknown values
    -- should be treated the same as @GTK_INTERFACE_CONTRAST_NO_PREFERENCE@.
    --
    -- /Since: 4.20/
    data InterfaceContrast =
          InterfaceContrastUnsupported
        -- ^ The system doesn\'t support contrast levels
        | InterfaceContrastNoPreference
        -- ^ No particular preference for contrast
        | InterfaceContrastMore
        -- ^ More contrast is preferred
        | InterfaceContrastLess
        -- ^ Less contrast is preferred
        | AnotherInterfaceContrast Int
        -- ^ Catch-all for unknown values
        deriving (Int -> InterfaceContrast -> ShowS
    [InterfaceContrast] -> ShowS
    InterfaceContrast -> String
    (Int -> InterfaceContrast -> ShowS)
    -> (InterfaceContrast -> String)
    -> ([InterfaceContrast] -> ShowS)
    -> Show InterfaceContrast
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> InterfaceContrast -> ShowS
    showsPrec :: Int -> InterfaceContrast -> ShowS
    $cshow :: InterfaceContrast -> String
    show :: InterfaceContrast -> String
    $cshowList :: [InterfaceContrast] -> ShowS
    showList :: [InterfaceContrast] -> ShowS
    Show, InterfaceContrast -> InterfaceContrast -> Bool
    (InterfaceContrast -> InterfaceContrast -> Bool)
    -> (InterfaceContrast -> InterfaceContrast -> Bool)
    -> Eq InterfaceContrast
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: InterfaceContrast -> InterfaceContrast -> Bool
    == :: InterfaceContrast -> InterfaceContrast -> Bool
    $c/= :: InterfaceContrast -> InterfaceContrast -> Bool
    /= :: InterfaceContrast -> InterfaceContrast -> Bool
    Eq)

    instance P.Enum InterfaceContrast where
        fromEnum :: InterfaceContrast -> Int
    fromEnum InterfaceContrast
    InterfaceContrastUnsupported = Int
    0
        fromEnum InterfaceContrast
    InterfaceContrastNoPreference = Int
    1
        fromEnum InterfaceContrast
    InterfaceContrastMore = Int
    2
        fromEnum InterfaceContrast
    InterfaceContrastLess = Int
    3
        fromEnum (AnotherInterfaceContrast Int
    k) = Int
    k

        toEnum :: Int -> InterfaceContrast
    toEnum Int
    0 = InterfaceContrast
    InterfaceContrastUnsupported
        toEnum Int
    1 = InterfaceContrast
    InterfaceContrastNoPreference
        toEnum Int
    2 = InterfaceContrast
    InterfaceContrastMore
        toEnum Int
    3 = InterfaceContrast
    InterfaceContrastLess
        toEnum Int
    k = Int -> InterfaceContrast
    AnotherInterfaceContrast Int
    k

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

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

    foreign import ccall "gtk_interface_contrast_get_type" c_gtk_interface_contrast_get_type ::
        IO GType

    instance B.Types.TypedObject InterfaceContrast where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_interface_contrast_get_type

    instance B.Types.BoxedEnum InterfaceContrast

    -- Enum InterfaceColorScheme
    -- | Values for the [Settings:gtkInterfaceColorScheme]("GI.Gtk.Objects.Settings#g:attr:gtkInterfaceColorScheme")
    -- and [CssProvider:prefersColorScheme]("GI.Gtk.Objects.CssProvider#g:attr:prefersColorScheme") properties
    -- that indicates what color scheme is used.
    --
    -- This information can be used inside CSS via media queries.
    --
    -- More values may be added to this enumeration. Unknown values
    -- should be treated the same as @GTK_INTERFACE_COLOR_SCHEME_DEFAULT@.
    --
    -- /Since: 4.20/
    data InterfaceColorScheme =
          InterfaceColorSchemeUnsupported
        -- ^ The system doesn\'t support color schemes
        | InterfaceColorSchemeDefault
        -- ^ The default color scheme is used
        | InterfaceColorSchemeDark
        -- ^ A dark color scheme is used
        | InterfaceColorSchemeLight
        -- ^ A light color scheme is used
        | AnotherInterfaceColorScheme Int
        -- ^ Catch-all for unknown values
        deriving (Int -> InterfaceColorScheme -> ShowS
    [InterfaceColorScheme] -> ShowS
    InterfaceColorScheme -> String
    (Int -> InterfaceColorScheme -> ShowS)
    -> (InterfaceColorScheme -> String)
    -> ([InterfaceColorScheme] -> ShowS)
    -> Show InterfaceColorScheme
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> InterfaceColorScheme -> ShowS
    showsPrec :: Int -> InterfaceColorScheme -> ShowS
    $cshow :: InterfaceColorScheme -> String
    show :: InterfaceColorScheme -> String
    $cshowList :: [InterfaceColorScheme] -> ShowS
    showList :: [InterfaceColorScheme] -> ShowS
    Show, InterfaceColorScheme -> InterfaceColorScheme -> Bool
    (InterfaceColorScheme -> InterfaceColorScheme -> Bool)
    -> (InterfaceColorScheme -> InterfaceColorScheme -> Bool)
    -> Eq InterfaceColorScheme
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: InterfaceColorScheme -> InterfaceColorScheme -> Bool
    == :: InterfaceColorScheme -> InterfaceColorScheme -> Bool
    $c/= :: InterfaceColorScheme -> InterfaceColorScheme -> Bool
    /= :: InterfaceColorScheme -> InterfaceColorScheme -> Bool
    Eq)

    instance P.Enum InterfaceColorScheme where
        fromEnum :: InterfaceColorScheme -> Int
    fromEnum InterfaceColorScheme
    InterfaceColorSchemeUnsupported = Int
    0
        fromEnum InterfaceColorScheme
    InterfaceColorSchemeDefault = Int
    1
        fromEnum InterfaceColorScheme
    InterfaceColorSchemeDark = Int
    2
        fromEnum InterfaceColorScheme
    InterfaceColorSchemeLight = Int
    3
        fromEnum (AnotherInterfaceColorScheme Int
    k) = Int
    k

        toEnum :: Int -> InterfaceColorScheme
    toEnum Int
    0 = InterfaceColorScheme
    InterfaceColorSchemeUnsupported
        toEnum Int
    1 = InterfaceColorScheme
    InterfaceColorSchemeDefault
        toEnum Int
    2 = InterfaceColorScheme
    InterfaceColorSchemeDark
        toEnum Int
    3 = InterfaceColorScheme
    InterfaceColorSchemeLight
        toEnum Int
    k = Int -> InterfaceColorScheme
    AnotherInterfaceColorScheme Int
    k

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

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

    foreign import ccall "gtk_interface_color_scheme_get_type" c_gtk_interface_color_scheme_get_type ::
        IO GType

    instance B.Types.TypedObject InterfaceColorScheme where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_interface_color_scheme_get_type

    instance B.Types.BoxedEnum InterfaceColorScheme

    -- Enum InscriptionOverflow
    -- | The different methods to handle text in t'GI.Gtk.Objects.Inscription.Inscription' when it doesn\'t
    -- fit the available space.
    --
    -- /Since: 4.8/
    data InscriptionOverflow =
          InscriptionOverflowClip
        -- ^ Clip the remaining text
        | InscriptionOverflowEllipsizeStart
        -- ^ Omit characters at the start of the text
        | InscriptionOverflowEllipsizeMiddle
        -- ^ Omit characters at the middle of the text
        | InscriptionOverflowEllipsizeEnd
        -- ^ Omit characters at the end of the text
        | AnotherInscriptionOverflow Int
        -- ^ Catch-all for unknown values
        deriving (Int -> InscriptionOverflow -> ShowS
    [InscriptionOverflow] -> ShowS
    InscriptionOverflow -> String
    (Int -> InscriptionOverflow -> ShowS)
    -> (InscriptionOverflow -> String)
    -> ([InscriptionOverflow] -> ShowS)
    -> Show InscriptionOverflow
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> InscriptionOverflow -> ShowS
    showsPrec :: Int -> InscriptionOverflow -> ShowS
    $cshow :: InscriptionOverflow -> String
    show :: InscriptionOverflow -> String
    $cshowList :: [InscriptionOverflow] -> ShowS
    showList :: [InscriptionOverflow] -> ShowS
    Show, InscriptionOverflow -> InscriptionOverflow -> Bool
    (InscriptionOverflow -> InscriptionOverflow -> Bool)
    -> (InscriptionOverflow -> InscriptionOverflow -> Bool)
    -> Eq InscriptionOverflow
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: InscriptionOverflow -> InscriptionOverflow -> Bool
    == :: InscriptionOverflow -> InscriptionOverflow -> Bool
    $c/= :: InscriptionOverflow -> InscriptionOverflow -> Bool
    /= :: InscriptionOverflow -> InscriptionOverflow -> Bool
    Eq)

    instance P.Enum InscriptionOverflow where
        fromEnum :: InscriptionOverflow -> Int
    fromEnum InscriptionOverflow
    InscriptionOverflowClip = Int
    0
        fromEnum InscriptionOverflow
    InscriptionOverflowEllipsizeStart = Int
    1
        fromEnum InscriptionOverflow
    InscriptionOverflowEllipsizeMiddle = Int
    2
        fromEnum InscriptionOverflow
    InscriptionOverflowEllipsizeEnd = Int
    3
        fromEnum (AnotherInscriptionOverflow Int
    k) = Int
    k

        toEnum :: Int -> InscriptionOverflow
    toEnum Int
    0 = InscriptionOverflow
    InscriptionOverflowClip
        toEnum Int
    1 = InscriptionOverflow
    InscriptionOverflowEllipsizeStart
        toEnum Int
    2 = InscriptionOverflow
    InscriptionOverflowEllipsizeMiddle
        toEnum Int
    3 = InscriptionOverflow
    InscriptionOverflowEllipsizeEnd
        toEnum Int
    k = Int -> InscriptionOverflow
    AnotherInscriptionOverflow Int
    k

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

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

    foreign import ccall "gtk_inscription_overflow_get_type" c_gtk_inscription_overflow_get_type ::
        IO GType

    instance B.Types.TypedObject InscriptionOverflow where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_inscription_overflow_get_type

    instance B.Types.BoxedEnum InscriptionOverflow

    -- 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 'GI.Gtk.Enums.InputPurposeDigits' and
    -- 'GI.Gtk.Enums.InputPurposeNumber' 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”.
    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 'GI.Gtk.Enums.InputPurposeFreeForm', but characters are hidden
        | InputPurposePin
        -- ^ Like 'GI.Gtk.Enums.InputPurposeDigits', 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; for instance, if the 'GI.Gtk.Objects.Image.imageGetStorageType'
    -- returns 'GI.Gtk.Enums.ImageTypePaintable', then you can call 'GI.Gtk.Objects.Image.imageGetPaintable'.
    --
    -- 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
        | ImageTypeIconName
        -- ^ the widget contains a named icon
        | ImageTypeGicon
        -- ^ the widget contains a @GIcon@
        | ImageTypePaintable
        -- ^ the widget contains a @GdkPaintable@
        | 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
    ImageTypeIconName = Int
    1
        fromEnum ImageType
    ImageTypeGicon = Int
    2
        fromEnum ImageType
    ImageTypePaintable = Int
    3
        fromEnum (AnotherImageType Int
    k) = Int
    k

        toEnum :: Int -> ImageType
    toEnum Int
    0 = ImageType
    ImageTypeEmpty
        toEnum Int
    1 = ImageType
    ImageTypeIconName
        toEnum Int
    2 = ImageType
    ImageTypeGicon
        toEnum Int
    3 = ImageType
    ImageTypePaintable
        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
    {-# DEPRECATED IconViewDropPosition ["(Since version 4.20)","There is no replacement."] #-}
    -- | An enum for determining where a dropped item goes.
    data IconViewDropPosition =
          IconViewDropPositionNoDrop
        -- ^ no drop possible
        | IconViewDropPositionDropInto
        -- ^ dropped item replaces the item
        | IconViewDropPositionDropLeft
        -- ^ dropped 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 icon sizes.
    --
    -- Icon sizes default to being inherited. Where they cannot be
    -- inherited, text size is the default.
    --
    -- All widgets which use @GtkIconSize@ set the normal-icons or
    -- large-icons style classes correspondingly, and let themes
    -- determine the actual size to be used with the
    -- @-gtk-icon-size@ CSS property.
    data IconSize =
          IconSizeInherit
        -- ^ Keep the size of the parent element
        | IconSizeNormal
        -- ^ Size similar to text size
        | IconSizeLarge
        -- ^ Large size, for example in an icon view
        | 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
    IconSizeInherit = Int
    0
        fromEnum IconSize
    IconSizeNormal = Int
    1
        fromEnum IconSize
    IconSizeLarge = Int
    2
        fromEnum (AnotherIconSize Int
    k) = Int
    k

        toEnum :: Int -> IconSize
    toEnum Int
    0 = IconSize
    IconSizeInherit
        toEnum Int
    1 = IconSize
    IconSizeNormal
        toEnum Int
    2 = IconSize
    IconSizeLarge
        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 GraphicsOffloadEnabled
    -- | Represents the state of graphics offloading.
    --
    -- /Since: 4.14/
    data GraphicsOffloadEnabled =
          GraphicsOffloadEnabledEnabled
        -- ^ Graphics offloading is enabled.
        | GraphicsOffloadEnabledDisabled
        -- ^ Graphics offloading is disabled.
        | AnotherGraphicsOffloadEnabled Int
        -- ^ Catch-all for unknown values
        deriving (Int -> GraphicsOffloadEnabled -> ShowS
    [GraphicsOffloadEnabled] -> ShowS
    GraphicsOffloadEnabled -> String
    (Int -> GraphicsOffloadEnabled -> ShowS)
    -> (GraphicsOffloadEnabled -> String)
    -> ([GraphicsOffloadEnabled] -> ShowS)
    -> Show GraphicsOffloadEnabled
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> GraphicsOffloadEnabled -> ShowS
    showsPrec :: Int -> GraphicsOffloadEnabled -> ShowS
    $cshow :: GraphicsOffloadEnabled -> String
    show :: GraphicsOffloadEnabled -> String
    $cshowList :: [GraphicsOffloadEnabled] -> ShowS
    showList :: [GraphicsOffloadEnabled] -> ShowS
    Show, GraphicsOffloadEnabled -> GraphicsOffloadEnabled -> Bool
    (GraphicsOffloadEnabled -> GraphicsOffloadEnabled -> Bool)
    -> (GraphicsOffloadEnabled -> GraphicsOffloadEnabled -> Bool)
    -> Eq GraphicsOffloadEnabled
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: GraphicsOffloadEnabled -> GraphicsOffloadEnabled -> Bool
    == :: GraphicsOffloadEnabled -> GraphicsOffloadEnabled -> Bool
    $c/= :: GraphicsOffloadEnabled -> GraphicsOffloadEnabled -> Bool
    /= :: GraphicsOffloadEnabled -> GraphicsOffloadEnabled -> Bool
    Eq)

    instance P.Enum GraphicsOffloadEnabled where
        fromEnum :: GraphicsOffloadEnabled -> Int
    fromEnum GraphicsOffloadEnabled
    GraphicsOffloadEnabledEnabled = Int
    0
        fromEnum GraphicsOffloadEnabled
    GraphicsOffloadEnabledDisabled = Int
    1
        fromEnum (AnotherGraphicsOffloadEnabled Int
    k) = Int
    k

        toEnum :: Int -> GraphicsOffloadEnabled
    toEnum Int
    0 = GraphicsOffloadEnabled
    GraphicsOffloadEnabledEnabled
        toEnum Int
    1 = GraphicsOffloadEnabled
    GraphicsOffloadEnabledDisabled
        toEnum Int
    k = Int -> GraphicsOffloadEnabled
    AnotherGraphicsOffloadEnabled Int
    k

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

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

    foreign import ccall "gtk_graphics_offload_enabled_get_type" c_gtk_graphics_offload_enabled_get_type ::
        IO GType

    instance B.Types.TypedObject GraphicsOffloadEnabled where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_graphics_offload_enabled_get_type

    instance B.Types.BoxedEnum GraphicsOffloadEnabled

    -- Enum FontRendering
    -- | Values for the [Settings:gtkFontRendering]("GI.Gtk.Objects.Settings#g:attr:gtkFontRendering") setting
    -- that influence how GTK renders fonts.
    --
    -- /Since: 4.16/
    data FontRendering =
          FontRenderingAutomatic
        -- ^ Set up font rendering automatically,
        --   taking factors like screen resolution and scale into account
        | FontRenderingManual
        -- ^ Follow low-level font-related settings
        --   when configuring font rendering
        | AnotherFontRendering Int
        -- ^ Catch-all for unknown values
        deriving (Int -> FontRendering -> ShowS
    [FontRendering] -> ShowS
    FontRendering -> String
    (Int -> FontRendering -> ShowS)
    -> (FontRendering -> String)
    -> ([FontRendering] -> ShowS)
    -> Show FontRendering
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FontRendering -> ShowS
    showsPrec :: Int -> FontRendering -> ShowS
    $cshow :: FontRendering -> String
    show :: FontRendering -> String
    $cshowList :: [FontRendering] -> ShowS
    showList :: [FontRendering] -> ShowS
    Show, FontRendering -> FontRendering -> Bool
    (FontRendering -> FontRendering -> Bool)
    -> (FontRendering -> FontRendering -> Bool) -> Eq FontRendering
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FontRendering -> FontRendering -> Bool
    == :: FontRendering -> FontRendering -> Bool
    $c/= :: FontRendering -> FontRendering -> Bool
    /= :: FontRendering -> FontRendering -> Bool
    Eq)

    instance P.Enum FontRendering where
        fromEnum :: FontRendering -> Int
    fromEnum FontRendering
    FontRenderingAutomatic = Int
    0
        fromEnum FontRendering
    FontRenderingManual = Int
    1
        fromEnum (AnotherFontRendering Int
    k) = Int
    k

        toEnum :: Int -> FontRendering
    toEnum Int
    0 = FontRendering
    FontRenderingAutomatic
        toEnum Int
    1 = FontRendering
    FontRenderingManual
        toEnum Int
    k = Int -> FontRendering
    AnotherFontRendering Int
    k

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

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

    foreign import ccall "gtk_font_rendering_get_type" c_gtk_font_rendering_get_type ::
        IO GType

    instance B.Types.TypedObject FontRendering where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_font_rendering_get_type

    instance B.Types.BoxedEnum FontRendering

    -- Enum FontLevel
    -- | The level of granularity for the font selection.
    --
    -- Depending on this value, the @PangoFontDescription@ that
    -- is returned by 'GI.Gtk.Objects.FontDialogButton.fontDialogButtonGetFontDesc'
    -- will have more or less fields set.
    --
    -- /Since: 4.10/
    data FontLevel =
          FontLevelFamily
        -- ^ Select a font family
        | FontLevelFace
        -- ^ Select a font face (i.e. a family and a style)
        | FontLevelFont
        -- ^ Select a font (i.e. a face with a size, and possibly font variations)
        | FontLevelFeatures
        -- ^ Select a font and font features
        | AnotherFontLevel Int
        -- ^ Catch-all for unknown values
        deriving (Int -> FontLevel -> ShowS
    [FontLevel] -> ShowS
    FontLevel -> String
    (Int -> FontLevel -> ShowS)
    -> (FontLevel -> String)
    -> ([FontLevel] -> ShowS)
    -> Show FontLevel
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FontLevel -> ShowS
    showsPrec :: Int -> FontLevel -> ShowS
    $cshow :: FontLevel -> String
    show :: FontLevel -> String
    $cshowList :: [FontLevel] -> ShowS
    showList :: [FontLevel] -> ShowS
    Show, FontLevel -> FontLevel -> Bool
    (FontLevel -> FontLevel -> Bool)
    -> (FontLevel -> FontLevel -> Bool) -> Eq FontLevel
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FontLevel -> FontLevel -> Bool
    == :: FontLevel -> FontLevel -> Bool
    $c/= :: FontLevel -> FontLevel -> Bool
    /= :: FontLevel -> FontLevel -> Bool
    Eq)

    instance P.Enum FontLevel where
        fromEnum :: FontLevel -> Int
    fromEnum FontLevel
    FontLevelFamily = Int
    0
        fromEnum FontLevel
    FontLevelFace = Int
    1
        fromEnum FontLevel
    FontLevelFont = Int
    2
        fromEnum FontLevel
    FontLevelFeatures = Int
    3
        fromEnum (AnotherFontLevel Int
    k) = Int
    k

        toEnum :: Int -> FontLevel
    toEnum Int
    0 = FontLevel
    FontLevelFamily
        toEnum Int
    1 = FontLevel
    FontLevelFace
        toEnum Int
    2 = FontLevel
    FontLevelFont
        toEnum Int
    3 = FontLevel
    FontLevelFeatures
        toEnum Int
    k = Int -> FontLevel
    AnotherFontLevel Int
    k

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

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

    foreign import ccall "gtk_font_level_get_type" c_gtk_font_level_get_type ::
        IO GType

    instance B.Types.TypedObject FontLevel where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_font_level_get_type

    instance B.Types.BoxedEnum FontLevel

    -- Enum FilterMatch
    -- | Describes the known strictness of a filter.
    --
    -- Note that for filters where the strictness is not known,
    -- @GTK_FILTER_MATCH_SOME@ is always an acceptable value,
    -- even if a filter does match all or no items.
    data FilterMatch =
          FilterMatchSome
        -- ^ The filter matches some items,
        --   'GI.Gtk.Objects.Filter.filterMatch' may return true or false
        | FilterMatchNone
        -- ^ The filter does not match any item,
        --   'GI.Gtk.Objects.Filter.filterMatch' will always return false
        | FilterMatchAll
        -- ^ The filter matches all items,
        --   'GI.Gtk.Objects.Filter.filterMatch' will alays return true
        | AnotherFilterMatch Int
        -- ^ Catch-all for unknown values
        deriving (Int -> FilterMatch -> ShowS
    [FilterMatch] -> ShowS
    FilterMatch -> String
    (Int -> FilterMatch -> ShowS)
    -> (FilterMatch -> String)
    -> ([FilterMatch] -> ShowS)
    -> Show FilterMatch
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FilterMatch -> ShowS
    showsPrec :: Int -> FilterMatch -> ShowS
    $cshow :: FilterMatch -> String
    show :: FilterMatch -> String
    $cshowList :: [FilterMatch] -> ShowS
    showList :: [FilterMatch] -> ShowS
    Show, FilterMatch -> FilterMatch -> Bool
    (FilterMatch -> FilterMatch -> Bool)
    -> (FilterMatch -> FilterMatch -> Bool) -> Eq FilterMatch
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FilterMatch -> FilterMatch -> Bool
    == :: FilterMatch -> FilterMatch -> Bool
    $c/= :: FilterMatch -> FilterMatch -> Bool
    /= :: FilterMatch -> FilterMatch -> Bool
    Eq)

    instance P.Enum FilterMatch where
        fromEnum :: FilterMatch -> Int
    fromEnum FilterMatch
    FilterMatchSome = Int
    0
        fromEnum FilterMatch
    FilterMatchNone = Int
    1
        fromEnum FilterMatch
    FilterMatchAll = Int
    2
        fromEnum (AnotherFilterMatch Int
    k) = Int
    k

        toEnum :: Int -> FilterMatch
    toEnum Int
    0 = FilterMatch
    FilterMatchSome
        toEnum Int
    1 = FilterMatch
    FilterMatchNone
        toEnum Int
    2 = FilterMatch
    FilterMatchAll
        toEnum Int
    k = Int -> FilterMatch
    AnotherFilterMatch Int
    k

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

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

    foreign import ccall "gtk_filter_match_get_type" c_gtk_filter_match_get_type ::
        IO GType

    instance B.Types.TypedObject FilterMatch where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_filter_match_get_type

    instance B.Types.BoxedEnum FilterMatch

    -- Enum FilterChange
    -- | Describes changes in a filter in more detail and allows objects
    -- using the filter to optimize refiltering items.
    --
    -- If you are writing an implementation and are not sure which
    -- value to pass, @GTK_FILTER_CHANGE_DIFFERENT@ is always a correct
    -- choice.
    --
    -- New values may be added in the future.
    data FilterChange =
          FilterChangeDifferent
        -- ^ The filter change cannot be
        --   described with any of the other enumeration values
        | FilterChangeLessStrict
        -- ^ The filter is less strict than
        --   it was before: All items that it used to return true
        --   still return true, others now may, too.
        | FilterChangeMoreStrict
        -- ^ The filter is more strict than
        --   it was before: All items that it used to return false
        --   still return false, others now may, too.
        | FilterChangeDifferentRewatch
        -- ^ Similar to 'GI.Gtk.Enums.FilterChangeDifferent',
        -- but signs that item watches should be recreated. This is used by
        -- t'GI.Gtk.Objects.FilterListModel.FilterListModel' to keep the list up-to-date when items
        -- change.
        --
        -- /Since: 4.20/
        | FilterChangeLessStrictRewatch
        -- ^ Similar to 'GI.Gtk.Enums.FilterChangeLessStrict',
        -- but signs that item watches should be recreated. This is used by
        -- t'GI.Gtk.Objects.FilterListModel.FilterListModel' to keep the list up-to-date when items
        -- change.
        --
        -- /Since: 4.20/
        | FilterChangeMoreStrictRewatch
        -- ^ Similar to 'GI.Gtk.Enums.FilterChangeMoreStrict',
        -- but signs that item watches should be recreated. This is used by
        -- t'GI.Gtk.Objects.FilterListModel.FilterListModel' to keep the list up-to-date when items
        -- change.
        --
        -- /Since: 4.20/
        | AnotherFilterChange Int
        -- ^ Catch-all for unknown values
        deriving (Int -> FilterChange -> ShowS
    [FilterChange] -> ShowS
    FilterChange -> String
    (Int -> FilterChange -> ShowS)
    -> (FilterChange -> String)
    -> ([FilterChange] -> ShowS)
    -> Show FilterChange
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FilterChange -> ShowS
    showsPrec :: Int -> FilterChange -> ShowS
    $cshow :: FilterChange -> String
    show :: FilterChange -> String
    $cshowList :: [FilterChange] -> ShowS
    showList :: [FilterChange] -> ShowS
    Show, FilterChange -> FilterChange -> Bool
    (FilterChange -> FilterChange -> Bool)
    -> (FilterChange -> FilterChange -> Bool) -> Eq FilterChange
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FilterChange -> FilterChange -> Bool
    == :: FilterChange -> FilterChange -> Bool
    $c/= :: FilterChange -> FilterChange -> Bool
    /= :: FilterChange -> FilterChange -> Bool
    Eq)

    instance P.Enum FilterChange where
        fromEnum :: FilterChange -> Int
    fromEnum FilterChange
    FilterChangeDifferent = Int
    0
        fromEnum FilterChange
    FilterChangeLessStrict = Int
    1
        fromEnum FilterChange
    FilterChangeMoreStrict = Int
    2
        fromEnum FilterChange
    FilterChangeDifferentRewatch = Int
    3
        fromEnum FilterChange
    FilterChangeLessStrictRewatch = Int
    4
        fromEnum FilterChange
    FilterChangeMoreStrictRewatch = Int
    5
        fromEnum (AnotherFilterChange Int
    k) = Int
    k

        toEnum :: Int -> FilterChange
    toEnum Int
    0 = FilterChange
    FilterChangeDifferent
        toEnum Int
    1 = FilterChange
    FilterChangeLessStrict
        toEnum Int
    2 = FilterChange
    FilterChangeMoreStrict
        toEnum Int
    3 = FilterChange
    FilterChangeDifferentRewatch
        toEnum Int
    4 = FilterChange
    FilterChangeLessStrictRewatch
        toEnum Int
    5 = FilterChange
    FilterChangeMoreStrictRewatch
        toEnum Int
    k = Int -> FilterChange
    AnotherFilterChange Int
    k

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

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

    foreign import ccall "gtk_filter_change_get_type" c_gtk_filter_change_get_type ::
        IO GType

    instance B.Types.TypedObject FilterChange where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_filter_change_get_type

    instance B.Types.BoxedEnum FilterChange

    -- Enum FileChooserError
    {-# DEPRECATED FileChooserError ["(Since version 4.20)","There is no replacement"] #-}
    -- | These identify the various errors that can occur while calling
    -- @GtkFileChooser@ 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 FileChooserAction
    -- | Describes whether a @GtkFileChooser@ 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.
        | 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 (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
    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 EventSequenceState
    -- | Describes the state of a t'GI.Gdk.Structs.EventSequence.EventSequence' in a [class/@gesture@/].
    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.
    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 EditableProperties
    -- | The identifiers for t'GI.Gtk.Interfaces.Editable.Editable' properties.
    --
    -- See 'GI.Gtk.Interfaces.Editable.editableInstallProperties' for details on how to
    -- implement the @GtkEditable@ interface.
    data EditableProperties =
          EditablePropertiesPropText
        -- ^ the property id for [Editable:text]("GI.Gtk.Interfaces.Editable#g:attr:text")
        | EditablePropertiesPropCursorPosition
        -- ^ the property id for [Editable:cursorPosition]("GI.Gtk.Interfaces.Editable#g:attr:cursorPosition")
        | EditablePropertiesPropSelectionBound
        -- ^ the property id for [Editable:selectionBound]("GI.Gtk.Interfaces.Editable#g:attr:selectionBound")
        | EditablePropertiesPropEditable
        -- ^ the property id for [Editable:editable]("GI.Gtk.Interfaces.Editable#g:attr:editable")
        | EditablePropertiesPropWidthChars
        -- ^ the property id for [Editable:widthChars]("GI.Gtk.Interfaces.Editable#g:attr:widthChars")
        | EditablePropertiesPropMaxWidthChars
        -- ^ the property id for [Editable:maxWidthChars]("GI.Gtk.Interfaces.Editable#g:attr:maxWidthChars")
        | EditablePropertiesPropXalign
        -- ^ the property id for [Editable:xalign]("GI.Gtk.Interfaces.Editable#g:attr:xalign")
        | EditablePropertiesPropEnableUndo
        -- ^ the property id for [Editable:enableUndo]("GI.Gtk.Interfaces.Editable#g:attr:enableUndo")
        | EditablePropertiesPropCompleteText
        -- ^ the property id for [Editable:completeText]("GI.Gtk.Interfaces.Editable#g:attr:completeText")
        | EditablePropertiesPropInputInterceptor
        -- ^ the property id for [Editable:inputInterceptor]("GI.Gtk.Interfaces.Editable#g:attr:inputInterceptor")
        | EditablePropertiesNumProperties
        -- ^ the number of properties
        | AnotherEditableProperties Int
        -- ^ Catch-all for unknown values
        deriving (Int -> EditableProperties -> ShowS
    [EditableProperties] -> ShowS
    EditableProperties -> String
    (Int -> EditableProperties -> ShowS)
    -> (EditableProperties -> String)
    -> ([EditableProperties] -> ShowS)
    -> Show EditableProperties
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EditableProperties -> ShowS
    showsPrec :: Int -> EditableProperties -> ShowS
    $cshow :: EditableProperties -> String
    show :: EditableProperties -> String
    $cshowList :: [EditableProperties] -> ShowS
    showList :: [EditableProperties] -> ShowS
    Show, EditableProperties -> EditableProperties -> Bool
    (EditableProperties -> EditableProperties -> Bool)
    -> (EditableProperties -> EditableProperties -> Bool)
    -> Eq EditableProperties
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EditableProperties -> EditableProperties -> Bool
    == :: EditableProperties -> EditableProperties -> Bool
    $c/= :: EditableProperties -> EditableProperties -> Bool
    /= :: EditableProperties -> EditableProperties -> Bool
    Eq)

    instance P.Enum EditableProperties where
        fromEnum :: EditableProperties -> Int
    fromEnum EditableProperties
    EditablePropertiesPropText = Int
    0
        fromEnum EditableProperties
    EditablePropertiesPropCursorPosition = Int
    1
        fromEnum EditableProperties
    EditablePropertiesPropSelectionBound = Int
    2
        fromEnum EditableProperties
    EditablePropertiesPropEditable = Int
    3
        fromEnum EditableProperties
    EditablePropertiesPropWidthChars = Int
    4
        fromEnum EditableProperties
    EditablePropertiesPropMaxWidthChars = Int
    5
        fromEnum EditableProperties
    EditablePropertiesPropXalign = Int
    6
        fromEnum EditableProperties
    EditablePropertiesPropEnableUndo = Int
    7
        fromEnum EditableProperties
    EditablePropertiesPropCompleteText = Int
    8
        fromEnum EditableProperties
    EditablePropertiesPropInputInterceptor = Int
    9
        fromEnum EditableProperties
    EditablePropertiesNumProperties = Int
    10
        fromEnum (AnotherEditableProperties Int
    k) = Int
    k

        toEnum :: Int -> EditableProperties
    toEnum Int
    0 = EditableProperties
    EditablePropertiesPropText
        toEnum Int
    1 = EditableProperties
    EditablePropertiesPropCursorPosition
        toEnum Int
    2 = EditableProperties
    EditablePropertiesPropSelectionBound
        toEnum Int
    3 = EditableProperties
    EditablePropertiesPropEditable
        toEnum Int
    4 = EditableProperties
    EditablePropertiesPropWidthChars
        toEnum Int
    5 = EditableProperties
    EditablePropertiesPropMaxWidthChars
        toEnum Int
    6 = EditableProperties
    EditablePropertiesPropXalign
        toEnum Int
    7 = EditableProperties
    EditablePropertiesPropEnableUndo
        toEnum Int
    8 = EditableProperties
    EditablePropertiesPropCompleteText
        toEnum Int
    9 = EditableProperties
    EditablePropertiesPropInputInterceptor
        toEnum Int
    10 = EditableProperties
    EditablePropertiesNumProperties
        toEnum Int
    k = Int -> EditableProperties
    AnotherEditableProperties Int
    k

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

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

    foreign import ccall "gtk_editable_properties_get_type" c_gtk_editable_properties_get_type ::
        IO GType

    instance B.Types.TypedObject EditableProperties where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_editable_properties_get_type

    instance B.Types.BoxedEnum EditableProperties

    -- 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 DialogError
    -- | Error codes in the @GTK_DIALOG_ERROR@ domain that can be returned
    -- by async dialog functions.
    --
    -- /Since: 4.10/
    data DialogError =
          DialogErrorFailed
        -- ^ Generic error condition for when
        --   an operation fails and no more specific code is applicable
        | DialogErrorCancelled
        -- ^ The async function call was cancelled
        --   via its @GCancellable@
        | DialogErrorDismissed
        -- ^ The operation was cancelled
        --   by the user (via a Cancel or Close button)
        | AnotherDialogError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DialogError -> ShowS
    [DialogError] -> ShowS
    DialogError -> String
    (Int -> DialogError -> ShowS)
    -> (DialogError -> String)
    -> ([DialogError] -> ShowS)
    -> Show DialogError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DialogError -> ShowS
    showsPrec :: Int -> DialogError -> ShowS
    $cshow :: DialogError -> String
    show :: DialogError -> String
    $cshowList :: [DialogError] -> ShowS
    showList :: [DialogError] -> ShowS
    Show, DialogError -> DialogError -> Bool
    (DialogError -> DialogError -> Bool)
    -> (DialogError -> DialogError -> Bool) -> Eq DialogError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DialogError -> DialogError -> Bool
    == :: DialogError -> DialogError -> Bool
    $c/= :: DialogError -> DialogError -> Bool
    /= :: DialogError -> DialogError -> Bool
    Eq)

    instance P.Enum DialogError where
        fromEnum :: DialogError -> Int
    fromEnum DialogError
    DialogErrorFailed = Int
    0
        fromEnum DialogError
    DialogErrorCancelled = Int
    1
        fromEnum DialogError
    DialogErrorDismissed = Int
    2
        fromEnum (AnotherDialogError Int
    k) = Int
    k

        toEnum :: Int -> DialogError
    toEnum Int
    0 = DialogError
    DialogErrorFailed
        toEnum Int
    1 = DialogError
    DialogErrorCancelled
        toEnum Int
    2 = DialogError
    DialogErrorDismissed
        toEnum Int
    k = Int -> DialogError
    AnotherDialogError Int
    k

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

    instance GErrorClass DialogError where
        gerrorClassDomain :: DialogError -> Text
    gerrorClassDomain DialogError
    _ = Text
    "gtk-dialog-error-quark"

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

    -- | Handle exceptions of type `DialogError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
    handleDialogError ::
        (DialogError -> GErrorMessage -> IO a) ->
        IO a ->
        IO a
    handleDialogError :: forall a. (DialogError -> Text -> IO a) -> IO a -> IO a
    handleDialogError = (DialogError -> 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 DialogError = '[]
    instance O.HasParentTypes DialogError

    foreign import ccall "gtk_dialog_error_get_type" c_gtk_dialog_error_get_type ::
        IO GType

    instance B.Types.TypedObject DialogError where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_dialog_error_get_type

    instance B.Types.BoxedEnum DialogError

    -- Enum DeleteType
    -- | Passed to various keybinding signals for deleting text.
    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 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 CssParserWarning
    -- | Warnings that can occur while parsing CSS.
    --
    -- Unlike @GtkCssParserError@s, warnings do not cause the parser to
    -- skip any input, but they indicate issues that should be fixed.
    data CssParserWarning =
          CssParserWarningDeprecated
        -- ^ The given construct is
        --   deprecated and will be removed in a future version
        | CssParserWarningSyntax
        -- ^ A syntax construct was used
        --   that should be avoided
        | CssParserWarningUnimplemented
        -- ^ A feature is not implemented
        | AnotherCssParserWarning Int
        -- ^ Catch-all for unknown values
        deriving (Int -> CssParserWarning -> ShowS
    [CssParserWarning] -> ShowS
    CssParserWarning -> String
    (Int -> CssParserWarning -> ShowS)
    -> (CssParserWarning -> String)
    -> ([CssParserWarning] -> ShowS)
    -> Show CssParserWarning
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CssParserWarning -> ShowS
    showsPrec :: Int -> CssParserWarning -> ShowS
    $cshow :: CssParserWarning -> String
    show :: CssParserWarning -> String
    $cshowList :: [CssParserWarning] -> ShowS
    showList :: [CssParserWarning] -> ShowS
    Show, CssParserWarning -> CssParserWarning -> Bool
    (CssParserWarning -> CssParserWarning -> Bool)
    -> (CssParserWarning -> CssParserWarning -> Bool)
    -> Eq CssParserWarning
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CssParserWarning -> CssParserWarning -> Bool
    == :: CssParserWarning -> CssParserWarning -> Bool
    $c/= :: CssParserWarning -> CssParserWarning -> Bool
    /= :: CssParserWarning -> CssParserWarning -> Bool
    Eq)

    instance P.Enum CssParserWarning where
        fromEnum :: CssParserWarning -> Int
    fromEnum CssParserWarning
    CssParserWarningDeprecated = Int
    0
        fromEnum CssParserWarning
    CssParserWarningSyntax = Int
    1
        fromEnum CssParserWarning
    CssParserWarningUnimplemented = Int
    2
        fromEnum (AnotherCssParserWarning Int
    k) = Int
    k

        toEnum :: Int -> CssParserWarning
    toEnum Int
    0 = CssParserWarning
    CssParserWarningDeprecated
        toEnum Int
    1 = CssParserWarning
    CssParserWarningSyntax
        toEnum Int
    2 = CssParserWarning
    CssParserWarningUnimplemented
        toEnum Int
    k = Int -> CssParserWarning
    AnotherCssParserWarning Int
    k

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

    -- Enum CssParserError
    -- | Errors that can occur while parsing CSS.
    --
    -- These errors are unexpected and will cause parts of the given CSS
    -- to be ignored.
    data CssParserError =
          CssParserErrorFailed
        -- ^ Unknown failure.
        | CssParserErrorSyntax
        -- ^ The given text does not form valid syntax
        | CssParserErrorImport
        -- ^ Failed to import a resource
        | CssParserErrorName
        -- ^ The given name has not been defined
        | CssParserErrorUnknownValue
        -- ^ The given value is not correct
        | AnotherCssParserError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> CssParserError -> ShowS
    [CssParserError] -> ShowS
    CssParserError -> String
    (Int -> CssParserError -> ShowS)
    -> (CssParserError -> String)
    -> ([CssParserError] -> ShowS)
    -> Show CssParserError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CssParserError -> ShowS
    showsPrec :: Int -> CssParserError -> ShowS
    $cshow :: CssParserError -> String
    show :: CssParserError -> String
    $cshowList :: [CssParserError] -> ShowS
    showList :: [CssParserError] -> ShowS
    Show, CssParserError -> CssParserError -> Bool
    (CssParserError -> CssParserError -> Bool)
    -> (CssParserError -> CssParserError -> Bool) -> Eq CssParserError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CssParserError -> CssParserError -> Bool
    == :: CssParserError -> CssParserError -> Bool
    $c/= :: CssParserError -> CssParserError -> Bool
    /= :: CssParserError -> CssParserError -> Bool
    Eq)

    instance P.Enum CssParserError where
        fromEnum :: CssParserError -> Int
    fromEnum CssParserError
    CssParserErrorFailed = Int
    0
        fromEnum CssParserError
    CssParserErrorSyntax = Int
    1
        fromEnum CssParserError
    CssParserErrorImport = Int
    2
        fromEnum CssParserError
    CssParserErrorName = Int
    3
        fromEnum CssParserError
    CssParserErrorUnknownValue = Int
    4
        fromEnum (AnotherCssParserError Int
    k) = Int
    k

        toEnum :: Int -> CssParserError
    toEnum Int
    0 = CssParserError
    CssParserErrorFailed
        toEnum Int
    1 = CssParserError
    CssParserErrorSyntax
        toEnum Int
    2 = CssParserError
    CssParserErrorImport
        toEnum Int
    3 = CssParserError
    CssParserErrorName
        toEnum Int
    4 = CssParserError
    CssParserErrorUnknownValue
        toEnum Int
    k = Int -> CssParserError
    AnotherCssParserError Int
    k

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

    instance GErrorClass CssParserError where
        gerrorClassDomain :: CssParserError -> Text
    gerrorClassDomain CssParserError
    _ = Text
    "gtk-css-parser-error-quark"

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

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

    -- Enum CornerType
    -- | Specifies which corner a child widget should be placed in when packed into
    -- a @GtkScrolledWindow.@
    --
    -- 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 ContentFit
    -- | Controls how a content should be made to fit inside an allocation.
    --
    -- /Since: 4.8/
    data ContentFit =
          ContentFitFill
        -- ^ Make the content fill the entire allocation,
        --   without taking its aspect ratio in consideration. The resulting
        --   content will appear as stretched if its aspect ratio is different
        --   from the allocation aspect ratio.
        | ContentFitContain
        -- ^ Scale the content to fit the allocation,
        --   while taking its aspect ratio in consideration. The resulting
        --   content will appear as letterboxed if its aspect ratio is different
        --   from the allocation aspect ratio.
        | ContentFitCover
        -- ^ Cover the entire allocation, while taking
        --   the content aspect ratio in consideration. The resulting content
        --   will appear as clipped if its aspect ratio is different from the
        --   allocation aspect ratio.
        | ContentFitScaleDown
        -- ^ The content is scaled down to fit the
        --   allocation, if needed, otherwise its original size is used.
        | AnotherContentFit Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ContentFit -> ShowS
    [ContentFit] -> ShowS
    ContentFit -> String
    (Int -> ContentFit -> ShowS)
    -> (ContentFit -> String)
    -> ([ContentFit] -> ShowS)
    -> Show ContentFit
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ContentFit -> ShowS
    showsPrec :: Int -> ContentFit -> ShowS
    $cshow :: ContentFit -> String
    show :: ContentFit -> String
    $cshowList :: [ContentFit] -> ShowS
    showList :: [ContentFit] -> ShowS
    Show, ContentFit -> ContentFit -> Bool
    (ContentFit -> ContentFit -> Bool)
    -> (ContentFit -> ContentFit -> Bool) -> Eq ContentFit
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ContentFit -> ContentFit -> Bool
    == :: ContentFit -> ContentFit -> Bool
    $c/= :: ContentFit -> ContentFit -> Bool
    /= :: ContentFit -> ContentFit -> Bool
    Eq)

    instance P.Enum ContentFit where
        fromEnum :: ContentFit -> Int
    fromEnum ContentFit
    ContentFitFill = Int
    0
        fromEnum ContentFit
    ContentFitContain = Int
    1
        fromEnum ContentFit
    ContentFitCover = Int
    2
        fromEnum ContentFit
    ContentFitScaleDown = Int
    3
        fromEnum (AnotherContentFit Int
    k) = Int
    k

        toEnum :: Int -> ContentFit
    toEnum Int
    0 = ContentFit
    ContentFitFill
        toEnum Int
    1 = ContentFit
    ContentFitContain
        toEnum Int
    2 = ContentFit
    ContentFitCover
        toEnum Int
    3 = ContentFit
    ContentFitScaleDown
        toEnum Int
    k = Int -> ContentFit
    AnotherContentFit Int
    k

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

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

    foreign import ccall "gtk_content_fit_get_type" c_gtk_content_fit_get_type ::
        IO GType

    instance B.Types.TypedObject ContentFit where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_content_fit_get_type

    instance B.Types.BoxedEnum ContentFit

    -- Enum ConstraintVflParserError
    -- | Domain for VFL parsing errors.
    data ConstraintVflParserError =
          ConstraintVflParserErrorInvalidSymbol
        -- ^ Invalid or unknown symbol
        | ConstraintVflParserErrorInvalidAttribute
        -- ^ Invalid or unknown attribute
        | ConstraintVflParserErrorInvalidView
        -- ^ Invalid or unknown view
        | ConstraintVflParserErrorInvalidMetric
        -- ^ Invalid or unknown metric
        | ConstraintVflParserErrorInvalidPriority
        -- ^ Invalid or unknown priority
        | ConstraintVflParserErrorInvalidRelation
        -- ^ Invalid or unknown relation
        | AnotherConstraintVflParserError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ConstraintVflParserError -> ShowS
    [ConstraintVflParserError] -> ShowS
    ConstraintVflParserError -> String
    (Int -> ConstraintVflParserError -> ShowS)
    -> (ConstraintVflParserError -> String)
    -> ([ConstraintVflParserError] -> ShowS)
    -> Show ConstraintVflParserError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ConstraintVflParserError -> ShowS
    showsPrec :: Int -> ConstraintVflParserError -> ShowS
    $cshow :: ConstraintVflParserError -> String
    show :: ConstraintVflParserError -> String
    $cshowList :: [ConstraintVflParserError] -> ShowS
    showList :: [ConstraintVflParserError] -> ShowS
    Show, ConstraintVflParserError -> ConstraintVflParserError -> Bool
    (ConstraintVflParserError -> ConstraintVflParserError -> Bool)
    -> (ConstraintVflParserError -> ConstraintVflParserError -> Bool)
    -> Eq ConstraintVflParserError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ConstraintVflParserError -> ConstraintVflParserError -> Bool
    == :: ConstraintVflParserError -> ConstraintVflParserError -> Bool
    $c/= :: ConstraintVflParserError -> ConstraintVflParserError -> Bool
    /= :: ConstraintVflParserError -> ConstraintVflParserError -> Bool
    Eq)

    instance P.Enum ConstraintVflParserError where
        fromEnum :: ConstraintVflParserError -> Int
    fromEnum ConstraintVflParserError
    ConstraintVflParserErrorInvalidSymbol = Int
    0
        fromEnum ConstraintVflParserError
    ConstraintVflParserErrorInvalidAttribute = Int
    1
        fromEnum ConstraintVflParserError
    ConstraintVflParserErrorInvalidView = Int
    2
        fromEnum ConstraintVflParserError
    ConstraintVflParserErrorInvalidMetric = Int
    3
        fromEnum ConstraintVflParserError
    ConstraintVflParserErrorInvalidPriority = Int
    4
        fromEnum ConstraintVflParserError
    ConstraintVflParserErrorInvalidRelation = Int
    5
        fromEnum (AnotherConstraintVflParserError Int
    k) = Int
    k

        toEnum :: Int -> ConstraintVflParserError
    toEnum Int
    0 = ConstraintVflParserError
    ConstraintVflParserErrorInvalidSymbol
        toEnum Int
    1 = ConstraintVflParserError
    ConstraintVflParserErrorInvalidAttribute
        toEnum Int
    2 = ConstraintVflParserError
    ConstraintVflParserErrorInvalidView
        toEnum Int
    3 = ConstraintVflParserError
    ConstraintVflParserErrorInvalidMetric
        toEnum Int
    4 = ConstraintVflParserError
    ConstraintVflParserErrorInvalidPriority
        toEnum Int
    5 = ConstraintVflParserError
    ConstraintVflParserErrorInvalidRelation
        toEnum Int
    k = Int -> ConstraintVflParserError
    AnotherConstraintVflParserError Int
    k

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

    instance GErrorClass ConstraintVflParserError where
        gerrorClassDomain :: ConstraintVflParserError -> Text
    gerrorClassDomain ConstraintVflParserError
    _ = Text
    "gtk-constraint-vfl-parser-error-quark"

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

    -- | Handle exceptions of type `ConstraintVflParserError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
    handleConstraintVflParserError ::
        (ConstraintVflParserError -> GErrorMessage -> IO a) ->
        IO a ->
        IO a
    handleConstraintVflParserError :: forall a.
    (ConstraintVflParserError -> Text -> IO a) -> IO a -> IO a
    handleConstraintVflParserError = (ConstraintVflParserError -> 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 ConstraintVflParserError = '[]
    instance O.HasParentTypes ConstraintVflParserError

    foreign import ccall "gtk_constraint_vfl_parser_error_get_type" c_gtk_constraint_vfl_parser_error_get_type ::
        IO GType

    instance B.Types.TypedObject ConstraintVflParserError where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_constraint_vfl_parser_error_get_type

    instance B.Types.BoxedEnum ConstraintVflParserError

    -- Enum ConstraintStrength
    -- | The strength of a constraint, expressed as a symbolic constant.
    --
    -- The strength of a [class/@constraint@/] can be expressed with any positive
    -- integer; the values of this enumeration can be used for readability.
    data ConstraintStrength =
          ConstraintStrengthRequired
        -- ^ The constraint is required towards solving the layout
        | ConstraintStrengthStrong
        -- ^ A strong constraint
        | ConstraintStrengthMedium
        -- ^ A medium constraint
        | ConstraintStrengthWeak
        -- ^ A weak constraint
        | AnotherConstraintStrength Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ConstraintStrength -> ShowS
    [ConstraintStrength] -> ShowS
    ConstraintStrength -> String
    (Int -> ConstraintStrength -> ShowS)
    -> (ConstraintStrength -> String)
    -> ([ConstraintStrength] -> ShowS)
    -> Show ConstraintStrength
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ConstraintStrength -> ShowS
    showsPrec :: Int -> ConstraintStrength -> ShowS
    $cshow :: ConstraintStrength -> String
    show :: ConstraintStrength -> String
    $cshowList :: [ConstraintStrength] -> ShowS
    showList :: [ConstraintStrength] -> ShowS
    Show, ConstraintStrength -> ConstraintStrength -> Bool
    (ConstraintStrength -> ConstraintStrength -> Bool)
    -> (ConstraintStrength -> ConstraintStrength -> Bool)
    -> Eq ConstraintStrength
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ConstraintStrength -> ConstraintStrength -> Bool
    == :: ConstraintStrength -> ConstraintStrength -> Bool
    $c/= :: ConstraintStrength -> ConstraintStrength -> Bool
    /= :: ConstraintStrength -> ConstraintStrength -> Bool
    Eq)

    instance P.Enum ConstraintStrength where
        fromEnum :: ConstraintStrength -> Int
    fromEnum ConstraintStrength
    ConstraintStrengthRequired = Int
    1001001000
        fromEnum ConstraintStrength
    ConstraintStrengthStrong = Int
    1000000000
        fromEnum ConstraintStrength
    ConstraintStrengthMedium = Int
    1000
        fromEnum ConstraintStrength
    ConstraintStrengthWeak = Int
    1
        fromEnum (AnotherConstraintStrength Int
    k) = Int
    k

        toEnum :: Int -> ConstraintStrength
    toEnum Int
    1001001000 = ConstraintStrength
    ConstraintStrengthRequired
        toEnum Int
    1000000000 = ConstraintStrength
    ConstraintStrengthStrong
        toEnum Int
    1000 = ConstraintStrength
    ConstraintStrengthMedium
        toEnum Int
    1 = ConstraintStrength
    ConstraintStrengthWeak
        toEnum Int
    k = Int -> ConstraintStrength
    AnotherConstraintStrength Int
    k

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

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

    foreign import ccall "gtk_constraint_strength_get_type" c_gtk_constraint_strength_get_type ::
        IO GType

    instance B.Types.TypedObject ConstraintStrength where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_constraint_strength_get_type

    instance B.Types.BoxedEnum ConstraintStrength

    -- Enum ConstraintRelation
    -- | The relation between two terms of a constraint.
    data ConstraintRelation =
          ConstraintRelationLe
        -- ^ Less than, or equal
        | ConstraintRelationEq
        -- ^ Equal
        | ConstraintRelationGe
        -- ^ Greater than, or equal
        | AnotherConstraintRelation Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ConstraintRelation -> ShowS
    [ConstraintRelation] -> ShowS
    ConstraintRelation -> String
    (Int -> ConstraintRelation -> ShowS)
    -> (ConstraintRelation -> String)
    -> ([ConstraintRelation] -> ShowS)
    -> Show ConstraintRelation
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ConstraintRelation -> ShowS
    showsPrec :: Int -> ConstraintRelation -> ShowS
    $cshow :: ConstraintRelation -> String
    show :: ConstraintRelation -> String
    $cshowList :: [ConstraintRelation] -> ShowS
    showList :: [ConstraintRelation] -> ShowS
    Show, ConstraintRelation -> ConstraintRelation -> Bool
    (ConstraintRelation -> ConstraintRelation -> Bool)
    -> (ConstraintRelation -> ConstraintRelation -> Bool)
    -> Eq ConstraintRelation
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ConstraintRelation -> ConstraintRelation -> Bool
    == :: ConstraintRelation -> ConstraintRelation -> Bool
    $c/= :: ConstraintRelation -> ConstraintRelation -> Bool
    /= :: ConstraintRelation -> ConstraintRelation -> Bool
    Eq)

    instance P.Enum ConstraintRelation where
        fromEnum :: ConstraintRelation -> Int
    fromEnum ConstraintRelation
    ConstraintRelationLe = Int
    -1
        fromEnum ConstraintRelation
    ConstraintRelationEq = Int
    0
        fromEnum ConstraintRelation
    ConstraintRelationGe = Int
    1
        fromEnum (AnotherConstraintRelation Int
    k) = Int
    k

        toEnum :: Int -> ConstraintRelation
    toEnum Int
    -1 = ConstraintRelation
    ConstraintRelationLe
        toEnum Int
    0 = ConstraintRelation
    ConstraintRelationEq
        toEnum Int
    1 = ConstraintRelation
    ConstraintRelationGe
        toEnum Int
    k = Int -> ConstraintRelation
    AnotherConstraintRelation Int
    k

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

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

    foreign import ccall "gtk_constraint_relation_get_type" c_gtk_constraint_relation_get_type ::
        IO GType

    instance B.Types.TypedObject ConstraintRelation where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_constraint_relation_get_type

    instance B.Types.BoxedEnum ConstraintRelation

    -- Enum ConstraintAttribute
    -- | The widget attributes that can be used when creating a [class/@constraint@/].
    data ConstraintAttribute =
          ConstraintAttributeNone
        -- ^ No attribute, used for constant
        --   relations
        | ConstraintAttributeLeft
        -- ^ The left edge of a widget, regardless of
        --   text direction
        | ConstraintAttributeRight
        -- ^ The right edge of a widget, regardless
        --   of text direction
        | ConstraintAttributeTop
        -- ^ The top edge of a widget
        | ConstraintAttributeBottom
        -- ^ The bottom edge of a widget
        | ConstraintAttributeStart
        -- ^ The leading edge of a widget, depending
        --   on text direction; equivalent to 'GI.Gtk.Enums.ConstraintAttributeLeft' for LTR
        --   languages, and 'GI.Gtk.Enums.ConstraintAttributeRight' for RTL ones
        | ConstraintAttributeEnd
        -- ^ The trailing edge of a widget, depending
        --   on text direction; equivalent to 'GI.Gtk.Enums.ConstraintAttributeRight' for LTR
        --   languages, and 'GI.Gtk.Enums.ConstraintAttributeLeft' for RTL ones
        | ConstraintAttributeWidth
        -- ^ The width of a widget
        | ConstraintAttributeHeight
        -- ^ The height of a widget
        | ConstraintAttributeCenterX
        -- ^ The center of a widget, on the
        --   horizontal axis
        | ConstraintAttributeCenterY
        -- ^ The center of a widget, on the
        --   vertical axis
        | ConstraintAttributeBaseline
        -- ^ The baseline of a widget
        | AnotherConstraintAttribute Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ConstraintAttribute -> ShowS
    [ConstraintAttribute] -> ShowS
    ConstraintAttribute -> String
    (Int -> ConstraintAttribute -> ShowS)
    -> (ConstraintAttribute -> String)
    -> ([ConstraintAttribute] -> ShowS)
    -> Show ConstraintAttribute
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ConstraintAttribute -> ShowS
    showsPrec :: Int -> ConstraintAttribute -> ShowS
    $cshow :: ConstraintAttribute -> String
    show :: ConstraintAttribute -> String
    $cshowList :: [ConstraintAttribute] -> ShowS
    showList :: [ConstraintAttribute] -> ShowS
    Show, ConstraintAttribute -> ConstraintAttribute -> Bool
    (ConstraintAttribute -> ConstraintAttribute -> Bool)
    -> (ConstraintAttribute -> ConstraintAttribute -> Bool)
    -> Eq ConstraintAttribute
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ConstraintAttribute -> ConstraintAttribute -> Bool
    == :: ConstraintAttribute -> ConstraintAttribute -> Bool
    $c/= :: ConstraintAttribute -> ConstraintAttribute -> Bool
    /= :: ConstraintAttribute -> ConstraintAttribute -> Bool
    Eq)

    instance P.Enum ConstraintAttribute where
        fromEnum :: ConstraintAttribute -> Int
    fromEnum ConstraintAttribute
    ConstraintAttributeNone = Int
    0
        fromEnum ConstraintAttribute
    ConstraintAttributeLeft = Int
    1
        fromEnum ConstraintAttribute
    ConstraintAttributeRight = Int
    2
        fromEnum ConstraintAttribute
    ConstraintAttributeTop = Int
    3
        fromEnum ConstraintAttribute
    ConstraintAttributeBottom = Int
    4
        fromEnum ConstraintAttribute
    ConstraintAttributeStart = Int
    5
        fromEnum ConstraintAttribute
    ConstraintAttributeEnd = Int
    6
        fromEnum ConstraintAttribute
    ConstraintAttributeWidth = Int
    7
        fromEnum ConstraintAttribute
    ConstraintAttributeHeight = Int
    8
        fromEnum ConstraintAttribute
    ConstraintAttributeCenterX = Int
    9
        fromEnum ConstraintAttribute
    ConstraintAttributeCenterY = Int
    10
        fromEnum ConstraintAttribute
    ConstraintAttributeBaseline = Int
    11
        fromEnum (AnotherConstraintAttribute Int
    k) = Int
    k

        toEnum :: Int -> ConstraintAttribute
    toEnum Int
    0 = ConstraintAttribute
    ConstraintAttributeNone
        toEnum Int
    1 = ConstraintAttribute
    ConstraintAttributeLeft
        toEnum Int
    2 = ConstraintAttribute
    ConstraintAttributeRight
        toEnum Int
    3 = ConstraintAttribute
    ConstraintAttributeTop
        toEnum Int
    4 = ConstraintAttribute
    ConstraintAttributeBottom
        toEnum Int
    5 = ConstraintAttribute
    ConstraintAttributeStart
        toEnum Int
    6 = ConstraintAttribute
    ConstraintAttributeEnd
        toEnum Int
    7 = ConstraintAttribute
    ConstraintAttributeWidth
        toEnum Int
    8 = ConstraintAttribute
    ConstraintAttributeHeight
        toEnum Int
    9 = ConstraintAttribute
    ConstraintAttributeCenterX
        toEnum Int
    10 = ConstraintAttribute
    ConstraintAttributeCenterY
        toEnum Int
    11 = ConstraintAttribute
    ConstraintAttributeBaseline
        toEnum Int
    k = Int -> ConstraintAttribute
    AnotherConstraintAttribute Int
    k

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

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

    foreign import ccall "gtk_constraint_attribute_get_type" c_gtk_constraint_attribute_get_type ::
        IO GType

    instance B.Types.TypedObject ConstraintAttribute where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_constraint_attribute_get_type

    instance B.Types.BoxedEnum ConstraintAttribute

    -- Enum Collation
    -- | Describes how a t'GI.Gtk.Objects.StringSorter.StringSorter' turns strings into sort keys to
    -- compare them.
    --
    -- Note that the result of sorting will in general depend on the current locale
    -- unless the mode is /@gTKCOLLATIONNONE@/.
    --
    -- /Since: 4.10/
    data Collation =
          CollationNone
        -- ^ Don\'t do any collation
        | CollationUnicode
        -- ^ Use 'GI.GLib.Functions.utf8CollateKey'
        | CollationFilename
        -- ^ Use 'GI.GLib.Functions.utf8CollateKeyForFilename'
        | AnotherCollation Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Collation -> ShowS
    [Collation] -> ShowS
    Collation -> String
    (Int -> Collation -> ShowS)
    -> (Collation -> String)
    -> ([Collation] -> ShowS)
    -> Show Collation
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Collation -> ShowS
    showsPrec :: Int -> Collation -> ShowS
    $cshow :: Collation -> String
    show :: Collation -> String
    $cshowList :: [Collation] -> ShowS
    showList :: [Collation] -> ShowS
    Show, Collation -> Collation -> Bool
    (Collation -> Collation -> Bool)
    -> (Collation -> Collation -> Bool) -> Eq Collation
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Collation -> Collation -> Bool
    == :: Collation -> Collation -> Bool
    $c/= :: Collation -> Collation -> Bool
    /= :: Collation -> Collation -> Bool
    Eq)

    instance P.Enum Collation where
        fromEnum :: Collation -> Int
    fromEnum Collation
    CollationNone = Int
    0
        fromEnum Collation
    CollationUnicode = Int
    1
        fromEnum Collation
    CollationFilename = Int
    2
        fromEnum (AnotherCollation Int
    k) = Int
    k

        toEnum :: Int -> Collation
    toEnum Int
    0 = Collation
    CollationNone
        toEnum Int
    1 = Collation
    CollationUnicode
        toEnum Int
    2 = Collation
    CollationFilename
        toEnum Int
    k = Int -> Collation
    AnotherCollation Int
    k

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

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

    foreign import ccall "gtk_collation_get_type" c_gtk_collation_get_type ::
        IO GType

    instance B.Types.TypedObject Collation where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_collation_get_type

    instance B.Types.BoxedEnum Collation

    -- Enum CellRendererMode
    {-# DEPRECATED CellRendererMode ["(Since version 4.20)","There is no replacement."] #-}
    -- | 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
    {-# DEPRECATED CellRendererAccelMode ["(Since version 4.20)","There is no replacement"] #-}
    -- | The available modes for [CellRendererAccel:accelMode]("GI.Gtk.Objects.CellRendererAccel#g:attr:accelMode").
    data CellRendererAccelMode =
          CellRendererAccelModeGtk
        -- ^ GTK accelerators mode
        | CellRendererAccelModeOther
        -- ^ Other accelerator mode
        | 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 (AnotherCellRendererAccelMode Int
    k) = Int
    k

        toEnum :: Int -> CellRendererAccelMode
    toEnum Int
    0 = CellRendererAccelMode
    CellRendererAccelModeGtk
        toEnum Int
    1 = CellRendererAccelMode
    CellRendererAccelModeOther
        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 @GtkDialog@.
    --
    -- If none of these choices are appropriate, simply use
    -- 'GI.Gtk.Enums.ButtonsTypeNone' and call t'GI.Gtk.Objects.Dialog.Dialog'.@/add_buttons/@().
    --
    -- > Please note that 'GI.Gtk.Enums.ButtonsTypeOk', 'GI.Gtk.Enums.ButtonsTypeYesNo'
    -- > and 'GI.Gtk.Enums.ButtonsTypeOkCancel' are discouraged by the
    -- > <https://developer.gnome.org/hig/ 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 BuilderError
    -- | Error codes that identify various errors that can occur while using
    -- @GtkBuilder@.
    data BuilderError =
          BuilderErrorInvalidTypeFunction
        -- ^ A type-func attribute didn’t name
        --  a function that returns a @GType@.
        | BuilderErrorUnhandledTag
        -- ^ The input contained a tag that @GtkBuilder@
        --  can’t handle.
        | BuilderErrorMissingAttribute
        -- ^ An attribute that is required by
        --  @GtkBuilder@ was missing.
        | BuilderErrorInvalidAttribute
        -- ^ @GtkBuilder@ found an attribute that
        --  it doesn’t understand.
        | BuilderErrorInvalidTag
        -- ^ @GtkBuilder@ found a tag that
        --  it doesn’t understand.
        | BuilderErrorMissingPropertyValue
        -- ^ A required property value was
        --  missing.
        | BuilderErrorInvalidValue
        -- ^ @GtkBuilder@ 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.
        | BuilderErrorInvalidFunction
        -- ^ A function could not be found. This often happens
        --   when symbols are set to be kept private. Compiling code with -rdynamic or using the
        --   @gmodule-export-2.0@ pkgconfig module can fix this problem.
        | 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 BuilderError
    BuilderErrorInvalidFunction = Int
    14
        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
    14 = BuilderError
    BuilderErrorInvalidFunction
        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
        | BorderStyleHidden
        -- ^ Same as 'GI.Gtk.Enums.BorderStyleNone'
        | 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
        | 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
    BorderStyleHidden = Int
    1
        fromEnum BorderStyle
    BorderStyleSolid = Int
    2
        fromEnum BorderStyle
    BorderStyleInset = Int
    3
        fromEnum BorderStyle
    BorderStyleOutset = 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
    BorderStyleHidden
        toEnum Int
    2 = BorderStyle
    BorderStyleSolid
        toEnum Int
    3 = BorderStyle
    BorderStyleInset
        toEnum Int
    4 = BorderStyle
    BorderStyleOutset
        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
    -- | Baseline position in a row of widgets.
    --
    -- 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 vertical space in the row is taller than the total
    -- requested height of the baseline-aligned children then it can use a
    -- @GtkBaselinePosition@ to select where to put the baseline inside the
    -- extra available space.
    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
    {-# DEPRECATED AssistantPageType ["(Since version 4.10)","@GtkAssistant@ will be removed in GTK 5"] #-}
    -- | Determines the role of a page inside a @GtkAssistant@.
    --
    -- The role is 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
    -- | Indicates 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.
        | 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 Align
    -- | Controls how a widget deals with extra space in a single dimension.
    --
    -- Alignment only matters if the widget receives a “too large” allocation,
    -- for example if you packed the widget with the [Widget:hexpand]("GI.Gtk.Objects.Widget#g:attr:hexpand")
    -- property inside a [class/@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 @GTK_ALIGN_START@ and @GTK_ALIGN_END@
    -- are interpreted relative to text direction.
    --
    -- Baseline support is optional for containers and widgets, and is only available
    -- for vertical alignment. @GTK_ALIGN_BASELINE_CENTER@ and @GTK_ALIGN_BASELINE_FILL@
    -- are treated similar to @GTK_ALIGN_CENTER@ and @GTK_ALIGN_FILL@, except that it
    -- positions the widget to line up the baselines, where that is supported.
    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
        | AlignBaselineFill
        -- ^ stretch to fill all space, but align the baseline.
        --
        -- /Since: 4.12/
        | AlignBaseline
        -- ^ align the widget according to the baseline.
        | AlignBaselineCenter
        -- ^ align the baseline.
        --
        -- /Since: 4.12/
        | 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
    AlignBaselineFill = Int
    4
        fromEnum Align
    AlignBaseline = Int
    4
        fromEnum Align
    AlignBaselineCenter = Int
    5
        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
    AlignBaselineFill
        toEnum Int
    5 = Align
    AlignBaselineCenter
        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

    -- Enum AccessibleTristate
    -- | The possible values for the 'GI.Gtk.Enums.AccessibleStatePressed'
    -- accessible state.
    --
    -- Note that the 'GI.Gtk.Enums.AccessibleTristateFalse' and
    -- 'GI.Gtk.Enums.AccessibleTristateTrue' have the same values
    -- as 'P.False' and 'P.True'.
    data AccessibleTristate =
          AccessibleTristateFalse
        -- ^ The state is @false@
        | AccessibleTristateTrue
        -- ^ The state is @true@
        | AccessibleTristateMixed
        -- ^ The state is @mixed@
        | AnotherAccessibleTristate Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AccessibleTristate -> ShowS
    [AccessibleTristate] -> ShowS
    AccessibleTristate -> String
    (Int -> AccessibleTristate -> ShowS)
    -> (AccessibleTristate -> String)
    -> ([AccessibleTristate] -> ShowS)
    -> Show AccessibleTristate
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AccessibleTristate -> ShowS
    showsPrec :: Int -> AccessibleTristate -> ShowS
    $cshow :: AccessibleTristate -> String
    show :: AccessibleTristate -> String
    $cshowList :: [AccessibleTristate] -> ShowS
    showList :: [AccessibleTristate] -> ShowS
    Show, AccessibleTristate -> AccessibleTristate -> Bool
    (AccessibleTristate -> AccessibleTristate -> Bool)
    -> (AccessibleTristate -> AccessibleTristate -> Bool)
    -> Eq AccessibleTristate
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AccessibleTristate -> AccessibleTristate -> Bool
    == :: AccessibleTristate -> AccessibleTristate -> Bool
    $c/= :: AccessibleTristate -> AccessibleTristate -> Bool
    /= :: AccessibleTristate -> AccessibleTristate -> Bool
    Eq)

    instance P.Enum AccessibleTristate where
        fromEnum :: AccessibleTristate -> Int
    fromEnum AccessibleTristate
    AccessibleTristateFalse = Int
    0
        fromEnum AccessibleTristate
    AccessibleTristateTrue = Int
    1
        fromEnum AccessibleTristate
    AccessibleTristateMixed = Int
    2
        fromEnum (AnotherAccessibleTristate Int
    k) = Int
    k

        toEnum :: Int -> AccessibleTristate
    toEnum Int
    0 = AccessibleTristate
    AccessibleTristateFalse
        toEnum Int
    1 = AccessibleTristate
    AccessibleTristateTrue
        toEnum Int
    2 = AccessibleTristate
    AccessibleTristateMixed
        toEnum Int
    k = Int -> AccessibleTristate
    AnotherAccessibleTristate Int
    k

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

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

    foreign import ccall "gtk_accessible_tristate_get_type" c_gtk_accessible_tristate_get_type ::
        IO GType

    instance B.Types.TypedObject AccessibleTristate where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_accessible_tristate_get_type

    instance B.Types.BoxedEnum AccessibleTristate

    -- Enum AccessibleTextGranularity
    -- | The granularity for queries about the text contents of a t'GI.Gtk.Interfaces.AccessibleText.AccessibleText'
    -- implementation.
    --
    -- /Since: 4.14/
    data AccessibleTextGranularity =
          AccessibleTextGranularityCharacter
        -- ^ Use the boundary between
        --   characters (including non-printing characters)
        | AccessibleTextGranularityWord
        -- ^ Use the boundary between words,
        --   starting from the beginning of the current word and ending at the
        --   beginning of the next word
        | AccessibleTextGranularitySentence
        -- ^ Use the boundary between
        --   sentences, starting from the beginning of the current sentence and
        --   ending at the beginning of the next sentence
        | AccessibleTextGranularityLine
        -- ^ Use the boundary between lines,
        --   starting from the beginning of the current line and ending at the
        --   beginning of the next line
        | AccessibleTextGranularityParagraph
        -- ^ Use the boundary between
        --   paragraphs, starting from the beginning of the current paragraph and
        --   ending at the beginning of the next paragraph
        | AnotherAccessibleTextGranularity Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AccessibleTextGranularity -> ShowS
    [AccessibleTextGranularity] -> ShowS
    AccessibleTextGranularity -> String
    (Int -> AccessibleTextGranularity -> ShowS)
    -> (AccessibleTextGranularity -> String)
    -> ([AccessibleTextGranularity] -> ShowS)
    -> Show AccessibleTextGranularity
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AccessibleTextGranularity -> ShowS
    showsPrec :: Int -> AccessibleTextGranularity -> ShowS
    $cshow :: AccessibleTextGranularity -> String
    show :: AccessibleTextGranularity -> String
    $cshowList :: [AccessibleTextGranularity] -> ShowS
    showList :: [AccessibleTextGranularity] -> ShowS
    Show, AccessibleTextGranularity -> AccessibleTextGranularity -> Bool
    (AccessibleTextGranularity -> AccessibleTextGranularity -> Bool)
    -> (AccessibleTextGranularity -> AccessibleTextGranularity -> Bool)
    -> Eq AccessibleTextGranularity
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AccessibleTextGranularity -> AccessibleTextGranularity -> Bool
    == :: AccessibleTextGranularity -> AccessibleTextGranularity -> Bool
    $c/= :: AccessibleTextGranularity -> AccessibleTextGranularity -> Bool
    /= :: AccessibleTextGranularity -> AccessibleTextGranularity -> Bool
    Eq)

    instance P.Enum AccessibleTextGranularity where
        fromEnum :: AccessibleTextGranularity -> Int
    fromEnum AccessibleTextGranularity
    AccessibleTextGranularityCharacter = Int
    0
        fromEnum AccessibleTextGranularity
    AccessibleTextGranularityWord = Int
    1
        fromEnum AccessibleTextGranularity
    AccessibleTextGranularitySentence = Int
    2
        fromEnum AccessibleTextGranularity
    AccessibleTextGranularityLine = Int
    3
        fromEnum AccessibleTextGranularity
    AccessibleTextGranularityParagraph = Int
    4
        fromEnum (AnotherAccessibleTextGranularity Int
    k) = Int
    k

        toEnum :: Int -> AccessibleTextGranularity
    toEnum Int
    0 = AccessibleTextGranularity
    AccessibleTextGranularityCharacter
        toEnum Int
    1 = AccessibleTextGranularity
    AccessibleTextGranularityWord
        toEnum Int
    2 = AccessibleTextGranularity
    AccessibleTextGranularitySentence
        toEnum Int
    3 = AccessibleTextGranularity
    AccessibleTextGranularityLine
        toEnum Int
    4 = AccessibleTextGranularity
    AccessibleTextGranularityParagraph
        toEnum Int
    k = Int -> AccessibleTextGranularity
    AnotherAccessibleTextGranularity Int
    k

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

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

    foreign import ccall "gtk_accessible_text_granularity_get_type" c_gtk_accessible_text_granularity_get_type ::
        IO GType

    instance B.Types.TypedObject AccessibleTextGranularity where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_accessible_text_granularity_get_type

    instance B.Types.BoxedEnum AccessibleTextGranularity

    -- Enum AccessibleTextContentChange
    -- | The type of contents change operation.
    --
    -- /Since: 4.14/
    data AccessibleTextContentChange =
          AccessibleTextContentChangeInsert
        -- ^ contents change as the result of
        --   an insert operation
        | AccessibleTextContentChangeRemove
        -- ^ contents change as the result of
        --   a remove operation
        | AnotherAccessibleTextContentChange Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AccessibleTextContentChange -> ShowS
    [AccessibleTextContentChange] -> ShowS
    AccessibleTextContentChange -> String
    (Int -> AccessibleTextContentChange -> ShowS)
    -> (AccessibleTextContentChange -> String)
    -> ([AccessibleTextContentChange] -> ShowS)
    -> Show AccessibleTextContentChange
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AccessibleTextContentChange -> ShowS
    showsPrec :: Int -> AccessibleTextContentChange -> ShowS
    $cshow :: AccessibleTextContentChange -> String
    show :: AccessibleTextContentChange -> String
    $cshowList :: [AccessibleTextContentChange] -> ShowS
    showList :: [AccessibleTextContentChange] -> ShowS
    Show, AccessibleTextContentChange -> AccessibleTextContentChange -> Bool
    (AccessibleTextContentChange
     -> AccessibleTextContentChange -> Bool)
    -> (AccessibleTextContentChange
        -> AccessibleTextContentChange -> Bool)
    -> Eq AccessibleTextContentChange
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AccessibleTextContentChange -> AccessibleTextContentChange -> Bool
    == :: AccessibleTextContentChange -> AccessibleTextContentChange -> Bool
    $c/= :: AccessibleTextContentChange -> AccessibleTextContentChange -> Bool
    /= :: AccessibleTextContentChange -> AccessibleTextContentChange -> Bool
    Eq)

    instance P.Enum AccessibleTextContentChange where
        fromEnum :: AccessibleTextContentChange -> Int
    fromEnum AccessibleTextContentChange
    AccessibleTextContentChangeInsert = Int
    0
        fromEnum AccessibleTextContentChange
    AccessibleTextContentChangeRemove = Int
    1
        fromEnum (AnotherAccessibleTextContentChange Int
    k) = Int
    k

        toEnum :: Int -> AccessibleTextContentChange
    toEnum Int
    0 = AccessibleTextContentChange
    AccessibleTextContentChangeInsert
        toEnum Int
    1 = AccessibleTextContentChange
    AccessibleTextContentChangeRemove
        toEnum Int
    k = Int -> AccessibleTextContentChange
    AnotherAccessibleTextContentChange Int
    k

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

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

    foreign import ccall "gtk_accessible_text_content_change_get_type" c_gtk_accessible_text_content_change_get_type ::
        IO GType

    instance B.Types.TypedObject AccessibleTextContentChange where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_accessible_text_content_change_get_type

    instance B.Types.BoxedEnum AccessibleTextContentChange

    -- Enum AccessibleState
    -- | The possible accessible states of a [iface/@accessible@/].
    data AccessibleState =
          AccessibleStateBusy
        -- ^ A “busy” state. This state has boolean values
        | AccessibleStateChecked
        -- ^ A “checked” state; indicates the current
        --   state of a [class/@checkButton@/]. Value type: [enum/@accessibleTristate@/]
        | AccessibleStateDisabled
        -- ^ A “disabled” state; corresponds to the
        --   [property/@widget@/:sensitive] property. It indicates a UI element
        --   that is perceivable, but not editable or operable. Value type: boolean
        | AccessibleStateExpanded
        -- ^ An “expanded” state; corresponds to the
        --   [property/@expander@/:expanded] property. Value type: boolean
        --   or undefined
        | AccessibleStateHidden
        -- ^ A “hidden” state; corresponds to the
        --   [property/@widget@/:visible] property. You can use this state
        --   explicitly on UI elements that should not be exposed to an assistive
        --   technology. Value type: boolean
        --   See also: 'GI.Gtk.Enums.AccessibleStateDisabled'
        | AccessibleStateInvalid
        -- ^ An “invalid” state; set when a widget
        --   is showing an error. Value type: [enum/@accessibleInvalidState@/]
        | AccessibleStatePressed
        -- ^ A “pressed” state; indicates the current
        --   state of a [class/@toggleButton@/]. Value type: [enum/@accessibleTristate@/]
        --   enumeration
        | AccessibleStateSelected
        -- ^ A “selected” state; set when a widget
        --   is selected. Value type: boolean or undefined
        | AccessibleStateVisited
        -- ^ Indicates that a widget with the GTK_ACCESSIBLE_ROLE_LINK has been visited.
        -- Value type: boolean.
        --
        -- /Since: 4.12/
        | AnotherAccessibleState Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AccessibleState -> ShowS
    [AccessibleState] -> ShowS
    AccessibleState -> String
    (Int -> AccessibleState -> ShowS)
    -> (AccessibleState -> String)
    -> ([AccessibleState] -> ShowS)
    -> Show AccessibleState
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AccessibleState -> ShowS
    showsPrec :: Int -> AccessibleState -> ShowS
    $cshow :: AccessibleState -> String
    show :: AccessibleState -> String
    $cshowList :: [AccessibleState] -> ShowS
    showList :: [AccessibleState] -> ShowS
    Show, AccessibleState -> AccessibleState -> Bool
    (AccessibleState -> AccessibleState -> Bool)
    -> (AccessibleState -> AccessibleState -> Bool)
    -> Eq AccessibleState
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AccessibleState -> AccessibleState -> Bool
    == :: AccessibleState -> AccessibleState -> Bool
    $c/= :: AccessibleState -> AccessibleState -> Bool
    /= :: AccessibleState -> AccessibleState -> Bool
    Eq)

    instance P.Enum AccessibleState where
        fromEnum :: AccessibleState -> Int
    fromEnum AccessibleState
    AccessibleStateBusy = Int
    0
        fromEnum AccessibleState
    AccessibleStateChecked = Int
    1
        fromEnum AccessibleState
    AccessibleStateDisabled = Int
    2
        fromEnum AccessibleState
    AccessibleStateExpanded = Int
    3
        fromEnum AccessibleState
    AccessibleStateHidden = Int
    4
        fromEnum AccessibleState
    AccessibleStateInvalid = Int
    5
        fromEnum AccessibleState
    AccessibleStatePressed = Int
    6
        fromEnum AccessibleState
    AccessibleStateSelected = Int
    7
        fromEnum AccessibleState
    AccessibleStateVisited = Int
    8
        fromEnum (AnotherAccessibleState Int
    k) = Int
    k

        toEnum :: Int -> AccessibleState
    toEnum Int
    0 = AccessibleState
    AccessibleStateBusy
        toEnum Int
    1 = AccessibleState
    AccessibleStateChecked
        toEnum Int
    2 = AccessibleState
    AccessibleStateDisabled
        toEnum Int
    3 = AccessibleState
    AccessibleStateExpanded
        toEnum Int
    4 = AccessibleState
    AccessibleStateHidden
        toEnum Int
    5 = AccessibleState
    AccessibleStateInvalid
        toEnum Int
    6 = AccessibleState
    AccessibleStatePressed
        toEnum Int
    7 = AccessibleState
    AccessibleStateSelected
        toEnum Int
    8 = AccessibleState
    AccessibleStateVisited
        toEnum Int
    k = Int -> AccessibleState
    AnotherAccessibleState Int
    k

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

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

    foreign import ccall "gtk_accessible_state_get_type" c_gtk_accessible_state_get_type ::
        IO GType

    instance B.Types.TypedObject AccessibleState where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_accessible_state_get_type

    instance B.Types.BoxedEnum AccessibleState

    -- Enum AccessibleSort
    -- | The possible values for the 'GI.Gtk.Enums.AccessiblePropertySort'
    -- accessible property.
    data AccessibleSort =
          AccessibleSortNone
        -- ^ There is no defined sort applied to the column.
        | AccessibleSortAscending
        -- ^ Items are sorted in ascending order by this column.
        | AccessibleSortDescending
        -- ^ Items are sorted in descending order by this column.
        | AccessibleSortOther
        -- ^ A sort algorithm other than ascending or
        --    descending has been applied.
        | AnotherAccessibleSort Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AccessibleSort -> ShowS
    [AccessibleSort] -> ShowS
    AccessibleSort -> String
    (Int -> AccessibleSort -> ShowS)
    -> (AccessibleSort -> String)
    -> ([AccessibleSort] -> ShowS)
    -> Show AccessibleSort
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AccessibleSort -> ShowS
    showsPrec :: Int -> AccessibleSort -> ShowS
    $cshow :: AccessibleSort -> String
    show :: AccessibleSort -> String
    $cshowList :: [AccessibleSort] -> ShowS
    showList :: [AccessibleSort] -> ShowS
    Show, AccessibleSort -> AccessibleSort -> Bool
    (AccessibleSort -> AccessibleSort -> Bool)
    -> (AccessibleSort -> AccessibleSort -> Bool) -> Eq AccessibleSort
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AccessibleSort -> AccessibleSort -> Bool
    == :: AccessibleSort -> AccessibleSort -> Bool
    $c/= :: AccessibleSort -> AccessibleSort -> Bool
    /= :: AccessibleSort -> AccessibleSort -> Bool
    Eq)

    instance P.Enum AccessibleSort where
        fromEnum :: AccessibleSort -> Int
    fromEnum AccessibleSort
    AccessibleSortNone = Int
    0
        fromEnum AccessibleSort
    AccessibleSortAscending = Int
    1
        fromEnum AccessibleSort
    AccessibleSortDescending = Int
    2
        fromEnum AccessibleSort
    AccessibleSortOther = Int
    3
        fromEnum (AnotherAccessibleSort Int
    k) = Int
    k

        toEnum :: Int -> AccessibleSort
    toEnum Int
    0 = AccessibleSort
    AccessibleSortNone
        toEnum Int
    1 = AccessibleSort
    AccessibleSortAscending
        toEnum Int
    2 = AccessibleSort
    AccessibleSortDescending
        toEnum Int
    3 = AccessibleSort
    AccessibleSortOther
        toEnum Int
    k = Int -> AccessibleSort
    AnotherAccessibleSort Int
    k

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

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

    foreign import ccall "gtk_accessible_sort_get_type" c_gtk_accessible_sort_get_type ::
        IO GType

    instance B.Types.TypedObject AccessibleSort where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_accessible_sort_get_type

    instance B.Types.BoxedEnum AccessibleSort

    -- Enum AccessibleRole
    -- | The accessible role for a [iface/@accessible@/] implementation.
    --
    -- Abstract roles are only used as part of the ontology; application
    -- developers must not use abstract roles in their code.
    data AccessibleRole =
          AccessibleRoleAlert
        -- ^ An element with important, and usually
        --   time-sensitive, information
        | AccessibleRoleAlertDialog
        -- ^ A type of dialog that contains an
        --   alert message
        | AccessibleRoleBanner
        -- ^ Unused
        | AccessibleRoleButton
        -- ^ An input element that allows for
        --   user-triggered actions when clicked or pressed
        | AccessibleRoleCaption
        -- ^ Unused
        | AccessibleRoleCell
        -- ^ Unused
        | AccessibleRoleCheckbox
        -- ^ A checkable input element that has
        --   three possible values: @true@, @false@, or @mixed@
        | AccessibleRoleColumnHeader
        -- ^ A header in a columned list.
        | AccessibleRoleComboBox
        -- ^ An input that controls another element,
        --   such as a list or a grid, that can dynamically pop up to help the user
        --   set the value of the input
        | AccessibleRoleCommand
        -- ^ Abstract role.
        | AccessibleRoleComposite
        -- ^ Abstract role.
        | AccessibleRoleDialog
        -- ^ A dialog is a window that is designed to interrupt
        --   the current processing of an application in order to prompt the user to enter
        --   information or require a response.
        | AccessibleRoleDocument
        -- ^ Content that assistive technology users may want to
        --   browse in a reading mode.
        | AccessibleRoleFeed
        -- ^ Unused
        | AccessibleRoleForm
        -- ^ Unused
        | AccessibleRoleGeneric
        -- ^ A nameless container that has no semantic meaning
        --   of its own. This is the role that GTK uses by default for widgets.
        | AccessibleRoleGrid
        -- ^ A grid of items.
        | AccessibleRoleGridCell
        -- ^ An item in a grid or tree grid.
        | AccessibleRoleGroup
        -- ^ An element that groups multiple related widgets. GTK uses
        --   this role for various containers, like t'GI.Gtk.Objects.HeaderBar.HeaderBar' or t'GI.Gtk.Objects.Notebook.Notebook'.
        | AccessibleRoleHeading
        -- ^ Unused
        | AccessibleRoleImg
        -- ^ An image.
        | AccessibleRoleInput
        -- ^ Abstract role.
        | AccessibleRoleLabel
        -- ^ A visible name or caption for a user interface component.
        | AccessibleRoleLandmark
        -- ^ Abstract role.
        | AccessibleRoleLegend
        -- ^ Unused
        | AccessibleRoleLink
        -- ^ A clickable link.
        | AccessibleRoleList
        -- ^ A list of items.
        | AccessibleRoleListBox
        -- ^ Unused.
        | AccessibleRoleListItem
        -- ^ An item in a list.
        | AccessibleRoleLog
        -- ^ Unused
        | AccessibleRoleMain
        -- ^ Unused
        | AccessibleRoleMarquee
        -- ^ Unused
        | AccessibleRoleMath
        -- ^ Unused
        | AccessibleRoleMeter
        -- ^ An element that represents a value within a known range.
        | AccessibleRoleMenu
        -- ^ A menu.
        | AccessibleRoleMenuBar
        -- ^ A menubar.
        | AccessibleRoleMenuItem
        -- ^ An item in a menu.
        | AccessibleRoleMenuItemCheckbox
        -- ^ A check item in a menu.
        | AccessibleRoleMenuItemRadio
        -- ^ A radio item in a menu.
        | AccessibleRoleNavigation
        -- ^ Unused
        | AccessibleRoleNone
        -- ^ An element that is not represented to accessibility technologies.
        --   This role is synonymous to /@gTKACCESSIBLEROLEPRESENTATION@/.
        | AccessibleRoleNote
        -- ^ Unused
        | AccessibleRoleOption
        -- ^ Unused
        | AccessibleRolePresentation
        -- ^ An element that is not represented to accessibility technologies.
        --   This role is synonymous to /@gTKACCESSIBLEROLENONE@/.
        | AccessibleRoleProgressBar
        -- ^ An element that displays the progress
        --   status for tasks that take a long time.
        | AccessibleRoleRadio
        -- ^ A checkable input in a group of radio roles,
        --   only one of which can be checked at a time.
        | AccessibleRoleRadioGroup
        -- ^ Unused
        | AccessibleRoleRange
        -- ^ Abstract role.
        | AccessibleRoleRegion
        -- ^ Unused
        | AccessibleRoleRow
        -- ^ A row in a columned list.
        | AccessibleRoleRowGroup
        -- ^ Unused
        | AccessibleRoleRowHeader
        -- ^ Unused
        | AccessibleRoleScrollbar
        -- ^ A graphical object that controls the scrolling
        --   of content within a viewing area, regardless of whether the content is fully
        --   displayed within the viewing area.
        | AccessibleRoleSearch
        -- ^ Unused
        | AccessibleRoleSearchBox
        -- ^ A type of textbox intended for specifying
        --   search criteria.
        | AccessibleRoleSection
        -- ^ Abstract role.
        | AccessibleRoleSectionHead
        -- ^ Abstract role.
        | AccessibleRoleSelect
        -- ^ Abstract role.
        | AccessibleRoleSeparator
        -- ^ A divider that separates and distinguishes
        --   sections of content or groups of menuitems.
        | AccessibleRoleSlider
        -- ^ A user input where the user selects a value
        --   from within a given range.
        | AccessibleRoleSpinButton
        -- ^ A form of range that expects the user to
        --   select from among discrete choices.
        | AccessibleRoleStatus
        -- ^ Unused
        | AccessibleRoleStructure
        -- ^ Abstract role.
        | AccessibleRoleSwitch
        -- ^ A type of checkbox that represents on\/off values,
        --   as opposed to checked\/unchecked values.
        | AccessibleRoleTab
        -- ^ An item in a list of tab used for switching pages.
        | AccessibleRoleTable
        -- ^ Unused
        | AccessibleRoleTabList
        -- ^ A list of tabs for switching pages.
        | AccessibleRoleTabPanel
        -- ^ A page in a notebook or stack.
        | AccessibleRoleTextBox
        -- ^ A type of input that allows free-form text
        --   as its value.
        | AccessibleRoleTime
        -- ^ Unused
        | AccessibleRoleTimer
        -- ^ Unused
        | AccessibleRoleToolbar
        -- ^ Unused
        | AccessibleRoleTooltip
        -- ^ Unused
        | AccessibleRoleTree
        -- ^ Unused
        | AccessibleRoleTreeGrid
        -- ^ A treeview-like, columned list.
        | AccessibleRoleTreeItem
        -- ^ Unused
        | AccessibleRoleWidget
        -- ^ Abstract role for interactive components of a
        --   graphical user interface
        | AccessibleRoleWindow
        -- ^ Abstract role for windows.
        | AccessibleRoleToggleButton
        -- ^ A type of push button which stays pressed until depressed by a second
        -- activation.
        --
        -- /Since: 4.10/
        | AccessibleRoleApplication
        -- ^ A toplevel element of a graphical user interface.
        --
        -- This is the role that GTK uses by default for windows.
        --
        -- /Since: 4.12/
        | AccessibleRoleParagraph
        -- ^ A paragraph of content.
        --
        -- /Since: 4.14/
        | AccessibleRoleBlockQuote
        -- ^ A section of content that is quoted from another source.
        --
        -- /Since: 4.14/
        | AccessibleRoleArticle
        -- ^ A section of a page that consists of a composition that forms an independent
        -- part of a document, page, or site.
        --
        -- /Since: 4.14/
        | AccessibleRoleComment
        -- ^ A comment contains content expressing reaction to other content.
        --
        -- /Since: 4.14/
        | AccessibleRoleTerminal
        -- ^ A virtual terminal.
        --
        -- /Since: 4.14/
        | AnotherAccessibleRole Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AccessibleRole -> ShowS
    [AccessibleRole] -> ShowS
    AccessibleRole -> String
    (Int -> AccessibleRole -> ShowS)
    -> (AccessibleRole -> String)
    -> ([AccessibleRole] -> ShowS)
    -> Show AccessibleRole
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AccessibleRole -> ShowS
    showsPrec :: Int -> AccessibleRole -> ShowS
    $cshow :: AccessibleRole -> String
    show :: AccessibleRole -> String
    $cshowList :: [AccessibleRole] -> ShowS
    showList :: [AccessibleRole] -> ShowS
    Show, AccessibleRole -> AccessibleRole -> Bool
    (AccessibleRole -> AccessibleRole -> Bool)
    -> (AccessibleRole -> AccessibleRole -> Bool) -> Eq AccessibleRole
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AccessibleRole -> AccessibleRole -> Bool
    == :: AccessibleRole -> AccessibleRole -> Bool
    $c/= :: AccessibleRole -> AccessibleRole -> Bool
    /= :: AccessibleRole -> AccessibleRole -> Bool
    Eq)

    instance P.Enum AccessibleRole where
        fromEnum :: AccessibleRole -> Int
    fromEnum AccessibleRole
    AccessibleRoleAlert = Int
    0
        fromEnum AccessibleRole
    AccessibleRoleAlertDialog = Int
    1
        fromEnum AccessibleRole
    AccessibleRoleBanner = Int
    2
        fromEnum AccessibleRole
    AccessibleRoleButton = Int
    3
        fromEnum AccessibleRole
    AccessibleRoleCaption = Int
    4
        fromEnum AccessibleRole
    AccessibleRoleCell = Int
    5
        fromEnum AccessibleRole
    AccessibleRoleCheckbox = Int
    6
        fromEnum AccessibleRole
    AccessibleRoleColumnHeader = Int
    7
        fromEnum AccessibleRole
    AccessibleRoleComboBox = Int
    8
        fromEnum AccessibleRole
    AccessibleRoleCommand = Int
    9
        fromEnum AccessibleRole
    AccessibleRoleComposite = Int
    10
        fromEnum AccessibleRole
    AccessibleRoleDialog = Int
    11
        fromEnum AccessibleRole
    AccessibleRoleDocument = Int
    12
        fromEnum AccessibleRole
    AccessibleRoleFeed = Int
    13
        fromEnum AccessibleRole
    AccessibleRoleForm = Int
    14
        fromEnum AccessibleRole
    AccessibleRoleGeneric = Int
    15
        fromEnum AccessibleRole
    AccessibleRoleGrid = Int
    16
        fromEnum AccessibleRole
    AccessibleRoleGridCell = Int
    17
        fromEnum AccessibleRole
    AccessibleRoleGroup = Int
    18
        fromEnum AccessibleRole
    AccessibleRoleHeading = Int
    19
        fromEnum AccessibleRole
    AccessibleRoleImg = Int
    20
        fromEnum AccessibleRole
    AccessibleRoleInput = Int
    21
        fromEnum AccessibleRole
    AccessibleRoleLabel = Int
    22
        fromEnum AccessibleRole
    AccessibleRoleLandmark = Int
    23
        fromEnum AccessibleRole
    AccessibleRoleLegend = Int
    24
        fromEnum AccessibleRole
    AccessibleRoleLink = Int
    25
        fromEnum AccessibleRole
    AccessibleRoleList = Int
    26
        fromEnum AccessibleRole
    AccessibleRoleListBox = Int
    27
        fromEnum AccessibleRole
    AccessibleRoleListItem = Int
    28
        fromEnum AccessibleRole
    AccessibleRoleLog = Int
    29
        fromEnum AccessibleRole
    AccessibleRoleMain = Int
    30
        fromEnum AccessibleRole
    AccessibleRoleMarquee = Int
    31
        fromEnum AccessibleRole
    AccessibleRoleMath = Int
    32
        fromEnum AccessibleRole
    AccessibleRoleMeter = Int
    33
        fromEnum AccessibleRole
    AccessibleRoleMenu = Int
    34
        fromEnum AccessibleRole
    AccessibleRoleMenuBar = Int
    35
        fromEnum AccessibleRole
    AccessibleRoleMenuItem = Int
    36
        fromEnum AccessibleRole
    AccessibleRoleMenuItemCheckbox = Int
    37
        fromEnum AccessibleRole
    AccessibleRoleMenuItemRadio = Int
    38
        fromEnum AccessibleRole
    AccessibleRoleNavigation = Int
    39
        fromEnum AccessibleRole
    AccessibleRoleNone = Int
    40
        fromEnum AccessibleRole
    AccessibleRoleNote = Int
    41
        fromEnum AccessibleRole
    AccessibleRoleOption = Int
    42
        fromEnum AccessibleRole
    AccessibleRolePresentation = Int
    43
        fromEnum AccessibleRole
    AccessibleRoleProgressBar = Int
    44
        fromEnum AccessibleRole
    AccessibleRoleRadio = Int
    45
        fromEnum AccessibleRole
    AccessibleRoleRadioGroup = Int
    46
        fromEnum AccessibleRole
    AccessibleRoleRange = Int
    47
        fromEnum AccessibleRole
    AccessibleRoleRegion = Int
    48
        fromEnum AccessibleRole
    AccessibleRoleRow = Int
    49
        fromEnum AccessibleRole
    AccessibleRoleRowGroup = Int
    50
        fromEnum AccessibleRole
    AccessibleRoleRowHeader = Int
    51
        fromEnum AccessibleRole
    AccessibleRoleScrollbar = Int
    52
        fromEnum AccessibleRole
    AccessibleRoleSearch = Int
    53
        fromEnum AccessibleRole
    AccessibleRoleSearchBox = Int
    54
        fromEnum AccessibleRole
    AccessibleRoleSection = Int
    55
        fromEnum AccessibleRole
    AccessibleRoleSectionHead = Int
    56
        fromEnum AccessibleRole
    AccessibleRoleSelect = Int
    57
        fromEnum AccessibleRole
    AccessibleRoleSeparator = Int
    58
        fromEnum AccessibleRole
    AccessibleRoleSlider = Int
    59
        fromEnum AccessibleRole
    AccessibleRoleSpinButton = Int
    60
        fromEnum AccessibleRole
    AccessibleRoleStatus = Int
    61
        fromEnum AccessibleRole
    AccessibleRoleStructure = Int
    62
        fromEnum AccessibleRole
    AccessibleRoleSwitch = Int
    63
        fromEnum AccessibleRole
    AccessibleRoleTab = Int
    64
        fromEnum AccessibleRole
    AccessibleRoleTable = Int
    65
        fromEnum AccessibleRole
    AccessibleRoleTabList = Int
    66
        fromEnum AccessibleRole
    AccessibleRoleTabPanel = Int
    67
        fromEnum AccessibleRole
    AccessibleRoleTextBox = Int
    68
        fromEnum AccessibleRole
    AccessibleRoleTime = Int
    69
        fromEnum AccessibleRole
    AccessibleRoleTimer = Int
    70
        fromEnum AccessibleRole
    AccessibleRoleToolbar = Int
    71
        fromEnum AccessibleRole
    AccessibleRoleTooltip = Int
    72
        fromEnum AccessibleRole
    AccessibleRoleTree = Int
    73
        fromEnum AccessibleRole
    AccessibleRoleTreeGrid = Int
    74
        fromEnum AccessibleRole
    AccessibleRoleTreeItem = Int
    75
        fromEnum AccessibleRole
    AccessibleRoleWidget = Int
    76
        fromEnum AccessibleRole
    AccessibleRoleWindow = Int
    77
        fromEnum AccessibleRole
    AccessibleRoleToggleButton = Int
    78
        fromEnum AccessibleRole
    AccessibleRoleApplication = Int
    79
        fromEnum AccessibleRole
    AccessibleRoleParagraph = Int
    80
        fromEnum AccessibleRole
    AccessibleRoleBlockQuote = Int
    81
        fromEnum AccessibleRole
    AccessibleRoleArticle = Int
    82
        fromEnum AccessibleRole
    AccessibleRoleComment = Int
    83
        fromEnum AccessibleRole
    AccessibleRoleTerminal = Int
    84
        fromEnum (AnotherAccessibleRole Int
    k) = Int
    k

        toEnum :: Int -> AccessibleRole
    toEnum Int
    0 = AccessibleRole
    AccessibleRoleAlert
        toEnum Int
    1 = AccessibleRole
    AccessibleRoleAlertDialog
        toEnum Int
    2 = AccessibleRole
    AccessibleRoleBanner
        toEnum Int
    3 = AccessibleRole
    AccessibleRoleButton
        toEnum Int
    4 = AccessibleRole
    AccessibleRoleCaption
        toEnum Int
    5 = AccessibleRole
    AccessibleRoleCell
        toEnum Int
    6 = AccessibleRole
    AccessibleRoleCheckbox
        toEnum Int
    7 = AccessibleRole
    AccessibleRoleColumnHeader
        toEnum Int
    8 = AccessibleRole
    AccessibleRoleComboBox
        toEnum Int
    9 = AccessibleRole
    AccessibleRoleCommand
        toEnum Int
    10 = AccessibleRole
    AccessibleRoleComposite
        toEnum Int
    11 = AccessibleRole
    AccessibleRoleDialog
        toEnum Int
    12 = AccessibleRole
    AccessibleRoleDocument
        toEnum Int
    13 = AccessibleRole
    AccessibleRoleFeed
        toEnum Int
    14 = AccessibleRole
    AccessibleRoleForm
        toEnum Int
    15 = AccessibleRole
    AccessibleRoleGeneric
        toEnum Int
    16 = AccessibleRole
    AccessibleRoleGrid
        toEnum Int
    17 = AccessibleRole
    AccessibleRoleGridCell
        toEnum Int
    18 = AccessibleRole
    AccessibleRoleGroup
        toEnum Int
    19 = AccessibleRole
    AccessibleRoleHeading
        toEnum Int
    20 = AccessibleRole
    AccessibleRoleImg
        toEnum Int
    21 = AccessibleRole
    AccessibleRoleInput
        toEnum Int
    22 = AccessibleRole
    AccessibleRoleLabel
        toEnum Int
    23 = AccessibleRole
    AccessibleRoleLandmark
        toEnum Int
    24 = AccessibleRole
    AccessibleRoleLegend
        toEnum Int
    25 = AccessibleRole
    AccessibleRoleLink
        toEnum Int
    26 = AccessibleRole
    AccessibleRoleList
        toEnum Int
    27 = AccessibleRole
    AccessibleRoleListBox
        toEnum Int
    28 = AccessibleRole
    AccessibleRoleListItem
        toEnum Int
    29 = AccessibleRole
    AccessibleRoleLog
        toEnum Int
    30 = AccessibleRole
    AccessibleRoleMain
        toEnum Int
    31 = AccessibleRole
    AccessibleRoleMarquee
        toEnum Int
    32 = AccessibleRole
    AccessibleRoleMath
        toEnum Int
    33 = AccessibleRole
    AccessibleRoleMeter
        toEnum Int
    34 = AccessibleRole
    AccessibleRoleMenu
        toEnum Int
    35 = AccessibleRole
    AccessibleRoleMenuBar
        toEnum Int
    36 = AccessibleRole
    AccessibleRoleMenuItem
        toEnum Int
    37 = AccessibleRole
    AccessibleRoleMenuItemCheckbox
        toEnum Int
    38 = AccessibleRole
    AccessibleRoleMenuItemRadio
        toEnum Int
    39 = AccessibleRole
    AccessibleRoleNavigation
        toEnum Int
    40 = AccessibleRole
    AccessibleRoleNone
        toEnum Int
    41 = AccessibleRole
    AccessibleRoleNote
        toEnum Int
    42 = AccessibleRole
    AccessibleRoleOption
        toEnum Int
    43 = AccessibleRole
    AccessibleRolePresentation
        toEnum Int
    44 = AccessibleRole
    AccessibleRoleProgressBar
        toEnum Int
    45 = AccessibleRole
    AccessibleRoleRadio
        toEnum Int
    46 = AccessibleRole
    AccessibleRoleRadioGroup
        toEnum Int
    47 = AccessibleRole
    AccessibleRoleRange
        toEnum Int
    48 = AccessibleRole
    AccessibleRoleRegion
        toEnum Int
    49 = AccessibleRole
    AccessibleRoleRow
        toEnum Int
    50 = AccessibleRole
    AccessibleRoleRowGroup
        toEnum Int
    51 = AccessibleRole
    AccessibleRoleRowHeader
        toEnum Int
    52 = AccessibleRole
    AccessibleRoleScrollbar
        toEnum Int
    53 = AccessibleRole
    AccessibleRoleSearch
        toEnum Int
    54 = AccessibleRole
    AccessibleRoleSearchBox
        toEnum Int
    55 = AccessibleRole
    AccessibleRoleSection
        toEnum Int
    56 = AccessibleRole
    AccessibleRoleSectionHead
        toEnum Int
    57 = AccessibleRole
    AccessibleRoleSelect
        toEnum Int
    58 = AccessibleRole
    AccessibleRoleSeparator
        toEnum Int
    59 = AccessibleRole
    AccessibleRoleSlider
        toEnum Int
    60 = AccessibleRole
    AccessibleRoleSpinButton
        toEnum Int
    61 = AccessibleRole
    AccessibleRoleStatus
        toEnum Int
    62 = AccessibleRole
    AccessibleRoleStructure
        toEnum Int
    63 = AccessibleRole
    AccessibleRoleSwitch
        toEnum Int
    64 = AccessibleRole
    AccessibleRoleTab
        toEnum Int
    65 = AccessibleRole
    AccessibleRoleTable
        toEnum Int
    66 = AccessibleRole
    AccessibleRoleTabList
        toEnum Int
    67 = AccessibleRole
    AccessibleRoleTabPanel
        toEnum Int
    68 = AccessibleRole
    AccessibleRoleTextBox
        toEnum Int
    69 = AccessibleRole
    AccessibleRoleTime
        toEnum Int
    70 = AccessibleRole
    AccessibleRoleTimer
        toEnum Int
    71 = AccessibleRole
    AccessibleRoleToolbar
        toEnum Int
    72 = AccessibleRole
    AccessibleRoleTooltip
        toEnum Int
    73 = AccessibleRole
    AccessibleRoleTree
        toEnum Int
    74 = AccessibleRole
    AccessibleRoleTreeGrid
        toEnum Int
    75 = AccessibleRole
    AccessibleRoleTreeItem
        toEnum Int
    76 = AccessibleRole
    AccessibleRoleWidget
        toEnum Int
    77 = AccessibleRole
    AccessibleRoleWindow
        toEnum Int
    78 = AccessibleRole
    AccessibleRoleToggleButton
        toEnum Int
    79 = AccessibleRole
    AccessibleRoleApplication
        toEnum Int
    80 = AccessibleRole
    AccessibleRoleParagraph
        toEnum Int
    81 = AccessibleRole
    AccessibleRoleBlockQuote
        toEnum Int
    82 = AccessibleRole
    AccessibleRoleArticle
        toEnum Int
    83 = AccessibleRole
    AccessibleRoleComment
        toEnum Int
    84 = AccessibleRole
    AccessibleRoleTerminal
        toEnum Int
    k = Int -> AccessibleRole
    AnotherAccessibleRole Int
    k

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

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

    foreign import ccall "gtk_accessible_role_get_type" c_gtk_accessible_role_get_type ::
        IO GType

    instance B.Types.TypedObject AccessibleRole where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_accessible_role_get_type

    instance B.Types.BoxedEnum AccessibleRole

    -- Enum AccessibleRelation
    -- | The possible accessible relations of a [iface/@accessible@/].
    --
    -- Accessible relations can be references to other widgets,
    -- integers or strings.
    data AccessibleRelation =
          AccessibleRelationActiveDescendant
        -- ^ Identifies the currently active
        --    element when focus is on a composite widget, combobox, textbox, group,
        --    or application. Value type: reference
        | AccessibleRelationColCount
        -- ^ Defines the total number of columns
        --    in a table, grid, or treegrid. Value type: integer
        | AccessibleRelationColIndex
        -- ^ Defines an element\'s column index or
        --    position with respect to the total number of columns within a table,
        --    grid, or treegrid. Value type: integer
        | AccessibleRelationColIndexText
        -- ^ Defines a human readable text
        --   alternative of 'GI.Gtk.Enums.AccessibleRelationColIndex'. Value type: string
        | AccessibleRelationColSpan
        -- ^ Defines the number of columns spanned
        --   by a cell or gridcell within a table, grid, or treegrid. Value type: integer
        | AccessibleRelationControls
        -- ^ Identifies the element (or elements) whose
        --    contents or presence are controlled by the current element. Value type: reference
        | AccessibleRelationDescribedBy
        -- ^ Identifies the element (or elements)
        --    that describes the object. Value type: reference
        | AccessibleRelationDetails
        -- ^ Identifies the element (or elements) that
        --    provide additional information related to the object. Value type: reference
        | AccessibleRelationErrorMessage
        -- ^ Identifies the element (or elements) that
        --    provide an error message for an object. Value type: reference
        | AccessibleRelationFlowTo
        -- ^ Identifies the next element (or elements)
        --    in an alternate reading order of content which, at the user\'s discretion,
        --    allows assistive technology to override the general default of reading in
        --    document source order. Value type: reference
        | AccessibleRelationLabelledBy
        -- ^ Identifies the element (or elements)
        --    that labels the current element. Value type: reference
        | AccessibleRelationOwns
        -- ^ Identifies an element (or elements) in order
        --    to define a visual, functional, or contextual parent\/child relationship
        --    between elements where the widget hierarchy cannot be used to represent
        --    the relationship. Value type: reference
        | AccessibleRelationPosInSet
        -- ^ Defines an element\'s number or position
        --    in the current set of listitems or treeitems. Value type: integer
        | AccessibleRelationRowCount
        -- ^ Defines the total number of rows in a table,
        --    grid, or treegrid. Value type: integer
        | AccessibleRelationRowIndex
        -- ^ Defines an element\'s row index or position
        --    with respect to the total number of rows within a table, grid, or treegrid.
        --    Value type: integer
        | AccessibleRelationRowIndexText
        -- ^ Defines a human readable text
        --    alternative of 'GI.Gtk.Enums.AccessibleRelationRowIndex'. Value type: string
        | AccessibleRelationRowSpan
        -- ^ Defines the number of rows spanned by a
        --    cell or gridcell within a table, grid, or treegrid. Value type: integer
        | AccessibleRelationSetSize
        -- ^ Defines the number of items in the current
        --    set of listitems or treeitems. Value type: integer
        | AccessibleRelationLabelFor
        -- ^ Identifies the element (or elements) that are labeled by the
        -- current element. Value type: reference
        --
        -- This relation is managed by GTK and should not be set from application code.
        --
        -- /Since: 4.18/
        | AccessibleRelationDescriptionFor
        -- ^ Identifies the element (or elements) that are described by
        -- the current element. Value type: reference
        --
        -- This relation is managed by GTK and should not be set from application code.
        --
        -- /Since: 4.18/
        | AccessibleRelationControlledBy
        -- ^ Identifies the element (or elements) that the current
        -- element is controlled by. Value type: reference
        --
        -- This relation is managed by GTK and should not be set from application code.
        --
        -- /Since: 4.18/
        | AccessibleRelationDetailsFor
        -- ^ Identifies the element (or elements) for which the current
        -- element provides additional information. Value type: reference
        --
        -- This relation is managed by GTK and should not be set from application code.
        --
        -- /Since: 4.18/
        | AccessibleRelationErrorMessageFor
        -- ^ Identifies the element (or elements) for which the current
        -- element provides an error message. Value type: reference
        --
        -- This relation is managed by GTK and should not be set from application code.
        --
        -- /Since: 4.18/
        | AccessibleRelationFlowFrom
        -- ^ Identifies the previous element (or elements) in an alternate
        -- reading order of content which, at the user\'s discretion, allows
        -- assistive technology to override the general default of reading in
        -- document source order. Value type: reference
        --
        -- This relation is managed by GTK and should not be set from application code.
        --
        -- /Since: 4.18/
        | AnotherAccessibleRelation Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AccessibleRelation -> ShowS
    [AccessibleRelation] -> ShowS
    AccessibleRelation -> String
    (Int -> AccessibleRelation -> ShowS)
    -> (AccessibleRelation -> String)
    -> ([AccessibleRelation] -> ShowS)
    -> Show AccessibleRelation
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AccessibleRelation -> ShowS
    showsPrec :: Int -> AccessibleRelation -> ShowS
    $cshow :: AccessibleRelation -> String
    show :: AccessibleRelation -> String
    $cshowList :: [AccessibleRelation] -> ShowS
    showList :: [AccessibleRelation] -> ShowS
    Show, AccessibleRelation -> AccessibleRelation -> Bool
    (AccessibleRelation -> AccessibleRelation -> Bool)
    -> (AccessibleRelation -> AccessibleRelation -> Bool)
    -> Eq AccessibleRelation
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AccessibleRelation -> AccessibleRelation -> Bool
    == :: AccessibleRelation -> AccessibleRelation -> Bool
    $c/= :: AccessibleRelation -> AccessibleRelation -> Bool
    /= :: AccessibleRelation -> AccessibleRelation -> Bool
    Eq)

    instance P.Enum AccessibleRelation where
        fromEnum :: AccessibleRelation -> Int
    fromEnum AccessibleRelation
    AccessibleRelationActiveDescendant = Int
    0
        fromEnum AccessibleRelation
    AccessibleRelationColCount = Int
    1
        fromEnum AccessibleRelation
    AccessibleRelationColIndex = Int
    2
        fromEnum AccessibleRelation
    AccessibleRelationColIndexText = Int
    3
        fromEnum AccessibleRelation
    AccessibleRelationColSpan = Int
    4
        fromEnum AccessibleRelation
    AccessibleRelationControls = Int
    5
        fromEnum AccessibleRelation
    AccessibleRelationDescribedBy = Int
    6
        fromEnum AccessibleRelation
    AccessibleRelationDetails = Int
    7
        fromEnum AccessibleRelation
    AccessibleRelationErrorMessage = Int
    8
        fromEnum AccessibleRelation
    AccessibleRelationFlowTo = Int
    9
        fromEnum AccessibleRelation
    AccessibleRelationLabelledBy = Int
    10
        fromEnum AccessibleRelation
    AccessibleRelationOwns = Int
    11
        fromEnum AccessibleRelation
    AccessibleRelationPosInSet = Int
    12
        fromEnum AccessibleRelation
    AccessibleRelationRowCount = Int
    13
        fromEnum AccessibleRelation
    AccessibleRelationRowIndex = Int
    14
        fromEnum AccessibleRelation
    AccessibleRelationRowIndexText = Int
    15
        fromEnum AccessibleRelation
    AccessibleRelationRowSpan = Int
    16
        fromEnum AccessibleRelation
    AccessibleRelationSetSize = Int
    17
        fromEnum AccessibleRelation
    AccessibleRelationLabelFor = Int
    18
        fromEnum AccessibleRelation
    AccessibleRelationDescriptionFor = Int
    19
        fromEnum AccessibleRelation
    AccessibleRelationControlledBy = Int
    20
        fromEnum AccessibleRelation
    AccessibleRelationDetailsFor = Int
    21
        fromEnum AccessibleRelation
    AccessibleRelationErrorMessageFor = Int
    22
        fromEnum AccessibleRelation
    AccessibleRelationFlowFrom = Int
    23
        fromEnum (AnotherAccessibleRelation Int
    k) = Int
    k

        toEnum :: Int -> AccessibleRelation
    toEnum Int
    0 = AccessibleRelation
    AccessibleRelationActiveDescendant
        toEnum Int
    1 = AccessibleRelation
    AccessibleRelationColCount
        toEnum Int
    2 = AccessibleRelation
    AccessibleRelationColIndex
        toEnum Int
    3 = AccessibleRelation
    AccessibleRelationColIndexText
        toEnum Int
    4 = AccessibleRelation
    AccessibleRelationColSpan
        toEnum Int
    5 = AccessibleRelation
    AccessibleRelationControls
        toEnum Int
    6 = AccessibleRelation
    AccessibleRelationDescribedBy
        toEnum Int
    7 = AccessibleRelation
    AccessibleRelationDetails
        toEnum Int
    8 = AccessibleRelation
    AccessibleRelationErrorMessage
        toEnum Int
    9 = AccessibleRelation
    AccessibleRelationFlowTo
        toEnum Int
    10 = AccessibleRelation
    AccessibleRelationLabelledBy
        toEnum Int
    11 = AccessibleRelation
    AccessibleRelationOwns
        toEnum Int
    12 = AccessibleRelation
    AccessibleRelationPosInSet
        toEnum Int
    13 = AccessibleRelation
    AccessibleRelationRowCount
        toEnum Int
    14 = AccessibleRelation
    AccessibleRelationRowIndex
        toEnum Int
    15 = AccessibleRelation
    AccessibleRelationRowIndexText
        toEnum Int
    16 = AccessibleRelation
    AccessibleRelationRowSpan
        toEnum Int
    17 = AccessibleRelation
    AccessibleRelationSetSize
        toEnum Int
    18 = AccessibleRelation
    AccessibleRelationLabelFor
        toEnum Int
    19 = AccessibleRelation
    AccessibleRelationDescriptionFor
        toEnum Int
    20 = AccessibleRelation
    AccessibleRelationControlledBy
        toEnum Int
    21 = AccessibleRelation
    AccessibleRelationDetailsFor
        toEnum Int
    22 = AccessibleRelation
    AccessibleRelationErrorMessageFor
        toEnum Int
    23 = AccessibleRelation
    AccessibleRelationFlowFrom
        toEnum Int
    k = Int -> AccessibleRelation
    AnotherAccessibleRelation Int
    k

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

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

    foreign import ccall "gtk_accessible_relation_get_type" c_gtk_accessible_relation_get_type ::
        IO GType

    instance B.Types.TypedObject AccessibleRelation where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_accessible_relation_get_type

    instance B.Types.BoxedEnum AccessibleRelation

    -- Enum AccessibleProperty
    -- | The possible accessible properties of a [iface/@accessible@/].
    data AccessibleProperty =
          AccessiblePropertyAutocomplete
        -- ^ Indicates whether inputting text
        --    could trigger display of one or more predictions of the user\'s intended
        --    value for a combobox, searchbox, or textbox and specifies how predictions
        --    would be presented if they were made. Value type: [enum/@accessibleAutocomplete@/]
        | AccessiblePropertyDescription
        -- ^ Defines a string value that describes
        --    or annotates the current element. Value type: string
        | AccessiblePropertyHasPopup
        -- ^ Indicates the availability of interactive
        --    popup element, such as menu or popover, that can be triggered by an
        --    element. Contrary to “aria-haspopup”, it doesn\'t indicate the type of the
        --    element, as such it cannot be used to indicate the availability of more
        --    complex elements such as dialog. Value type: boolean
        | AccessiblePropertyKeyShortcuts
        -- ^ Indicates keyboard shortcuts that an
        --    author has implemented to activate or give focus to an element. Value type:
        --    string. The format of the value is a space-separated list of shortcuts, with
        --    each shortcut consisting of one or more modifiers (@Control@, @Alt@ or @Shift@),
        --    followed by a non-modifier key, all separated by @+@. The
        --    <https://www.w3.org/TR/wai-aria/#aria-keyshortcuts WAI-ARIA> reference
        --    specifies how to build keyboard shortcuts strings, with specific values
        --    for each key which are the same regardless of the language, so these
        --    strings can\'t be built from localized key names. You can convert an
        --    accelerator into the matching key shortcuts label with
        --    'GI.Gtk.Functions.acceleratorGetAccessibleLabel'.
        --    Examples: @F2@, @Alt+F@, @Control+Shift+N@
        | AccessiblePropertyLabel
        -- ^ Defines a string value that labels the current
        --    element. Value type: string
        | AccessiblePropertyLevel
        -- ^ Defines the hierarchical level of an element
        --    within a structure. Value type: integer
        | AccessiblePropertyModal
        -- ^ Indicates whether an element is modal when
        --    displayed. Value type: boolean
        | AccessiblePropertyMultiLine
        -- ^ Indicates whether a text box accepts
        --    multiple lines of input or only a single line. Value type: boolean
        | AccessiblePropertyMultiSelectable
        -- ^ Indicates that the user may select
        --    more than one item from the current selectable descendants. Value type:
        --    boolean
        | AccessiblePropertyOrientation
        -- ^ Indicates whether the element\'s
        --    orientation is horizontal, vertical, or unknown\/ambiguous. Value type:
        --    [enum/@orientation@/]
        | AccessiblePropertyPlaceholder
        -- ^ Defines a short hint (a word or short
        --    phrase) intended to aid the user with data entry when the control has no
        --    value. A hint could be a sample value or a brief description of the expected
        --    format. Value type: string
        | AccessiblePropertyReadOnly
        -- ^ Indicates that the element is not editable,
        --    but is otherwise operable. Value type: boolean
        | AccessiblePropertyRequired
        -- ^ Indicates that user input is required on
        --    the element before a form may be submitted. Value type: boolean
        | AccessiblePropertyRoleDescription
        -- ^ Defines a human-readable,
        --    author-localized description for the role of an element. Value type: string
        | AccessiblePropertySort
        -- ^ Indicates if items in a table or grid are
        --    sorted in ascending or descending order. Value type: [enum/@accessibleSort@/]
        | AccessiblePropertyValueMax
        -- ^ Defines the maximum allowed value for a
        --    range widget. Value type: double
        | AccessiblePropertyValueMin
        -- ^ Defines the minimum allowed value for a
        --    range widget. Value type: double
        | AccessiblePropertyValueNow
        -- ^ Defines the current value for a range widget.
        --    Value type: double
        | AccessiblePropertyValueText
        -- ^ Defines the human readable text alternative
        --    of 'GI.Gtk.Enums.AccessiblePropertyValueNow' for a range widget. Value type: string
        | AccessiblePropertyHelpText
        -- ^ Defines a string value that provides a description of non-standard keyboard
        -- interactions of the current element. Value type: string
        --
        -- /Since: 4.16/
        | AnotherAccessibleProperty Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AccessibleProperty -> ShowS
    [AccessibleProperty] -> ShowS
    AccessibleProperty -> String
    (Int -> AccessibleProperty -> ShowS)
    -> (AccessibleProperty -> String)
    -> ([AccessibleProperty] -> ShowS)
    -> Show AccessibleProperty
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AccessibleProperty -> ShowS
    showsPrec :: Int -> AccessibleProperty -> ShowS
    $cshow :: AccessibleProperty -> String
    show :: AccessibleProperty -> String
    $cshowList :: [AccessibleProperty] -> ShowS
    showList :: [AccessibleProperty] -> ShowS
    Show, AccessibleProperty -> AccessibleProperty -> Bool
    (AccessibleProperty -> AccessibleProperty -> Bool)
    -> (AccessibleProperty -> AccessibleProperty -> Bool)
    -> Eq AccessibleProperty
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AccessibleProperty -> AccessibleProperty -> Bool
    == :: AccessibleProperty -> AccessibleProperty -> Bool
    $c/= :: AccessibleProperty -> AccessibleProperty -> Bool
    /= :: AccessibleProperty -> AccessibleProperty -> Bool
    Eq)

    instance P.Enum AccessibleProperty where
        fromEnum :: AccessibleProperty -> Int
    fromEnum AccessibleProperty
    AccessiblePropertyAutocomplete = Int
    0
        fromEnum AccessibleProperty
    AccessiblePropertyDescription = Int
    1
        fromEnum AccessibleProperty
    AccessiblePropertyHasPopup = Int
    2
        fromEnum AccessibleProperty
    AccessiblePropertyKeyShortcuts = Int
    3
        fromEnum AccessibleProperty
    AccessiblePropertyLabel = Int
    4
        fromEnum AccessibleProperty
    AccessiblePropertyLevel = Int
    5
        fromEnum AccessibleProperty
    AccessiblePropertyModal = Int
    6
        fromEnum AccessibleProperty
    AccessiblePropertyMultiLine = Int
    7
        fromEnum AccessibleProperty
    AccessiblePropertyMultiSelectable = Int
    8
        fromEnum AccessibleProperty
    AccessiblePropertyOrientation = Int
    9
        fromEnum AccessibleProperty
    AccessiblePropertyPlaceholder = Int
    10
        fromEnum AccessibleProperty
    AccessiblePropertyReadOnly = Int
    11
        fromEnum AccessibleProperty
    AccessiblePropertyRequired = Int
    12
        fromEnum AccessibleProperty
    AccessiblePropertyRoleDescription = Int
    13
        fromEnum AccessibleProperty
    AccessiblePropertySort = Int
    14
        fromEnum AccessibleProperty
    AccessiblePropertyValueMax = Int
    15
        fromEnum AccessibleProperty
    AccessiblePropertyValueMin = Int
    16
        fromEnum AccessibleProperty
    AccessiblePropertyValueNow = Int
    17
        fromEnum AccessibleProperty
    AccessiblePropertyValueText = Int
    18
        fromEnum AccessibleProperty
    AccessiblePropertyHelpText = Int
    19
        fromEnum (AnotherAccessibleProperty Int
    k) = Int
    k

        toEnum :: Int -> AccessibleProperty
    toEnum Int
    0 = AccessibleProperty
    AccessiblePropertyAutocomplete
        toEnum Int
    1 = AccessibleProperty
    AccessiblePropertyDescription
        toEnum Int
    2 = AccessibleProperty
    AccessiblePropertyHasPopup
        toEnum Int
    3 = AccessibleProperty
    AccessiblePropertyKeyShortcuts
        toEnum Int
    4 = AccessibleProperty
    AccessiblePropertyLabel
        toEnum Int
    5 = AccessibleProperty
    AccessiblePropertyLevel
        toEnum Int
    6 = AccessibleProperty
    AccessiblePropertyModal
        toEnum Int
    7 = AccessibleProperty
    AccessiblePropertyMultiLine
        toEnum Int
    8 = AccessibleProperty
    AccessiblePropertyMultiSelectable
        toEnum Int
    9 = AccessibleProperty
    AccessiblePropertyOrientation
        toEnum Int
    10 = AccessibleProperty
    AccessiblePropertyPlaceholder
        toEnum Int
    11 = AccessibleProperty
    AccessiblePropertyReadOnly
        toEnum Int
    12 = AccessibleProperty
    AccessiblePropertyRequired
        toEnum Int
    13 = AccessibleProperty
    AccessiblePropertyRoleDescription
        toEnum Int
    14 = AccessibleProperty
    AccessiblePropertySort
        toEnum Int
    15 = AccessibleProperty
    AccessiblePropertyValueMax
        toEnum Int
    16 = AccessibleProperty
    AccessiblePropertyValueMin
        toEnum Int
    17 = AccessibleProperty
    AccessiblePropertyValueNow
        toEnum Int
    18 = AccessibleProperty
    AccessiblePropertyValueText
        toEnum Int
    19 = AccessibleProperty
    AccessiblePropertyHelpText
        toEnum Int
    k = Int -> AccessibleProperty
    AnotherAccessibleProperty Int
    k

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

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

    foreign import ccall "gtk_accessible_property_get_type" c_gtk_accessible_property_get_type ::
        IO GType

    instance B.Types.TypedObject AccessibleProperty where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_accessible_property_get_type

    instance B.Types.BoxedEnum AccessibleProperty

    -- Enum AccessiblePlatformState
    -- | The various platform states which can be queried
    -- using 'GI.Gtk.Interfaces.Accessible.accessibleGetPlatformState'.
    --
    -- /Since: 4.10/
    data AccessiblePlatformState =
          AccessiblePlatformStateFocusable
        -- ^ whether the accessible can be focused
        | AccessiblePlatformStateFocused
        -- ^ whether the accessible has focus
        | AccessiblePlatformStateActive
        -- ^ whether the accessible is active
        | AnotherAccessiblePlatformState Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AccessiblePlatformState -> ShowS
    [AccessiblePlatformState] -> ShowS
    AccessiblePlatformState -> String
    (Int -> AccessiblePlatformState -> ShowS)
    -> (AccessiblePlatformState -> String)
    -> ([AccessiblePlatformState] -> ShowS)
    -> Show AccessiblePlatformState
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AccessiblePlatformState -> ShowS
    showsPrec :: Int -> AccessiblePlatformState -> ShowS
    $cshow :: AccessiblePlatformState -> String
    show :: AccessiblePlatformState -> String
    $cshowList :: [AccessiblePlatformState] -> ShowS
    showList :: [AccessiblePlatformState] -> ShowS
    Show, AccessiblePlatformState -> AccessiblePlatformState -> Bool
    (AccessiblePlatformState -> AccessiblePlatformState -> Bool)
    -> (AccessiblePlatformState -> AccessiblePlatformState -> Bool)
    -> Eq AccessiblePlatformState
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AccessiblePlatformState -> AccessiblePlatformState -> Bool
    == :: AccessiblePlatformState -> AccessiblePlatformState -> Bool
    $c/= :: AccessiblePlatformState -> AccessiblePlatformState -> Bool
    /= :: AccessiblePlatformState -> AccessiblePlatformState -> Bool
    Eq)

    instance P.Enum AccessiblePlatformState where
        fromEnum :: AccessiblePlatformState -> Int
    fromEnum AccessiblePlatformState
    AccessiblePlatformStateFocusable = Int
    0
        fromEnum AccessiblePlatformState
    AccessiblePlatformStateFocused = Int
    1
        fromEnum AccessiblePlatformState
    AccessiblePlatformStateActive = Int
    2
        fromEnum (AnotherAccessiblePlatformState Int
    k) = Int
    k

        toEnum :: Int -> AccessiblePlatformState
    toEnum Int
    0 = AccessiblePlatformState
    AccessiblePlatformStateFocusable
        toEnum Int
    1 = AccessiblePlatformState
    AccessiblePlatformStateFocused
        toEnum Int
    2 = AccessiblePlatformState
    AccessiblePlatformStateActive
        toEnum Int
    k = Int -> AccessiblePlatformState
    AnotherAccessiblePlatformState Int
    k

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

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

    foreign import ccall "gtk_accessible_platform_state_get_type" c_gtk_accessible_platform_state_get_type ::
        IO GType

    instance B.Types.TypedObject AccessiblePlatformState where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_accessible_platform_state_get_type

    instance B.Types.BoxedEnum AccessiblePlatformState

    -- Enum AccessibleInvalidState
    -- | The possible values for the 'GI.Gtk.Enums.AccessibleStateInvalid'
    -- accessible state.
    --
    -- Note that the 'GI.Gtk.Enums.AccessibleInvalidStateFalse' and
    -- 'GI.Gtk.Enums.AccessibleInvalidStateTrue' have the same values
    -- as 'P.False' and 'P.True'.
    data AccessibleInvalidState =
          AccessibleInvalidStateFalse
        -- ^ There are no detected errors in the value
        | AccessibleInvalidStateTrue
        -- ^ The value entered by the user has failed validation
        | AccessibleInvalidStateGrammar
        -- ^ A grammatical error was detected
        | AccessibleInvalidStateSpelling
        -- ^ A spelling error was detected
        | AnotherAccessibleInvalidState Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AccessibleInvalidState -> ShowS
    [AccessibleInvalidState] -> ShowS
    AccessibleInvalidState -> String
    (Int -> AccessibleInvalidState -> ShowS)
    -> (AccessibleInvalidState -> String)
    -> ([AccessibleInvalidState] -> ShowS)
    -> Show AccessibleInvalidState
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AccessibleInvalidState -> ShowS
    showsPrec :: Int -> AccessibleInvalidState -> ShowS
    $cshow :: AccessibleInvalidState -> String
    show :: AccessibleInvalidState -> String
    $cshowList :: [AccessibleInvalidState] -> ShowS
    showList :: [AccessibleInvalidState] -> ShowS
    Show, AccessibleInvalidState -> AccessibleInvalidState -> Bool
    (AccessibleInvalidState -> AccessibleInvalidState -> Bool)
    -> (AccessibleInvalidState -> AccessibleInvalidState -> Bool)
    -> Eq AccessibleInvalidState
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AccessibleInvalidState -> AccessibleInvalidState -> Bool
    == :: AccessibleInvalidState -> AccessibleInvalidState -> Bool
    $c/= :: AccessibleInvalidState -> AccessibleInvalidState -> Bool
    /= :: AccessibleInvalidState -> AccessibleInvalidState -> Bool
    Eq)

    instance P.Enum AccessibleInvalidState where
        fromEnum :: AccessibleInvalidState -> Int
    fromEnum AccessibleInvalidState
    AccessibleInvalidStateFalse = Int
    0
        fromEnum AccessibleInvalidState
    AccessibleInvalidStateTrue = Int
    1
        fromEnum AccessibleInvalidState
    AccessibleInvalidStateGrammar = Int
    2
        fromEnum AccessibleInvalidState
    AccessibleInvalidStateSpelling = Int
    3
        fromEnum (AnotherAccessibleInvalidState Int
    k) = Int
    k

        toEnum :: Int -> AccessibleInvalidState
    toEnum Int
    0 = AccessibleInvalidState
    AccessibleInvalidStateFalse
        toEnum Int
    1 = AccessibleInvalidState
    AccessibleInvalidStateTrue
        toEnum Int
    2 = AccessibleInvalidState
    AccessibleInvalidStateGrammar
        toEnum Int
    3 = AccessibleInvalidState
    AccessibleInvalidStateSpelling
        toEnum Int
    k = Int -> AccessibleInvalidState
    AnotherAccessibleInvalidState Int
    k

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

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

    foreign import ccall "gtk_accessible_invalid_state_get_type" c_gtk_accessible_invalid_state_get_type ::
        IO GType

    instance B.Types.TypedObject AccessibleInvalidState where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_accessible_invalid_state_get_type

    instance B.Types.BoxedEnum AccessibleInvalidState

    -- Enum AccessibleAutocomplete
    -- | The possible values for the 'GI.Gtk.Enums.AccessiblePropertyAutocomplete'
    -- accessible property.
    data AccessibleAutocomplete =
          AccessibleAutocompleteNone
        -- ^ Automatic suggestions are not displayed.
        | AccessibleAutocompleteInline
        -- ^ When a user is providing input, text
        --    suggesting one way to complete the provided input may be dynamically
        --    inserted after the caret.
        | AccessibleAutocompleteList
        -- ^ When a user is providing input, an element
        --    containing a collection of values that could complete the provided input
        --    may be displayed.
        | AccessibleAutocompleteBoth
        -- ^ When a user is providing input, an element
        --    containing a collection of values that could complete the provided input
        --    may be displayed. If displayed, one value in the collection is automatically
        --    selected, and the text needed to complete the automatically selected value
        --    appears after the caret in the input.
        | AnotherAccessibleAutocomplete Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AccessibleAutocomplete -> ShowS
    [AccessibleAutocomplete] -> ShowS
    AccessibleAutocomplete -> String
    (Int -> AccessibleAutocomplete -> ShowS)
    -> (AccessibleAutocomplete -> String)
    -> ([AccessibleAutocomplete] -> ShowS)
    -> Show AccessibleAutocomplete
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AccessibleAutocomplete -> ShowS
    showsPrec :: Int -> AccessibleAutocomplete -> ShowS
    $cshow :: AccessibleAutocomplete -> String
    show :: AccessibleAutocomplete -> String
    $cshowList :: [AccessibleAutocomplete] -> ShowS
    showList :: [AccessibleAutocomplete] -> ShowS
    Show, AccessibleAutocomplete -> AccessibleAutocomplete -> Bool
    (AccessibleAutocomplete -> AccessibleAutocomplete -> Bool)
    -> (AccessibleAutocomplete -> AccessibleAutocomplete -> Bool)
    -> Eq AccessibleAutocomplete
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AccessibleAutocomplete -> AccessibleAutocomplete -> Bool
    == :: AccessibleAutocomplete -> AccessibleAutocomplete -> Bool
    $c/= :: AccessibleAutocomplete -> AccessibleAutocomplete -> Bool
    /= :: AccessibleAutocomplete -> AccessibleAutocomplete -> Bool
    Eq)

    instance P.Enum AccessibleAutocomplete where
        fromEnum :: AccessibleAutocomplete -> Int
    fromEnum AccessibleAutocomplete
    AccessibleAutocompleteNone = Int
    0
        fromEnum AccessibleAutocomplete
    AccessibleAutocompleteInline = Int
    1
        fromEnum AccessibleAutocomplete
    AccessibleAutocompleteList = Int
    2
        fromEnum AccessibleAutocomplete
    AccessibleAutocompleteBoth = Int
    3
        fromEnum (AnotherAccessibleAutocomplete Int
    k) = Int
    k

        toEnum :: Int -> AccessibleAutocomplete
    toEnum Int
    0 = AccessibleAutocomplete
    AccessibleAutocompleteNone
        toEnum Int
    1 = AccessibleAutocomplete
    AccessibleAutocompleteInline
        toEnum Int
    2 = AccessibleAutocomplete
    AccessibleAutocompleteList
        toEnum Int
    3 = AccessibleAutocomplete
    AccessibleAutocompleteBoth
        toEnum Int
    k = Int -> AccessibleAutocomplete
    AnotherAccessibleAutocomplete Int
    k

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

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

    foreign import ccall "gtk_accessible_autocomplete_get_type" c_gtk_accessible_autocomplete_get_type ::
        IO GType

    instance B.Types.TypedObject AccessibleAutocomplete where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_accessible_autocomplete_get_type

    instance B.Types.BoxedEnum AccessibleAutocomplete

    -- Enum AccessibleAnnouncementPriority
    -- | The priority of an accessibility announcement.
    --
    -- /Since: 4.14/
    data AccessibleAnnouncementPriority =
          AccessibleAnnouncementPriorityLow
        -- ^ The announcement is low priority,
        --   and might be read only on the user\'s request.
        | AccessibleAnnouncementPriorityMedium
        -- ^ The announcement is of medium
        --   priority, and is usually spoken at the next opportunity, such as at the
        --   end of speaking the current sentence or when the user pauses typing.
        | AccessibleAnnouncementPriorityHigh
        -- ^ The announcement is of high
        --   priority, and is usually spoken immediately. Because an interruption
        --   might disorient users or cause them to not complete their current task,
        --   authors SHOULD NOT use high priority announcements unless the
        --   interruption is imperative. An example would be a notification about a
        --   critical battery power level.
        | AnotherAccessibleAnnouncementPriority Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AccessibleAnnouncementPriority -> ShowS
    [AccessibleAnnouncementPriority] -> ShowS
    AccessibleAnnouncementPriority -> String
    (Int -> AccessibleAnnouncementPriority -> ShowS)
    -> (AccessibleAnnouncementPriority -> String)
    -> ([AccessibleAnnouncementPriority] -> ShowS)
    -> Show AccessibleAnnouncementPriority
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AccessibleAnnouncementPriority -> ShowS
    showsPrec :: Int -> AccessibleAnnouncementPriority -> ShowS
    $cshow :: AccessibleAnnouncementPriority -> String
    show :: AccessibleAnnouncementPriority -> String
    $cshowList :: [AccessibleAnnouncementPriority] -> ShowS
    showList :: [AccessibleAnnouncementPriority] -> ShowS
    Show, AccessibleAnnouncementPriority
    -> AccessibleAnnouncementPriority -> Bool
    (AccessibleAnnouncementPriority
     -> AccessibleAnnouncementPriority -> Bool)
    -> (AccessibleAnnouncementPriority
        -> AccessibleAnnouncementPriority -> Bool)
    -> Eq AccessibleAnnouncementPriority
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AccessibleAnnouncementPriority
    -> AccessibleAnnouncementPriority -> Bool
    == :: AccessibleAnnouncementPriority
    -> AccessibleAnnouncementPriority -> Bool
    $c/= :: AccessibleAnnouncementPriority
    -> AccessibleAnnouncementPriority -> Bool
    /= :: AccessibleAnnouncementPriority
    -> AccessibleAnnouncementPriority -> Bool
    Eq)

    instance P.Enum AccessibleAnnouncementPriority where
        fromEnum :: AccessibleAnnouncementPriority -> Int
    fromEnum AccessibleAnnouncementPriority
    AccessibleAnnouncementPriorityLow = Int
    0
        fromEnum AccessibleAnnouncementPriority
    AccessibleAnnouncementPriorityMedium = Int
    1
        fromEnum AccessibleAnnouncementPriority
    AccessibleAnnouncementPriorityHigh = Int
    2
        fromEnum (AnotherAccessibleAnnouncementPriority Int
    k) = Int
    k

        toEnum :: Int -> AccessibleAnnouncementPriority
    toEnum Int
    0 = AccessibleAnnouncementPriority
    AccessibleAnnouncementPriorityLow
        toEnum Int
    1 = AccessibleAnnouncementPriority
    AccessibleAnnouncementPriorityMedium
        toEnum Int
    2 = AccessibleAnnouncementPriority
    AccessibleAnnouncementPriorityHigh
        toEnum Int
    k = Int -> AccessibleAnnouncementPriority
    AnotherAccessibleAnnouncementPriority Int
    k

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

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

    foreign import ccall "gtk_accessible_announcement_priority_get_type" c_gtk_accessible_announcement_priority_get_type ::
        IO GType

    instance B.Types.TypedObject AccessibleAnnouncementPriority where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_accessible_announcement_priority_get_type

    instance B.Types.BoxedEnum AccessibleAnnouncementPriority