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

    -- ** eventContextGetType #method:eventContextGetType#

        eventContextGetType                     ,

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

    -- ** getUserShell #method:getUserShell#

        getUserShell                            ,

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

    -- 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
        CString
    result <- IO CString
    vte_get_user_shell
        Text -> CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "getUserShell" CString
    result
        [Char]
    result' <- HasCallStack => CString -> IO [Char]
    CString -> IO [Char]
    cstringToString CString
    result
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    result
        [Char] -> IO [Char]
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Char]
    result'

    -- 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
        Word32
    result <- IO Word32
    vte_get_minor_version
        Word32 -> IO Word32
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    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
        Word32
    result <- IO Word32
    vte_get_micro_version
        Word32 -> IO Word32
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    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
        Word32
    result <- IO Word32
    vte_get_major_version
        Word32 -> IO Word32
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    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
        CString
    result <- IO CString
    vte_get_features
        Text -> CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "getFeatures" CString
    result
        Text
    result' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result
        Text -> IO Text
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    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
        CInt
    result <- IO CInt
    vte_get_feature_flags
        let result' :: [FeatureFlags]
    result' = CInt -> [FeatureFlags]
    forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
    wordToGFlags CInt
    result
        [FeatureFlags] -> IO [FeatureFlags]
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [FeatureFlags]
    result'

    -- function get_encodings
    -- Args: [ Arg
    --           { argCName = "include_aliases"
    --           , argType = TBasicType TBoolean
    --           , 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
        Ptr CString
    result <- CInt -> IO (Ptr CString)
    vte_get_encodings CInt
    includeAliases'
        Text -> Ptr CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "getEncodings" Ptr CString
    result
        [Text]
    result' <- HasCallStack => Ptr CString -> IO [Text]
    Ptr CString -> IO [Text]
    unpackZeroTerminatedUTF8CArray Ptr CString
    result
        (CString -> IO ()) -> Ptr CString -> IO ()
    forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
    mapZeroTerminatedCArray CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr CString
    result
        Ptr CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr CString
    result
        [Text] -> IO [Text]
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Text]
    result'

    -- function get_encoding_supported
    -- Args: [ Arg
    --           { argCName = "encoding"
    --           , argType = TBasicType TUTF8
    --           , 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
        CString
    encoding' <- Text -> IO CString
    textToCString Text
    encoding
        CInt
    result <- CString -> IO CInt
    vte_get_encoding_supported CString
    encoding'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    encoding'
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

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

    foreign import ccall "vte_event_context_get_type" vte_event_context_get_type ::
        IO CGType

    -- | /No description available in the introspection data./
    eventContextGetType ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m GType
    eventContextGetType :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m GType
    eventContextGetType  = IO GType -> m GType
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GType -> m GType) -> IO GType -> m GType
    forall a b. (a -> b) -> a -> b
    $ do
        CGType
    result <- IO CGType
    vte_event_context_get_type
        let result' :: GType
    result' = CGType -> GType
    GType CGType
    result
        GType -> IO GType
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return GType
    result'