{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Represents a ssh interactive prompt.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Ggit.Structs.CredSshInteractivePrompt
    ( 

-- * Exported types
    CredSshInteractivePrompt(..)            ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [isMasked]("GI.Ggit.Structs.CredSshInteractivePrompt#g:method:isMasked"), [ref]("GI.Ggit.Structs.CredSshInteractivePrompt#g:method:ref"), [unref]("GI.Ggit.Structs.CredSshInteractivePrompt#g:method:unref").
-- 
-- ==== Getters
-- [getInstruction]("GI.Ggit.Structs.CredSshInteractivePrompt#g:method:getInstruction"), [getName]("GI.Ggit.Structs.CredSshInteractivePrompt#g:method:getName"), [getResponse]("GI.Ggit.Structs.CredSshInteractivePrompt#g:method:getResponse"), [getText]("GI.Ggit.Structs.CredSshInteractivePrompt#g:method:getText").
-- 
-- ==== Setters
-- [setResponse]("GI.Ggit.Structs.CredSshInteractivePrompt#g:method:setResponse").

#if defined(ENABLE_OVERLOADING)
    ResolveCredSshInteractivePromptMethod   ,
#endif

-- ** getInstruction #method:getInstruction#

#if defined(ENABLE_OVERLOADING)
    CredSshInteractivePromptGetInstructionMethodInfo,
#endif
    credSshInteractivePromptGetInstruction  ,


-- ** getName #method:getName#

#if defined(ENABLE_OVERLOADING)
    CredSshInteractivePromptGetNameMethodInfo,
#endif
    credSshInteractivePromptGetName         ,


-- ** getResponse #method:getResponse#

#if defined(ENABLE_OVERLOADING)
    CredSshInteractivePromptGetResponseMethodInfo,
#endif
    credSshInteractivePromptGetResponse     ,


-- ** getText #method:getText#

#if defined(ENABLE_OVERLOADING)
    CredSshInteractivePromptGetTextMethodInfo,
#endif
    credSshInteractivePromptGetText         ,


-- ** isMasked #method:isMasked#

#if defined(ENABLE_OVERLOADING)
    CredSshInteractivePromptIsMaskedMethodInfo,
#endif
    credSshInteractivePromptIsMasked        ,


-- ** new #method:new#

    credSshInteractivePromptNew             ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    CredSshInteractivePromptRefMethodInfo   ,
#endif
    credSshInteractivePromptRef             ,


-- ** setResponse #method:setResponse#

#if defined(ENABLE_OVERLOADING)
    CredSshInteractivePromptSetResponseMethodInfo,
#endif
    credSshInteractivePromptSetResponse     ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    CredSshInteractivePromptUnrefMethodInfo ,
#endif
    credSshInteractivePromptUnref           ,




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


-- | Memory-managed wrapper type.
newtype CredSshInteractivePrompt = CredSshInteractivePrompt (SP.ManagedPtr CredSshInteractivePrompt)
    deriving (CredSshInteractivePrompt -> CredSshInteractivePrompt -> Bool
(CredSshInteractivePrompt -> CredSshInteractivePrompt -> Bool)
-> (CredSshInteractivePrompt -> CredSshInteractivePrompt -> Bool)
-> Eq CredSshInteractivePrompt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CredSshInteractivePrompt -> CredSshInteractivePrompt -> Bool
== :: CredSshInteractivePrompt -> CredSshInteractivePrompt -> Bool
$c/= :: CredSshInteractivePrompt -> CredSshInteractivePrompt -> Bool
/= :: CredSshInteractivePrompt -> CredSshInteractivePrompt -> Bool
Eq)

instance SP.ManagedPtrNewtype CredSshInteractivePrompt where
    toManagedPtr :: CredSshInteractivePrompt -> ManagedPtr CredSshInteractivePrompt
toManagedPtr (CredSshInteractivePrompt ManagedPtr CredSshInteractivePrompt
p) = ManagedPtr CredSshInteractivePrompt
p

foreign import ccall "ggit_cred_ssh_interactive_prompt_get_type" c_ggit_cred_ssh_interactive_prompt_get_type :: 
    IO GType

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

instance B.Types.TypedObject CredSshInteractivePrompt where
    glibType :: IO GType
glibType = IO GType
c_ggit_cred_ssh_interactive_prompt_get_type

instance B.Types.GBoxed CredSshInteractivePrompt

-- | Convert 'CredSshInteractivePrompt' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe CredSshInteractivePrompt) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ggit_cred_ssh_interactive_prompt_get_type
    gvalueSet_ :: Ptr GValue -> Maybe CredSshInteractivePrompt -> IO ()
gvalueSet_ Ptr GValue
gv Maybe CredSshInteractivePrompt
P.Nothing = Ptr GValue -> Ptr CredSshInteractivePrompt -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr CredSshInteractivePrompt
forall a. Ptr a
FP.nullPtr :: FP.Ptr CredSshInteractivePrompt)
    gvalueSet_ Ptr GValue
