{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.WebKit2.Structs.Credential
    ( 

-- * Exported types
    Credential(..)                          ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [copy]("GI.WebKit2.Structs.Credential#g:method:copy"), [free]("GI.WebKit2.Structs.Credential#g:method:free"), [hasPassword]("GI.WebKit2.Structs.Credential#g:method:hasPassword").
-- 
-- ==== Getters
-- [getCertificate]("GI.WebKit2.Structs.Credential#g:method:getCertificate"), [getPassword]("GI.WebKit2.Structs.Credential#g:method:getPassword"), [getPersistence]("GI.WebKit2.Structs.Credential#g:method:getPersistence"), [getUsername]("GI.WebKit2.Structs.Credential#g:method:getUsername").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveCredentialMethod                 ,
#endif

-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    CredentialCopyMethodInfo                ,
#endif
    credentialCopy                          ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    CredentialFreeMethodInfo                ,
#endif
    credentialFree                          ,


-- ** getCertificate #method:getCertificate#

#if defined(ENABLE_OVERLOADING)
    CredentialGetCertificateMethodInfo      ,
#endif
    credentialGetCertificate                ,


-- ** getPassword #method:getPassword#

#if defined(ENABLE_OVERLOADING)
    CredentialGetPasswordMethodInfo         ,
#endif
    credentialGetPassword                   ,


-- ** getPersistence #method:getPersistence#

#if defined(ENABLE_OVERLOADING)
    CredentialGetPersistenceMethodInfo      ,
#endif
    credentialGetPersistence                ,


-- ** getUsername #method:getUsername#

#if defined(ENABLE_OVERLOADING)
    CredentialGetUsernameMethodInfo         ,
#endif
    credentialGetUsername                   ,


-- ** hasPassword #method:hasPassword#

#if defined(ENABLE_OVERLOADING)
    CredentialHasPasswordMethodInfo         ,
#endif
    credentialHasPassword                   ,


-- ** new #method:new#

    credentialNew                           ,


-- ** newForCertificate #method:newForCertificate#

    credentialNewForCertificate             ,


-- ** newForCertificatePin #method:newForCertificatePin#

    credentialNewForCertificatePin          ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.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

import qualified GI.Gio.Objects.TlsCertificate as Gio.TlsCertificate
import {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums

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

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

foreign import ccall "webkit_credential_get_type" c_webkit_credential_get_type :: 
    IO GType

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

instance B.Types.TypedObject Credential where
    glibType :: IO GType
glibType = IO GType
c_webkit_credential_get_type

instance B.Types.GBoxed Credential

-- | Convert 'Credential' 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 Credential) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_webkit_credential_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Credential -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Credential
P.Nothing = Ptr GValue -> Ptr Credential -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Credential
forall a. Ptr a
FP.nullPtr :: FP.Ptr Credential)
    gvalueSet_ Ptr GValue
gv (P.Just Credential
obj) = Credential -> (Ptr Credential -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Credential
obj (Ptr GValue -> Ptr Credential -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Credential)
gvalueGet_ Ptr GValue
gv = do
        Ptr Credential
ptr <- Ptr GValue -> IO (Ptr Credential)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Credential)
        if Ptr Credential
ptr Ptr Credential -> Ptr Credential -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Credential
forall a. Ptr a
FP.nullPtr
        then Credential -> Maybe Credential
forall a. a -> Maybe a
P.Just (Credential -> Maybe Credential)
-> IO Credential -> IO (Maybe Credential)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Credential -> Credential)
-> Ptr Credential -> IO Credential
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Credential -> Credential
Credential Ptr Credential
ptr
        else Maybe Credential -> IO (Maybe Credential)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Credential
forall a. Maybe a
P.Nothing
        
    


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

-- method Credential::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "username"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The username for the new credential"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "password"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The password for the new credential"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "persistence"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "CredentialPersistence" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The #WebKitCredentialPersistence of the new credential"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "WebKit2" , name = "Credential" })
-- throws : False
-- Skip return : False

