    {- |
    Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    License    : LGPL-2.1
    Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

    'GI.Gio.Objects.TlsDatabase.TlsDatabase' is used to lookup certificates and other information
    from a certificate or key store. It is an abstract base class which
    TLS library specific subtypes override.

    A 'GI.Gio.Objects.TlsDatabase.TlsDatabase' may be accessed from multiple threads by the TLS backend.
    All implementations are required to be fully thread-safe.

    Most common client applications will not directly interact with
    'GI.Gio.Objects.TlsDatabase.TlsDatabase'. It is used internally by 'GI.Gio.Objects.TlsConnection.TlsConnection'.

    /Since: 2.30/
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.TlsDatabase
        (

    -- * Exported types
        TlsDatabase(..)                         ,
        IsTlsDatabase                           ,
        toTlsDatabase                           ,
        noTlsDatabase                           ,

     -- * Methods
    -- ** createCertificateHandle #method:createCertificateHandle#

    #if ENABLE_OVERLOADING
        TlsDatabaseCreateCertificateHandleMethodInfo,
    #endif
        tlsDatabaseCreateCertificateHandle      ,

    -- ** lookupCertificateForHandle #method:lookupCertificateForHandle#

    #if ENABLE_OVERLOADING
        TlsDatabaseLookupCertificateForHandleMethodInfo,
    #endif
        tlsDatabaseLookupCertificateForHandle   ,

    -- ** lookupCertificateForHandleAsync #method:lookupCertificateForHandleAsync#

    #if ENABLE_OVERLOADING
        TlsDatabaseLookupCertificateForHandleAsyncMethodInfo,
    #endif
        tlsDatabaseLookupCertificateForHandleAsync,

    -- ** lookupCertificateForHandleFinish #method:lookupCertificateForHandleFinish#

    #if ENABLE_OVERLOADING
        TlsDatabaseLookupCertificateForHandleFinishMethodInfo,
    #endif
        tlsDatabaseLookupCertificateForHandleFinish,

    -- ** lookupCertificateIssuer #method:lookupCertificateIssuer#

    #if ENABLE_OVERLOADING
        TlsDatabaseLookupCertificateIssuerMethodInfo,
    #endif
        tlsDatabaseLookupCertificateIssuer      ,

    -- ** lookupCertificateIssuerAsync #method:lookupCertificateIssuerAsync#

    #if ENABLE_OVERLOADING
        TlsDatabaseLookupCertificateIssuerAsyncMethodInfo,
    #endif
        tlsDatabaseLookupCertificateIssuerAsync ,

    -- ** lookupCertificateIssuerFinish #method:lookupCertificateIssuerFinish#

    #if ENABLE_OVERLOADING
        TlsDatabaseLookupCertificateIssuerFinishMethodInfo,
    #endif
        tlsDatabaseLookupCertificateIssuerFinish,

    -- ** lookupCertificatesIssuedBy #method:lookupCertificatesIssuedBy#

    #if ENABLE_OVERLOADING
        TlsDatabaseLookupCertificatesIssuedByMethodInfo,
    #endif
        tlsDatabaseLookupCertificatesIssuedBy   ,

    -- ** lookupCertificatesIssuedByAsync #method:lookupCertificatesIssuedByAsync#

    #if ENABLE_OVERLOADING
        TlsDatabaseLookupCertificatesIssuedByAsyncMethodInfo,
    #endif
        tlsDatabaseLookupCertificatesIssuedByAsync,

    -- ** lookupCertificatesIssuedByFinish #method:lookupCertificatesIssuedByFinish#

    #if ENABLE_OVERLOADING
        TlsDatabaseLookupCertificatesIssuedByFinishMethodInfo,
    #endif
        tlsDatabaseLookupCertificatesIssuedByFinish,

    -- ** verifyChain #method:verifyChain#

    #if ENABLE_OVERLOADING
        TlsDatabaseVerifyChainMethodInfo        ,
    #endif
        tlsDatabaseVerifyChain                  ,

    -- ** verifyChainAsync #method:verifyChainAsync#

    #if ENABLE_OVERLOADING
        TlsDatabaseVerifyChainAsyncMethodInfo   ,
    #endif
        tlsDatabaseVerifyChainAsync             ,

    -- ** verifyChainFinish #method:verifyChainFinish#

    #if ENABLE_OVERLOADING
        TlsDatabaseVerifyChainFinishMethodInfo  ,
    #endif
        tlsDatabaseVerifyChainFinish            ,

        ) 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.ManagedPtr as B.ManagedPtr
    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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gio.Callbacks as Gio.Callbacks
    import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
    import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.SocketConnectable as Gio.SocketConnectable
    import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
    import {-# SOURCE #-} qualified GI.Gio.Objects.TlsCertificate as Gio.TlsCertificate
    import {-# SOURCE #-} qualified GI.Gio.Objects.TlsInteraction as Gio.TlsInteraction

    -- | Memory-managed wrapper type.
    newtype TlsDatabase = TlsDatabase (ManagedPtr TlsDatabase)
    foreign import ccall "g_tls_database_get_type"
        c_g_tls_database_get_type :: IO GType

    instance GObject TlsDatabase where
        gobjectType _ = c_g_tls_database_get_type

    -- | Type class for types which can be safely cast to `TlsDatabase`, for instance with `toTlsDatabase`.
    class GObject o => IsTlsDatabase o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError TlsDatabase a) =>
        IsTlsDatabase a
    #endif
    instance IsTlsDatabase TlsDatabase
    instance GObject.Object.IsObject TlsDatabase

    -- | Cast to `TlsDatabase`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toTlsDatabase :: (MonadIO m, IsTlsDatabase o) => o -> m TlsDatabase
    toTlsDatabase = liftIO . unsafeCastTo TlsDatabase

    -- | A convenience alias for `Nothing` :: `Maybe` `TlsDatabase`.
    noTlsDatabase :: Maybe TlsDatabase
    noTlsDatabase = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveTlsDatabaseMethod (t :: Symbol) (o :: *) :: * where
        ResolveTlsDatabaseMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveTlsDatabaseMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveTlsDatabaseMethod "createCertificateHandle" o = TlsDatabaseCreateCertificateHandleMethodInfo
        ResolveTlsDatabaseMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveTlsDatabaseMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveTlsDatabaseMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveTlsDatabaseMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveTlsDatabaseMethod "lookupCertificateForHandle" o = TlsDatabaseLookupCertificateForHandleMethodInfo
        ResolveTlsDatabaseMethod "lookupCertificateForHandleAsync" o = TlsDatabaseLookupCertificateForHandleAsyncMethodInfo
        ResolveTlsDatabaseMethod "lookupCertificateForHandleFinish" o = TlsDatabaseLookupCertificateForHandleFinishMethodInfo
        ResolveTlsDatabaseMethod "lookupCertificateIssuer" o = TlsDatabaseLookupCertificateIssuerMethodInfo
        ResolveTlsDatabaseMethod "lookupCertificateIssuerAsync" o = TlsDatabaseLookupCertificateIssuerAsyncMethodInfo
        ResolveTlsDatabaseMethod "lookupCertificateIssuerFinish" o = TlsDatabaseLookupCertificateIssuerFinishMethodInfo
        ResolveTlsDatabaseMethod "lookupCertificatesIssuedBy" o = TlsDatabaseLookupCertificatesIssuedByMethodInfo
        ResolveTlsDatabaseMethod "lookupCertificatesIssuedByAsync" o = TlsDatabaseLookupCertificatesIssuedByAsyncMethodInfo
        ResolveTlsDatabaseMethod "lookupCertificatesIssuedByFinish" o = TlsDatabaseLookupCertificatesIssuedByFinishMethodInfo
        ResolveTlsDatabaseMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveTlsDatabaseMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveTlsDatabaseMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveTlsDatabaseMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveTlsDatabaseMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveTlsDatabaseMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveTlsDatabaseMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveTlsDatabaseMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveTlsDatabaseMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveTlsDatabaseMethod "verifyChain" o = TlsDatabaseVerifyChainMethodInfo
        ResolveTlsDatabaseMethod "verifyChainAsync" o = TlsDatabaseVerifyChainAsyncMethodInfo
        ResolveTlsDatabaseMethod "verifyChainFinish" o = TlsDatabaseVerifyChainFinishMethodInfo
        ResolveTlsDatabaseMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveTlsDatabaseMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveTlsDatabaseMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveTlsDatabaseMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveTlsDatabaseMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveTlsDatabaseMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveTlsDatabaseMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveTlsDatabaseMethod t TlsDatabase, O.MethodInfo info TlsDatabase p) => O.IsLabelProxy t (TlsDatabase -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveTlsDatabaseMethod t TlsDatabase, O.MethodInfo info TlsDatabase p) => O.IsLabel t (TlsDatabase -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #else
        fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #endif
    #endif

    #endif

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

    #if ENABLE_OVERLOADING
    #endif

    #if ENABLE_OVERLOADING
    type instance O.SignalList TlsDatabase = TlsDatabaseSignalList
    type TlsDatabaseSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

    #endif

    -- method TlsDatabase::create_certificate_handle
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "certificate", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificate"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "certificate for which to create a handle.", 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 "g_tls_database_create_certificate_handle" g_tls_database_create_certificate_handle ::
        Ptr TlsDatabase ->                      -- self : TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
        Ptr Gio.TlsCertificate.TlsCertificate -> -- certificate : TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
        IO CString

    {- |
    Create a handle string for the certificate. The database will only be able
    to create a handle for certificates that originate from the database. In
    cases where the database cannot create a handle for a certificate, 'Nothing'
    will be returned.

    This handle should be stable across various instances of the application,
    and between applications. If a certificate is modified in the database,
    then it is not guaranteed that this handle will continue to point to it.

    /Since: 2.30/
    -}
    tlsDatabaseCreateCertificateHandle ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsDatabase a, Gio.TlsCertificate.IsTlsCertificate b) =>
        a
        {- ^ /@self@/: a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' -}
        -> b
        {- ^ /@certificate@/: certificate for which to create a handle. -}
        -> m (Maybe T.Text)
        {- ^ __Returns:__ a newly allocated string containing the
    handle. -}
    tlsDatabaseCreateCertificateHandle self certificate = liftIO $ do
        self' <- unsafeManagedPtrCastPtr self
        certificate' <- unsafeManagedPtrCastPtr certificate
        result <- g_tls_database_create_certificate_handle self' certificate'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- cstringToText result'
            freeMem result'
            return result''
        touchManagedPtr self
        touchManagedPtr certificate
        return maybeResult

    #if ENABLE_OVERLOADING
    data TlsDatabaseCreateCertificateHandleMethodInfo
    instance (signature ~ (b -> m (Maybe T.Text)), MonadIO m, IsTlsDatabase a, Gio.TlsCertificate.IsTlsCertificate b) => O.MethodInfo TlsDatabaseCreateCertificateHandleMethodInfo a signature where
        overloadedMethod _ = tlsDatabaseCreateCertificateHandle

    #endif

    -- method TlsDatabase::lookup_certificate_for_handle
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "handle", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a certificate handle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interaction", argType = TInterface (Name {namespace = "Gio", name = "TlsInteraction"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "used to interact with the user if necessary", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabaseLookupFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags which affect the lookup.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "TlsCertificate"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_tls_database_lookup_certificate_for_handle" g_tls_database_lookup_certificate_for_handle ::
        Ptr TlsDatabase ->                      -- self : TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
        CString ->                              -- handle : TBasicType TUTF8
        Ptr Gio.TlsInteraction.TlsInteraction -> -- interaction : TInterface (Name {namespace = "Gio", name = "TlsInteraction"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "TlsDatabaseLookupFlags"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Gio.TlsCertificate.TlsCertificate)

    {- |
    Lookup a certificate by its handle.

    The handle should have been created by calling
    'GI.Gio.Objects.TlsDatabase.tlsDatabaseCreateCertificateHandle' on a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' object of
    the same TLS backend. The handle is designed to remain valid across
    instantiations of the database.

    If the handle is no longer valid, or does not point to a certificate in
    this database, then 'Nothing' will be returned.

    This function can block, use 'GI.Gio.Objects.TlsDatabase.tlsDatabaseLookupCertificateForHandleAsync' to perform
    the lookup operation asynchronously.

    /Since: 2.30/
    -}
    tlsDatabaseLookupCertificateForHandle ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsDatabase a, Gio.TlsInteraction.IsTlsInteraction b, Gio.Cancellable.IsCancellable c) =>
        a
        {- ^ /@self@/: a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' -}
        -> T.Text
        {- ^ /@handle@/: a certificate handle -}
        -> Maybe (b)
        {- ^ /@interaction@/: used to interact with the user if necessary -}
        -> Gio.Enums.TlsDatabaseLookupFlags
        {- ^ /@flags@/: Flags which affect the lookup. -}
        -> Maybe (c)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> m (Maybe Gio.TlsCertificate.TlsCertificate)
        {- ^ __Returns:__ a newly allocated
    'GI.Gio.Objects.TlsCertificate.TlsCertificate', or 'Nothing'. Use 'GI.GObject.Objects.Object.objectUnref' to release the certificate. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    tlsDatabaseLookupCertificateForHandle self handle interaction flags cancellable = liftIO $ do
        self' <- unsafeManagedPtrCastPtr self
        handle' <- textToCString handle
        maybeInteraction <- case interaction of
            Nothing -> return nullPtr
            Just jInteraction -> do
                jInteraction' <- unsafeManagedPtrCastPtr jInteraction
                return jInteraction'
        let flags' = (fromIntegral . fromEnum) flags
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_tls_database_lookup_certificate_for_handle self' handle' maybeInteraction flags' maybeCancellable
            maybeResult <- convertIfNonNull result $ \result' -> do
                result'' <- (wrapObject Gio.TlsCertificate.TlsCertificate) result'
                return result''
            touchManagedPtr self
            whenJust interaction touchManagedPtr
            whenJust cancellable touchManagedPtr
            freeMem handle'
            return maybeResult
         ) (do
            freeMem handle'
         )

    #if ENABLE_OVERLOADING
    data TlsDatabaseLookupCertificateForHandleMethodInfo
    instance (signature ~ (T.Text -> Maybe (b) -> Gio.Enums.TlsDatabaseLookupFlags -> Maybe (c) -> m (Maybe Gio.TlsCertificate.TlsCertificate)), MonadIO m, IsTlsDatabase a, Gio.TlsInteraction.IsTlsInteraction b, Gio.Cancellable.IsCancellable c) => O.MethodInfo TlsDatabaseLookupCertificateForHandleMethodInfo a signature where
        overloadedMethod _ = tlsDatabaseLookupCertificateForHandle

    #endif

    -- method TlsDatabase::lookup_certificate_for_handle_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "handle", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a certificate handle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interaction", argType = TInterface (Name {namespace = "Gio", name = "TlsInteraction"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "used to interact with the user if necessary", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabaseLookupFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags which affect the lookup.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call when the operation completes", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to the callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_tls_database_lookup_certificate_for_handle_async" g_tls_database_lookup_certificate_for_handle_async ::
        Ptr TlsDatabase ->                      -- self : TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
        CString ->                              -- handle : TBasicType TUTF8
        Ptr Gio.TlsInteraction.TlsInteraction -> -- interaction : TInterface (Name {namespace = "Gio", name = "TlsInteraction"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "TlsDatabaseLookupFlags"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    Asynchronously lookup a certificate by its handle in the database. See
    'GI.Gio.Objects.TlsDatabase.tlsDatabaseLookupCertificateForHandle' for more information.

    /Since: 2.30/
    -}
    tlsDatabaseLookupCertificateForHandleAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsDatabase a, Gio.TlsInteraction.IsTlsInteraction b, Gio.Cancellable.IsCancellable c) =>
        a
        {- ^ /@self@/: a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' -}
        -> T.Text
        {- ^ /@handle@/: a certificate handle -}
        -> Maybe (b)
        {- ^ /@interaction@/: used to interact with the user if necessary -}
        -> Gio.Enums.TlsDatabaseLookupFlags
        {- ^ /@flags@/: Flags which affect the lookup. -}
        -> Maybe (c)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the operation completes -}
        -> m ()
    tlsDatabaseLookupCertificateForHandleAsync self handle interaction flags cancellable callback = liftIO $ do
        self' <- unsafeManagedPtrCastPtr self
        handle' <- textToCString handle
        maybeInteraction <- case interaction of
            Nothing -> return nullPtr
            Just jInteraction -> do
                jInteraction' <- unsafeManagedPtrCastPtr jInteraction
                return jInteraction'
        let flags' = (fromIntegral . fromEnum) flags
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_tls_database_lookup_certificate_for_handle_async self' handle' maybeInteraction flags' maybeCancellable maybeCallback userData
        touchManagedPtr self
        whenJust interaction touchManagedPtr
        whenJust cancellable touchManagedPtr
        freeMem handle'
        return ()

    #if ENABLE_OVERLOADING
    data TlsDatabaseLookupCertificateForHandleAsyncMethodInfo
    instance (signature ~ (T.Text -> Maybe (b) -> Gio.Enums.TlsDatabaseLookupFlags -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsTlsDatabase a, Gio.TlsInteraction.IsTlsInteraction b, Gio.Cancellable.IsCancellable c) => O.MethodInfo TlsDatabaseLookupCertificateForHandleAsyncMethodInfo a signature where
        overloadedMethod _ = tlsDatabaseLookupCertificateForHandleAsync

    #endif

    -- method TlsDatabase::lookup_certificate_for_handle_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "TlsCertificate"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_tls_database_lookup_certificate_for_handle_finish" g_tls_database_lookup_certificate_for_handle_finish ::
        Ptr TlsDatabase ->                      -- self : TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Gio.TlsCertificate.TlsCertificate)

    {- |
    Finish an asynchronous lookup of a certificate by its handle. See
    @/g_tls_database_lookup_certificate_by_handle()/@ for more information.

    If the handle is no longer valid, or does not point to a certificate in
    this database, then 'Nothing' will be returned.

    /Since: 2.30/
    -}
    tlsDatabaseLookupCertificateForHandleFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsDatabase a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@self@/: a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m Gio.TlsCertificate.TlsCertificate
        {- ^ __Returns:__ a newly allocated 'GI.Gio.Objects.TlsCertificate.TlsCertificate' object.
    Use 'GI.GObject.Objects.Object.objectUnref' to release the certificate. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    tlsDatabaseLookupCertificateForHandleFinish self result_ = liftIO $ do
        self' <- unsafeManagedPtrCastPtr self
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            result <- propagateGError $ g_tls_database_lookup_certificate_for_handle_finish self' result_'
            checkUnexpectedReturnNULL "tlsDatabaseLookupCertificateForHandleFinish" result
            result' <- (wrapObject Gio.TlsCertificate.TlsCertificate) result
            touchManagedPtr self
            touchManagedPtr result_
            return result'
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data TlsDatabaseLookupCertificateForHandleFinishMethodInfo
    instance (signature ~ (b -> m Gio.TlsCertificate.TlsCertificate), MonadIO m, IsTlsDatabase a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo TlsDatabaseLookupCertificateForHandleFinishMethodInfo a signature where
        overloadedMethod _ = tlsDatabaseLookupCertificateForHandleFinish

    #endif

    -- method TlsDatabase::lookup_certificate_issuer
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "certificate", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificate"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsCertificate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interaction", argType = TInterface (Name {namespace = "Gio", name = "TlsInteraction"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "used to interact with the user if necessary", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabaseLookupFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags which affect the lookup operation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "TlsCertificate"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_tls_database_lookup_certificate_issuer" g_tls_database_lookup_certificate_issuer ::
        Ptr TlsDatabase ->                      -- self : TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
        Ptr Gio.TlsCertificate.TlsCertificate -> -- certificate : TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
        Ptr Gio.TlsInteraction.TlsInteraction -> -- interaction : TInterface (Name {namespace = "Gio", name = "TlsInteraction"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "TlsDatabaseLookupFlags"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Gio.TlsCertificate.TlsCertificate)

    {- |
    Lookup the issuer of /@certificate@/ in the database.

    The 'GI.Gio.Objects.TlsCertificate.TlsCertificate':@/issuer/@ property
    of /@certificate@/ is not modified, and the two certificates are not hooked
    into a chain.

    This function can block, use 'GI.Gio.Objects.TlsDatabase.tlsDatabaseLookupCertificateIssuerAsync' to perform
    the lookup operation asynchronously.

    /Since: 2.30/
    -}
    tlsDatabaseLookupCertificateIssuer ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsDatabase a, Gio.TlsCertificate.IsTlsCertificate b, Gio.TlsInteraction.IsTlsInteraction c, Gio.Cancellable.IsCancellable d) =>
        a
        {- ^ /@self@/: a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' -}
        -> b
        {- ^ /@certificate@/: a 'GI.Gio.Objects.TlsCertificate.TlsCertificate' -}
        -> Maybe (c)
        {- ^ /@interaction@/: used to interact with the user if necessary -}
        -> Gio.Enums.TlsDatabaseLookupFlags
        {- ^ /@flags@/: flags which affect the lookup operation -}
        -> Maybe (d)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> m Gio.TlsCertificate.TlsCertificate
        {- ^ __Returns:__ a newly allocated issuer 'GI.Gio.Objects.TlsCertificate.TlsCertificate',
    or 'Nothing'. Use 'GI.GObject.Objects.Object.objectUnref' to release the certificate. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    tlsDatabaseLookupCertificateIssuer self certificate interaction flags cancellable = liftIO $ do
        self' <- unsafeManagedPtrCastPtr self
        certificate' <- unsafeManagedPtrCastPtr certificate
        maybeInteraction <- case interaction of
            Nothing -> return nullPtr
            Just jInteraction -> do
                jInteraction' <- unsafeManagedPtrCastPtr jInteraction
                return jInteraction'
        let flags' = (fromIntegral . fromEnum) flags
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_tls_database_lookup_certificate_issuer self' certificate' maybeInteraction flags' maybeCancellable
            checkUnexpectedReturnNULL "tlsDatabaseLookupCertificateIssuer" result
            result' <- (wrapObject Gio.TlsCertificate.TlsCertificate) result
            touchManagedPtr self
            touchManagedPtr certificate
            whenJust interaction touchManagedPtr
            whenJust cancellable touchManagedPtr
            return result'
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data TlsDatabaseLookupCertificateIssuerMethodInfo
    instance (signature ~ (b -> Maybe (c) -> Gio.Enums.TlsDatabaseLookupFlags -> Maybe (d) -> m Gio.TlsCertificate.TlsCertificate), MonadIO m, IsTlsDatabase a, Gio.TlsCertificate.IsTlsCertificate b, Gio.TlsInteraction.IsTlsInteraction c, Gio.Cancellable.IsCancellable d) => O.MethodInfo TlsDatabaseLookupCertificateIssuerMethodInfo a signature where
        overloadedMethod _ = tlsDatabaseLookupCertificateIssuer

    #endif

    -- method TlsDatabase::lookup_certificate_issuer_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "certificate", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificate"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsCertificate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interaction", argType = TInterface (Name {namespace = "Gio", name = "TlsInteraction"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "used to interact with the user if necessary", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabaseLookupFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags which affect the lookup operation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call when the operation completes", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to the callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_tls_database_lookup_certificate_issuer_async" g_tls_database_lookup_certificate_issuer_async ::
        Ptr TlsDatabase ->                      -- self : TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
        Ptr Gio.TlsCertificate.TlsCertificate -> -- certificate : TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
        Ptr Gio.TlsInteraction.TlsInteraction -> -- interaction : TInterface (Name {namespace = "Gio", name = "TlsInteraction"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "TlsDatabaseLookupFlags"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    Asynchronously lookup the issuer of /@certificate@/ in the database. See
    'GI.Gio.Objects.TlsDatabase.tlsDatabaseLookupCertificateIssuer' for more information.

    /Since: 2.30/
    -}
    tlsDatabaseLookupCertificateIssuerAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsDatabase a, Gio.TlsCertificate.IsTlsCertificate b, Gio.TlsInteraction.IsTlsInteraction c, Gio.Cancellable.IsCancellable d) =>
        a
        {- ^ /@self@/: a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' -}
        -> b
        {- ^ /@certificate@/: a 'GI.Gio.Objects.TlsCertificate.TlsCertificate' -}
        -> Maybe (c)
        {- ^ /@interaction@/: used to interact with the user if necessary -}
        -> Gio.Enums.TlsDatabaseLookupFlags
        {- ^ /@flags@/: flags which affect the lookup operation -}
        -> Maybe (d)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the operation completes -}
        -> m ()
    tlsDatabaseLookupCertificateIssuerAsync self certificate interaction flags cancellable callback = liftIO $ do
        self' <- unsafeManagedPtrCastPtr self
        certificate' <- unsafeManagedPtrCastPtr certificate
        maybeInteraction <- case interaction of
            Nothing -> return nullPtr
            Just jInteraction -> do
                jInteraction' <- unsafeManagedPtrCastPtr jInteraction
                return jInteraction'
        let flags' = (fromIntegral . fromEnum) flags
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_tls_database_lookup_certificate_issuer_async self' certificate' maybeInteraction flags' maybeCancellable maybeCallback userData
        touchManagedPtr self
        touchManagedPtr certificate
        whenJust interaction touchManagedPtr
        whenJust cancellable touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data TlsDatabaseLookupCertificateIssuerAsyncMethodInfo
    instance (signature ~ (b -> Maybe (c) -> Gio.Enums.TlsDatabaseLookupFlags -> Maybe (d) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsTlsDatabase a, Gio.TlsCertificate.IsTlsCertificate b, Gio.TlsInteraction.IsTlsInteraction c, Gio.Cancellable.IsCancellable d) => O.MethodInfo TlsDatabaseLookupCertificateIssuerAsyncMethodInfo a signature where
        overloadedMethod _ = tlsDatabaseLookupCertificateIssuerAsync

    #endif

    -- method TlsDatabase::lookup_certificate_issuer_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "TlsCertificate"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_tls_database_lookup_certificate_issuer_finish" g_tls_database_lookup_certificate_issuer_finish ::
        Ptr TlsDatabase ->                      -- self : TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Gio.TlsCertificate.TlsCertificate)

    {- |
    Finish an asynchronous lookup issuer operation. See
    'GI.Gio.Objects.TlsDatabase.tlsDatabaseLookupCertificateIssuer' for more information.

    /Since: 2.30/
    -}
    tlsDatabaseLookupCertificateIssuerFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsDatabase a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@self@/: a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m Gio.TlsCertificate.TlsCertificate
        {- ^ __Returns:__ a newly allocated issuer 'GI.Gio.Objects.TlsCertificate.TlsCertificate',
    or 'Nothing'. Use 'GI.GObject.Objects.Object.objectUnref' to release the certificate. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    tlsDatabaseLookupCertificateIssuerFinish self result_ = liftIO $ do
        self' <- unsafeManagedPtrCastPtr self
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            result <- propagateGError $ g_tls_database_lookup_certificate_issuer_finish self' result_'
            checkUnexpectedReturnNULL "tlsDatabaseLookupCertificateIssuerFinish" result
            result' <- (wrapObject Gio.TlsCertificate.TlsCertificate) result
            touchManagedPtr self
            touchManagedPtr result_
            return result'
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data TlsDatabaseLookupCertificateIssuerFinishMethodInfo
    instance (signature ~ (b -> m Gio.TlsCertificate.TlsCertificate), MonadIO m, IsTlsDatabase a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo TlsDatabaseLookupCertificateIssuerFinishMethodInfo a signature where
        overloadedMethod _ = tlsDatabaseLookupCertificateIssuerFinish

    #endif

    -- method TlsDatabase::lookup_certificates_issued_by
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "issuer_raw_dn", argType = TByteArray, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GByteArray which holds the DER encoded issuer DN.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interaction", argType = TInterface (Name {namespace = "Gio", name = "TlsInteraction"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "used to interact with the user if necessary", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabaseLookupFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags which affect the lookup operation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TGList (TInterface (Name {namespace = "Gio", name = "TlsCertificate"})))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_tls_database_lookup_certificates_issued_by" g_tls_database_lookup_certificates_issued_by ::
        Ptr TlsDatabase ->                      -- self : TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
        Ptr GByteArray ->                       -- issuer_raw_dn : TByteArray
        Ptr Gio.TlsInteraction.TlsInteraction -> -- interaction : TInterface (Name {namespace = "Gio", name = "TlsInteraction"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "TlsDatabaseLookupFlags"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr (GList (Ptr Gio.TlsCertificate.TlsCertificate)))

    {- |
    Lookup certificates issued by this issuer in the database.

    This function can block, use 'GI.Gio.Objects.TlsDatabase.tlsDatabaseLookupCertificatesIssuedByAsync' to perform
    the lookup operation asynchronously.

    /Since: 2.30/
    -}
    tlsDatabaseLookupCertificatesIssuedBy ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsDatabase a, Gio.TlsInteraction.IsTlsInteraction b, Gio.Cancellable.IsCancellable c) =>
        a
        {- ^ /@self@/: a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' -}
        -> ByteString
        {- ^ /@issuerRawDn@/: a 'GI.GLib.Structs.ByteArray.ByteArray' which holds the DER encoded issuer DN. -}
        -> Maybe (b)
        {- ^ /@interaction@/: used to interact with the user if necessary -}
        -> Gio.Enums.TlsDatabaseLookupFlags
        {- ^ /@flags@/: Flags which affect the lookup operation. -}
        -> Maybe (c)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> m [Gio.TlsCertificate.TlsCertificate]
        {- ^ __Returns:__ a newly allocated list of 'GI.Gio.Objects.TlsCertificate.TlsCertificate'
    objects. Use 'GI.GObject.Objects.Object.objectUnref' on each certificate, and @/g_list_free()/@ on the release the list. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    tlsDatabaseLookupCertificatesIssuedBy self issuerRawDn interaction flags cancellable = liftIO $ do
        self' <- unsafeManagedPtrCastPtr self
        issuerRawDn' <- packGByteArray issuerRawDn
        maybeInteraction <- case interaction of
            Nothing -> return nullPtr
            Just jInteraction -> do
                jInteraction' <- unsafeManagedPtrCastPtr jInteraction
                return jInteraction'
        let flags' = (fromIntegral . fromEnum) flags
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_tls_database_lookup_certificates_issued_by self' issuerRawDn' maybeInteraction flags' maybeCancellable
            result' <- unpackGList result
            result'' <- mapM (wrapObject Gio.TlsCertificate.TlsCertificate) result'
            g_list_free result
            touchManagedPtr self
            whenJust interaction touchManagedPtr
            whenJust cancellable touchManagedPtr
            unrefGByteArray issuerRawDn'
            return result''
         ) (do
            unrefGByteArray issuerRawDn'
         )

    #if ENABLE_OVERLOADING
    data TlsDatabaseLookupCertificatesIssuedByMethodInfo
    instance (signature ~ (ByteString -> Maybe (b) -> Gio.Enums.TlsDatabaseLookupFlags -> Maybe (c) -> m [Gio.TlsCertificate.TlsCertificate]), MonadIO m, IsTlsDatabase a, Gio.TlsInteraction.IsTlsInteraction b, Gio.Cancellable.IsCancellable c) => O.MethodInfo TlsDatabaseLookupCertificatesIssuedByMethodInfo a signature where
        overloadedMethod _ = tlsDatabaseLookupCertificatesIssuedBy

    #endif

    -- method TlsDatabase::lookup_certificates_issued_by_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "issuer_raw_dn", argType = TByteArray, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GByteArray which holds the DER encoded issuer DN.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interaction", argType = TInterface (Name {namespace = "Gio", name = "TlsInteraction"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "used to interact with the user if necessary", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabaseLookupFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags which affect the lookup operation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call when the operation completes", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to the callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_tls_database_lookup_certificates_issued_by_async" g_tls_database_lookup_certificates_issued_by_async ::
        Ptr TlsDatabase ->                      -- self : TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
        Ptr GByteArray ->                       -- issuer_raw_dn : TByteArray
        Ptr Gio.TlsInteraction.TlsInteraction -> -- interaction : TInterface (Name {namespace = "Gio", name = "TlsInteraction"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "TlsDatabaseLookupFlags"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    Asynchronously lookup certificates issued by this issuer in the database. See
    'GI.Gio.Objects.TlsDatabase.tlsDatabaseLookupCertificatesIssuedBy' for more information.

    The database may choose to hold a reference to the issuer byte array for the duration
    of of this asynchronous operation. The byte array should not be modified during
    this time.

    /Since: 2.30/
    -}
    tlsDatabaseLookupCertificatesIssuedByAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsDatabase a, Gio.TlsInteraction.IsTlsInteraction b, Gio.Cancellable.IsCancellable c) =>
        a
        {- ^ /@self@/: a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' -}
        -> ByteString
        {- ^ /@issuerRawDn@/: a 'GI.GLib.Structs.ByteArray.ByteArray' which holds the DER encoded issuer DN. -}
        -> Maybe (b)
        {- ^ /@interaction@/: used to interact with the user if necessary -}
        -> Gio.Enums.TlsDatabaseLookupFlags
        {- ^ /@flags@/: Flags which affect the lookup operation. -}
        -> Maybe (c)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the operation completes -}
        -> m ()
    tlsDatabaseLookupCertificatesIssuedByAsync self issuerRawDn interaction flags cancellable callback = liftIO $ do
        self' <- unsafeManagedPtrCastPtr self
        issuerRawDn' <- packGByteArray issuerRawDn
        maybeInteraction <- case interaction of
            Nothing -> return nullPtr
            Just jInteraction -> do
                jInteraction' <- unsafeManagedPtrCastPtr jInteraction
                return jInteraction'
        let flags' = (fromIntegral . fromEnum) flags
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_tls_database_lookup_certificates_issued_by_async self' issuerRawDn' maybeInteraction flags' maybeCancellable maybeCallback userData
        touchManagedPtr self
        whenJust interaction touchManagedPtr
        whenJust cancellable touchManagedPtr
        unrefGByteArray issuerRawDn'
        return ()

    #if ENABLE_OVERLOADING
    data TlsDatabaseLookupCertificatesIssuedByAsyncMethodInfo
    instance (signature ~ (ByteString -> Maybe (b) -> Gio.Enums.TlsDatabaseLookupFlags -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsTlsDatabase a, Gio.TlsInteraction.IsTlsInteraction b, Gio.Cancellable.IsCancellable c) => O.MethodInfo TlsDatabaseLookupCertificatesIssuedByAsyncMethodInfo a signature where
        overloadedMethod _ = tlsDatabaseLookupCertificatesIssuedByAsync

    #endif

    -- method TlsDatabase::lookup_certificates_issued_by_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TGList (TInterface (Name {namespace = "Gio", name = "TlsCertificate"})))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_tls_database_lookup_certificates_issued_by_finish" g_tls_database_lookup_certificates_issued_by_finish ::
        Ptr TlsDatabase ->                      -- self : TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr (GList (Ptr Gio.TlsCertificate.TlsCertificate)))

    {- |
    Finish an asynchronous lookup of certificates. See
    'GI.Gio.Objects.TlsDatabase.tlsDatabaseLookupCertificatesIssuedBy' for more information.

    /Since: 2.30/
    -}
    tlsDatabaseLookupCertificatesIssuedByFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsDatabase a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@self@/: a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m [Gio.TlsCertificate.TlsCertificate]
        {- ^ __Returns:__ a newly allocated list of 'GI.Gio.Objects.TlsCertificate.TlsCertificate'
    objects. Use 'GI.GObject.Objects.Object.objectUnref' on each certificate, and @/g_list_free()/@ on the release the list. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    tlsDatabaseLookupCertificatesIssuedByFinish self result_ = liftIO $ do
        self' <- unsafeManagedPtrCastPtr self
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            result <- propagateGError $ g_tls_database_lookup_certificates_issued_by_finish self' result_'
            result' <- unpackGList result
            result'' <- mapM (wrapObject Gio.TlsCertificate.TlsCertificate) result'
            g_list_free result
            touchManagedPtr self
            touchManagedPtr result_
            return result''
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data TlsDatabaseLookupCertificatesIssuedByFinishMethodInfo
    instance (signature ~ (b -> m [Gio.TlsCertificate.TlsCertificate]), MonadIO m, IsTlsDatabase a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo TlsDatabaseLookupCertificatesIssuedByFinishMethodInfo a signature where
        overloadedMethod _ = tlsDatabaseLookupCertificatesIssuedByFinish

    #endif

    -- method TlsDatabase::verify_chain
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "chain", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificate"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsCertificate chain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "purpose", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the purpose that this certificate chain will be used for.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "identity", argType = TInterface (Name {namespace = "Gio", name = "SocketConnectable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the expected peer identity", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interaction", argType = TInterface (Name {namespace = "Gio", name = "TlsInteraction"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "used to interact with the user if necessary", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabaseVerifyFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "additional verify flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_tls_database_verify_chain" g_tls_database_verify_chain ::
        Ptr TlsDatabase ->                      -- self : TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
        Ptr Gio.TlsCertificate.TlsCertificate -> -- chain : TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
        CString ->                              -- purpose : TBasicType TUTF8
        Ptr Gio.SocketConnectable.SocketConnectable -> -- identity : TInterface (Name {namespace = "Gio", name = "SocketConnectable"})
        Ptr Gio.TlsInteraction.TlsInteraction -> -- interaction : TInterface (Name {namespace = "Gio", name = "TlsInteraction"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "TlsDatabaseVerifyFlags"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CUInt

    {- |
    Determines the validity of a certificate chain after looking up and
    adding any missing certificates to the chain.

    /@chain@/ is a chain of 'GI.Gio.Objects.TlsCertificate.TlsCertificate' objects each pointing to the next
    certificate in the chain by its 'GI.Gio.Objects.TlsCertificate.TlsCertificate':@/issuer/@ property. The chain may initially
    consist of one or more certificates. After the verification process is
    complete, /@chain@/ may be modified by adding missing certificates, or removing
    extra certificates. If a certificate anchor was found, then it is added to
    the /@chain@/.

    /@purpose@/ describes the purpose (or usage) for which the certificate
    is being used. Typically /@purpose@/ will be set to 'GI.Gio.Constants.TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER'
    which means that the certificate is being used to authenticate a server
    (and we are acting as the client).

    The /@identity@/ is used to check for pinned certificates (trust exceptions)
    in the database. These will override the normal verification process on a
    host by host basis.

    Currently there are no /@flags@/, and 'GI.Gio.Flags.TlsDatabaseVerifyFlagsNone' should be
    used.

    If /@chain@/ is found to be valid, then the return value will be 0. If
    /@chain@/ is found to be invalid, then the return value will indicate
    the problems found. If the function is unable to determine whether
    /@chain@/ is valid or not (eg, because /@cancellable@/ is triggered
    before it completes) then the return value will be
    'GI.Gio.Flags.TlsCertificateFlagsGenericError' and /@error@/ will be set
    accordingly. /@error@/ is not set when /@chain@/ is successfully analyzed
    but found to be invalid.

    This function can block, use 'GI.Gio.Objects.TlsDatabase.tlsDatabaseVerifyChainAsync' to perform
    the verification operation asynchronously.

    /Since: 2.30/
    -}
    tlsDatabaseVerifyChain ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsDatabase a, Gio.TlsCertificate.IsTlsCertificate b, Gio.SocketConnectable.IsSocketConnectable c, Gio.TlsInteraction.IsTlsInteraction d, Gio.Cancellable.IsCancellable e) =>
        a
        {- ^ /@self@/: a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' -}
        -> b
        {- ^ /@chain@/: a 'GI.Gio.Objects.TlsCertificate.TlsCertificate' chain -}
        -> T.Text
        {- ^ /@purpose@/: the purpose that this certificate chain will be used for. -}
        -> Maybe (c)
        {- ^ /@identity@/: the expected peer identity -}
        -> Maybe (d)
        {- ^ /@interaction@/: used to interact with the user if necessary -}
        -> [Gio.Flags.TlsDatabaseVerifyFlags]
        {- ^ /@flags@/: additional verify flags -}
        -> Maybe (e)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> m [Gio.Flags.TlsCertificateFlags]
        {- ^ __Returns:__ the appropriate 'GI.Gio.Flags.TlsCertificateFlags' which represents the
    result of verification. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    tlsDatabaseVerifyChain self chain purpose identity interaction flags cancellable = liftIO $ do
        self' <- unsafeManagedPtrCastPtr self
        chain' <- unsafeManagedPtrCastPtr chain
        purpose' <- textToCString purpose
        maybeIdentity <- case identity of
            Nothing -> return nullPtr
            Just jIdentity -> do
                jIdentity' <- unsafeManagedPtrCastPtr jIdentity
                return jIdentity'
        maybeInteraction <- case interaction of
            Nothing -> return nullPtr
            Just jInteraction -> do
                jInteraction' <- unsafeManagedPtrCastPtr jInteraction
                return jInteraction'
        let flags' = gflagsToWord flags
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_tls_database_verify_chain self' chain' purpose' maybeIdentity maybeInteraction flags' maybeCancellable
            let result' = wordToGFlags result
            touchManagedPtr self
            touchManagedPtr chain
            whenJust identity touchManagedPtr
            whenJust interaction touchManagedPtr
            whenJust cancellable touchManagedPtr
            freeMem purpose'
            return result'
         ) (do
            freeMem purpose'
         )

    #if ENABLE_OVERLOADING
    data TlsDatabaseVerifyChainMethodInfo
    instance (signature ~ (b -> T.Text -> Maybe (c) -> Maybe (d) -> [Gio.Flags.TlsDatabaseVerifyFlags] -> Maybe (e) -> m [Gio.Flags.TlsCertificateFlags]), MonadIO m, IsTlsDatabase a, Gio.TlsCertificate.IsTlsCertificate b, Gio.SocketConnectable.IsSocketConnectable c, Gio.TlsInteraction.IsTlsInteraction d, Gio.Cancellable.IsCancellable e) => O.MethodInfo TlsDatabaseVerifyChainMethodInfo a signature where
        overloadedMethod _ = tlsDatabaseVerifyChain

    #endif

    -- method TlsDatabase::verify_chain_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "chain", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificate"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsCertificate chain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "purpose", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the purpose that this certificate chain will be used for.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "identity", argType = TInterface (Name {namespace = "Gio", name = "SocketConnectable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the expected peer identity", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interaction", argType = TInterface (Name {namespace = "Gio", name = "TlsInteraction"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "used to interact with the user if necessary", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabaseVerifyFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "additional verify flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call when the operation completes", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 8, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to the callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_tls_database_verify_chain_async" g_tls_database_verify_chain_async ::
        Ptr TlsDatabase ->                      -- self : TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
        Ptr Gio.TlsCertificate.TlsCertificate -> -- chain : TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
        CString ->                              -- purpose : TBasicType TUTF8
        Ptr Gio.SocketConnectable.SocketConnectable -> -- identity : TInterface (Name {namespace = "Gio", name = "SocketConnectable"})
        Ptr Gio.TlsInteraction.TlsInteraction -> -- interaction : TInterface (Name {namespace = "Gio", name = "TlsInteraction"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "TlsDatabaseVerifyFlags"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    Asynchronously determines the validity of a certificate chain after
    looking up and adding any missing certificates to the chain. See
    'GI.Gio.Objects.TlsDatabase.tlsDatabaseVerifyChain' for more information.

    /Since: 2.30/
    -}
    tlsDatabaseVerifyChainAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsDatabase a, Gio.TlsCertificate.IsTlsCertificate b, Gio.SocketConnectable.IsSocketConnectable c, Gio.TlsInteraction.IsTlsInteraction d, Gio.Cancellable.IsCancellable e) =>
        a
        {- ^ /@self@/: a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' -}
        -> b
        {- ^ /@chain@/: a 'GI.Gio.Objects.TlsCertificate.TlsCertificate' chain -}
        -> T.Text
        {- ^ /@purpose@/: the purpose that this certificate chain will be used for. -}
        -> Maybe (c)
        {- ^ /@identity@/: the expected peer identity -}
        -> Maybe (d)
        {- ^ /@interaction@/: used to interact with the user if necessary -}
        -> [Gio.Flags.TlsDatabaseVerifyFlags]
        {- ^ /@flags@/: additional verify flags -}
        -> Maybe (e)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the operation completes -}
        -> m ()
    tlsDatabaseVerifyChainAsync self chain purpose identity interaction flags cancellable callback = liftIO $ do
        self' <- unsafeManagedPtrCastPtr self
        chain' <- unsafeManagedPtrCastPtr chain
        purpose' <- textToCString purpose
        maybeIdentity <- case identity of
            Nothing -> return nullPtr
            Just jIdentity -> do
                jIdentity' <- unsafeManagedPtrCastPtr jIdentity
                return jIdentity'
        maybeInteraction <- case interaction of
            Nothing -> return nullPtr
            Just jInteraction -> do
                jInteraction' <- unsafeManagedPtrCastPtr jInteraction
                return jInteraction'
        let flags' = gflagsToWord flags
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_tls_database_verify_chain_async self' chain' purpose' maybeIdentity maybeInteraction flags' maybeCancellable maybeCallback userData
        touchManagedPtr self
        touchManagedPtr chain
        whenJust identity touchManagedPtr
        whenJust interaction touchManagedPtr
        whenJust cancellable touchManagedPtr
        freeMem purpose'
        return ()

    #if ENABLE_OVERLOADING
    data TlsDatabaseVerifyChainAsyncMethodInfo
    instance (signature ~ (b -> T.Text -> Maybe (c) -> Maybe (d) -> [Gio.Flags.TlsDatabaseVerifyFlags] -> Maybe (e) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsTlsDatabase a, Gio.TlsCertificate.IsTlsCertificate b, Gio.SocketConnectable.IsSocketConnectable c, Gio.TlsInteraction.IsTlsInteraction d, Gio.Cancellable.IsCancellable e) => O.MethodInfo TlsDatabaseVerifyChainAsyncMethodInfo a signature where
        overloadedMethod _ = tlsDatabaseVerifyChainAsync

    #endif

    -- method TlsDatabase::verify_chain_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_tls_database_verify_chain_finish" g_tls_database_verify_chain_finish ::
        Ptr TlsDatabase ->                      -- self : TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO CUInt

    {- |
    Finish an asynchronous verify chain operation. See
    'GI.Gio.Objects.TlsDatabase.tlsDatabaseVerifyChain' for more information.

    If /@chain@/ is found to be valid, then the return value will be 0. If
    /@chain@/ is found to be invalid, then the return value will indicate
    the problems found. If the function is unable to determine whether
    /@chain@/ is valid or not (eg, because /@cancellable@/ is triggered
    before it completes) then the return value will be
    'GI.Gio.Flags.TlsCertificateFlagsGenericError' and /@error@/ will be set
    accordingly. /@error@/ is not set when /@chain@/ is successfully analyzed
    but found to be invalid.

    /Since: 2.30/
    -}
    tlsDatabaseVerifyChainFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsTlsDatabase a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@self@/: a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m [Gio.Flags.TlsCertificateFlags]
        {- ^ __Returns:__ the appropriate 'GI.Gio.Flags.TlsCertificateFlags' which represents the
    result of verification. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    tlsDatabaseVerifyChainFinish self result_ = liftIO $ do
        self' <- unsafeManagedPtrCastPtr self
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            result <- propagateGError $ g_tls_database_verify_chain_finish self' result_'
            let result' = wordToGFlags result
            touchManagedPtr self
            touchManagedPtr result_
            return result'
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data TlsDatabaseVerifyChainFinishMethodInfo
    instance (signature ~ (b -> m [Gio.Flags.TlsCertificateFlags]), MonadIO m, IsTlsDatabase a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo TlsDatabaseVerifyChainFinishMethodInfo a signature where
        overloadedMethod _ = tlsDatabaseVerifyChainFinish

    #endif