    {- |
    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.Interfaces.DtlsConnection.DtlsConnection' is the base DTLS connection class type, which wraps
    a 'GI.Gio.Interfaces.DatagramBased.DatagramBased' and provides DTLS encryption on top of it. Its
    subclasses, 'GI.Gio.Interfaces.DtlsClientConnection.DtlsClientConnection' and 'GI.Gio.Interfaces.DtlsServerConnection.DtlsServerConnection',
    implement client-side and server-side DTLS, respectively.

    For TLS support, see 'GI.Gio.Objects.TlsConnection.TlsConnection'.

    As DTLS is datagram based, 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' implements 'GI.Gio.Interfaces.DatagramBased.DatagramBased',
    presenting a datagram-socket-like API for the encrypted connection. This
    operates over a base datagram connection, which is also a 'GI.Gio.Interfaces.DatagramBased.DatagramBased'
    ('GI.Gio.Interfaces.DtlsConnection.DtlsConnection':@/base-socket/@).

    To close a DTLS connection, use 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionClose'.

    Neither 'GI.Gio.Interfaces.DtlsServerConnection.DtlsServerConnection' or 'GI.Gio.Interfaces.DtlsClientConnection.DtlsClientConnection' set the peer address
    on their base 'GI.Gio.Interfaces.DatagramBased.DatagramBased' if it is a 'GI.Gio.Objects.Socket.Socket' — it is up to the caller to
    do that if they wish. If they do not, and 'GI.Gio.Objects.Socket.socketClose' is called on the
    base socket, the 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' will not raise a 'GI.Gio.Enums.IOErrorEnumNotConnected'
    error on further I\/O.

    /Since: 2.48/
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Interfaces.DtlsConnection
        (

    -- * Exported types
        DtlsConnection(..)                      ,
        noDtlsConnection                        ,
        IsDtlsConnection                        ,
        toDtlsConnection                        ,

     -- * Methods
    -- ** close #method:close#

    #if ENABLE_OVERLOADING
        DtlsConnectionCloseMethodInfo           ,
    #endif
        dtlsConnectionClose                     ,

    -- ** closeAsync #method:closeAsync#

    #if ENABLE_OVERLOADING
        DtlsConnectionCloseAsyncMethodInfo      ,
    #endif
        dtlsConnectionCloseAsync                ,

    -- ** closeFinish #method:closeFinish#

    #if ENABLE_OVERLOADING
        DtlsConnectionCloseFinishMethodInfo     ,
    #endif
        dtlsConnectionCloseFinish               ,

    -- ** emitAcceptCertificate #method:emitAcceptCertificate#

    #if ENABLE_OVERLOADING
        DtlsConnectionEmitAcceptCertificateMethodInfo,
    #endif
        dtlsConnectionEmitAcceptCertificate     ,

    -- ** getCertificate #method:getCertificate#

    #if ENABLE_OVERLOADING
        DtlsConnectionGetCertificateMethodInfo  ,
    #endif
        dtlsConnectionGetCertificate            ,

    -- ** getDatabase #method:getDatabase#

    #if ENABLE_OVERLOADING
        DtlsConnectionGetDatabaseMethodInfo     ,
    #endif
        dtlsConnectionGetDatabase               ,

    -- ** getInteraction #method:getInteraction#

    #if ENABLE_OVERLOADING
        DtlsConnectionGetInteractionMethodInfo  ,
    #endif
        dtlsConnectionGetInteraction            ,

    -- ** getNegotiatedProtocol #method:getNegotiatedProtocol#

    #if ENABLE_OVERLOADING
        DtlsConnectionGetNegotiatedProtocolMethodInfo,
    #endif
        dtlsConnectionGetNegotiatedProtocol     ,

    -- ** getPeerCertificate #method:getPeerCertificate#

    #if ENABLE_OVERLOADING
        DtlsConnectionGetPeerCertificateMethodInfo,
    #endif
        dtlsConnectionGetPeerCertificate        ,

    -- ** getPeerCertificateErrors #method:getPeerCertificateErrors#

    #if ENABLE_OVERLOADING
        DtlsConnectionGetPeerCertificateErrorsMethodInfo,
    #endif
        dtlsConnectionGetPeerCertificateErrors  ,

    -- ** getRehandshakeMode #method:getRehandshakeMode#

    #if ENABLE_OVERLOADING
        DtlsConnectionGetRehandshakeModeMethodInfo,
    #endif
        dtlsConnectionGetRehandshakeMode        ,

    -- ** getRequireCloseNotify #method:getRequireCloseNotify#

    #if ENABLE_OVERLOADING
        DtlsConnectionGetRequireCloseNotifyMethodInfo,
    #endif
        dtlsConnectionGetRequireCloseNotify     ,

    -- ** handshake #method:handshake#

    #if ENABLE_OVERLOADING
        DtlsConnectionHandshakeMethodInfo       ,
    #endif
        dtlsConnectionHandshake                 ,

    -- ** handshakeAsync #method:handshakeAsync#

    #if ENABLE_OVERLOADING
        DtlsConnectionHandshakeAsyncMethodInfo  ,
    #endif
        dtlsConnectionHandshakeAsync            ,

    -- ** handshakeFinish #method:handshakeFinish#

    #if ENABLE_OVERLOADING
        DtlsConnectionHandshakeFinishMethodInfo ,
    #endif
        dtlsConnectionHandshakeFinish           ,

    -- ** setAdvertisedProtocols #method:setAdvertisedProtocols#

    #if ENABLE_OVERLOADING
        DtlsConnectionSetAdvertisedProtocolsMethodInfo,
    #endif
        dtlsConnectionSetAdvertisedProtocols    ,

    -- ** setCertificate #method:setCertificate#

    #if ENABLE_OVERLOADING
        DtlsConnectionSetCertificateMethodInfo  ,
    #endif
        dtlsConnectionSetCertificate            ,

    -- ** setDatabase #method:setDatabase#

    #if ENABLE_OVERLOADING
        DtlsConnectionSetDatabaseMethodInfo     ,
    #endif
        dtlsConnectionSetDatabase               ,

    -- ** setInteraction #method:setInteraction#

    #if ENABLE_OVERLOADING
        DtlsConnectionSetInteractionMethodInfo  ,
    #endif
        dtlsConnectionSetInteraction            ,

    -- ** setRehandshakeMode #method:setRehandshakeMode#

    #if ENABLE_OVERLOADING
        DtlsConnectionSetRehandshakeModeMethodInfo,
    #endif
        dtlsConnectionSetRehandshakeMode        ,

    -- ** setRequireCloseNotify #method:setRequireCloseNotify#

    #if ENABLE_OVERLOADING
        DtlsConnectionSetRequireCloseNotifyMethodInfo,
    #endif
        dtlsConnectionSetRequireCloseNotify     ,

    -- ** shutdown #method:shutdown#

    #if ENABLE_OVERLOADING
        DtlsConnectionShutdownMethodInfo        ,
    #endif
        dtlsConnectionShutdown                  ,

    -- ** shutdownAsync #method:shutdownAsync#

    #if ENABLE_OVERLOADING
        DtlsConnectionShutdownAsyncMethodInfo   ,
    #endif
        dtlsConnectionShutdownAsync             ,

    -- ** shutdownFinish #method:shutdownFinish#

    #if ENABLE_OVERLOADING
        DtlsConnectionShutdownFinishMethodInfo  ,
    #endif
        dtlsConnectionShutdownFinish            ,

     -- * Properties
    -- ** advertisedProtocols #attr:advertisedProtocols#
    {- | The list of application-layer protocols that the connection
    advertises that it is willing to speak. See
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetAdvertisedProtocols'.

    /Since: 2.60/
    -}
    #if ENABLE_OVERLOADING
        DtlsConnectionAdvertisedProtocolsPropertyInfo,
    #endif
        clearDtlsConnectionAdvertisedProtocols  ,
        constructDtlsConnectionAdvertisedProtocols,
    #if ENABLE_OVERLOADING
        dtlsConnectionAdvertisedProtocols       ,
    #endif
        getDtlsConnectionAdvertisedProtocols    ,
        setDtlsConnectionAdvertisedProtocols    ,

    -- ** baseSocket #attr:baseSocket#
    {- | The 'GI.Gio.Interfaces.DatagramBased.DatagramBased' that the connection wraps. Note that this may be any
    implementation of 'GI.Gio.Interfaces.DatagramBased.DatagramBased', not just a 'GI.Gio.Objects.Socket.Socket'.

    /Since: 2.48/
    -}
    #if ENABLE_OVERLOADING
        DtlsConnectionBaseSocketPropertyInfo    ,
    #endif
        constructDtlsConnectionBaseSocket       ,
    #if ENABLE_OVERLOADING
        dtlsConnectionBaseSocket                ,
    #endif
        getDtlsConnectionBaseSocket             ,

    -- ** certificate #attr:certificate#
    {- | The connection\'s certificate; see
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetCertificate'.

    /Since: 2.48/
    -}
    #if ENABLE_OVERLOADING
        DtlsConnectionCertificatePropertyInfo   ,
    #endif
        constructDtlsConnectionCertificate      ,
    #if ENABLE_OVERLOADING
        dtlsConnectionCertificate               ,
    #endif
        getDtlsConnectionCertificate            ,
        setDtlsConnectionCertificate            ,

    -- ** database #attr:database#
    {- | The certificate database to use when verifying this TLS connection.
    If no certificate database is set, then the default database will be
    used. See 'GI.Gio.Interfaces.TlsBackend.tlsBackendGetDefaultDatabase'.

    /Since: 2.48/
    -}
    #if ENABLE_OVERLOADING
        DtlsConnectionDatabasePropertyInfo      ,
    #endif
        constructDtlsConnectionDatabase         ,
    #if ENABLE_OVERLOADING
        dtlsConnectionDatabase                  ,
    #endif
        getDtlsConnectionDatabase               ,
        setDtlsConnectionDatabase               ,

    -- ** interaction #attr:interaction#
    {- | A 'GI.Gio.Objects.TlsInteraction.TlsInteraction' object to be used when the connection or certificate
    database need to interact with the user. This will be used to prompt the
    user for passwords where necessary.

    /Since: 2.48/
    -}
    #if ENABLE_OVERLOADING
        DtlsConnectionInteractionPropertyInfo   ,
    #endif
        clearDtlsConnectionInteraction          ,
        constructDtlsConnectionInteraction      ,
    #if ENABLE_OVERLOADING
        dtlsConnectionInteraction               ,
    #endif
        getDtlsConnectionInteraction            ,
        setDtlsConnectionInteraction            ,

    -- ** negotiatedProtocol #attr:negotiatedProtocol#
    {- | The application-layer protocol negotiated during the TLS
    handshake. See 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionGetNegotiatedProtocol'.

    /Since: 2.60/
    -}
    #if ENABLE_OVERLOADING
        DtlsConnectionNegotiatedProtocolPropertyInfo,
    #endif
    #if ENABLE_OVERLOADING
        dtlsConnectionNegotiatedProtocol        ,
    #endif
        getDtlsConnectionNegotiatedProtocol     ,

    -- ** peerCertificate #attr:peerCertificate#
    {- | The connection\'s peer\'s certificate, after the TLS handshake has
    completed and the certificate has been accepted. Note in
    particular that this is not yet set during the emission of
    'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'::@/accept-certificate/@.

    (You can watch for a 'GI.GObject.Objects.Object.Object'::@/notify/@ signal on this property to
    detect when a handshake has occurred.)

    /Since: 2.48/
    -}
    #if ENABLE_OVERLOADING
        DtlsConnectionPeerCertificatePropertyInfo,
    #endif
    #if ENABLE_OVERLOADING
        dtlsConnectionPeerCertificate           ,
    #endif
        getDtlsConnectionPeerCertificate        ,

    -- ** peerCertificateErrors #attr:peerCertificateErrors#
    {- | The errors noticed-and-ignored while verifying
    'GI.Gio.Interfaces.DtlsConnection.DtlsConnection':@/peer-certificate/@. Normally this should be 0, but
    it may not be if 'GI.Gio.Interfaces.DtlsClientConnection.DtlsClientConnection':@/validation-flags/@ is not
    'GI.Gio.Flags.TlsCertificateFlagsValidateAll', or if
    'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'::@/accept-certificate/@ overrode the default
    behavior.

    /Since: 2.48/
    -}
    #if ENABLE_OVERLOADING
        DtlsConnectionPeerCertificateErrorsPropertyInfo,
    #endif
    #if ENABLE_OVERLOADING
        dtlsConnectionPeerCertificateErrors     ,
    #endif
        getDtlsConnectionPeerCertificateErrors  ,

    -- ** rehandshakeMode #attr:rehandshakeMode#
    {- | The rehandshaking mode. See
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetRehandshakeMode'.

    /Since: 2.48/
    -}
    #if ENABLE_OVERLOADING
        DtlsConnectionRehandshakeModePropertyInfo,
    #endif
        constructDtlsConnectionRehandshakeMode  ,
    #if ENABLE_OVERLOADING
        dtlsConnectionRehandshakeMode           ,
    #endif
        getDtlsConnectionRehandshakeMode        ,
        setDtlsConnectionRehandshakeMode        ,

    -- ** requireCloseNotify #attr:requireCloseNotify#
    {- | Whether or not proper TLS close notification is required.
    See 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetRequireCloseNotify'.

    /Since: 2.48/
    -}
    #if ENABLE_OVERLOADING
        DtlsConnectionRequireCloseNotifyPropertyInfo,
    #endif
        constructDtlsConnectionRequireCloseNotify,
    #if ENABLE_OVERLOADING
        dtlsConnectionRequireCloseNotify        ,
    #endif
        getDtlsConnectionRequireCloseNotify     ,
        setDtlsConnectionRequireCloseNotify     ,

     -- * Signals
    -- ** acceptCertificate #signal:acceptCertificate#

        C_DtlsConnectionAcceptCertificateCallback,
        DtlsConnectionAcceptCertificateCallback ,
    #if ENABLE_OVERLOADING
        DtlsConnectionAcceptCertificateSignalInfo,
    #endif
        afterDtlsConnectionAcceptCertificate    ,
        genClosure_DtlsConnectionAcceptCertificate,
        mk_DtlsConnectionAcceptCertificateCallback,
        noDtlsConnectionAcceptCertificateCallback,
        onDtlsConnectionAcceptCertificate       ,
        wrap_DtlsConnectionAcceptCertificateCallback,

        ) 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.DatagramBased as Gio.DatagramBased
    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.TlsDatabase as Gio.TlsDatabase
    import {-# SOURCE #-} qualified GI.Gio.Objects.TlsInteraction as Gio.TlsInteraction

    -- interface DtlsConnection
    -- | Memory-managed wrapper type.
    newtype DtlsConnection = DtlsConnection (ManagedPtr DtlsConnection)
    -- | A convenience alias for `Nothing` :: `Maybe` `DtlsConnection`.
    noDtlsConnection :: Maybe DtlsConnection
    noDtlsConnection = Nothing

    -- signal DtlsConnection::accept-certificate
    {- |
    Emitted during the TLS handshake after the peer certificate has
    been received. You can examine /@peerCert@/\'s certification path by
    calling 'GI.Gio.Objects.TlsCertificate.tlsCertificateGetIssuer' on it.

    For a client-side connection, /@peerCert@/ is the server\'s
    certificate, and the signal will only be emitted if the
    certificate was not acceptable according to /@conn@/\'s
    'GI.Gio.Interfaces.DtlsClientConnection.DtlsClientConnection':@/validation_flags/@. If you would like the
    certificate to be accepted despite /@errors@/, return 'True' from the
    signal handler. Otherwise, if no handler accepts the certificate,
    the handshake will fail with 'GI.Gio.Enums.TlsErrorBadCertificate'.

    For a server-side connection, /@peerCert@/ is the certificate
    presented by the client, if this was requested via the server\'s
    'GI.Gio.Interfaces.DtlsServerConnection.DtlsServerConnection':@/authentication_mode/@. On the server side,
    the signal is always emitted when the client presents a
    certificate, and the certificate will only be accepted if a
    handler returns 'True'.

    Note that if this signal is emitted as part of asynchronous I\/O
    in the main thread, then you should not attempt to interact with
    the user before returning from the signal handler. If you want to
    let the user decide whether or not to accept the certificate, you
    would have to return 'False' from the signal handler on the first
    attempt, and then after the connection attempt returns a
    'GI.Gio.Enums.TlsErrorBadCertificate', you can interact with the user, and
    if the user decides to accept the certificate, remember that fact,
    create a new connection, and return 'True' from the signal handler
    the next time.

    If you are doing I\/O in another thread, you do not
    need to worry about this, and can simply block in the signal
    handler until the UI thread returns an answer.

    /Since: 2.48/
    -}
    type DtlsConnectionAcceptCertificateCallback =
        Gio.TlsCertificate.TlsCertificate
        {- ^ /@peerCert@/: the peer\'s 'GI.Gio.Objects.TlsCertificate.TlsCertificate' -}
        -> [Gio.Flags.TlsCertificateFlags]
        {- ^ /@errors@/: the problems with /@peerCert@/. -}
        -> IO Bool
        {- ^ __Returns:__ 'True' to accept /@peerCert@/ (which will also
    immediately end the signal emission). 'False' to allow the signal
    emission to continue, which will cause the handshake to fail if
    no one else overrides it. -}

    -- | A convenience synonym for @`Nothing` :: `Maybe` `DtlsConnectionAcceptCertificateCallback`@.
    noDtlsConnectionAcceptCertificateCallback :: Maybe DtlsConnectionAcceptCertificateCallback
    noDtlsConnectionAcceptCertificateCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_DtlsConnectionAcceptCertificateCallback =
        Ptr () ->                               -- object
        Ptr Gio.TlsCertificate.TlsCertificate ->
        CUInt ->
        Ptr () ->                               -- user_data
        IO CInt

    -- | Generate a function pointer callable from C code, from a `C_DtlsConnectionAcceptCertificateCallback`.
    foreign import ccall "wrapper"
        mk_DtlsConnectionAcceptCertificateCallback :: C_DtlsConnectionAcceptCertificateCallback -> IO (FunPtr C_DtlsConnectionAcceptCertificateCallback)

    -- | Wrap the callback into a `Closure`.
    genClosure_DtlsConnectionAcceptCertificate :: DtlsConnectionAcceptCertificateCallback -> IO Closure
    genClosure_DtlsConnectionAcceptCertificate cb = do
        let cb' = wrap_DtlsConnectionAcceptCertificateCallback cb
        mk_DtlsConnectionAcceptCertificateCallback cb' >>= newCClosure

    -- | Wrap a `DtlsConnectionAcceptCertificateCallback` into a `C_DtlsConnectionAcceptCertificateCallback`.
    wrap_DtlsConnectionAcceptCertificateCallback ::
        DtlsConnectionAcceptCertificateCallback ->
        C_DtlsConnectionAcceptCertificateCallback
    wrap_DtlsConnectionAcceptCertificateCallback _cb _ peerCert errors _ = do
        peerCert' <- (newObject Gio.TlsCertificate.TlsCertificate) peerCert
        let errors' = wordToGFlags errors
        result <- _cb  peerCert' errors'
        let result' = (fromIntegral . fromEnum) result
        return result'

    {- |
    Connect a signal handler for the “@accept-certificate@” signal, to be run before the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.on' dtlsConnection #acceptCertificate callback
    @
    -}
    onDtlsConnectionAcceptCertificate :: (IsDtlsConnection a, MonadIO m) => a -> DtlsConnectionAcceptCertificateCallback -> m SignalHandlerId
    onDtlsConnectionAcceptCertificate obj cb = liftIO $ do
        let cb' = wrap_DtlsConnectionAcceptCertificateCallback cb
        cb'' <- mk_DtlsConnectionAcceptCertificateCallback cb'
        connectSignalFunPtr obj "accept-certificate" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@accept-certificate@” signal, to be run after the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.after' dtlsConnection #acceptCertificate callback
    @
    -}
    afterDtlsConnectionAcceptCertificate :: (IsDtlsConnection a, MonadIO m) => a -> DtlsConnectionAcceptCertificateCallback -> m SignalHandlerId
    afterDtlsConnectionAcceptCertificate obj cb = liftIO $ do
        let cb' = wrap_DtlsConnectionAcceptCertificateCallback cb
        cb'' <- mk_DtlsConnectionAcceptCertificateCallback cb'
        connectSignalFunPtr obj "accept-certificate" cb'' SignalConnectAfter

    #if ENABLE_OVERLOADING
    data DtlsConnectionAcceptCertificateSignalInfo
    instance SignalInfo DtlsConnectionAcceptCertificateSignalInfo where
        type HaskellCallbackType DtlsConnectionAcceptCertificateSignalInfo = DtlsConnectionAcceptCertificateCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_DtlsConnectionAcceptCertificateCallback cb
            cb'' <- mk_DtlsConnectionAcceptCertificateCallback cb'
            connectSignalFunPtr obj "accept-certificate" cb'' connectMode

    type instance O.SignalList DtlsConnection = DtlsConnectionSignalList
    type DtlsConnectionSignalList = ('[ '("acceptCertificate", DtlsConnectionAcceptCertificateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

    #endif

    foreign import ccall "g_dtls_connection_get_type"
        c_g_dtls_connection_get_type :: IO GType

    instance GObject DtlsConnection where
        gobjectType _ = c_g_dtls_connection_get_type

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

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

    -- VVV Prop "advertised-protocols"
       -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Just True)

    {- |
    Get the value of the “@advertised-protocols@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' dtlsConnection #advertisedProtocols
    @
    -}
    getDtlsConnectionAdvertisedProtocols :: (MonadIO m, IsDtlsConnection o) => o -> m (Maybe [T.Text])
    getDtlsConnectionAdvertisedProtocols obj = liftIO $ getObjectPropertyStringArray obj "advertised-protocols"

    {- |
    Set the value of the “@advertised-protocols@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' dtlsConnection [ #advertisedProtocols 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setDtlsConnectionAdvertisedProtocols :: (MonadIO m, IsDtlsConnection o) => o -> [T.Text] -> m ()
    setDtlsConnectionAdvertisedProtocols obj val = liftIO $ setObjectPropertyStringArray obj "advertised-protocols" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@advertised-protocols@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDtlsConnectionAdvertisedProtocols :: (IsDtlsConnection o) => [T.Text] -> IO (GValueConstruct o)
    constructDtlsConnectionAdvertisedProtocols val = constructObjectPropertyStringArray "advertised-protocols" (Just val)

    {- |
    Set the value of the “@advertised-protocols@” property to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #advertisedProtocols
    @
    -}
    clearDtlsConnectionAdvertisedProtocols :: (MonadIO m, IsDtlsConnection o) => o -> m ()
    clearDtlsConnectionAdvertisedProtocols obj = liftIO $ setObjectPropertyStringArray obj "advertised-protocols" (Nothing :: Maybe [T.Text])

    #if ENABLE_OVERLOADING
    data DtlsConnectionAdvertisedProtocolsPropertyInfo
    instance AttrInfo DtlsConnectionAdvertisedProtocolsPropertyInfo where
        type AttrAllowedOps DtlsConnectionAdvertisedProtocolsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint DtlsConnectionAdvertisedProtocolsPropertyInfo = (~) [T.Text]
        type AttrBaseTypeConstraint DtlsConnectionAdvertisedProtocolsPropertyInfo = IsDtlsConnection
        type AttrGetType DtlsConnectionAdvertisedProtocolsPropertyInfo = (Maybe [T.Text])
        type AttrLabel DtlsConnectionAdvertisedProtocolsPropertyInfo = "advertised-protocols"
        type AttrOrigin DtlsConnectionAdvertisedProtocolsPropertyInfo = DtlsConnection
        attrGet _ = getDtlsConnectionAdvertisedProtocols
        attrSet _ = setDtlsConnectionAdvertisedProtocols
        attrConstruct _ = constructDtlsConnectionAdvertisedProtocols
        attrClear _ = clearDtlsConnectionAdvertisedProtocols
    #endif

    -- VVV Prop "base-socket"
       -- Type: TInterface (Name {namespace = "Gio", name = "DatagramBased"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    {- |
    Get the value of the “@base-socket@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' dtlsConnection #baseSocket
    @
    -}
    getDtlsConnectionBaseSocket :: (MonadIO m, IsDtlsConnection o) => o -> m (Maybe Gio.DatagramBased.DatagramBased)
    getDtlsConnectionBaseSocket obj = liftIO $ getObjectPropertyObject obj "base-socket" Gio.DatagramBased.DatagramBased

    {- |
    Construct a `GValueConstruct` with valid value for the “@base-socket@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDtlsConnectionBaseSocket :: (IsDtlsConnection o, Gio.DatagramBased.IsDatagramBased a) => a -> IO (GValueConstruct o)
    constructDtlsConnectionBaseSocket val = constructObjectPropertyObject "base-socket" (Just val)

    #if ENABLE_OVERLOADING
    data DtlsConnectionBaseSocketPropertyInfo
    instance AttrInfo DtlsConnectionBaseSocketPropertyInfo where
        type AttrAllowedOps DtlsConnectionBaseSocketPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint DtlsConnectionBaseSocketPropertyInfo = Gio.DatagramBased.IsDatagramBased
        type AttrBaseTypeConstraint DtlsConnectionBaseSocketPropertyInfo = IsDtlsConnection
        type AttrGetType DtlsConnectionBaseSocketPropertyInfo = (Maybe Gio.DatagramBased.DatagramBased)
        type AttrLabel DtlsConnectionBaseSocketPropertyInfo = "base-socket"
        type AttrOrigin DtlsConnectionBaseSocketPropertyInfo = DtlsConnection
        attrGet _ = getDtlsConnectionBaseSocket
        attrSet _ = undefined
        attrConstruct _ = constructDtlsConnectionBaseSocket
        attrClear _ = undefined
    #endif

    -- VVV Prop "certificate"
       -- Type: TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    {- |
    Get the value of the “@certificate@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' dtlsConnection #certificate
    @
    -}
    getDtlsConnectionCertificate :: (MonadIO m, IsDtlsConnection o) => o -> m Gio.TlsCertificate.TlsCertificate
    getDtlsConnectionCertificate obj = liftIO $ checkUnexpectedNothing "getDtlsConnectionCertificate" $ getObjectPropertyObject obj "certificate" Gio.TlsCertificate.TlsCertificate

    {- |
    Set the value of the “@certificate@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' dtlsConnection [ #certificate 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setDtlsConnectionCertificate :: (MonadIO m, IsDtlsConnection o, Gio.TlsCertificate.IsTlsCertificate a) => o -> a -> m ()
    setDtlsConnectionCertificate obj val = liftIO $ setObjectPropertyObject obj "certificate" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@certificate@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDtlsConnectionCertificate :: (IsDtlsConnection o, Gio.TlsCertificate.IsTlsCertificate a) => a -> IO (GValueConstruct o)
    constructDtlsConnectionCertificate val = constructObjectPropertyObject "certificate" (Just val)

    #if ENABLE_OVERLOADING
    data DtlsConnectionCertificatePropertyInfo
    instance AttrInfo DtlsConnectionCertificatePropertyInfo where
        type AttrAllowedOps DtlsConnectionCertificatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint DtlsConnectionCertificatePropertyInfo = Gio.TlsCertificate.IsTlsCertificate
        type AttrBaseTypeConstraint DtlsConnectionCertificatePropertyInfo = IsDtlsConnection
        type AttrGetType DtlsConnectionCertificatePropertyInfo = Gio.TlsCertificate.TlsCertificate
        type AttrLabel DtlsConnectionCertificatePropertyInfo = "certificate"
        type AttrOrigin DtlsConnectionCertificatePropertyInfo = DtlsConnection
        attrGet _ = getDtlsConnectionCertificate
        attrSet _ = setDtlsConnectionCertificate
        attrConstruct _ = constructDtlsConnectionCertificate
        attrClear _ = undefined
    #endif

    -- VVV Prop "database"
       -- Type: TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    {- |
    Get the value of the “@database@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' dtlsConnection #database
    @
    -}
    getDtlsConnectionDatabase :: (MonadIO m, IsDtlsConnection o) => o -> m Gio.TlsDatabase.TlsDatabase
    getDtlsConnectionDatabase obj = liftIO $ checkUnexpectedNothing "getDtlsConnectionDatabase" $ getObjectPropertyObject obj "database" Gio.TlsDatabase.TlsDatabase

    {- |
    Set the value of the “@database@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' dtlsConnection [ #database 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setDtlsConnectionDatabase :: (MonadIO m, IsDtlsConnection o, Gio.TlsDatabase.IsTlsDatabase a) => o -> a -> m ()
    setDtlsConnectionDatabase obj val = liftIO $ setObjectPropertyObject obj "database" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@database@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDtlsConnectionDatabase :: (IsDtlsConnection o, Gio.TlsDatabase.IsTlsDatabase a) => a -> IO (GValueConstruct o)
    constructDtlsConnectionDatabase val = constructObjectPropertyObject "database" (Just val)

    #if ENABLE_OVERLOADING
    data DtlsConnectionDatabasePropertyInfo
    instance AttrInfo DtlsConnectionDatabasePropertyInfo where
        type AttrAllowedOps DtlsConnectionDatabasePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint DtlsConnectionDatabasePropertyInfo = Gio.TlsDatabase.IsTlsDatabase
        type AttrBaseTypeConstraint DtlsConnectionDatabasePropertyInfo = IsDtlsConnection
        type AttrGetType DtlsConnectionDatabasePropertyInfo = Gio.TlsDatabase.TlsDatabase
        type AttrLabel DtlsConnectionDatabasePropertyInfo = "database"
        type AttrOrigin DtlsConnectionDatabasePropertyInfo = DtlsConnection
        attrGet _ = getDtlsConnectionDatabase
        attrSet _ = setDtlsConnectionDatabase
        attrConstruct _ = constructDtlsConnectionDatabase
        attrClear _ = undefined
    #endif

    -- VVV Prop "interaction"
       -- Type: TInterface (Name {namespace = "Gio", name = "TlsInteraction"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just True)

    {- |
    Get the value of the “@interaction@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' dtlsConnection #interaction
    @
    -}
    getDtlsConnectionInteraction :: (MonadIO m, IsDtlsConnection o) => o -> m Gio.TlsInteraction.TlsInteraction
    getDtlsConnectionInteraction obj = liftIO $ checkUnexpectedNothing "getDtlsConnectionInteraction" $ getObjectPropertyObject obj "interaction" Gio.TlsInteraction.TlsInteraction

    {- |
    Set the value of the “@interaction@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' dtlsConnection [ #interaction 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setDtlsConnectionInteraction :: (MonadIO m, IsDtlsConnection o, Gio.TlsInteraction.IsTlsInteraction a) => o -> a -> m ()
    setDtlsConnectionInteraction obj val = liftIO $ setObjectPropertyObject obj "interaction" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@interaction@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDtlsConnectionInteraction :: (IsDtlsConnection o, Gio.TlsInteraction.IsTlsInteraction a) => a -> IO (GValueConstruct o)
    constructDtlsConnectionInteraction val = constructObjectPropertyObject "interaction" (Just val)

    {- |
    Set the value of the “@interaction@” property to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #interaction
    @
    -}
    clearDtlsConnectionInteraction :: (MonadIO m, IsDtlsConnection o) => o -> m ()
    clearDtlsConnectionInteraction obj = liftIO $ setObjectPropertyObject obj "interaction" (Nothing :: Maybe Gio.TlsInteraction.TlsInteraction)

    #if ENABLE_OVERLOADING
    data DtlsConnectionInteractionPropertyInfo
    instance AttrInfo DtlsConnectionInteractionPropertyInfo where
        type AttrAllowedOps DtlsConnectionInteractionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint DtlsConnectionInteractionPropertyInfo = Gio.TlsInteraction.IsTlsInteraction
        type AttrBaseTypeConstraint DtlsConnectionInteractionPropertyInfo = IsDtlsConnection
        type AttrGetType DtlsConnectionInteractionPropertyInfo = Gio.TlsInteraction.TlsInteraction
        type AttrLabel DtlsConnectionInteractionPropertyInfo = "interaction"
        type AttrOrigin DtlsConnectionInteractionPropertyInfo = DtlsConnection
        attrGet _ = getDtlsConnectionInteraction
        attrSet _ = setDtlsConnectionInteraction
        attrConstruct _ = constructDtlsConnectionInteraction
        attrClear _ = clearDtlsConnectionInteraction
    #endif

    -- VVV Prop "negotiated-protocol"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable]
       -- Nullable: (Just True,Nothing)

    {- |
    Get the value of the “@negotiated-protocol@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' dtlsConnection #negotiatedProtocol
    @
    -}
    getDtlsConnectionNegotiatedProtocol :: (MonadIO m, IsDtlsConnection o) => o -> m (Maybe T.Text)
    getDtlsConnectionNegotiatedProtocol obj = liftIO $ getObjectPropertyString obj "negotiated-protocol"

    #if ENABLE_OVERLOADING
    data DtlsConnectionNegotiatedProtocolPropertyInfo
    instance AttrInfo DtlsConnectionNegotiatedProtocolPropertyInfo where
        type AttrAllowedOps DtlsConnectionNegotiatedProtocolPropertyInfo = '[ 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint DtlsConnectionNegotiatedProtocolPropertyInfo = (~) ()
        type AttrBaseTypeConstraint DtlsConnectionNegotiatedProtocolPropertyInfo = IsDtlsConnection
        type AttrGetType DtlsConnectionNegotiatedProtocolPropertyInfo = (Maybe T.Text)
        type AttrLabel DtlsConnectionNegotiatedProtocolPropertyInfo = "negotiated-protocol"
        type AttrOrigin DtlsConnectionNegotiatedProtocolPropertyInfo = DtlsConnection
        attrGet _ = getDtlsConnectionNegotiatedProtocol
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "peer-certificate"
       -- Type: TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
       -- Flags: [PropertyReadable]
       -- Nullable: (Just False,Nothing)

    {- |
    Get the value of the “@peer-certificate@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' dtlsConnection #peerCertificate
    @
    -}
    getDtlsConnectionPeerCertificate :: (MonadIO m, IsDtlsConnection o) => o -> m Gio.TlsCertificate.TlsCertificate
    getDtlsConnectionPeerCertificate obj = liftIO $ checkUnexpectedNothing "getDtlsConnectionPeerCertificate" $ getObjectPropertyObject obj "peer-certificate" Gio.TlsCertificate.TlsCertificate

    #if ENABLE_OVERLOADING
    data DtlsConnectionPeerCertificatePropertyInfo
    instance AttrInfo DtlsConnectionPeerCertificatePropertyInfo where
        type AttrAllowedOps DtlsConnectionPeerCertificatePropertyInfo = '[ 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint DtlsConnectionPeerCertificatePropertyInfo = (~) ()
        type AttrBaseTypeConstraint DtlsConnectionPeerCertificatePropertyInfo = IsDtlsConnection
        type AttrGetType DtlsConnectionPeerCertificatePropertyInfo = Gio.TlsCertificate.TlsCertificate
        type AttrLabel DtlsConnectionPeerCertificatePropertyInfo = "peer-certificate"
        type AttrOrigin DtlsConnectionPeerCertificatePropertyInfo = DtlsConnection
        attrGet _ = getDtlsConnectionPeerCertificate
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "peer-certificate-errors"
       -- Type: TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"})
       -- Flags: [PropertyReadable]
       -- Nullable: (Just False,Nothing)

    {- |
    Get the value of the “@peer-certificate-errors@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' dtlsConnection #peerCertificateErrors
    @
    -}
    getDtlsConnectionPeerCertificateErrors :: (MonadIO m, IsDtlsConnection o) => o -> m [Gio.Flags.TlsCertificateFlags]
    getDtlsConnectionPeerCertificateErrors obj = liftIO $ getObjectPropertyFlags obj "peer-certificate-errors"

    #if ENABLE_OVERLOADING
    data DtlsConnectionPeerCertificateErrorsPropertyInfo
    instance AttrInfo DtlsConnectionPeerCertificateErrorsPropertyInfo where
        type AttrAllowedOps DtlsConnectionPeerCertificateErrorsPropertyInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint DtlsConnectionPeerCertificateErrorsPropertyInfo = (~) ()
        type AttrBaseTypeConstraint DtlsConnectionPeerCertificateErrorsPropertyInfo = IsDtlsConnection
        type AttrGetType DtlsConnectionPeerCertificateErrorsPropertyInfo = [Gio.Flags.TlsCertificateFlags]
        type AttrLabel DtlsConnectionPeerCertificateErrorsPropertyInfo = "peer-certificate-errors"
        type AttrOrigin DtlsConnectionPeerCertificateErrorsPropertyInfo = DtlsConnection
        attrGet _ = getDtlsConnectionPeerCertificateErrors
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "rehandshake-mode"
       -- Type: TInterface (Name {namespace = "Gio", name = "TlsRehandshakeMode"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
       -- Nullable: (Just False,Just False)

    {- |
    Get the value of the “@rehandshake-mode@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' dtlsConnection #rehandshakeMode
    @
    -}
    getDtlsConnectionRehandshakeMode :: (MonadIO m, IsDtlsConnection o) => o -> m Gio.Enums.TlsRehandshakeMode
    getDtlsConnectionRehandshakeMode obj = liftIO $ getObjectPropertyEnum obj "rehandshake-mode"

    {- |
    Set the value of the “@rehandshake-mode@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' dtlsConnection [ #rehandshakeMode 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setDtlsConnectionRehandshakeMode :: (MonadIO m, IsDtlsConnection o) => o -> Gio.Enums.TlsRehandshakeMode -> m ()
    setDtlsConnectionRehandshakeMode obj val = liftIO $ setObjectPropertyEnum obj "rehandshake-mode" val

    {- |
    Construct a `GValueConstruct` with valid value for the “@rehandshake-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDtlsConnectionRehandshakeMode :: (IsDtlsConnection o) => Gio.Enums.TlsRehandshakeMode -> IO (GValueConstruct o)
    constructDtlsConnectionRehandshakeMode val = constructObjectPropertyEnum "rehandshake-mode" val

    #if ENABLE_OVERLOADING
    data DtlsConnectionRehandshakeModePropertyInfo
    instance AttrInfo DtlsConnectionRehandshakeModePropertyInfo where
        type AttrAllowedOps DtlsConnectionRehandshakeModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint DtlsConnectionRehandshakeModePropertyInfo = (~) Gio.Enums.TlsRehandshakeMode
        type AttrBaseTypeConstraint DtlsConnectionRehandshakeModePropertyInfo = IsDtlsConnection
        type AttrGetType DtlsConnectionRehandshakeModePropertyInfo = Gio.Enums.TlsRehandshakeMode
        type AttrLabel DtlsConnectionRehandshakeModePropertyInfo = "rehandshake-mode"
        type AttrOrigin DtlsConnectionRehandshakeModePropertyInfo = DtlsConnection
        attrGet _ = getDtlsConnectionRehandshakeMode
        attrSet _ = setDtlsConnectionRehandshakeMode
        attrConstruct _ = constructDtlsConnectionRehandshakeMode
        attrClear _ = undefined
    #endif

    -- VVV Prop "require-close-notify"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
       -- Nullable: (Just False,Just False)

    {- |
    Get the value of the “@require-close-notify@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' dtlsConnection #requireCloseNotify
    @
    -}
    getDtlsConnectionRequireCloseNotify :: (MonadIO m, IsDtlsConnection o) => o -> m Bool
    getDtlsConnectionRequireCloseNotify obj = liftIO $ getObjectPropertyBool obj "require-close-notify"

    {- |
    Set the value of the “@require-close-notify@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' dtlsConnection [ #requireCloseNotify 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setDtlsConnectionRequireCloseNotify :: (MonadIO m, IsDtlsConnection o) => o -> Bool -> m ()
    setDtlsConnectionRequireCloseNotify obj val = liftIO $ setObjectPropertyBool obj "require-close-notify" val

    {- |
    Construct a `GValueConstruct` with valid value for the “@require-close-notify@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDtlsConnectionRequireCloseNotify :: (IsDtlsConnection o) => Bool -> IO (GValueConstruct o)
    constructDtlsConnectionRequireCloseNotify val = constructObjectPropertyBool "require-close-notify" val

    #if ENABLE_OVERLOADING
    data DtlsConnectionRequireCloseNotifyPropertyInfo
    instance AttrInfo DtlsConnectionRequireCloseNotifyPropertyInfo where
        type AttrAllowedOps DtlsConnectionRequireCloseNotifyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint DtlsConnectionRequireCloseNotifyPropertyInfo = (~) Bool
        type AttrBaseTypeConstraint DtlsConnectionRequireCloseNotifyPropertyInfo = IsDtlsConnection
        type AttrGetType DtlsConnectionRequireCloseNotifyPropertyInfo = Bool
        type AttrLabel DtlsConnectionRequireCloseNotifyPropertyInfo = "require-close-notify"
        type AttrOrigin DtlsConnectionRequireCloseNotifyPropertyInfo = DtlsConnection
        attrGet _ = getDtlsConnectionRequireCloseNotify
        attrSet _ = setDtlsConnectionRequireCloseNotify
        attrConstruct _ = constructDtlsConnectionRequireCloseNotify
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList DtlsConnection
    type instance O.AttributeList DtlsConnection = DtlsConnectionAttributeList
    type DtlsConnectionAttributeList = ('[ '("advertisedProtocols", DtlsConnectionAdvertisedProtocolsPropertyInfo), '("baseSocket", DtlsConnectionBaseSocketPropertyInfo), '("certificate", DtlsConnectionCertificatePropertyInfo), '("database", DtlsConnectionDatabasePropertyInfo), '("interaction", DtlsConnectionInteractionPropertyInfo), '("negotiatedProtocol", DtlsConnectionNegotiatedProtocolPropertyInfo), '("peerCertificate", DtlsConnectionPeerCertificatePropertyInfo), '("peerCertificateErrors", DtlsConnectionPeerCertificateErrorsPropertyInfo), '("rehandshakeMode", DtlsConnectionRehandshakeModePropertyInfo), '("requireCloseNotify", DtlsConnectionRequireCloseNotifyPropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    dtlsConnectionAdvertisedProtocols :: AttrLabelProxy "advertisedProtocols"
    dtlsConnectionAdvertisedProtocols = AttrLabelProxy

    dtlsConnectionBaseSocket :: AttrLabelProxy "baseSocket"
    dtlsConnectionBaseSocket = AttrLabelProxy

    dtlsConnectionCertificate :: AttrLabelProxy "certificate"
    dtlsConnectionCertificate = AttrLabelProxy

    dtlsConnectionDatabase :: AttrLabelProxy "database"
    dtlsConnectionDatabase = AttrLabelProxy

    dtlsConnectionInteraction :: AttrLabelProxy "interaction"
    dtlsConnectionInteraction = AttrLabelProxy

    dtlsConnectionNegotiatedProtocol :: AttrLabelProxy "negotiatedProtocol"
    dtlsConnectionNegotiatedProtocol = AttrLabelProxy

    dtlsConnectionPeerCertificate :: AttrLabelProxy "peerCertificate"
    dtlsConnectionPeerCertificate = AttrLabelProxy

    dtlsConnectionPeerCertificateErrors :: AttrLabelProxy "peerCertificateErrors"
    dtlsConnectionPeerCertificateErrors = AttrLabelProxy

    dtlsConnectionRehandshakeMode :: AttrLabelProxy "rehandshakeMode"
    dtlsConnectionRehandshakeMode = AttrLabelProxy

    dtlsConnectionRequireCloseNotify :: AttrLabelProxy "requireCloseNotify"
    dtlsConnectionRequireCloseNotify = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    type family ResolveDtlsConnectionMethod (t :: Symbol) (o :: *) :: * where
        ResolveDtlsConnectionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveDtlsConnectionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveDtlsConnectionMethod "close" o = DtlsConnectionCloseMethodInfo
        ResolveDtlsConnectionMethod "closeAsync" o = DtlsConnectionCloseAsyncMethodInfo
        ResolveDtlsConnectionMethod "closeFinish" o = DtlsConnectionCloseFinishMethodInfo
        ResolveDtlsConnectionMethod "conditionCheck" o = Gio.DatagramBased.DatagramBasedConditionCheckMethodInfo
        ResolveDtlsConnectionMethod "conditionWait" o = Gio.DatagramBased.DatagramBasedConditionWaitMethodInfo
        ResolveDtlsConnectionMethod "createSource" o = Gio.DatagramBased.DatagramBasedCreateSourceMethodInfo
        ResolveDtlsConnectionMethod "emitAcceptCertificate" o = DtlsConnectionEmitAcceptCertificateMethodInfo
        ResolveDtlsConnectionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveDtlsConnectionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveDtlsConnectionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveDtlsConnectionMethod "handshake" o = DtlsConnectionHandshakeMethodInfo
        ResolveDtlsConnectionMethod "handshakeAsync" o = DtlsConnectionHandshakeAsyncMethodInfo
        ResolveDtlsConnectionMethod "handshakeFinish" o = DtlsConnectionHandshakeFinishMethodInfo
        ResolveDtlsConnectionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveDtlsConnectionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveDtlsConnectionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveDtlsConnectionMethod "receiveMessages" o = Gio.DatagramBased.DatagramBasedReceiveMessagesMethodInfo
        ResolveDtlsConnectionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveDtlsConnectionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveDtlsConnectionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveDtlsConnectionMethod "sendMessages" o = Gio.DatagramBased.DatagramBasedSendMessagesMethodInfo
        ResolveDtlsConnectionMethod "shutdown" o = DtlsConnectionShutdownMethodInfo
        ResolveDtlsConnectionMethod "shutdownAsync" o = DtlsConnectionShutdownAsyncMethodInfo
        ResolveDtlsConnectionMethod "shutdownFinish" o = DtlsConnectionShutdownFinishMethodInfo
        ResolveDtlsConnectionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveDtlsConnectionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveDtlsConnectionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveDtlsConnectionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveDtlsConnectionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveDtlsConnectionMethod "getCertificate" o = DtlsConnectionGetCertificateMethodInfo
        ResolveDtlsConnectionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveDtlsConnectionMethod "getDatabase" o = DtlsConnectionGetDatabaseMethodInfo
        ResolveDtlsConnectionMethod "getInteraction" o = DtlsConnectionGetInteractionMethodInfo
        ResolveDtlsConnectionMethod "getNegotiatedProtocol" o = DtlsConnectionGetNegotiatedProtocolMethodInfo
        ResolveDtlsConnectionMethod "getPeerCertificate" o = DtlsConnectionGetPeerCertificateMethodInfo
        ResolveDtlsConnectionMethod "getPeerCertificateErrors" o = DtlsConnectionGetPeerCertificateErrorsMethodInfo
        ResolveDtlsConnectionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveDtlsConnectionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveDtlsConnectionMethod "getRehandshakeMode" o = DtlsConnectionGetRehandshakeModeMethodInfo
        ResolveDtlsConnectionMethod "getRequireCloseNotify" o = DtlsConnectionGetRequireCloseNotifyMethodInfo
        ResolveDtlsConnectionMethod "setAdvertisedProtocols" o = DtlsConnectionSetAdvertisedProtocolsMethodInfo
        ResolveDtlsConnectionMethod "setCertificate" o = DtlsConnectionSetCertificateMethodInfo
        ResolveDtlsConnectionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveDtlsConnectionMethod "setDatabase" o = DtlsConnectionSetDatabaseMethodInfo
        ResolveDtlsConnectionMethod "setInteraction" o = DtlsConnectionSetInteractionMethodInfo
        ResolveDtlsConnectionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveDtlsConnectionMethod "setRehandshakeMode" o = DtlsConnectionSetRehandshakeModeMethodInfo
        ResolveDtlsConnectionMethod "setRequireCloseNotify" o = DtlsConnectionSetRequireCloseNotifyMethodInfo
        ResolveDtlsConnectionMethod l o = O.MethodResolutionFailed l o

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

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveDtlsConnectionMethod t DtlsConnection, O.MethodInfo info DtlsConnection p) => O.IsLabel t (DtlsConnection -> 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

    -- method DtlsConnection::close
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", 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 (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_dtls_connection_close" g_dtls_connection_close ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Close the DTLS connection. This is equivalent to calling
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionShutdown' to shut down both sides of the connection.

    Closing a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' waits for all buffered but untransmitted data to
    be sent before it completes. It then sends a @close_notify@ DTLS alert to the
    peer and may wait for a @close_notify@ to be received from the peer. It does
    not close the underlying 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection':@/base-socket/@; that must be closed
    separately.

    Once /@conn@/ is closed, all other operations will return 'GI.Gio.Enums.IOErrorEnumClosed'.
    Closing a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' multiple times will not return an error.

    @/GDtlsConnections/@ will be automatically closed when the last reference is
    dropped, but you might want to call this function to make sure resources are
    released as early as possible.

    If /@cancellable@/ is cancelled, the 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' may be left
    partially-closed and any pending untransmitted data may be lost. Call
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionClose' again to complete closing the 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'.

    /Since: 2.48/
    -}
    dtlsConnectionClose ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dtlsConnectionClose conn cancellable = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_dtls_connection_close conn' maybeCancellable
            touchManagedPtr conn
            whenJust cancellable touchManagedPtr
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data DtlsConnectionCloseMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DtlsConnectionCloseMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionClose

    #endif

    -- method DtlsConnection::close_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the [I/O priority][io-priority] of the request", 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 close operation is complete", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, 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_dtls_connection_close_async" g_dtls_connection_close_async ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        Int32 ->                                -- io_priority : TBasicType TInt
        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 close the DTLS connection. See 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionClose' for
    more information.

    /Since: 2.48/
    -}
    dtlsConnectionCloseAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> Int32
        {- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the close operation is complete -}
        -> m ()
    dtlsConnectionCloseAsync conn ioPriority cancellable callback = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        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_dtls_connection_close_async conn' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr conn
        whenJust cancellable touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data DtlsConnectionCloseAsyncMethodInfo
    instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DtlsConnectionCloseAsyncMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionCloseAsync

    #endif

    -- method DtlsConnection::close_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", 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 (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_dtls_connection_close_finish" g_dtls_connection_close_finish ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Finish an asynchronous TLS close operation. See 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionClose'
    for more information.

    /Since: 2.48/
    -}
    dtlsConnectionCloseFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dtlsConnectionCloseFinish conn result_ = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            _ <- propagateGError $ g_dtls_connection_close_finish conn' result_'
            touchManagedPtr conn
            touchManagedPtr result_
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data DtlsConnectionCloseFinishMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsDtlsConnection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo DtlsConnectionCloseFinishMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionCloseFinish

    #endif

    -- method DtlsConnection::emit_accept_certificate
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "peer_cert", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificate"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the peer's #GTlsCertificate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "errors", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the problems with @peer_cert", 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 "g_dtls_connection_emit_accept_certificate" g_dtls_connection_emit_accept_certificate ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        Ptr Gio.TlsCertificate.TlsCertificate -> -- peer_cert : TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
        CUInt ->                                -- errors : TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"})
        IO CInt

    {- |
    Used by 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' implementations to emit the
    'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'::@/accept-certificate/@ signal.

    /Since: 2.48/
    -}
    dtlsConnectionEmitAcceptCertificate ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.TlsCertificate.IsTlsCertificate b) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> b
        {- ^ /@peerCert@/: the peer\'s 'GI.Gio.Objects.TlsCertificate.TlsCertificate' -}
        -> [Gio.Flags.TlsCertificateFlags]
        {- ^ /@errors@/: the problems with /@peerCert@/ -}
        -> m Bool
        {- ^ __Returns:__ 'True' if one of the signal handlers has returned
        'True' to accept /@peerCert@/ -}
    dtlsConnectionEmitAcceptCertificate conn peerCert errors = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        peerCert' <- unsafeManagedPtrCastPtr peerCert
        let errors' = gflagsToWord errors
        result <- g_dtls_connection_emit_accept_certificate conn' peerCert' errors'
        let result' = (/= 0) result
        touchManagedPtr conn
        touchManagedPtr peerCert
        return result'

    #if ENABLE_OVERLOADING
    data DtlsConnectionEmitAcceptCertificateMethodInfo
    instance (signature ~ (b -> [Gio.Flags.TlsCertificateFlags] -> m Bool), MonadIO m, IsDtlsConnection a, Gio.TlsCertificate.IsTlsCertificate b) => O.MethodInfo DtlsConnectionEmitAcceptCertificateMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionEmitAcceptCertificate

    #endif

    -- method DtlsConnection::get_certificate
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", 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 "g_dtls_connection_get_certificate" g_dtls_connection_get_certificate ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        IO (Ptr Gio.TlsCertificate.TlsCertificate)

    {- |
    Gets /@conn@/\'s certificate, as set by
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetCertificate'.

    /Since: 2.48/
    -}
    dtlsConnectionGetCertificate ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> m Gio.TlsCertificate.TlsCertificate
        {- ^ __Returns:__ /@conn@/\'s certificate, or 'Nothing' -}
    dtlsConnectionGetCertificate conn = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        result <- g_dtls_connection_get_certificate conn'
        checkUnexpectedReturnNULL "dtlsConnectionGetCertificate" result
        result' <- (newObject Gio.TlsCertificate.TlsCertificate) result
        touchManagedPtr conn
        return result'

    #if ENABLE_OVERLOADING
    data DtlsConnectionGetCertificateMethodInfo
    instance (signature ~ (m Gio.TlsCertificate.TlsCertificate), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionGetCertificateMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionGetCertificate

    #endif

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

    foreign import ccall "g_dtls_connection_get_database" g_dtls_connection_get_database ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        IO (Ptr Gio.TlsDatabase.TlsDatabase)

    {- |
    Gets the certificate database that /@conn@/ uses to verify
    peer certificates. See 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetDatabase'.

    /Since: 2.48/
    -}
    dtlsConnectionGetDatabase ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> m Gio.TlsDatabase.TlsDatabase
        {- ^ __Returns:__ the certificate database that /@conn@/ uses or 'Nothing' -}
    dtlsConnectionGetDatabase conn = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        result <- g_dtls_connection_get_database conn'
        checkUnexpectedReturnNULL "dtlsConnectionGetDatabase" result
        result' <- (newObject Gio.TlsDatabase.TlsDatabase) result
        touchManagedPtr conn
        return result'

    #if ENABLE_OVERLOADING
    data DtlsConnectionGetDatabaseMethodInfo
    instance (signature ~ (m Gio.TlsDatabase.TlsDatabase), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionGetDatabaseMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionGetDatabase

    #endif

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

    foreign import ccall "g_dtls_connection_get_interaction" g_dtls_connection_get_interaction ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        IO (Ptr Gio.TlsInteraction.TlsInteraction)

    {- |
    Get the object that will be used to interact with the user. It will be used
    for things like prompting the user for passwords. If 'Nothing' is returned, then
    no user interaction will occur for this connection.

    /Since: 2.48/
    -}
    dtlsConnectionGetInteraction ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
        a
        {- ^ /@conn@/: a connection -}
        -> m Gio.TlsInteraction.TlsInteraction
        {- ^ __Returns:__ The interaction object. -}
    dtlsConnectionGetInteraction conn = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        result <- g_dtls_connection_get_interaction conn'
        checkUnexpectedReturnNULL "dtlsConnectionGetInteraction" result
        result' <- (newObject Gio.TlsInteraction.TlsInteraction) result
        touchManagedPtr conn
        return result'

    #if ENABLE_OVERLOADING
    data DtlsConnectionGetInteractionMethodInfo
    instance (signature ~ (m Gio.TlsInteraction.TlsInteraction), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionGetInteractionMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionGetInteraction

    #endif

    -- method DtlsConnection::get_negotiated_protocol
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", 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_dtls_connection_get_negotiated_protocol" g_dtls_connection_get_negotiated_protocol ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        IO CString

    {- |
    Gets the name of the application-layer protocol negotiated during
    the handshake.

    If the peer did not use the ALPN extension, or did not advertise a
    protocol that matched one of /@conn@/\'s protocols, or the TLS backend
    does not support ALPN, then this will be 'Nothing'. See
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetAdvertisedProtocols'.

    /Since: 2.60/
    -}
    dtlsConnectionGetNegotiatedProtocol ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> m (Maybe T.Text)
        {- ^ __Returns:__ the negotiated protocol, or 'Nothing' -}
    dtlsConnectionGetNegotiatedProtocol conn = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        result <- g_dtls_connection_get_negotiated_protocol conn'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- cstringToText result'
            return result''
        touchManagedPtr conn
        return maybeResult

    #if ENABLE_OVERLOADING
    data DtlsConnectionGetNegotiatedProtocolMethodInfo
    instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionGetNegotiatedProtocolMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionGetNegotiatedProtocol

    #endif

    -- method DtlsConnection::get_peer_certificate
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", 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 "g_dtls_connection_get_peer_certificate" g_dtls_connection_get_peer_certificate ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        IO (Ptr Gio.TlsCertificate.TlsCertificate)

    {- |
    Gets /@conn@/\'s peer\'s certificate after the handshake has completed.
    (It is not set during the emission of
    'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'::@/accept-certificate/@.)

    /Since: 2.48/
    -}
    dtlsConnectionGetPeerCertificate ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> m Gio.TlsCertificate.TlsCertificate
        {- ^ __Returns:__ /@conn@/\'s peer\'s certificate, or 'Nothing' -}
    dtlsConnectionGetPeerCertificate conn = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        result <- g_dtls_connection_get_peer_certificate conn'
        checkUnexpectedReturnNULL "dtlsConnectionGetPeerCertificate" result
        result' <- (newObject Gio.TlsCertificate.TlsCertificate) result
        touchManagedPtr conn
        return result'

    #if ENABLE_OVERLOADING
    data DtlsConnectionGetPeerCertificateMethodInfo
    instance (signature ~ (m Gio.TlsCertificate.TlsCertificate), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionGetPeerCertificateMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionGetPeerCertificate

    #endif

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

    foreign import ccall "g_dtls_connection_get_peer_certificate_errors" g_dtls_connection_get_peer_certificate_errors ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        IO CUInt

    {- |
    Gets the errors associated with validating /@conn@/\'s peer\'s
    certificate, after the handshake has completed. (It is not set
    during the emission of 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'::@/accept-certificate/@.)

    /Since: 2.48/
    -}
    dtlsConnectionGetPeerCertificateErrors ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> m [Gio.Flags.TlsCertificateFlags]
        {- ^ __Returns:__ /@conn@/\'s peer\'s certificate errors -}
    dtlsConnectionGetPeerCertificateErrors conn = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        result <- g_dtls_connection_get_peer_certificate_errors conn'
        let result' = wordToGFlags result
        touchManagedPtr conn
        return result'

    #if ENABLE_OVERLOADING
    data DtlsConnectionGetPeerCertificateErrorsMethodInfo
    instance (signature ~ (m [Gio.Flags.TlsCertificateFlags]), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionGetPeerCertificateErrorsMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionGetPeerCertificateErrors

    #endif

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

    foreign import ccall "g_dtls_connection_get_rehandshake_mode" g_dtls_connection_get_rehandshake_mode ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        IO CUInt

    {- |
    Gets /@conn@/ rehandshaking mode. See
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetRehandshakeMode' for details.

    /Since: 2.48/
    -}
    dtlsConnectionGetRehandshakeMode ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> m Gio.Enums.TlsRehandshakeMode
        {- ^ __Returns:__ /@conn@/\'s rehandshaking mode -}
    dtlsConnectionGetRehandshakeMode conn = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        result <- g_dtls_connection_get_rehandshake_mode conn'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr conn
        return result'

    #if ENABLE_OVERLOADING
    data DtlsConnectionGetRehandshakeModeMethodInfo
    instance (signature ~ (m Gio.Enums.TlsRehandshakeMode), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionGetRehandshakeModeMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionGetRehandshakeMode

    #endif

    -- method DtlsConnection::get_require_close_notify
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", 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 "g_dtls_connection_get_require_close_notify" g_dtls_connection_get_require_close_notify ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        IO CInt

    {- |
    Tests whether or not /@conn@/ expects a proper TLS close notification
    when the connection is closed. See
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetRequireCloseNotify' for details.

    /Since: 2.48/
    -}
    dtlsConnectionGetRequireCloseNotify ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if /@conn@/ requires a proper TLS close notification. -}
    dtlsConnectionGetRequireCloseNotify conn = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        result <- g_dtls_connection_get_require_close_notify conn'
        let result' = (/= 0) result
        touchManagedPtr conn
        return result'

    #if ENABLE_OVERLOADING
    data DtlsConnectionGetRequireCloseNotifyMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionGetRequireCloseNotifyMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionGetRequireCloseNotify

    #endif

    -- method DtlsConnection::handshake
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", 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 (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_dtls_connection_handshake" g_dtls_connection_handshake ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Attempts a TLS handshake on /@conn@/.

    On the client side, it is never necessary to call this method;
    although the connection needs to perform a handshake after
    connecting (or after sending a \"STARTTLS\"-type command) and may
    need to rehandshake later if the server requests it,
    'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' will handle this for you automatically when you try
    to send or receive data on the connection. However, you can call
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionHandshake' manually if you want to know for sure
    whether the initial handshake succeeded or failed (as opposed to
    just immediately trying to write to /@conn@/, in which
    case if it fails, it may not be possible to tell if it failed
    before or after completing the handshake).

    Likewise, on the server side, although a handshake is necessary at
    the beginning of the communication, you do not need to call this
    function explicitly unless you want clearer error reporting.

    If TLS 1.2 or older is in use, you may call
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionHandshake' after the initial handshake to
    rehandshake; however, this usage is deprecated because rehandshaking
    is no longer part of the TLS protocol in TLS 1.3. Accordingly, the
    behavior of calling this function after the initial handshake is now
    undefined, except it is guaranteed to be reasonable and
    nondestructive so as to preserve compatibility with code written for
    older versions of GLib.

    'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'::@/accept_certificate/@ may be emitted during the
    handshake.

    /Since: 2.48/
    -}
    dtlsConnectionHandshake ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dtlsConnectionHandshake conn cancellable = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_dtls_connection_handshake conn' maybeCancellable
            touchManagedPtr conn
            whenJust cancellable touchManagedPtr
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data DtlsConnectionHandshakeMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DtlsConnectionHandshakeMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionHandshake

    #endif

    -- method DtlsConnection::handshake_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the [I/O priority][io-priority] of the request", 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 handshake is complete", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, 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_dtls_connection_handshake_async" g_dtls_connection_handshake_async ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        Int32 ->                                -- io_priority : TBasicType TInt
        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 performs a TLS handshake on /@conn@/. See
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionHandshake' for more information.

    /Since: 2.48/
    -}
    dtlsConnectionHandshakeAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> Int32
        {- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the handshake is complete -}
        -> m ()
    dtlsConnectionHandshakeAsync conn ioPriority cancellable callback = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        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_dtls_connection_handshake_async conn' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr conn
        whenJust cancellable touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data DtlsConnectionHandshakeAsyncMethodInfo
    instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DtlsConnectionHandshakeAsyncMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionHandshakeAsync

    #endif

    -- method DtlsConnection::handshake_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", 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 (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_dtls_connection_handshake_finish" g_dtls_connection_handshake_finish ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Finish an asynchronous TLS handshake operation. See
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionHandshake' for more information.

    /Since: 2.48/
    -}
    dtlsConnectionHandshakeFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dtlsConnectionHandshakeFinish conn result_ = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            _ <- propagateGError $ g_dtls_connection_handshake_finish conn' result_'
            touchManagedPtr conn
            touchManagedPtr result_
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data DtlsConnectionHandshakeFinishMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsDtlsConnection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo DtlsConnectionHandshakeFinishMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionHandshakeFinish

    #endif

    -- method DtlsConnection::set_advertised_protocols
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "protocols", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a %NULL-terminated\n  array of ALPN protocol names (eg, \"http/1.1\", \"h2\"), or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_dtls_connection_set_advertised_protocols" g_dtls_connection_set_advertised_protocols ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        Ptr CString ->                          -- protocols : TCArray True (-1) (-1) (TBasicType TUTF8)
        IO ()

    {- |
    Sets the list of application-layer protocols to advertise that the
    caller is willing to speak on this connection. The
    Application-Layer Protocol Negotiation (ALPN) extension will be
    used to negotiate a compatible protocol with the peer; use
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionGetNegotiatedProtocol' to find the negotiated
    protocol after the handshake.  Specifying 'Nothing' for the the value
    of /@protocols@/ will disable ALPN negotiation.

    See <https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids IANA TLS ALPN Protocol IDs>
    for a list of registered protocol IDs.

    /Since: 2.60/
    -}
    dtlsConnectionSetAdvertisedProtocols ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> Maybe ([T.Text])
        {- ^ /@protocols@/: a 'Nothing'-terminated
      array of ALPN protocol names (eg, \"http\/1.1\", \"h2\"), or 'Nothing' -}
        -> m ()
    dtlsConnectionSetAdvertisedProtocols conn protocols = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        maybeProtocols <- case protocols of
            Nothing -> return nullPtr
            Just jProtocols -> do
                jProtocols' <- packZeroTerminatedUTF8CArray jProtocols
                return jProtocols'
        g_dtls_connection_set_advertised_protocols conn' maybeProtocols
        touchManagedPtr conn
        mapZeroTerminatedCArray freeMem maybeProtocols
        freeMem maybeProtocols
        return ()

    #if ENABLE_OVERLOADING
    data DtlsConnectionSetAdvertisedProtocolsMethodInfo
    instance (signature ~ (Maybe ([T.Text]) -> m ()), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionSetAdvertisedProtocolsMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionSetAdvertisedProtocols

    #endif

    -- method DtlsConnection::set_certificate
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", 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 "the certificate to use for @conn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_dtls_connection_set_certificate" g_dtls_connection_set_certificate ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        Ptr Gio.TlsCertificate.TlsCertificate -> -- certificate : TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
        IO ()

    {- |
    This sets the certificate that /@conn@/ will present to its peer
    during the TLS handshake. For a 'GI.Gio.Interfaces.DtlsServerConnection.DtlsServerConnection', it is
    mandatory to set this, and that will normally be done at construct
    time.

    For a 'GI.Gio.Interfaces.DtlsClientConnection.DtlsClientConnection', this is optional. If a handshake fails
    with 'GI.Gio.Enums.TlsErrorCertificateRequired', that means that the server
    requires a certificate, and if you try connecting again, you should
    call this method first. You can call
    'GI.Gio.Interfaces.DtlsClientConnection.dtlsClientConnectionGetAcceptedCas' on the failed connection
    to get a list of Certificate Authorities that the server will
    accept certificates from.

    (It is also possible that a server will allow the connection with
    or without a certificate; in that case, if you don\'t provide a
    certificate, you can tell that the server requested one by the fact
    that 'GI.Gio.Interfaces.DtlsClientConnection.dtlsClientConnectionGetAcceptedCas' will return
    non-'Nothing'.)

    /Since: 2.48/
    -}
    dtlsConnectionSetCertificate ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.TlsCertificate.IsTlsCertificate b) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> b
        {- ^ /@certificate@/: the certificate to use for /@conn@/ -}
        -> m ()
    dtlsConnectionSetCertificate conn certificate = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        certificate' <- unsafeManagedPtrCastPtr certificate
        g_dtls_connection_set_certificate conn' certificate'
        touchManagedPtr conn
        touchManagedPtr certificate
        return ()

    #if ENABLE_OVERLOADING
    data DtlsConnectionSetCertificateMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsDtlsConnection a, Gio.TlsCertificate.IsTlsCertificate b) => O.MethodInfo DtlsConnectionSetCertificateMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionSetCertificate

    #endif

    -- method DtlsConnection::set_database
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "database", 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}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_dtls_connection_set_database" g_dtls_connection_set_database ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        Ptr Gio.TlsDatabase.TlsDatabase ->      -- database : TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
        IO ()

    {- |
    Sets the certificate database that is used to verify peer certificates.
    This is set to the default database by default. See
    'GI.Gio.Interfaces.TlsBackend.tlsBackendGetDefaultDatabase'. If set to 'Nothing', then
    peer certificate validation will always set the
    'GI.Gio.Flags.TlsCertificateFlagsUnknownCa' error (meaning
    'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'::@/accept-certificate/@ will always be emitted on
    client-side connections, unless that bit is not set in
    'GI.Gio.Interfaces.DtlsClientConnection.DtlsClientConnection':@/validation-flags/@).

    /Since: 2.48/
    -}
    dtlsConnectionSetDatabase ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.TlsDatabase.IsTlsDatabase b) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> b
        {- ^ /@database@/: a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' -}
        -> m ()
    dtlsConnectionSetDatabase conn database = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        database' <- unsafeManagedPtrCastPtr database
        g_dtls_connection_set_database conn' database'
        touchManagedPtr conn
        touchManagedPtr database
        return ()

    #if ENABLE_OVERLOADING
    data DtlsConnectionSetDatabaseMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsDtlsConnection a, Gio.TlsDatabase.IsTlsDatabase b) => O.MethodInfo DtlsConnectionSetDatabaseMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionSetDatabase

    #endif

    -- method DtlsConnection::set_interaction
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a connection", 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 "an interaction object, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_dtls_connection_set_interaction" g_dtls_connection_set_interaction ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        Ptr Gio.TlsInteraction.TlsInteraction -> -- interaction : TInterface (Name {namespace = "Gio", name = "TlsInteraction"})
        IO ()

    {- |
    Set the object that will be used to interact with the user. It will be used
    for things like prompting the user for passwords.

    The /@interaction@/ argument will normally be a derived subclass of
    'GI.Gio.Objects.TlsInteraction.TlsInteraction'. 'Nothing' can also be provided if no user interaction
    should occur for this connection.

    /Since: 2.48/
    -}
    dtlsConnectionSetInteraction ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.TlsInteraction.IsTlsInteraction b) =>
        a
        {- ^ /@conn@/: a connection -}
        -> Maybe (b)
        {- ^ /@interaction@/: an interaction object, or 'Nothing' -}
        -> m ()
    dtlsConnectionSetInteraction conn interaction = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        maybeInteraction <- case interaction of
            Nothing -> return nullPtr
            Just jInteraction -> do
                jInteraction' <- unsafeManagedPtrCastPtr jInteraction
                return jInteraction'
        g_dtls_connection_set_interaction conn' maybeInteraction
        touchManagedPtr conn
        whenJust interaction touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data DtlsConnectionSetInteractionMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsDtlsConnection a, Gio.TlsInteraction.IsTlsInteraction b) => O.MethodInfo DtlsConnectionSetInteractionMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionSetInteraction

    #endif

    -- method DtlsConnection::set_rehandshake_mode
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Gio", name = "TlsRehandshakeMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the rehandshaking mode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_dtls_connection_set_rehandshake_mode" g_dtls_connection_set_rehandshake_mode ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        CUInt ->                                -- mode : TInterface (Name {namespace = "Gio", name = "TlsRehandshakeMode"})
        IO ()

    {-# DEPRECATED dtlsConnectionSetRehandshakeMode ["(Since version 2.60.)","Changing the rehandshake mode is no longer","  required for compatibility. Also, rehandshaking has been removed","  from the TLS protocol in TLS 1.3."] #-}
    {- |
    Sets how /@conn@/ behaves with respect to rehandshaking requests.

    'GI.Gio.Enums.TlsRehandshakeModeNever' means that it will never agree to
    rehandshake after the initial handshake is complete. (For a client,
    this means it will refuse rehandshake requests from the server, and
    for a server, this means it will close the connection with an error
    if the client attempts to rehandshake.)

    'GI.Gio.Enums.TlsRehandshakeModeSafely' means that the connection will allow a
    rehandshake only if the other end of the connection supports the
    TLS @renegotiation_info@ extension. This is the default behavior,
    but means that rehandshaking will not work against older
    implementations that do not support that extension.

    'GI.Gio.Enums.TlsRehandshakeModeUnsafely' means that the connection will allow
    rehandshaking even without the @renegotiation_info@ extension. On
    the server side in particular, this is not recommended, since it
    leaves the server open to certain attacks. However, this mode is
    necessary if you need to allow renegotiation with older client
    software.

    /Since: 2.48/
    -}
    dtlsConnectionSetRehandshakeMode ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> Gio.Enums.TlsRehandshakeMode
        {- ^ /@mode@/: the rehandshaking mode -}
        -> m ()
    dtlsConnectionSetRehandshakeMode conn mode = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        let mode' = (fromIntegral . fromEnum) mode
        g_dtls_connection_set_rehandshake_mode conn' mode'
        touchManagedPtr conn
        return ()

    #if ENABLE_OVERLOADING
    data DtlsConnectionSetRehandshakeModeMethodInfo
    instance (signature ~ (Gio.Enums.TlsRehandshakeMode -> m ()), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionSetRehandshakeModeMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionSetRehandshakeMode

    #endif

    -- method DtlsConnection::set_require_close_notify
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "require_close_notify", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether or not to require close notification", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_dtls_connection_set_require_close_notify" g_dtls_connection_set_require_close_notify ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        CInt ->                                 -- require_close_notify : TBasicType TBoolean
        IO ()

    {- |
    Sets whether or not /@conn@/ expects a proper TLS close notification
    before the connection is closed. If this is 'True' (the default),
    then /@conn@/ will expect to receive a TLS close notification from its
    peer before the connection is closed, and will return a
    'GI.Gio.Enums.TlsErrorEof' error if the connection is closed without proper
    notification (since this may indicate a network error, or
    man-in-the-middle attack).

    In some protocols, the application will know whether or not the
    connection was closed cleanly based on application-level data
    (because the application-level data includes a length field, or is
    somehow self-delimiting); in this case, the close notify is
    redundant and may be omitted. You
    can use 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetRequireCloseNotify' to tell /@conn@/
    to allow an \"unannounced\" connection close, in which case the close
    will show up as a 0-length read, as in a non-TLS
    'GI.Gio.Interfaces.DatagramBased.DatagramBased', and it is up to the application to check that
    the data has been fully received.

    Note that this only affects the behavior when the peer closes the
    connection; when the application calls 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionCloseAsync' on
    /@conn@/ itself, this will send a close notification regardless of the
    setting of this property. If you explicitly want to do an unclean
    close, you can close /@conn@/\'s 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection':@/base-socket/@ rather
    than closing /@conn@/ itself.

    /Since: 2.48/
    -}
    dtlsConnectionSetRequireCloseNotify ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> Bool
        {- ^ /@requireCloseNotify@/: whether or not to require close notification -}
        -> m ()
    dtlsConnectionSetRequireCloseNotify conn requireCloseNotify = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        let requireCloseNotify' = (fromIntegral . fromEnum) requireCloseNotify
        g_dtls_connection_set_require_close_notify conn' requireCloseNotify'
        touchManagedPtr conn
        return ()

    #if ENABLE_OVERLOADING
    data DtlsConnectionSetRequireCloseNotifyMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionSetRequireCloseNotifyMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionSetRequireCloseNotify

    #endif

    -- method DtlsConnection::shutdown
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "shutdown_read", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to stop reception of incoming datagrams", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "shutdown_write", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to stop sending outgoing datagrams", 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 (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_dtls_connection_shutdown" g_dtls_connection_shutdown ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        CInt ->                                 -- shutdown_read : TBasicType TBoolean
        CInt ->                                 -- shutdown_write : TBasicType TBoolean
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Shut down part or all of a DTLS connection.

    If /@shutdownRead@/ is 'True' then the receiving side of the connection is shut
    down, and further reading is disallowed. Subsequent calls to
    'GI.Gio.Interfaces.DatagramBased.datagramBasedReceiveMessages' will return 'GI.Gio.Enums.IOErrorEnumClosed'.

    If /@shutdownWrite@/ is 'True' then the sending side of the connection is shut
    down, and further writing is disallowed. Subsequent calls to
    'GI.Gio.Interfaces.DatagramBased.datagramBasedSendMessages' will return 'GI.Gio.Enums.IOErrorEnumClosed'.

    It is allowed for both /@shutdownRead@/ and /@shutdownWrite@/ to be TRUE — this
    is equivalent to calling 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionClose'.

    If /@cancellable@/ is cancelled, the 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' may be left
    partially-closed and any pending untransmitted data may be lost. Call
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionShutdown' again to complete closing the 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'.

    /Since: 2.48/
    -}
    dtlsConnectionShutdown ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> Bool
        {- ^ /@shutdownRead@/: 'True' to stop reception of incoming datagrams -}
        -> Bool
        {- ^ /@shutdownWrite@/: 'True' to stop sending outgoing datagrams -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dtlsConnectionShutdown conn shutdownRead shutdownWrite cancellable = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        let shutdownRead' = (fromIntegral . fromEnum) shutdownRead
        let shutdownWrite' = (fromIntegral . fromEnum) shutdownWrite
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_dtls_connection_shutdown conn' shutdownRead' shutdownWrite' maybeCancellable
            touchManagedPtr conn
            whenJust cancellable touchManagedPtr
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data DtlsConnectionShutdownMethodInfo
    instance (signature ~ (Bool -> Bool -> Maybe (b) -> m ()), MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DtlsConnectionShutdownMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionShutdown

    #endif

    -- method DtlsConnection::shutdown_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "shutdown_read", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to stop reception of incoming datagrams", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "shutdown_write", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to stop sending outgoing datagrams", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the [I/O priority][io-priority] of the request", 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 shutdown operation is complete", 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_dtls_connection_shutdown_async" g_dtls_connection_shutdown_async ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        CInt ->                                 -- shutdown_read : TBasicType TBoolean
        CInt ->                                 -- shutdown_write : TBasicType TBoolean
        Int32 ->                                -- io_priority : TBasicType TInt
        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 shut down part or all of the DTLS connection. See
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionShutdown' for more information.

    /Since: 2.48/
    -}
    dtlsConnectionShutdownAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> Bool
        {- ^ /@shutdownRead@/: 'True' to stop reception of incoming datagrams -}
        -> Bool
        {- ^ /@shutdownWrite@/: 'True' to stop sending outgoing datagrams -}
        -> Int32
        {- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the shutdown operation is complete -}
        -> m ()
    dtlsConnectionShutdownAsync conn shutdownRead shutdownWrite ioPriority cancellable callback = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        let shutdownRead' = (fromIntegral . fromEnum) shutdownRead
        let shutdownWrite' = (fromIntegral . fromEnum) shutdownWrite
        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_dtls_connection_shutdown_async conn' shutdownRead' shutdownWrite' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr conn
        whenJust cancellable touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data DtlsConnectionShutdownAsyncMethodInfo
    instance (signature ~ (Bool -> Bool -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DtlsConnectionShutdownAsyncMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionShutdownAsync

    #endif

    -- method DtlsConnection::shutdown_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", 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 (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_dtls_connection_shutdown_finish" g_dtls_connection_shutdown_finish ::
        Ptr DtlsConnection ->                   -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Finish an asynchronous TLS shutdown operation. See
    'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionShutdown' for more information.

    /Since: 2.48/
    -}
    dtlsConnectionShutdownFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dtlsConnectionShutdownFinish conn result_ = liftIO $ do
        conn' <- unsafeManagedPtrCastPtr conn
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            _ <- propagateGError $ g_dtls_connection_shutdown_finish conn' result_'
            touchManagedPtr conn
            touchManagedPtr result_
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data DtlsConnectionShutdownFinishMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsDtlsConnection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo DtlsConnectionShutdownFinishMethodInfo a signature where
        overloadedMethod _ = dtlsConnectionShutdownFinish

    #endif