foreign import ccall "webkit_credential_new" webkit_credential_new :: 
    CString ->                              -- username : TBasicType TUTF8
    CString ->                              -- password : TBasicType TUTF8
    CUInt ->                                -- persistence : TInterface (Name {namespace = "WebKit2", name = "CredentialPersistence"})
    IO (Ptr Credential)

-- | Create a new credential from the provided username, password and persistence mode.
-- 
-- /Since: 2.2/
credentialNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@username@/: The username for the new credential
    -> T.Text
    -- ^ /@password@/: The password for the new credential
    -> WebKit2.Enums.CredentialPersistence
    -- ^ /@persistence@/: The t'GI.WebKit2.Enums.CredentialPersistence' of the new credential
    -> m Credential
    -- ^ __Returns:__ A t'GI.WebKit2.Structs.Credential.Credential'.
credentialNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Text -> CredentialPersistence -> m Credential
credentialNew Text
username Text
password CredentialPersistence
persistence = IO Credential -> m Credential
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Credential -> m Credential) -> IO Credential -> m Credential
forall a b. (a -> b) -> a -> b
$ do
    CString
username' <- Text -> IO CString
textToCString Text
username
    CString
password' <- Text -> IO CString
textToCString Text
password
    let persistence' :: CUInt
persistence' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (CredentialPersistence -> Int) -> CredentialPersistence -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CredentialPersistence -> Int
forall a. Enum a => a -> Int
fromEnum) CredentialPersistence
persistence
    Ptr Credential
result <- CString -> CString -> CUInt -> IO (Ptr Credential)
webkit_credential_new CString
username' CString
password' CUInt
persistence'
    Text -> Ptr Credential -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"credentialNew" Ptr Credential
result
    Credential
result' <- ((ManagedPtr Credential -> Credential)
-> Ptr Credential -> IO Credential
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Credential -> Credential
Credential) Ptr Credential
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
username'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
password'
    Credential -> IO Credential
forall (m :: * -> *) a. Monad m => a -> m a
return Credential
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Credential::new_for_certificate
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "certificate"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "TlsCertificate" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GTlsCertificate, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "persistence"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "CredentialPersistence" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The #WebKitCredentialPersistence of the new credential"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "WebKit2" , name = "Credential" })
-- throws : False
-- Skip return : False

foreign import ccall "webkit_credential_new_for_certificate" webkit_credential_new_for_certificate :: 
    Ptr Gio.TlsCertificate.TlsCertificate -> -- certificate : TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
    CUInt ->                                -- persistence : TInterface (Name {namespace = "WebKit2", name = "CredentialPersistence"})
    IO (Ptr Credential)

-- | Create a new credential from the /@certificate@/ and persistence mode.
-- Note that 'GI.WebKit2.Enums.CredentialPersistencePermanent' is not supported for certificate credentials.
-- 
-- /Since: 2.34/
credentialNewForCertificate ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.TlsCertificate.IsTlsCertificate a) =>
    Maybe (a)
    -- ^ /@certificate@/: The t'GI.Gio.Objects.TlsCertificate.TlsCertificate', or 'P.Nothing'
    -> WebKit2.Enums.CredentialPersistence
    -- ^ /@persistence@/: The t'GI.WebKit2.Enums.CredentialPersistence' of the new credential
    -> m Credential
    -- ^ __Returns:__ A t'GI.WebKit2.Structs.Credential.Credential'.
credentialNewForCertificate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTlsCertificate a) =>
Maybe a -> CredentialPersistence -> m Credential
credentialNewForCertificate Maybe a
certificate CredentialPersistence
persistence = IO Credential -> m Credential
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Credential -> m Credential) -> IO Credential -> m Credential
forall a b. (a -> b) -> a -> b
$ do
    Ptr TlsCertificate
maybeCertificate <- case Maybe a
certificate of
        Maybe a
Nothing -> Ptr TlsCertificate -> IO (Ptr TlsCertificate)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TlsCertificate
forall a. Ptr a
nullPtr
        Just a
jCertificate -> do
            Ptr TlsCertificate
jCertificate' <- a -> IO (Ptr TlsCertificate)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCertificate
            Ptr TlsCertificate -> IO (Ptr TlsCertificate)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TlsCertificate
