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

     -- * Methods

    -- ** getEncodingSupported #method:getEncodingSupported#

        getEncodingSupported                    ,

    -- ** getEncodings #method:getEncodings#

        getEncodings                            ,

    -- ** getFeatureFlags #method:getFeatureFlags#

        getFeatureFlags                         ,

    -- ** getFeatures #method:getFeatures#

        getFeatures                             ,

    -- ** getMajorVersion #method:getMajorVersion#

        getMajorVersion                         ,

    -- ** getMicroVersion #method:getMicroVersion#

        getMicroVersion                         ,

    -- ** getMinorVersion #method:getMinorVersion#

        getMinorVersion                         ,

    -- ** getTermprops #method:getTermprops#

        getTermprops                            ,

    -- ** getUserShell #method:getUserShell#

        getUserShell                            ,

    -- ** installTermprop #method:installTermprop#

        installTermprop                         ,

    -- ** installTermpropAlias #method:installTermpropAlias#

        installTermpropAlias                    ,

    -- ** queryTermprop #method:queryTermprop#

        queryTermprop                           ,

    -- ** queryTermpropById #method:queryTermpropById#

        queryTermpropById                       ,

        ) 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)
    import {-# SOURCE #-} qualified GI.Vte.Enums as Vte.Enums
    import {-# SOURCE #-} qualified GI.Vte.Flags as Vte.Flags

    #else
    import {-# SOURCE #-} qualified GI.Vte.Enums as Vte.Enums
    import {-# SOURCE #-} qualified GI.Vte.Flags as Vte.Flags

    #endif

    -- function query_termprop_by_id
    -- Args: [ Arg
    --           { argCName = "prop"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a termprop ID" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char**"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a location to store the termprop's name"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "type"
    --           , argType =
    --               TInterface Name { namespace = "Vte" , name = "PropertyType" }
    --           , argCType = Just "VtePropertyType*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a location to store the termprop's type as a #VtePropertyType"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType =
    --               TInterface Name { namespace = "Vte" , name = "PropertyFlags" }
    --           , argCType = Just "VtePropertyFlags*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a location to store the termprop's flags as a #VtePropertyFlags"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_query_termprop_by_id" vte_query_termprop_by_id ::
        Int32 ->                                -- prop : TBasicType TInt
        Ptr CString ->                          -- name : TBasicType TUTF8
        Ptr CUInt ->                            -- type : TInterface (Name {namespace = "Vte", name = "PropertyType"})
        Ptr CUInt ->                            -- flags : TInterface (Name {namespace = "Vte", name = "PropertyFlags"})
        IO CInt

    -- | Like 'GI.Vte.Functions.queryTermprop' except that it takes the termprop by ID.
    -- See that function for more information.
    --
    -- For an alias termprop (see 'GI.Vte.Functions.installTermpropAlias'), /@resolvedName@/
    -- will be name of the alias\' target termprop; otherwise it will be /@name@/.
    --
    -- /Since: 0.78/
    queryTermpropById ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Int32
        -- ^ /@prop@/: a termprop ID
        -> m ((Bool, T.Text, Vte.Enums.PropertyType, [Vte.Flags.PropertyFlags]))
        -- ^ __Returns:__ 'P.True' iff the termprop exists, and then /@name@/, /@type@/ and
        --   /@flags@/ will be filled in
    queryTermpropById :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Int32 -> m (Bool, Text, PropertyType, [PropertyFlags])
    queryTermpropById Int32
    prop = IO (Bool, Text, PropertyType, [PropertyFlags])
    -> m (Bool, Text, PropertyType, [PropertyFlags])
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Bool, Text, PropertyType, [PropertyFlags])
     -> m (Bool, Text, PropertyType, [PropertyFlags]))
    -> IO (Bool, Text, PropertyType, [PropertyFlags])
    -> m (Bool, Text, PropertyType, [PropertyFlags])
    forall a b. (a -> b) -> a -> b
    $ do
        name <- IO (Ptr CString)
    forall a. Storable a => IO (Ptr a)
    callocMem :: IO (Ptr CString)
        type_ <- allocMem :: IO (Ptr CUInt)
        flags <- allocMem :: IO (Ptr CUInt)
        result <- vte_query_termprop_by_id prop name type_ flags
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        name' <- peek name
        name'' <- cstringToText name'
        type_' <- peek type_
        let type_'' = (Int -> PropertyType
    forall a. Enum a => Int -> a
    toEnum (Int -> PropertyType) -> (CUInt -> Int) -> CUInt -> PropertyType
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    type_'
        flags' <- peek flags
        let flags'' = CUInt -> [PropertyFlags]
    forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
    wordToGFlags CUInt
    flags'
        freeMem name
        freeMem type_
        freeMem flags
        return (result', name'', type_'', flags'')

    -- function query_termprop
    -- Args: [ Arg
    --           { argCName = "name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a termprop name" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "resolved_name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char**"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a location to store the termprop's name"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "prop"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a location to store the termprop's ID"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "type"
    --           , argType =
    --               TInterface Name { namespace = "Vte" , name = "PropertyType" }
    --           , argCType = Just "VtePropertyType*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a location to store the termprop's type as a #VtePropertyType"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType =
    --               TInterface Name { namespace = "Vte" , name = "PropertyFlags" }
    --           , argCType = Just "VtePropertyFlags*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a location to store the termprop's flags as a #VtePropertyFlags"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_query_termprop" vte_query_termprop ::
        CString ->                              -- name : TBasicType TUTF8
        Ptr CString ->                          -- resolved_name : TBasicType TUTF8
        Ptr Int32 ->                            -- prop : TBasicType TInt
        Ptr CUInt ->                            -- type : TInterface (Name {namespace = "Vte", name = "PropertyType"})
        Ptr CUInt ->                            -- flags : TInterface (Name {namespace = "Vte", name = "PropertyFlags"})
        IO CInt

    -- | Gets the property type of the termprop. For properties installed by
    -- 'GI.Vte.Functions.installTermprop', the name starts with \"vte.ext.\".
    --
    -- For an alias termprop (see 'GI.Vte.Functions.installTermpropAlias'), /@resolvedName@/
    -- will be name of the alias\' target termprop; otherwise it will be /@name@/.
    --
    -- /Since: 0.78/
    queryTermprop ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -- ^ /@name@/: a termprop name
        -> m ((Bool, T.Text, Int32, Vte.Enums.PropertyType, [Vte.Flags.PropertyFlags]))
        -- ^ __Returns:__ 'P.True' iff the termprop exists, and then /@prop@/, /@type@/ and
        --   /@flags@/ will be filled in
    queryTermprop :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Text -> m (Bool, Text, Int32, PropertyType, [PropertyFlags])
    queryTermprop Text
    name = IO (Bool, Text, Int32, PropertyType, [PropertyFlags])
    -> m (Bool, Text, Int32, PropertyType, [PropertyFlags])
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Bool, Text, Int32, PropertyType, [PropertyFlags])
     -> m (Bool, Text, Int32, PropertyType, [PropertyFlags]))
    -> IO (Bool, Text, Int32, PropertyType, [PropertyFlags])
    -> m (Bool, Text, Int32, PropertyType, [PropertyFlags])
    forall a b. (a -> b) -> a -> b
    $ do
        name' <- Text -> IO CString
    textToCString Text
    name
        resolvedName <- callocMem :: IO (Ptr CString)
        prop <- allocMem :: IO (Ptr Int32)
        type_ <- allocMem :: IO (Ptr CUInt)
        flags <- allocMem :: IO (Ptr CUInt)
        result <- vte_query_termprop name' resolvedName prop type_ flags
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        resolvedName' <- peek resolvedName
        resolvedName'' <- cstringToText resolvedName'
        prop' <- peek prop
        type_' <- peek type_
        let type_'' = (Int -> PropertyType
    forall a. Enum a => Int -> a
    toEnum (Int -> PropertyType) -> (CUInt -> Int) -> CUInt -> PropertyType
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    type_'
        flags' <- peek flags
        let flags'' = CUInt -> [PropertyFlags]
    forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
    wordToGFlags CUInt
    flags'
        freeMem name'
        freeMem resolvedName
        freeMem prop
        freeMem type_
        freeMem flags
        return (result', resolvedName'', prop', type_'', flags'')

    -- function install_termprop_alias
    -- Args: [ Arg
    --           { argCName = "name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a namespaced property name"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "target_name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the target property name"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_install_termprop_alias" vte_install_termprop_alias ::
        CString ->                              -- name : TBasicType TUTF8
        CString ->                              -- target_name : TBasicType TUTF8
        IO Int32

    -- | Installs a new terminal property /@name@/ as an alias for the terminal
    -- property /@targetName@/.
    --
    -- /Since: 0.78/
    installTermpropAlias ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -- ^ /@name@/: a namespaced property name
        -> T.Text
        -- ^ /@targetName@/: the target property name
        -> m Int32
        -- ^ __Returns:__ the ID for the termprop /@targetName@/
    installTermpropAlias :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Text -> Text -> m Int32
    installTermpropAlias Text
    name Text
    targetName = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        name' <- Text -> IO CString
    textToCString Text
    name
        targetName' <- textToCString targetName
        result <- vte_install_termprop_alias name' targetName'
        freeMem name'
        freeMem targetName'
        return result

    -- function install_termprop
    -- Args: [ Arg
    --           { argCName = "name"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a namespaced property name"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "type"
    --           , argType =
    --               TInterface Name { namespace = "Vte" , name = "PropertyType" }
    --           , argCType = Just "VtePropertyType"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #VtePropertyType to use for the property"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType =
    --               TInterface Name { namespace = "Vte" , name = "PropertyFlags" }
    --           , argCType = Just "VtePropertyFlags"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "flags from #VtePropertyFlags"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_install_termprop" vte_install_termprop ::
        CString ->                              -- name : TBasicType TUTF8
        CUInt ->                                -- type : TInterface (Name {namespace = "Vte", name = "PropertyType"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Vte", name = "PropertyFlags"})
        IO Int32

    -- | Installs a new terminal property that can be set by the application.
    --
    -- /@name@/ must follow the rules for termprop names as laid out above; it
    -- must have at least 4 components, the first two of which must be \"vte\",
    -- and \"ext\". Use the 'GI.Vte.Constants.TERMPROP_NAME_PREFIX' macro which defines this
    -- name prefix.
    --
    -- You should use an identifier for your terminal as the first component
    -- after the prefix, as a namespace marker.
    --
    -- It is a programming error to call this function with a /@name@/ that does
    -- not meet these requirements.
    --
    -- It is a programming error to call this function after any t'GI.Vte.Objects.Terminal.Terminal'
    -- instances have been created.
    --
    -- It is a programming error to call this function if the named termprop
    -- is already installed with a different type or flags.
    --
    -- /Since: 0.78/
    installTermprop ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -- ^ /@name@/: a namespaced property name
        -> Vte.Enums.PropertyType
        -- ^ /@type@/: a t'GI.Vte.Enums.PropertyType' to use for the property
        -> [Vte.Flags.PropertyFlags]
        -- ^ /@flags@/: flags from t'GI.Vte.Flags.PropertyFlags'
        -> m Int32
        -- ^ __Returns:__ an ID for the termprop
    installTermprop :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Text -> PropertyType -> [PropertyFlags] -> m Int32
    installTermprop Text
    name PropertyType
    type_ [PropertyFlags]
    flags = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        name' <- Text -> IO CString
    textToCString Text
    name
        let type_' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (PropertyType -> Int) -> PropertyType -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PropertyType -> Int
    forall a. Enum a => a -> Int
    fromEnum) PropertyType
    type_
        let flags' = [PropertyFlags] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [PropertyFlags]
    flags
        result <- vte_install_termprop name' type_' flags'
        freeMem name'
        return result

    -- function get_user_shell
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TBasicType TFileName)
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_get_user_shell" vte_get_user_shell ::
        IO CString

    -- | Gets the user\'s shell, or 'P.Nothing'. In the latter case, the
    -- system default (usually \"\/bin\/sh\") should be used.
    getUserShell ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m [Char]
        -- ^ __Returns:__ a newly allocated string with the
        --   user\'s shell, or 'P.Nothing'
    getUserShell :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m [Char]
    getUserShell  = IO [Char] -> m [Char]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [Char] -> m [Char]) -> IO [Char] -> m [Char]
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO CString
    vte_get_user_shell
        checkUnexpectedReturnNULL "getUserShell" result
        result' <- cstringToString result
        freeMem result
        return result'

    -- function get_termprops
    -- Args: [ Arg
    --           { argCName = "length"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a location to store the length of the returned array"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "length"
    --              , argType = TBasicType TSize
    --              , argCType = Just "gsize*"
    --              , direction = DirectionOut
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText =
    --                        Just "a location to store the length of the returned array"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , argCallbackUserData = False
    --              , transfer = TransferEverything
    --              }
    --          ]
    -- returnType: Just (TCArray False (-1) 0 (TBasicType TUTF8))
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_get_termprops" vte_get_termprops ::
        Ptr FCT.CSize ->                        -- length : TBasicType TSize
        IO (Ptr CString)

    -- | Gets the names of the installed termprops in an unspecified order.
    --
    -- /Since: 0.78/
    getTermprops ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m (Maybe [T.Text])
        -- ^ __Returns:__ the names of the installed
        --   termprops, or 'P.Nothing' if there are no termprops
    getTermprops :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m (Maybe [Text])
    getTermprops  = IO (Maybe [Text]) -> m (Maybe [Text])
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe [Text]) -> m (Maybe [Text]))
    -> IO (Maybe [Text]) -> m (Maybe [Text])
    forall a b. (a -> b) -> a -> b
    $ do
        length_ <- IO (Ptr CSize)
    forall a. Storable a => IO (Ptr a)
    allocMem :: IO (Ptr FCT.CSize)
        result <- vte_get_termprops length_
        length_' <- peek length_
        maybeResult <- convertIfNonNull result $ \Ptr CString
    result' -> do
            result'' <- (CSize -> Ptr CString -> IO [Text]
    forall a.
    (HasCallStack, Integral a) =>
    a -> Ptr CString -> IO [Text]
    unpackUTF8CArrayWithLength CSize
    length_') Ptr CString
    result'
            freeMem result'
            return result''
        freeMem length_
        return maybeResult

    -- function get_minor_version
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TBasicType TUInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_get_minor_version" vte_get_minor_version ::
        IO Word32

    -- | Returns the minor version of the VTE library at runtime.
    -- Contrast this with 'GI.Vte.Constants.MINOR_VERSION' which represents
    -- the version of the VTE library that the code was compiled
    -- with.
    --
    -- /Since: 0.40/
    getMinorVersion ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Word32
        -- ^ __Returns:__ the minor version
    getMinorVersion :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
    getMinorVersion  = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO Word32
    vte_get_minor_version
        return result

    -- function get_micro_version
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TBasicType TUInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_get_micro_version" vte_get_micro_version ::
        IO Word32

    -- | Returns the micro version of the VTE library at runtime.
    -- Contrast this with 'GI.Vte.Constants.MICRO_VERSION' which represents
    -- the version of the VTE library that the code was compiled
    -- with.
    --
    -- /Since: 0.40/
    getMicroVersion ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Word32
        -- ^ __Returns:__ the micro version
    getMicroVersion :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
    getMicroVersion  = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO Word32
    vte_get_micro_version
        return result

    -- function get_major_version
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TBasicType TUInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_get_major_version" vte_get_major_version ::
        IO Word32

    -- | Returns the major version of the VTE library at runtime.
    -- Contrast this with 'GI.Vte.Constants.MAJOR_VERSION' which represents
    -- the version of the VTE library that the code was compiled
    -- with.
    --
    -- /Since: 0.40/
    getMajorVersion ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Word32
        -- ^ __Returns:__ the major version
    getMajorVersion :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
    getMajorVersion  = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO Word32
    vte_get_major_version
        return result

    -- function get_features
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_get_features" vte_get_features ::
        IO CString

    -- | Gets a list of features vte was compiled with.
    --
    -- /Since: 0.40/
    getFeatures ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m T.Text
        -- ^ __Returns:__ a string with features
    getFeatures :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Text
    getFeatures  = IO Text -> m Text
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO CString
    vte_get_features
        checkUnexpectedReturnNULL "getFeatures" result
        result' <- cstringToText result
        return result'

    -- function get_feature_flags
    -- Args: []
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Vte" , name = "FeatureFlags" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_get_feature_flags" vte_get_feature_flags ::
        IO CInt

    -- | Gets features VTE was compiled with.
    --
    -- /Since: 0.62/
    getFeatureFlags ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m [Vte.Flags.FeatureFlags]
        -- ^ __Returns:__ flags from t'GI.Vte.Flags.FeatureFlags'
    getFeatureFlags :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m [FeatureFlags]
    getFeatureFlags  = IO [FeatureFlags] -> m [FeatureFlags]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [FeatureFlags] -> m [FeatureFlags])
    -> IO [FeatureFlags] -> m [FeatureFlags]
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO CInt
    vte_get_feature_flags
        let result' = CInt -> [FeatureFlags]
    forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
    wordToGFlags CInt
    result
        return result'

    -- function get_encodings
    -- Args: [ Arg
    --           { argCName = "include_aliases"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "whether to include alias names"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TCArray True (-1) (-1) (TBasicType TUTF8))
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_get_encodings" vte_get_encodings ::
        CInt ->                                 -- include_aliases : TBasicType TBoolean
        IO (Ptr CString)

    {-# DEPRECATED getEncodings ["(Since version 0.60)"] #-}
    -- | Gets the list of supported legacy encodings.
    --
    -- If ICU support is not available, this returns an empty vector.
    -- Note that UTF-8 is always supported; you can select it by
    -- passing 'P.Nothing' to 'GI.Vte.Objects.Terminal.terminalSetEncoding'.
    --
    -- /Since: 0.60/
    getEncodings ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Bool
        -- ^ /@includeAliases@/: whether to include alias names
        -> m [T.Text]
        -- ^ __Returns:__ the list of supported encodings; free with
        --   'GI.GLib.Functions.strfreev'
    getEncodings :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Bool -> m [Text]
    getEncodings Bool
    includeAliases = IO [Text] -> m [Text]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
    forall a b. (a -> b) -> a -> b
    $ do
        let includeAliases' :: CInt
    includeAliases' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    includeAliases
        result <- CInt -> IO (Ptr CString)
    vte_get_encodings CInt
    includeAliases'
        checkUnexpectedReturnNULL "getEncodings" result
        result' <- unpackZeroTerminatedUTF8CArray result
        mapZeroTerminatedCArray freeMem result
        freeMem result
        return result'

    -- function get_encoding_supported
    -- Args: [ Arg
    --           { argCName = "encoding"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the legacy encoding"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "vte_get_encoding_supported" vte_get_encoding_supported ::
        CString ->                              -- encoding : TBasicType TUTF8
        IO CInt

    {-# DEPRECATED getEncodingSupported ["(Since version 0.60)"] #-}
    -- | Queries whether the legacy encoding /@encoding@/ is supported.
    --
    -- If ICU support is not available, this function always returns 'P.False'.
    --
    -- Note that UTF-8 is always supported; you can select it by
    -- passing 'P.Nothing' to 'GI.Vte.Objects.Terminal.terminalSetEncoding'.
    --
    -- /Since: 0.60/
    getEncodingSupported ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -- ^ /@encoding@/: the name of the legacy encoding
        -> m Bool
        -- ^ __Returns:__ 'P.True' iff the legacy encoding /@encoding@/ is supported
    getEncodingSupported :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m Bool
    getEncodingSupported Text
    encoding = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        encoding' <- Text -> IO CString
    textToCString Text
    encoding
        result <- vte_get_encoding_supported encoding'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        freeMem encoding'
        return result'