gv (P.Just CredSshInteractivePrompt
obj) = CredSshInteractivePrompt
-> (Ptr CredSshInteractivePrompt -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr CredSshInteractivePrompt
obj (Ptr GValue -> Ptr CredSshInteractivePrompt -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe CredSshInteractivePrompt)
gvalueGet_ Ptr GValue
gv = do
        Ptr CredSshInteractivePrompt
ptr <- Ptr GValue -> IO (Ptr CredSshInteractivePrompt)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr CredSshInteractivePrompt)
        if Ptr CredSshInteractivePrompt
ptr Ptr CredSshInteractivePrompt
-> Ptr CredSshInteractivePrompt -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr CredSshInteractivePrompt
forall a. Ptr a
FP.nullPtr
        then CredSshInteractivePrompt -> Maybe CredSshInteractivePrompt
forall a. a -> Maybe a
P.Just (CredSshInteractivePrompt -> Maybe CredSshInteractivePrompt)
-> IO CredSshInteractivePrompt
-> IO (Maybe CredSshInteractivePrompt)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr CredSshInteractivePrompt -> CredSshInteractivePrompt)
-> Ptr CredSshInteractivePrompt -> IO CredSshInteractivePrompt
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr CredSshInteractivePrompt -> CredSshInteractivePrompt
CredSshInteractivePrompt Ptr CredSshInteractivePrompt
ptr
        else Maybe CredSshInteractivePrompt
-> IO (Maybe CredSshInteractivePrompt)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe CredSshInteractivePrompt
forall a. Maybe a
P.Nothing
        
    


#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList CredSshInteractivePrompt
type instance O.AttributeList CredSshInteractivePrompt = CredSshInteractivePromptAttributeList
type CredSshInteractivePromptAttributeList = ('[ ] :: [(Symbol, *)])
#endif

-- method CredSshInteractivePrompt::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "instruction"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "is_masked"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Ggit" , name = "CredSshInteractivePrompt" })
-- throws : False
-- Skip return : False

foreign import ccall "ggit_cred_ssh_interactive_prompt_new" ggit_cred_ssh_interactive_prompt_new :: 
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- instruction : TBasicType TUTF8
    CString ->                              -- text : TBasicType TUTF8
    CInt ->                                 -- is_masked : TBasicType TBoolean
    IO (Ptr CredSshInteractivePrompt)

-- | /No description available in the introspection data./
credSshInteractivePromptNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -> T.Text
    -> T.Text
    -> Bool
    -> m CredSshInteractivePrompt
credSshInteractivePromptNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Text -> Text -> Bool -> m CredSshInteractivePrompt
credSshInteractivePromptNew Text
name Text
instruction Text
text Bool
isMasked = IO CredSshInteractivePrompt -> m CredSshInteractivePrompt
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CredSshInteractivePrompt -> m CredSshInteractivePrompt)
-> IO CredSshInteractivePrompt -> m CredSshInteractivePrompt
forall a b. (a -> b) -> a -> b
$ do
    CString
name' <- Text -> IO CString
textToCString Text
name
    CString
instruction' <- Text -> IO CString
textToCString Text
instruction
    CString
text' <- Text -> IO CString
textToCString Text
text
    let isMasked' :: CInt
isMasked' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
fromEnum) Bool
isMasked
    Ptr CredSshInteractivePrompt
result <- CString
-> CString -> CString -> CInt -> IO (Ptr CredSshInteractivePrompt)
ggit_cred_ssh_interactive_prompt_new CString
name' CString
instruction' CString
text' CInt
isMasked'
    Text -> Ptr CredSshInteractivePrompt -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"credSshInteractivePromptNew" Ptr CredSshInteractivePrompt