jCertificate'
    let persistence' :: CUInt
persistence' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (CredentialPersistence -> Int) -> CredentialPersistence -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CredentialPersistence -> Int
forall a. Enum a => a -> Int
fromEnum) CredentialPersistence
persistence
    Ptr Credential
result <- Ptr TlsCertificate -> CUInt -> IO (Ptr Credential)
webkit_credential_new_for_certificate Ptr TlsCertificate
maybeCertificate CUInt
persistence'
    Text -> Ptr Credential -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"credentialNewForCertificate" Ptr Credential
result
    Credential
result' <- ((ManagedPtr Credential -> Credential)
-> Ptr Credential -> IO Credential
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Credential -> Credential
Credential) Ptr Credential
result
    Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
certificate a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    Credential -> IO Credential
forall (m :: * -> *) a. Monad m => a -> m a
return Credential
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Credential::new_for_certificate_pin
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "pin"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The PIN for the new credential"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "persistence"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "CredentialPersistence" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The #WebKitCredentialPersistence of the new credential"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "WebKit2" , name = "Credential" })
-- throws : False
-- Skip return : False

foreign import ccall "webkit_credential_new_for_certificate_pin" webkit_credential_new_for_certificate_pin :: 
    CString ->                              -- pin : TBasicType TUTF8
    CUInt ->                                -- persistence : TInterface (Name {namespace = "WebKit2", name = "CredentialPersistence"})
    IO (Ptr Credential)

-- | Create a new credential from the provided PIN and persistence mode.
-- Note that 'GI.WebKit2.Enums.CredentialPersistencePermanent' is not supported for certificate pin credentials.
-- 
-- /Since: 2.34/
credentialNewForCertificatePin ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@pin@/: The PIN for the new credential
    -> WebKit2.Enums.CredentialPersistence
    -- ^ /@persistence@/: The t'GI.WebKit2.Enums.CredentialPersistence' of the new credential
    -> m Credential
    -- ^ __Returns:__ A t'GI.WebKit2.Structs.Credential.Credential'.
credentialNewForCertificatePin :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> CredentialPersistence -> m Credential
credentialNewForCertificatePin Text
pin CredentialPersistence
persistence = IO Credential -> m Credential
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Credential -> m Credential) -> IO Credential -> m Credential
forall a b. (a -> b) -> a -> b
$ do
    CString
pin' <- Text -> IO CString
textToCString Text
pin
    let persistence' :: CUInt
persistence' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (CredentialPersistence -> Int) -> CredentialPersistence -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CredentialPersistence -> Int
forall a. Enum a => a -> Int
fromEnum) CredentialPersistence
persistence
    Ptr Credential
result <- CString -> CUInt -> IO (Ptr Credential)
webkit_credential_new_for_certificate_pin CString
pin' CUInt
persistence'
    Text -> Ptr Credential -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"credentialNewForCertificatePin" Ptr Credential
result
    Credential
result' <- ((ManagedPtr Credential -> Credential)
-> Ptr Credential -> IO Credential
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Credential -> Credential
Credential) Ptr Credential
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
pin'
    Credential -> IO Credential
forall (m :: * -> *) a. Monad m => a -> m a
return Credential
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "webkit_credential_copy" webkit_credential_copy :: 
    Ptr Credential ->                       -- credential : TInterface (Name {namespace = "WebKit2", name = "Credential"})
    IO (Ptr Credential)

-- | Make a copy of the t'GI.WebKit2.Structs.Credential.Credential'.
-- 
-- /Since: 2.2/
credentialCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Credential
    -- ^ /@credential@/: a t'GI.WebKit2.Structs.Credential.Credential'
    -> m Credential
    -- ^ __Returns:__ A copy of passed in t'GI.WebKit2.Structs.Credential.Credential'
credentialCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Credential -> m Credential
credentialCopy Credential
credential = IO Credential -> m Credential
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Credential -> m Credential) -> IO Credential -> m Credential
forall a b. (a -> b) -> a -> b
$ do
    Ptr Credential
credential' <- Credential -> IO (Ptr Credential)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Credential
credential
    Ptr Credential
