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

     -- * Flags

    -- ** FeatureFlags #flag:FeatureFlags#

        FeatureFlags(..)                        ,

    -- ** PtyFlags #flag:PtyFlags#

        PtyFlags(..)                            ,

        ) 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

    -- Flags PtyFlags
    -- | /No description available in the introspection data./
    data PtyFlags =
          PtyFlagsNoLastlog
        -- ^ Unused. Deprecated: 0.38
        | PtyFlagsNoUtmp
        -- ^ Unused. Deprecated: 0.38
        | PtyFlagsNoWtmp
        -- ^ Unused. Deprecated: 0.38
        | PtyFlagsNoHelper
        -- ^ Unused. Deprecated: 0.38
        | PtyFlagsNoFallback
        -- ^ Unused. Deprecated: 0.38
        | PtyFlagsNoSession
        -- ^ Do not start a new session for the child in
        --   'GI.Vte.Objects.Pty.ptyChildSetup'. See man:setsid(2) for more information. Since: 0.58
        | PtyFlagsNoCtty
        -- ^ Do not set the PTY as the controlling TTY for the child
        --   in 'GI.Vte.Objects.Pty.ptyChildSetup'. See man:tty_ioctl(4) for more information. Since: 0.58
        | PtyFlagsDefault
        -- ^ the default flags
        | AnotherPtyFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PtyFlags -> ShowS
    [PtyFlags] -> ShowS
    PtyFlags -> String
    (Int -> PtyFlags -> ShowS)
    -> (PtyFlags -> String) -> ([PtyFlags] -> ShowS) -> Show PtyFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PtyFlags -> ShowS
    showsPrec :: Int -> PtyFlags -> ShowS
    $cshow :: PtyFlags -> String
    show :: PtyFlags -> String
    $cshowList :: [PtyFlags] -> ShowS
    showList :: [PtyFlags] -> ShowS
    Show, PtyFlags -> PtyFlags -> Bool
    (PtyFlags -> PtyFlags -> Bool)
    -> (PtyFlags -> PtyFlags -> Bool) -> Eq PtyFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PtyFlags -> PtyFlags -> Bool
    == :: PtyFlags -> PtyFlags -> Bool
    $c/= :: PtyFlags -> PtyFlags -> Bool
    /= :: PtyFlags -> PtyFlags -> Bool
    Eq)

    instance P.Enum PtyFlags where
        fromEnum :: PtyFlags -> Int
    fromEnum PtyFlags
    PtyFlagsNoLastlog = Int
    1
        fromEnum PtyFlags
    PtyFlagsNoUtmp = Int
    2
        fromEnum PtyFlags
    PtyFlagsNoWtmp = Int
    4
        fromEnum PtyFlags
    PtyFlagsNoHelper = Int
    8
        fromEnum PtyFlags
    PtyFlagsNoFallback = Int
    16
        fromEnum PtyFlags
    PtyFlagsNoSession = Int
    32
        fromEnum PtyFlags
    PtyFlagsNoCtty = Int
    64
        fromEnum PtyFlags
    PtyFlagsDefault = Int
    0
        fromEnum (AnotherPtyFlags Int
    k) = Int
    k

        toEnum :: Int -> PtyFlags
    toEnum Int
    1 = PtyFlags
    PtyFlagsNoLastlog
        toEnum Int
    2 = PtyFlags
    PtyFlagsNoUtmp
        toEnum Int
    4 = PtyFlags
    PtyFlagsNoWtmp
        toEnum Int
    8 = PtyFlags
    PtyFlagsNoHelper
        toEnum Int
    16 = PtyFlags
    PtyFlagsNoFallback
        toEnum Int
    32 = PtyFlags
    PtyFlagsNoSession
        toEnum Int
    64 = PtyFlags
    PtyFlagsNoCtty
        toEnum Int
    0 = PtyFlags
    PtyFlagsDefault
        toEnum Int
    k = Int -> PtyFlags
    AnotherPtyFlags Int
    k

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

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

    foreign import ccall "vte_pty_flags_get_type" c_vte_pty_flags_get_type ::
        IO GType

    instance B.Types.TypedObject PtyFlags where
        glibType :: IO GType
    glibType = IO GType
    c_vte_pty_flags_get_type

    instance B.Types.BoxedFlags PtyFlags

    instance IsGFlag PtyFlags

    -- Flags FeatureFlags
    -- | An enumeration type for features.
    --
    -- /Since: 0.62/
    data FeatureFlags =
          FeatureFlagsFlagBidi
        -- ^ whether VTE was built with bidirectional text support
        | FeatureFlagsFlagIcu
        -- ^ whether VTE was built with ICU support
        | FeatureFlagsFlagSystemd
        -- ^ whether VTE was built with systemd support
        | FeatureFlagsFlagSixel
        -- ^ whether VTE was built with SIXEL support
        | FeatureFlagsFlagsMask
        -- ^ mask of all feature flags
        | AnotherFeatureFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> FeatureFlags -> ShowS
    [FeatureFlags] -> ShowS
    FeatureFlags -> String
    (Int -> FeatureFlags -> ShowS)
    -> (FeatureFlags -> String)
    -> ([FeatureFlags] -> ShowS)
    -> Show FeatureFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FeatureFlags -> ShowS
    showsPrec :: Int -> FeatureFlags -> ShowS
    $cshow :: FeatureFlags -> String
    show :: FeatureFlags -> String
    $cshowList :: [FeatureFlags] -> ShowS
    showList :: [FeatureFlags] -> ShowS
    Show, FeatureFlags -> FeatureFlags -> Bool
    (FeatureFlags -> FeatureFlags -> Bool)
    -> (FeatureFlags -> FeatureFlags -> Bool) -> Eq FeatureFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FeatureFlags -> FeatureFlags -> Bool
    == :: FeatureFlags -> FeatureFlags -> Bool
    $c/= :: FeatureFlags -> FeatureFlags -> Bool
    /= :: FeatureFlags -> FeatureFlags -> Bool
    Eq)

    instance P.Enum FeatureFlags where
        fromEnum :: FeatureFlags -> Int
    fromEnum FeatureFlags
    FeatureFlagsFlagBidi = Int
    1
        fromEnum FeatureFlags
    FeatureFlagsFlagIcu = Int
    2
        fromEnum FeatureFlags
    FeatureFlagsFlagSystemd = Int
    4
        fromEnum FeatureFlags
    FeatureFlagsFlagSixel = Int
    8
        fromEnum FeatureFlags
    FeatureFlagsFlagsMask = Int
    -1
        fromEnum (AnotherFeatureFlags Int
    k) = Int
    k

        toEnum :: Int -> FeatureFlags
    toEnum Int
    1 = FeatureFlags
    FeatureFlagsFlagBidi
        toEnum Int
    2 = FeatureFlags
    FeatureFlagsFlagIcu
        toEnum Int
    4 = FeatureFlags
    FeatureFlagsFlagSystemd
        toEnum Int
    8 = FeatureFlags
    FeatureFlagsFlagSixel
        toEnum Int
    -1 = FeatureFlags
    FeatureFlagsFlagsMask
        toEnum Int
    k = Int -> FeatureFlags
    AnotherFeatureFlags Int
    k

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

    instance IsGFlag FeatureFlags