result
    CredSshInteractivePrompt
result' <- ((ManagedPtr CredSshInteractivePrompt -> CredSshInteractivePrompt)
-> Ptr CredSshInteractivePrompt -> IO CredSshInteractivePrompt
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr CredSshInteractivePrompt -> CredSshInteractivePrompt
CredSshInteractivePrompt) Ptr CredSshInteractivePrompt
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
instruction'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
text'
    CredSshInteractivePrompt -> IO CredSshInteractivePrompt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CredSshInteractivePrompt
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method CredSshInteractivePrompt::get_instruction
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "prompt"
--           , argType =
--               TInterface
--                 Name { namespace = "Ggit" , name = "CredSshInteractivePrompt" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "ggit_cred_ssh_interactive_prompt_get_instruction" ggit_cred_ssh_interactive_prompt_get_instruction :: 
    Ptr CredSshInteractivePrompt ->         -- prompt : TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"})
    IO CString

-- | /No description available in the introspection data./
credSshInteractivePromptGetInstruction ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CredSshInteractivePrompt
    -> m T.Text
credSshInteractivePromptGetInstruction :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CredSshInteractivePrompt -> m Text
credSshInteractivePromptGetInstruction CredSshInteractivePrompt
prompt = 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
    Ptr CredSshInteractivePrompt
prompt' <- CredSshInteractivePrompt -> IO (Ptr CredSshInteractivePrompt)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CredSshInteractivePrompt
prompt
    CString
result <- Ptr CredSshInteractivePrompt -> IO CString
ggit_cred_ssh_interactive_prompt_get_instruction Ptr CredSshInteractivePrompt
prompt'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"credSshInteractivePromptGetInstruction" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CredSshInteractivePrompt -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CredSshInteractivePrompt
prompt
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data CredSshInteractivePromptGetInstructionMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod CredSshInteractivePromptGetInstructionMethodInfo CredSshInteractivePrompt signature where
    overloadedMethod = credSshInteractivePromptGetInstruction

instance O.OverloadedMethodInfo CredSshInteractivePromptGetInstructionMethodInfo CredSshInteractivePrompt where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.CredSshInteractivePrompt.credSshInteractivePromptGetInstruction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-CredSshInteractivePrompt.html#v:credSshInteractivePromptGetInstruction"
        })


#endif

-- method CredSshInteractivePrompt::get_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "prompt"
--           , argType =
--               TInterface
--                 Name { namespace = "Ggit" , name = "CredSshInteractivePrompt" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "ggit_cred_ssh_interactive_prompt_get_name" ggit_cred_ssh_interactive_prompt_get_name :: 
    Ptr CredSshInteractivePrompt ->         -- prompt : TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"})
    IO CString

-- | /No description available in the introspection data./
credSshInteractivePromptGetName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CredSshInteractivePrompt
    -> m T.Text
credSshInteractivePromptGetName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CredSshInteractivePrompt -> m Text
credSshInteractivePromptGetName CredSshInteractivePrompt
prompt = 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
    Ptr CredSshInteractivePrompt
prompt' <- CredSshInteractivePrompt -> IO (Ptr CredSshInteractivePrompt)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CredSshInteractivePrompt
prompt
    CString
result <- Ptr CredSshInteractivePrompt -> IO CString
ggit_cred_ssh_interactive_prompt_get_name Ptr CredSshInteractivePrompt
prompt'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"credSshInteractivePromptGetName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CredSshInteractivePrompt -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CredSshInteractivePrompt
prompt
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data CredSshInteractivePromptGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod CredSshInteractivePromptGetNameMethodInfo CredSshInteractivePrompt signature where
    overloadedMethod = credSshInteractivePromptGetName

instance O.OverloadedMethodInfo CredSshInteractivePromptGetNameMethodInfo CredSshInteractivePrompt where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.CredSshInteractivePrompt.credSshInteractivePromptGetName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-CredSshInteractivePrompt.html#v:credSshInteractivePromptGetName"
        })


#endif