result <- Ptr Credential -> IO (Ptr Credential)
webkit_credential_copy Ptr Credential
credential'
    Text -> Ptr Credential -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"credentialCopy" Ptr Credential
result
    Credential
result' <- ((ManagedPtr Credential -> Credential)
-> Ptr Credential -> IO Credential
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Credential -> Credential
Credential) Ptr Credential
result
    Credential -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Credential
credential
    Credential -> IO Credential
forall (m :: * -> *) a. Monad m => a -> m a
return Credential
result'

#if defined(ENABLE_OVERLOADING)
data CredentialCopyMethodInfo
instance (signature ~ (m Credential), MonadIO m) => O.OverloadedMethod CredentialCopyMethodInfo Credential signature where
    overloadedMethod = credentialCopy

instance O.OverloadedMethodInfo CredentialCopyMethodInfo Credential where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Structs.Credential.credentialCopy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.28/docs/GI-WebKit2-Structs-Credential.html#v:credentialCopy"
        })


#endif

-- method Credential::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "credential"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "Credential" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitCredential"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_credential_free" webkit_credential_free :: 
    Ptr Credential ->                       -- credential : TInterface (Name {namespace = "WebKit2", name = "Credential"})
    IO ()

-- | Free the t'GI.WebKit2.Structs.Credential.Credential'.
-- 
-- /Since: 2.2/
credentialFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Credential
    -- ^ /@credential@/: A t'GI.WebKit2.Structs.Credential.Credential'
    -> m ()
credentialFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Credential -> m ()
credentialFree Credential
credential = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Credential
credential' <- Credential -> IO (Ptr Credential)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Credential
credential
    Ptr Credential -> IO ()
webkit_credential_free Ptr Credential
credential'
    Credential -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Credential
credential
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CredentialFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod CredentialFreeMethodInfo Credential signature where
    overloadedMethod = credentialFree

instance O.OverloadedMethodInfo CredentialFreeMethodInfo Credential where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Structs.Credential.credentialFree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.28/docs/GI-WebKit2-Structs-Credential.html#v:credentialFree"
        })


#endif

-- method Credential::get_certificate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "credential"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "Credential" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitCredential"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gio" , name = "TlsCertificate" })
-- throws : False
-- Skip return : False

foreign import ccall "webkit_credential_get_certificate" webkit_credential_get_certificate :: 
    Ptr Credential ->                       -- credential : TInterface (Name {namespace = "WebKit2", name = "Credential"})
    IO (Ptr Gio.TlsCertificate.TlsCertificate)

-- | Get the certificate currently held by this t'GI.WebKit2.Structs.Credential.Credential'.
-- 
-- /Since: 2.34/
credentialGetCertificate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Credential
    -- ^ /@credential@/: a t'GI.WebKit2.Structs.Credential.Credential'
    -> m Gio.TlsCertificate.TlsCertificate
    -- ^ __Returns:__ a t'GI.Gio.Objects.TlsCertificate.TlsCertificate', or 'P.Nothing'
credentialGetCertificate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Credential -> m TlsCertificate
credentialGetCertificate Credential
credential = IO TlsCertificate -> m TlsCertificate
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TlsCertificate -> m TlsCertificate)
-> IO TlsCertificate -> m TlsCertificate
forall a b. (a -> b) -> a -> b
$ do
    Ptr Credential
credential' <- Credential -> IO (Ptr Credential)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Credential
credential
    Ptr TlsCertificate
result <- Ptr Credential -> IO (Ptr TlsCertificate)
webkit_credential_get_certificate Ptr Credential
credential'
    Text -> Ptr TlsCertificate -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"credentialGetCertificate" Ptr TlsCertificate
result
    TlsCertificate
result' <- ((ManagedPtr TlsCertificate -> TlsCertificate)
-> Ptr TlsCertificate -> IO TlsCertificate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TlsCertificate -> TlsCertificate
Gio.TlsCertificate.TlsCertificate) Ptr TlsCertificate
result
    Credential -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Credential
credential
    TlsCertificate -> IO TlsCertificate
forall (m :: * -> *) a. Monad m => a -> m a
return TlsCertificate
result'

