    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Vte.Enums
        (

     -- * Enumerations
    -- ** CursorBlinkMode #enum:CursorBlinkMode#

        CursorBlinkMode(..)                     ,

    -- ** CursorShape #enum:CursorShape#

        CursorShape(..)                         ,

    -- ** EraseBinding #enum:EraseBinding#

        EraseBinding(..)                        ,

    -- ** Format #enum:Format#

        Format(..)                              ,

    -- ** PtyError #enum:PtyError#

        PtyError(..)                            ,
        catchPtyError                           ,
        handlePtyError                          ,

    -- ** RegexError #enum:RegexError#

        RegexError(..)                          ,
        catchRegexError                         ,
        handleRegexError                        ,

    -- ** TextBlinkMode #enum:TextBlinkMode#

        TextBlinkMode(..)                       ,

    -- ** WriteFlags #enum:WriteFlags#

        WriteFlags(..)                          ,

        ) 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.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.Text as T
    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

    -- Enum WriteFlags
    -- | A flag type to determine how terminal contents should be written
    -- to an output stream.
    data WriteFlags =
          WriteFlagsDefault
        -- ^ Write contents as UTF-8 text.  This is the default.
        | AnotherWriteFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> WriteFlags -> ShowS
    [WriteFlags] -> ShowS
    WriteFlags -> String
    (Int -> WriteFlags -> ShowS)
    -> (WriteFlags -> String)
    -> ([WriteFlags] -> ShowS)
    -> Show WriteFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [WriteFlags] -> ShowS
    $cshowList :: [WriteFlags] -> ShowS
    show :: WriteFlags -> String
    $cshow :: WriteFlags -> String
    showsPrec :: Int -> WriteFlags -> ShowS
    $cshowsPrec :: Int -> WriteFlags -> ShowS
    Show, WriteFlags -> WriteFlags -> Bool
    (WriteFlags -> WriteFlags -> Bool)
    -> (WriteFlags -> WriteFlags -> Bool) -> Eq WriteFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: WriteFlags -> WriteFlags -> Bool
    $c/= :: WriteFlags -> WriteFlags -> Bool
    == :: WriteFlags -> WriteFlags -> Bool
    $c== :: WriteFlags -> WriteFlags -> Bool
    Eq)

    instance P.Enum WriteFlags where
        fromEnum :: WriteFlags -> Int
    fromEnum WriteFlagsDefault = 0
        fromEnum (AnotherWriteFlags k :: Int
    k) = Int
    k

        toEnum :: Int -> WriteFlags
    toEnum 0 = WriteFlags
    WriteFlagsDefault
        toEnum k :: Int
    k = Int -> WriteFlags
    AnotherWriteFlags Int
    k

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

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

    foreign import ccall "vte_write_flags_get_type" c_vte_write_flags_get_type ::
        IO GType

    instance B.Types.TypedObject WriteFlags where
        glibType :: IO GType
    glibType = IO GType
    c_vte_write_flags_get_type

    instance B.Types.BoxedEnum WriteFlags

    -- Enum TextBlinkMode
    -- | An enumerated type which can be used to indicate whether the terminal allows
    -- the text contents to be blinked.
    --
    -- /Since: 0.52/
    data TextBlinkMode =
          TextBlinkModeNever
        -- ^ Do not blink the text.
        | TextBlinkModeFocused
        -- ^ Allow blinking text only if the terminal is focused.
        | TextBlinkModeUnfocused
        -- ^ Allow blinking text only if the terminal is unfocused.
        | TextBlinkModeAlways
        -- ^ Allow blinking text. This is the default.
        | AnotherTextBlinkMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TextBlinkMode -> ShowS
    [TextBlinkMode] -> ShowS
    TextBlinkMode -> String
    (Int -> TextBlinkMode -> ShowS)
    -> (TextBlinkMode -> String)
    -> ([TextBlinkMode] -> ShowS)
    -> Show TextBlinkMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [TextBlinkMode] -> ShowS
    $cshowList :: [TextBlinkMode] -> ShowS
    show :: TextBlinkMode -> String
    $cshow :: TextBlinkMode -> String
    showsPrec :: Int -> TextBlinkMode -> ShowS
    $cshowsPrec :: Int -> TextBlinkMode -> ShowS
    Show, TextBlinkMode -> TextBlinkMode -> Bool
    (TextBlinkMode -> TextBlinkMode -> Bool)
    -> (TextBlinkMode -> TextBlinkMode -> Bool) -> Eq TextBlinkMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: TextBlinkMode -> TextBlinkMode -> Bool
    $c/= :: TextBlinkMode -> TextBlinkMode -> Bool
    == :: TextBlinkMode -> TextBlinkMode -> Bool
    $c== :: TextBlinkMode -> TextBlinkMode -> Bool
    Eq)

    instance P.Enum TextBlinkMode where
        fromEnum :: TextBlinkMode -> Int
    fromEnum TextBlinkModeNever = 0
        fromEnum TextBlinkModeFocused = 1
        fromEnum TextBlinkModeUnfocused = 2
        fromEnum TextBlinkModeAlways = 3
        fromEnum (AnotherTextBlinkMode k :: Int
    k) = Int
    k

        toEnum :: Int -> TextBlinkMode
    toEnum 0 = TextBlinkMode
    TextBlinkModeNever
        toEnum 1 = TextBlinkMode
    TextBlinkModeFocused
        toEnum 2 = TextBlinkMode
    TextBlinkModeUnfocused
        toEnum 3 = TextBlinkMode
    TextBlinkModeAlways
        toEnum k :: Int
    k = Int -> TextBlinkMode
    AnotherTextBlinkMode Int
    k

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

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

    foreign import ccall "vte_text_blink_mode_get_type" c_vte_text_blink_mode_get_type ::
        IO GType

    instance B.Types.TypedObject TextBlinkMode where
        glibType :: IO GType
    glibType = IO GType
    c_vte_text_blink_mode_get_type

    instance B.Types.BoxedEnum TextBlinkMode

    -- Enum RegexError
    -- | An enum type for regex errors. In addition to the values listed above,
    -- any PCRE2 error values may occur.
    --
    -- /Since: 0.46/
    data RegexError =
          RegexErrorIncompatible
        -- ^ The PCRE2 library was built without
        --   Unicode support which is required for VTE
        | RegexErrorNotSupported
        -- ^ Regexes are not supported because VTE was
        --   built without PCRE2 support
        | AnotherRegexError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> RegexError -> ShowS
    [RegexError] -> ShowS
    RegexError -> String
    (Int -> RegexError -> ShowS)
    -> (RegexError -> String)
    -> ([RegexError] -> ShowS)
    -> Show RegexError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [RegexError] -> ShowS
    $cshowList :: [RegexError] -> ShowS
    show :: RegexError -> String
    $cshow :: RegexError -> String
    showsPrec :: Int -> RegexError -> ShowS
    $cshowsPrec :: Int -> RegexError -> ShowS
    Show, RegexError -> RegexError -> Bool
    (RegexError -> RegexError -> Bool)
    -> (RegexError -> RegexError -> Bool) -> Eq RegexError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: RegexError -> RegexError -> Bool
    $c/= :: RegexError -> RegexError -> Bool
    == :: RegexError -> RegexError -> Bool
    $c== :: RegexError -> RegexError -> Bool
    Eq)

    instance P.Enum RegexError where
        fromEnum :: RegexError -> Int
    fromEnum RegexErrorIncompatible = 2147483646
        fromEnum RegexErrorNotSupported = 2147483647
        fromEnum (AnotherRegexError k :: Int
    k) = Int
    k

        toEnum :: Int -> RegexError
    toEnum 2147483646 = RegexError
    RegexErrorIncompatible
        toEnum 2147483647 = RegexError
    RegexErrorNotSupported
        toEnum k :: Int
    k = Int -> RegexError
    AnotherRegexError Int
    k

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

    instance GErrorClass RegexError where
        gerrorClassDomain :: RegexError -> Text
    gerrorClassDomain _ = "vte-regex-error"

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

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

    foreign import ccall "vte_regex_error_get_type" c_vte_regex_error_get_type ::
        IO GType

    instance B.Types.TypedObject RegexError where
        glibType :: IO GType
    glibType = IO GType
    c_vte_regex_error_get_type

    instance B.Types.BoxedEnum RegexError

    -- Enum PtyError
    -- | /No description available in the introspection data./
    data PtyError =
          PtyErrorPtyHelperFailed
        -- ^ Obsolete. Deprecated: 0.42
        | PtyErrorPty98Failed
        -- ^ failure when using PTY98 to allocate the PTY
        | AnotherPtyError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PtyError -> ShowS
    [PtyError] -> ShowS
    PtyError -> String
    (Int -> PtyError -> ShowS)
    -> (PtyError -> String) -> ([PtyError] -> ShowS) -> Show PtyError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [PtyError] -> ShowS
    $cshowList :: [PtyError] -> ShowS
    show :: PtyError -> String
    $cshow :: PtyError -> String
    showsPrec :: Int -> PtyError -> ShowS
    $cshowsPrec :: Int -> PtyError -> ShowS
    Show, PtyError -> PtyError -> Bool
    (PtyError -> PtyError -> Bool)
    -> (PtyError -> PtyError -> Bool) -> Eq PtyError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: PtyError -> PtyError -> Bool
    $c/= :: PtyError -> PtyError -> Bool
    == :: PtyError -> PtyError -> Bool
    $c== :: PtyError -> PtyError -> Bool
    Eq)

    instance P.Enum PtyError where
        fromEnum :: PtyError -> Int
    fromEnum PtyErrorPtyHelperFailed = 0
        fromEnum PtyErrorPty98Failed = 1
        fromEnum (AnotherPtyError k :: Int
    k) = Int
    k

        toEnum :: Int -> PtyError
    toEnum 0 = PtyError
    PtyErrorPtyHelperFailed
        toEnum 1 = PtyError
    PtyErrorPty98Failed
        toEnum k :: Int
    k = Int -> PtyError
    AnotherPtyError Int
    k

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

    instance GErrorClass PtyError where
        gerrorClassDomain :: PtyError -> Text
    gerrorClassDomain _ = "vte-pty-error"

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

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

    foreign import ccall "vte_pty_error_get_type" c_vte_pty_error_get_type ::
        IO GType

    instance B.Types.TypedObject PtyError where
        glibType :: IO GType
    glibType = IO GType
    c_vte_pty_error_get_type

    instance B.Types.BoxedEnum PtyError

    -- Enum Format
    -- | An enumeration type that can be used to specify the format the selection
    -- should be copied to the clipboard in.
    --
    -- /Since: 0.50/
    data Format =
          FormatText
        -- ^ Export as plain text
        | FormatHtml
        -- ^ Export as HTML formatted text
        | AnotherFormat Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Format -> ShowS
    [Format] -> ShowS
    Format -> String
    (Int -> Format -> ShowS)
    -> (Format -> String) -> ([Format] -> ShowS) -> Show Format
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Format] -> ShowS
    $cshowList :: [Format] -> ShowS
    show :: Format -> String
    $cshow :: Format -> String
    showsPrec :: Int -> Format -> ShowS
    $cshowsPrec :: Int -> Format -> ShowS
    Show, Format -> Format -> Bool
    (Format -> Format -> Bool)
    -> (Format -> Format -> Bool) -> Eq Format
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Format -> Format -> Bool
    $c/= :: Format -> Format -> Bool
    == :: Format -> Format -> Bool
    $c== :: Format -> Format -> Bool
    Eq)

    instance P.Enum Format where
        fromEnum :: Format -> Int
    fromEnum FormatText = 1
        fromEnum FormatHtml = 2
        fromEnum (AnotherFormat k :: Int
    k) = Int
    k

        toEnum :: Int -> Format
    toEnum 1 = Format
    FormatText
        toEnum 2 = Format
    FormatHtml
        toEnum k :: Int
    k = Int -> Format
    AnotherFormat Int
    k

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

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

    foreign import ccall "vte_format_get_type" c_vte_format_get_type ::
        IO GType

    instance B.Types.TypedObject Format where
        glibType :: IO GType
    glibType = IO GType
    c_vte_format_get_type

    instance B.Types.BoxedEnum Format

    -- Enum EraseBinding
    -- | An enumerated type which can be used to indicate which string the terminal
    -- should send to an application when the user presses the Delete or Backspace
    -- keys.
    data EraseBinding =
          EraseBindingAuto
        -- ^ For backspace, attempt to determine the right value from the terminal\'s IO settings.  For delete, use the control sequence.
        | EraseBindingAsciiBackspace
        -- ^ Send an ASCII backspace character (0x08).
        | EraseBindingAsciiDelete
        -- ^ Send an ASCII delete character (0x7F).
        | EraseBindingDeleteSequence
        -- ^ Send the \"\@/@7@/\" control sequence.
        | EraseBindingTty
        -- ^ Send terminal\'s \"erase\" setting.
        | AnotherEraseBinding Int
        -- ^ Catch-all for unknown values
        deriving (Int -> EraseBinding -> ShowS
    [EraseBinding] -> ShowS
    EraseBinding -> String
    (Int -> EraseBinding -> ShowS)
    -> (EraseBinding -> String)
    -> ([EraseBinding] -> ShowS)
    -> Show EraseBinding
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [EraseBinding] -> ShowS
    $cshowList :: [EraseBinding] -> ShowS
    show :: EraseBinding -> String
    $cshow :: EraseBinding -> String
    showsPrec :: Int -> EraseBinding -> ShowS
    $cshowsPrec :: Int -> EraseBinding -> ShowS
    Show, EraseBinding -> EraseBinding -> Bool
    (EraseBinding -> EraseBinding -> Bool)
    -> (EraseBinding -> EraseBinding -> Bool) -> Eq EraseBinding
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: EraseBinding -> EraseBinding -> Bool
    $c/= :: EraseBinding -> EraseBinding -> Bool
    == :: EraseBinding -> EraseBinding -> Bool
    $c== :: EraseBinding -> EraseBinding -> Bool
    Eq)

    instance P.Enum EraseBinding where
        fromEnum :: EraseBinding -> Int
    fromEnum EraseBindingAuto = 0
        fromEnum EraseBindingAsciiBackspace = 1
        fromEnum EraseBindingAsciiDelete = 2
        fromEnum EraseBindingDeleteSequence = 3
        fromEnum EraseBindingTty = 4
        fromEnum (AnotherEraseBinding k :: Int
    k) = Int
    k

        toEnum :: Int -> EraseBinding
    toEnum 0 = EraseBinding
    EraseBindingAuto
        toEnum 1 = EraseBinding
    EraseBindingAsciiBackspace
        toEnum 2 = EraseBinding
    EraseBindingAsciiDelete
        toEnum 3 = EraseBinding
    EraseBindingDeleteSequence
        toEnum 4 = EraseBinding
    EraseBindingTty
        toEnum k :: Int
    k = Int -> EraseBinding
    AnotherEraseBinding Int
    k

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

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

    foreign import ccall "vte_erase_binding_get_type" c_vte_erase_binding_get_type ::
        IO GType

    instance B.Types.TypedObject EraseBinding where
        glibType :: IO GType
    glibType = IO GType
    c_vte_erase_binding_get_type

    instance B.Types.BoxedEnum EraseBinding

    -- Enum CursorShape
    -- | An enumerated type which can be used to indicate what should the terminal
    -- draw at the cursor position.
    data CursorShape =
          CursorShapeBlock
        -- ^ Draw a block cursor.  This is the default.
        | CursorShapeIbeam
        -- ^ Draw a vertical bar on the left side of character.
        -- This is similar to the default cursor for other GTK+ widgets.
        | CursorShapeUnderline
        -- ^ Draw a horizontal bar below the character.
        | AnotherCursorShape Int
        -- ^ Catch-all for unknown values
        deriving (Int -> CursorShape -> ShowS
    [CursorShape] -> ShowS
    CursorShape -> String
    (Int -> CursorShape -> ShowS)
    -> (CursorShape -> String)
    -> ([CursorShape] -> ShowS)
    -> Show CursorShape
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [CursorShape] -> ShowS
    $cshowList :: [CursorShape] -> ShowS
    show :: CursorShape -> String
    $cshow :: CursorShape -> String
    showsPrec :: Int -> CursorShape -> ShowS
    $cshowsPrec :: Int -> CursorShape -> ShowS
    Show, CursorShape -> CursorShape -> Bool
    (CursorShape -> CursorShape -> Bool)
    -> (CursorShape -> CursorShape -> Bool) -> Eq CursorShape
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: CursorShape -> CursorShape -> Bool
    $c/= :: CursorShape -> CursorShape -> Bool
    == :: CursorShape -> CursorShape -> Bool
    $c== :: CursorShape -> CursorShape -> Bool
    Eq)

    instance P.Enum CursorShape where
        fromEnum :: CursorShape -> Int
    fromEnum CursorShapeBlock = 0
        fromEnum CursorShapeIbeam = 1
        fromEnum CursorShapeUnderline = 2
        fromEnum (AnotherCursorShape k :: Int
    k) = Int
    k

        toEnum :: Int -> CursorShape
    toEnum 0 = CursorShape
    CursorShapeBlock
        toEnum 1 = CursorShape
    CursorShapeIbeam
        toEnum 2 = CursorShape
    CursorShapeUnderline
        toEnum k :: Int
    k = Int -> CursorShape
    AnotherCursorShape Int
    k

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

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

    foreign import ccall "vte_cursor_shape_get_type" c_vte_cursor_shape_get_type ::
        IO GType

    instance B.Types.TypedObject CursorShape where
        glibType :: IO GType
    glibType = IO GType
    c_vte_cursor_shape_get_type

    instance B.Types.BoxedEnum CursorShape

    -- Enum CursorBlinkMode
    -- | An enumerated type which can be used to indicate the cursor blink mode
    -- for the terminal.
    data CursorBlinkMode =
          CursorBlinkModeSystem
        -- ^ Follow GTK+ settings for cursor blinking.
        | CursorBlinkModeOn
        -- ^ Cursor blinks.
        | CursorBlinkModeOff
        -- ^ Cursor does not blink.
        | AnotherCursorBlinkMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> CursorBlinkMode -> ShowS
    [CursorBlinkMode] -> ShowS
    CursorBlinkMode -> String
    (Int -> CursorBlinkMode -> ShowS)
    -> (CursorBlinkMode -> String)
    -> ([CursorBlinkMode] -> ShowS)
    -> Show CursorBlinkMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [CursorBlinkMode] -> ShowS
    $cshowList :: [CursorBlinkMode] -> ShowS
    show :: CursorBlinkMode -> String
    $cshow :: CursorBlinkMode -> String
    showsPrec :: Int -> CursorBlinkMode -> ShowS
    $cshowsPrec :: Int -> CursorBlinkMode -> ShowS
    Show, CursorBlinkMode -> CursorBlinkMode -> Bool
    (CursorBlinkMode -> CursorBlinkMode -> Bool)
    -> (CursorBlinkMode -> CursorBlinkMode -> Bool)
    -> Eq CursorBlinkMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: CursorBlinkMode -> CursorBlinkMode -> Bool
    $c/= :: CursorBlinkMode -> CursorBlinkMode -> Bool
    == :: CursorBlinkMode -> CursorBlinkMode -> Bool
    $c== :: CursorBlinkMode -> CursorBlinkMode -> Bool
    Eq)

    instance P.Enum CursorBlinkMode where
        fromEnum :: CursorBlinkMode -> Int
    fromEnum CursorBlinkModeSystem = 0
        fromEnum CursorBlinkModeOn = 1
        fromEnum CursorBlinkModeOff = 2
        fromEnum (AnotherCursorBlinkMode k :: Int
    k) = Int
    k

        toEnum :: Int -> CursorBlinkMode
    toEnum 0 = CursorBlinkMode
    CursorBlinkModeSystem
        toEnum 1 = CursorBlinkMode
    CursorBlinkModeOn
        toEnum 2 = CursorBlinkMode
    CursorBlinkModeOff
        toEnum k :: Int
    k = Int -> CursorBlinkMode
    AnotherCursorBlinkMode Int
    k

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

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

    foreign import ccall "vte_cursor_blink_mode_get_type" c_vte_cursor_blink_mode_get_type ::
        IO GType

    instance B.Types.TypedObject CursorBlinkMode where
        glibType :: IO GType
    glibType = IO GType
    c_vte_cursor_blink_mode_get_type

    instance B.Types.BoxedEnum CursorBlinkMode