-- method CredSshInteractivePrompt::get_response
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "prompt"
--           , argType =
--               TInterface
--                 Name { namespace = "Ggit" , name = "CredSshInteractivePrompt" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "ggit_cred_ssh_interactive_prompt_get_response" ggit_cred_ssh_interactive_prompt_get_response :: 
    Ptr CredSshInteractivePrompt ->         -- prompt : TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"})
    IO CString

-- | /No description available in the introspection data./
credSshInteractivePromptGetResponse ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CredSshInteractivePrompt
    -> m T.Text
credSshInteractivePromptGetResponse :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CredSshInteractivePrompt -> m Text
credSshInteractivePromptGetResponse CredSshInteractivePrompt
prompt = 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
    Ptr CredSshInteractivePrompt
prompt' <- CredSshInteractivePrompt -> IO (Ptr CredSshInteractivePrompt)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CredSshInteractivePrompt
prompt
    CString
result <- Ptr CredSshInteractivePrompt -> IO CString
ggit_cred_ssh_interactive_prompt_get_response Ptr CredSshInteractivePrompt
prompt'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"credSshInteractivePromptGetResponse" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CredSshInteractivePrompt -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CredSshInteractivePrompt
prompt
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data CredSshInteractivePromptGetResponseMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod CredSshInteractivePromptGetResponseMethodInfo CredSshInteractivePrompt signature where
    overloadedMethod = credSshInteractivePromptGetResponse

instance O.OverloadedMethodInfo CredSshInteractivePromptGetResponseMethodInfo CredSshInteractivePrompt where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.CredSshInteractivePrompt.credSshInteractivePromptGetResponse",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-CredSshInteractivePrompt.html#v:credSshInteractivePromptGetResponse"
        })


#endif

-- method CredSshInteractivePrompt::get_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "prompt"
--           , argType =
--               TInterface
--                 Name { namespace = "Ggit" , name = "CredSshInteractivePrompt" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "ggit_cred_ssh_interactive_prompt_get_text" ggit_cred_ssh_interactive_prompt_get_text :: 
    Ptr CredSshInteractivePrompt ->         -- prompt : TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"})
    IO CString

-- | /No description available in the introspection data./
credSshInteractivePromptGetText ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CredSshInteractivePrompt
    -> m T.Text
credSshInteractivePromptGetText :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CredSshInteractivePrompt -> m Text
credSshInteractivePromptGetText CredSshInteractivePrompt
prompt = 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
    Ptr CredSshInteractivePrompt
prompt' <- CredSshInteractivePrompt -> IO (Ptr CredSshInteractivePrompt)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CredSshInteractivePrompt
prompt
    CString
result <- Ptr CredSshInteractivePrompt -> IO CString
ggit_cred_ssh_interactive_prompt_get_text Ptr CredSshInteractivePrompt
prompt'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"credSshInteractivePromptGetText" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CredSshInteractivePrompt -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CredSshInteractivePrompt
prompt
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data CredSshInteractivePromptGetTextMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod CredSshInteractivePromptGetTextMethodInfo CredSshInteractivePrompt signature where
    overloadedMethod = credSshInteractivePromptGetText

instance O.OverloadedMethodInfo CredSshInteractivePromptGetTextMethodInfo CredSshInteractivePrompt where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.CredSshInteractivePrompt.credSshInteractivePromptGetText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-CredSshInteractivePrompt.html#v:credSshInteractivePromptGetText"
        })


#endif

-- method CredSshInteractivePrompt::is_masked
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "prompt"
--           , argType =
--               TInterface
--                 Name { namespace = "Ggit" , name = "CredSshInteractivePrompt" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ggit_cred_ssh_interactive_prompt_is_masked" ggit_cred_ssh_interactive_prompt_is_masked :: 
    Ptr CredSshInteractivePrompt ->         -- prompt : TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"})
    IO CInt

-- | /No description available in the introspection data./
credSshInteractivePromptIsMasked ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CredSshInteractivePrompt
    -> m Bool
credSshInteractivePromptIsMasked :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CredSshInteractivePrompt -> m Bool
credSshInteractivePromptIsMasked CredSshInteractivePrompt
prompt = 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
    Ptr CredSshInteractivePrompt
prompt' <- CredSshInteractivePrompt -> IO (Ptr CredSshInteractivePrompt)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CredSshInteractivePrompt
prompt
    CInt
result <- Ptr CredSshInteractivePrompt -> IO CInt
ggit_cred_ssh_interactive_prompt_is_masked Ptr CredSshInteractivePrompt
prompt'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CredSshInteractivePrompt -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CredSshInteractivePrompt
prompt
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data CredSshInteractivePromptIsMaskedMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod CredSshInteractivePromptIsMaskedMethodInfo CredSshInteractivePrompt signature where
    overloadedMethod = credSshInteractivePromptIsMasked

instance O.OverloadedMethodInfo CredSshInteractivePromptIsMaskedMethodInfo CredSshInteractivePrompt where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.CredSshInteractivePrompt.credSshInteractivePromptIsMasked",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-CredSshInteractivePrompt.html#v:credSshInteractivePromptIsMasked"
        })