#if defined(ENABLE_OVERLOADING)
data CredentialGetCertificateMethodInfo
instance (signature ~ (m Gio.TlsCertificate.TlsCertificate), MonadIO m) => O.OverloadedMethod CredentialGetCertificateMethodInfo Credential signature where
    overloadedMethod = credentialGetCertificate

instance O.OverloadedMethodInfo CredentialGetCertificateMethodInfo Credential where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Structs.Credential.credentialGetCertificate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.28/docs/GI-WebKit2-Structs-Credential.html#v:credentialGetCertificate"
        })


#endif

-- method Credential::get_password
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "credential"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "Credential" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitCredential"
--                 , 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 "webkit_credential_get_password" webkit_credential_get_password :: 
    Ptr Credential ->                       -- credential : TInterface (Name {namespace = "WebKit2", name = "Credential"})
    IO CString

-- | Get the password currently held by this t'GI.WebKit2.Structs.Credential.Credential'.
-- 
-- /Since: 2.2/
credentialGetPassword ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Credential
    -- ^ /@credential@/: a t'GI.WebKit2.Structs.Credential.Credential'
    -> m T.Text
    -- ^ __Returns:__ The password stored in the t'GI.WebKit2.Structs.Credential.Credential'.
credentialGetPassword :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Credential -> m Text
credentialGetPassword Credential
credential = IO Text -> m Text
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 Credential
credential' <- Credential -> IO (Ptr Credential)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Credential
credential
    CString
result <- Ptr Credential -> IO CString
webkit_credential_get_password Ptr Credential
credential'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"credentialGetPassword" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    Credential -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Credential
credential
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data CredentialGetPasswordMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod CredentialGetPasswordMethodInfo Credential signature where
    overloadedMethod = credentialGetPassword

instance O.OverloadedMethodInfo CredentialGetPasswordMethodInfo Credential where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Structs.Credential.credentialGetPassword",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.28/docs/GI-WebKit2-Structs-Credential.html#v:credentialGetPassword"
        })


#endif

-- method Credential::get_persistence
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "credential"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "Credential" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitCredential"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "WebKit2" , name = "CredentialPersistence" })
-- throws : False
-- Skip return : False

foreign import ccall "webkit_credential_get_persistence" webkit_credential_get_persistence :: 
    Ptr Credential ->                       -- credential : TInterface (Name {namespace = "WebKit2", name = "Credential"})
    IO CUInt

-- | Get the persistence mode currently held by this t'GI.WebKit2.Structs.Credential.Credential'.
-- 
-- /Since: 2.2/
credentialGetPersistence ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Credential
    -- ^ /@credential@/: a t'GI.WebKit2.Structs.Credential.Credential'
    -> m WebKit2.Enums.CredentialPersistence
    -- ^ __Returns:__ The t'GI.WebKit2.Enums.CredentialPersistence' stored in the t'GI.WebKit2.Structs.Credential.Credential'.
credentialGetPersistence :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Credential -> m CredentialPersistence
credentialGetPersistence Credential
credential = IO CredentialPersistence -> m CredentialPersistence
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CredentialPersistence -> m CredentialPersistence)
-> IO CredentialPersistence -> m CredentialPersistence
forall a b. (a -> b) -> a -> b
$ do
    Ptr Credential
credential' <- Credential -> IO (Ptr Credential)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Credential
credential
    CUInt
result <- Ptr Credential -> IO CUInt
webkit_credential_get_persistence Ptr Credential
credential'
    let result' :: CredentialPersistence
result' = (Int -> CredentialPersistence
forall a. Enum a => Int -> a
toEnum (Int -> CredentialPersistence)
-> (CUInt -> Int) -> CUInt -> CredentialPersistence
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    Credential -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Credential
credential
    CredentialPersistence -> IO CredentialPersistence
forall (m :: * -> *) a. Monad m => a -> m a
return CredentialPersistence
result'

#if defined(ENABLE_OVERLOADING)
data CredentialGetPersistenceMethodInfo
instance (signature ~ (m WebKit2.Enums.CredentialPersistence), MonadIO m) => O.OverloadedMethod CredentialGetPersistenceMethodInfo Credential signature where
    overloadedMethod = credentialGetPersistence

instance O.OverloadedMethodInfo CredentialGetPersistenceMethodInfo Credential where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Structs.Credential.credentialGetPersistence",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.28/docs/GI-WebKit2-Structs-Credential.html#v:credentialGetPersistence"
        })


#endif

-- method Credential::get_username
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "credential"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "Credential" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitCredential"
--                 , 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 "webkit_credential_get_username" webkit_credential_get_username :: 
    Ptr Credential ->                       -- credential : TInterface (Name {namespace = "WebKit2", name = "Credential"})
    IO CString

-- | Get the username currently held by this t'GI.WebKit2.Structs.Credential.Credential'.
-- 
-- /Since: 2.2/
credentialGetUsername ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Credential
    -- ^ /@credential@/: a t'GI.WebKit2.Structs.Credential.Credential'
    -> m T.Text
    -- ^ __Returns:__ The username stored in the t'GI.WebKit2.Structs.Credential.Credential'.
credentialGetUsername :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Credential -> m Text
credentialGetUsername Credential
credential = IO Text -> m Text
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 Credential
credential' <- Credential -> IO (Ptr Credential)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Credential
credential
    CString
result <- Ptr Credential -> IO CString
webkit_credential_get_username Ptr Credential
credential'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"credentialGetUsername" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    Credential -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Credential
credential
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data CredentialGetUsernameMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod CredentialGetUsernameMethodInfo Credential signature where
    overloadedMethod = credentialGetUsername

instance O.OverloadedMethodInfo CredentialGetUsernameMethodInfo Credential where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Structs.Credential.credentialGetUsername",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.28/docs/GI-WebKit2-Structs-Credential.html#v:credentialGetUsername"
        })


#endif

-- method Credential::has_password
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "credential"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "Credential" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitCredential"
--                 , 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 "webkit_credential_has_password" webkit_credential_has_password :: 
    Ptr Credential ->                       -- credential : TInterface (Name {namespace = "WebKit2", name = "Credential"})
    IO CInt

-- | Determine whether this credential has a password stored.
-- 
-- /Since: 2.2/
credentialHasPassword ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Credential
    -- ^ /@credential@/: a t'GI.WebKit2.Structs.Credential.Credential'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the credential has a password or 'P.False' otherwise.
credentialHasPassword :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Credential -> m Bool
credentialHasPassword Credential
credential = IO Bool -> m Bool
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 Credential
credential' <- Credential -> IO (Ptr Credential)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Credential
credential
    CInt
result <- Ptr Credential -> IO CInt
webkit_credential_has_password Ptr Credential
credential'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Credential -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Credential
credential
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data CredentialHasPasswordMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod CredentialHasPasswordMethodInfo Credential signature where
    overloadedMethod = credentialHasPassword

instance O.OverloadedMethodInfo CredentialHasPasswordMethodInfo Credential where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Structs.Credential.credentialHasPassword",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.28/docs/GI-WebKit2-Structs-Credential.html#v:credentialHasPassword"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveCredentialMethod (t :: Symbol) (o :: *) :: * where
    ResolveCredentialMethod "copy" o = CredentialCopyMethodInfo
    ResolveCredentialMethod "free" o = CredentialFreeMethodInfo
    ResolveCredentialMethod "hasPassword" o = CredentialHasPasswordMethodInfo
    ResolveCredentialMethod "getCertificate" o = CredentialGetCertificateMethodInfo
    ResolveCredentialMethod "getPassword" o = CredentialGetPasswordMethodInfo
    ResolveCredentialMethod "getPersistence" o = CredentialGetPersistenceMethodInfo
    ResolveCredentialMethod "getUsername" o = CredentialGetUsernameMethodInfo
    ResolveCredentialMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveCredentialMethod t Credential, O.OverloadedMethod info Credential p) => OL.IsLabel t (Credential -> 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 ~ ResolveCredentialMethod t Credential, O.OverloadedMethod info Credential p, R.HasField t Credential p) => R.HasField t Credential p where
    getField = O.overloadedMethod @info

#endif

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

#endif