#endif

-- method CredSshInteractivePrompt::ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "prompt"
--           , argType =
--               TInterface
--                 Name { namespace = "Ggit" , name = "CredSshInteractivePrompt" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Ggit" , name = "CredSshInteractivePrompt" })
-- throws : False
-- Skip return : False

foreign import ccall "ggit_cred_ssh_interactive_prompt_ref" ggit_cred_ssh_interactive_prompt_ref :: 
    Ptr CredSshInteractivePrompt ->         -- prompt : TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"})
    IO (Ptr CredSshInteractivePrompt)

-- | /No description available in the introspection data./
credSshInteractivePromptRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CredSshInteractivePrompt
    -> m CredSshInteractivePrompt
credSshInteractivePromptRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CredSshInteractivePrompt -> m CredSshInteractivePrompt
credSshInteractivePromptRef CredSshInteractivePrompt
prompt = IO CredSshInteractivePrompt -> m CredSshInteractivePrompt
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CredSshInteractivePrompt -> m CredSshInteractivePrompt)
-> IO CredSshInteractivePrompt -> m CredSshInteractivePrompt
forall a b. (a -> b) -> a -> b
$ do
    Ptr CredSshInteractivePrompt
prompt' <- CredSshInteractivePrompt -> IO (Ptr CredSshInteractivePrompt)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CredSshInteractivePrompt
prompt
    Ptr CredSshInteractivePrompt
result <- Ptr CredSshInteractivePrompt -> IO (Ptr CredSshInteractivePrompt)
ggit_cred_ssh_interactive_prompt_ref Ptr CredSshInteractivePrompt
prompt'
    Text -> Ptr CredSshInteractivePrompt -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"credSshInteractivePromptRef" Ptr CredSshInteractivePrompt
result
    CredSshInteractivePrompt
result' <- ((ManagedPtr CredSshInteractivePrompt -> CredSshInteractivePrompt)
-> Ptr CredSshInteractivePrompt -> IO CredSshInteractivePrompt
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr CredSshInteractivePrompt -> CredSshInteractivePrompt
CredSshInteractivePrompt) Ptr CredSshInteractivePrompt
result
    CredSshInteractivePrompt -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CredSshInteractivePrompt
prompt
    CredSshInteractivePrompt -> IO CredSshInteractivePrompt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CredSshInteractivePrompt
result'

#if defined(ENABLE_OVERLOADING)
data CredSshInteractivePromptRefMethodInfo
instance (signature ~ (m CredSshInteractivePrompt), MonadIO m) => O.OverloadedMethod CredSshInteractivePromptRefMethodInfo CredSshInteractivePrompt signature where
    overloadedMethod = credSshInteractivePromptRef

instance O.OverloadedMethodInfo CredSshInteractivePromptRefMethodInfo CredSshInteractivePrompt where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.CredSshInteractivePrompt.credSshInteractivePromptRef",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-CredSshInteractivePrompt.html#v:credSshInteractivePromptRef"
        })


#endif

-- method CredSshInteractivePrompt::set_response
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "prompt"
--           , argType =
--               TInterface
--                 Name { namespace = "Ggit" , name = "CredSshInteractivePrompt" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "response"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_cred_ssh_interactive_prompt_set_response" ggit_cred_ssh_interactive_prompt_set_response :: 
    Ptr CredSshInteractivePrompt ->         -- prompt : TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"})
    CString ->                              -- response : TBasicType TUTF8
    IO ()

-- | /No description available in the introspection data./
credSshInteractivePromptSetResponse ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CredSshInteractivePrompt
    -> T.Text
    -> m ()
credSshInteractivePromptSetResponse :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CredSshInteractivePrompt -> Text -> m ()
credSshInteractivePromptSetResponse CredSshInteractivePrompt
prompt Text
response = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr CredSshInteractivePrompt
prompt' <- CredSshInteractivePrompt -> IO (Ptr CredSshInteractivePrompt)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CredSshInteractivePrompt
prompt
    CString
response' <- Text -> IO CString
textToCString Text
response
    Ptr CredSshInteractivePrompt -> CString -> IO ()
ggit_cred_ssh_interactive_prompt_set_response Ptr CredSshInteractivePrompt
prompt' CString
response'
    CredSshInteractivePrompt -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CredSshInteractivePrompt
prompt
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
response'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CredSshInteractivePromptSetResponseMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod CredSshInteractivePromptSetResponseMethodInfo CredSshInteractivePrompt signature where
    overloadedMethod = credSshInteractivePromptSetResponse

instance O.OverloadedMethodInfo CredSshInteractivePromptSetResponseMethodInfo CredSshInteractivePrompt where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.CredSshInteractivePrompt.credSshInteractivePromptSetResponse",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-CredSshInteractivePrompt.html#v:credSshInteractivePromptSetResponse"
        })


#endif

-- method CredSshInteractivePrompt::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "prompt"
--           , argType =
--               TInterface
--                 Name { namespace = "Ggit" , name = "CredSshInteractivePrompt" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_cred_ssh_interactive_prompt_unref" ggit_cred_ssh_interactive_prompt_unref :: 
    Ptr CredSshInteractivePrompt ->         -- prompt : TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"})
    IO ()

-- | /No description available in the introspection data./
credSshInteractivePromptUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CredSshInteractivePrompt
    -> m ()
credSshInteractivePromptUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CredSshInteractivePrompt -> m ()
credSshInteractivePromptUnref CredSshInteractivePrompt
prompt = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr CredSshInteractivePrompt
prompt' <- CredSshInteractivePrompt -> IO (Ptr CredSshInteractivePrompt)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CredSshInteractivePrompt
prompt
    Ptr CredSshInteractivePrompt -> IO ()
ggit_cred_ssh_interactive_prompt_unref Ptr CredSshInteractivePrompt
prompt'
    CredSshInteractivePrompt -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CredSshInteractivePrompt
prompt
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CredSshInteractivePromptUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod CredSshInteractivePromptUnrefMethodInfo CredSshInteractivePrompt signature where
    overloadedMethod = credSshInteractivePromptUnref

instance O.OverloadedMethodInfo CredSshInteractivePromptUnrefMethodInfo CredSshInteractivePrompt where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.CredSshInteractivePrompt.credSshInteractivePromptUnref",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-CredSshInteractivePrompt.html#v:credSshInteractivePromptUnref"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveCredSshInteractivePromptMethod (t :: Symbol) (o :: *) :: * where
    ResolveCredSshInteractivePromptMethod "isMasked" o = CredSshInteractivePromptIsMaskedMethodInfo
    ResolveCredSshInteractivePromptMethod "ref" o = CredSshInteractivePromptRefMethodInfo
    ResolveCredSshInteractivePromptMethod "unref" o = CredSshInteractivePromptUnrefMethodInfo
    ResolveCredSshInteractivePromptMethod "getInstruction" o = CredSshInteractivePromptGetInstructionMethodInfo
    ResolveCredSshInteractivePromptMethod "getName" o = CredSshInteractivePromptGetNameMethodInfo
    ResolveCredSshInteractivePromptMethod "getResponse" o = CredSshInteractivePromptGetResponseMethodInfo
    ResolveCredSshInteractivePromptMethod "getText" o = CredSshInteractivePromptGetTextMethodInfo
    ResolveCredSshInteractivePromptMethod "setResponse" o = CredSshInteractivePromptSetResponseMethodInfo
    ResolveCredSshInteractivePromptMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveCredSshInteractivePromptMethod t CredSshInteractivePrompt, O.OverloadedMethod info CredSshInteractivePrompt p) => OL.IsLabel t (CredSshInteractivePrompt -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveCredSshInteractivePromptMethod t CredSshInteractivePrompt, O.OverloadedMethod info CredSshInteractivePrompt p, R.HasField t CredSshInteractivePrompt p) => R.HasField t CredSshInteractivePrompt p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveCredSshInteractivePromptMethod t CredSshInteractivePrompt, O.OverloadedMethodInfo info CredSshInteractivePrompt) => OL.IsLabel t (O.MethodProxy info CredSshInteractivePrompt) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif