    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- This is the subclass of t'GI.Gio.Objects.SocketConnection.SocketConnection' that is created
    -- for TCP\/IP sockets.
    --
    -- /Since: 2.22/

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gio.Objects.TcpConnection
        (

    -- * Exported types
        TcpConnection(..)                       ,
        IsTcpConnection                         ,
        toTcpConnection                         ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [clearPending]("GI.Gio.Objects.IOStream#g:method:clearPending"), [close]("GI.Gio.Objects.IOStream#g:method:close"), [closeAsync]("GI.Gio.Objects.IOStream#g:method:closeAsync"), [closeFinish]("GI.Gio.Objects.IOStream#g:method:closeFinish"), [connect]("GI.Gio.Objects.SocketConnection#g:method:connect"), [connectAsync]("GI.Gio.Objects.SocketConnection#g:method:connectAsync"), [connectFinish]("GI.Gio.Objects.SocketConnection#g:method:connectFinish"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hasPending]("GI.Gio.Objects.IOStream#g:method:hasPending"), [isClosed]("GI.Gio.Objects.IOStream#g:method:isClosed"), [isConnected]("GI.Gio.Objects.SocketConnection#g:method:isConnected"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [spliceAsync]("GI.Gio.Objects.IOStream#g:method:spliceAsync"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
    --
    -- ==== Getters
    -- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getGracefulDisconnect]("GI.Gio.Objects.TcpConnection#g:method:getGracefulDisconnect"), [getInputStream]("GI.Gio.Objects.IOStream#g:method:getInputStream"), [getLocalAddress]("GI.Gio.Objects.SocketConnection#g:method:getLocalAddress"), [getOutputStream]("GI.Gio.Objects.IOStream#g:method:getOutputStream"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRemoteAddress]("GI.Gio.Objects.SocketConnection#g:method:getRemoteAddress"), [getSocket]("GI.Gio.Objects.SocketConnection#g:method:getSocket").
    --
    -- ==== Setters
    -- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setGracefulDisconnect]("GI.Gio.Objects.TcpConnection#g:method:setGracefulDisconnect"), [setPending]("GI.Gio.Objects.IOStream#g:method:setPending"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

    #if defined(ENABLE_OVERLOADING)
        ResolveTcpConnectionMethod              ,
    #endif

    -- ** getGracefulDisconnect #method:getGracefulDisconnect#

    #if defined(ENABLE_OVERLOADING)
        TcpConnectionGetGracefulDisconnectMethodInfo,
    #endif
        tcpConnectionGetGracefulDisconnect      ,

    -- ** setGracefulDisconnect #method:setGracefulDisconnect#

    #if defined(ENABLE_OVERLOADING)
        TcpConnectionSetGracefulDisconnectMethodInfo,
    #endif
        tcpConnectionSetGracefulDisconnect      ,

     -- * Properties

    -- ** gracefulDisconnect #attr:gracefulDisconnect#
    -- | Whether 'GI.Gio.Objects.IOStream.iOStreamClose' does a graceful disconnect.
    --
    -- /Since: 2.22/

    #if defined(ENABLE_OVERLOADING)
        TcpConnectionGracefulDisconnectPropertyInfo,
    #endif
        constructTcpConnectionGracefulDisconnect,
        getTcpConnectionGracefulDisconnect      ,
        setTcpConnectionGracefulDisconnect      ,
    #if defined(ENABLE_OVERLOADING)
        tcpConnectionGracefulDisconnect         ,
    #endif

        ) where

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

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL
    import qualified GHC.Records as R

    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gio.Objects.IOStream as Gio.IOStream
    import {-# SOURCE #-} qualified GI.Gio.Objects.SocketConnection as Gio.SocketConnection

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

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

    foreign import ccall "g_tcp_connection_get_type"
        c_g_tcp_connection_get_type :: IO B.Types.GType

    instance B.Types.TypedObject TcpConnection where
        glibType :: IO GType
    glibType = IO GType
    c_g_tcp_connection_get_type

    instance B.Types.GObject TcpConnection

    -- | Type class for types which can be safely cast to `TcpConnection`, for instance with `toTcpConnection`.
    class (SP.GObject o, O.IsDescendantOf TcpConnection o) => IsTcpConnection o
    instance (SP.GObject o, O.IsDescendantOf TcpConnection o) => IsTcpConnection o

    instance O.HasParentTypes TcpConnection
    type instance O.ParentTypes TcpConnection = '[Gio.SocketConnection.SocketConnection, Gio.IOStream.IOStream, GObject.Object.Object]

    -- | Cast to `TcpConnection`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toTcpConnection :: (MIO.MonadIO m, IsTcpConnection o) => o -> m TcpConnection
    toTcpConnection :: forall (m :: * -> *) o.
    (MonadIO m, IsTcpConnection o) =>
    o -> m TcpConnection
    toTcpConnection = IO TcpConnection -> m TcpConnection
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO TcpConnection -> m TcpConnection)
    -> (o -> IO TcpConnection) -> o -> m TcpConnection
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ManagedPtr TcpConnection -> TcpConnection)
    -> o -> IO TcpConnection
    forall o o'.
    (HasCallStack, ManagedPtrNewtype o, TypedObject o,
     ManagedPtrNewtype o', TypedObject o') =>
    (ManagedPtr o' -> o') -> o -> IO o'
    B.ManagedPtr.unsafeCastTo ManagedPtr TcpConnection -> TcpConnection
    TcpConnection

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

    #if defined(ENABLE_OVERLOADING)
    type family ResolveTcpConnectionMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveTcpConnectionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveTcpConnectionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveTcpConnectionMethod "clearPending" o = Gio.IOStream.IOStreamClearPendingMethodInfo
        ResolveTcpConnectionMethod "close" o = Gio.IOStream.IOStreamCloseMethodInfo
        ResolveTcpConnectionMethod "closeAsync" o = Gio.IOStream.IOStreamCloseAsyncMethodInfo
        ResolveTcpConnectionMethod "closeFinish" o = Gio.IOStream.IOStreamCloseFinishMethodInfo
        ResolveTcpConnectionMethod "connect" o = Gio.SocketConnection.SocketConnectionConnectMethodInfo
        ResolveTcpConnectionMethod "connectAsync" o = Gio.SocketConnection.SocketConnectionConnectAsyncMethodInfo
        ResolveTcpConnectionMethod "connectFinish" o = Gio.SocketConnection.SocketConnectionConnectFinishMethodInfo
        ResolveTcpConnectionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveTcpConnectionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveTcpConnectionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveTcpConnectionMethod "hasPending" o = Gio.IOStream.IOStreamHasPendingMethodInfo
        ResolveTcpConnectionMethod "isClosed" o = Gio.IOStream.IOStreamIsClosedMethodInfo
        ResolveTcpConnectionMethod "isConnected" o = Gio.SocketConnection.SocketConnectionIsConnectedMethodInfo
        ResolveTcpConnectionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveTcpConnectionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveTcpConnectionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveTcpConnectionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveTcpConnectionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveTcpConnectionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveTcpConnectionMethod "spliceAsync" o = Gio.IOStream.IOStreamSpliceAsyncMethodInfo
        ResolveTcpConnectionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveTcpConnectionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveTcpConnectionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveTcpConnectionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveTcpConnectionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveTcpConnectionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveTcpConnectionMethod "getGracefulDisconnect" o = TcpConnectionGetGracefulDisconnectMethodInfo
        ResolveTcpConnectionMethod "getInputStream" o = Gio.IOStream.IOStreamGetInputStreamMethodInfo
        ResolveTcpConnectionMethod "getLocalAddress" o = Gio.SocketConnection.SocketConnectionGetLocalAddressMethodInfo
        ResolveTcpConnectionMethod "getOutputStream" o = Gio.IOStream.IOStreamGetOutputStreamMethodInfo
        ResolveTcpConnectionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveTcpConnectionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveTcpConnectionMethod "getRemoteAddress" o = Gio.SocketConnection.SocketConnectionGetRemoteAddressMethodInfo
        ResolveTcpConnectionMethod "getSocket" o = Gio.SocketConnection.SocketConnectionGetSocketMethodInfo
        ResolveTcpConnectionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveTcpConnectionMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveTcpConnectionMethod "setGracefulDisconnect" o = TcpConnectionSetGracefulDisconnectMethodInfo
        ResolveTcpConnectionMethod "setPending" o = Gio.IOStream.IOStreamSetPendingMethodInfo
        ResolveTcpConnectionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveTcpConnectionMethod l o = O.MethodResolutionFailed l o

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

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

    #endif

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

    #endif

    -- VVV Prop "graceful-disconnect"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@graceful-disconnect@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' tcpConnection #gracefulDisconnect
    -- @
    getTcpConnectionGracefulDisconnect :: (MonadIO m, IsTcpConnection o) => o -> m Bool
    getTcpConnectionGracefulDisconnect :: forall (m :: * -> *) o.
    (MonadIO m, IsTcpConnection o) =>
    o -> m Bool
    getTcpConnectionGracefulDisconnect o
    obj = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    obj String
    "graceful-disconnect"

    -- | Set the value of the “@graceful-disconnect@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' tcpConnection [ #gracefulDisconnect 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTcpConnectionGracefulDisconnect :: (MonadIO m, IsTcpConnection o) => o -> Bool -> m ()
    setTcpConnectionGracefulDisconnect :: forall (m :: * -> *) o.
    (MonadIO m, IsTcpConnection o) =>
    o -> Bool -> m ()
    setTcpConnectionGracefulDisconnect o
    obj Bool
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Bool -> IO ()
    forall a. GObject a => a -> String -> Bool -> IO ()
    B.Properties.setObjectPropertyBool o
    obj String
    "graceful-disconnect" Bool
    val

    -- | Construct a `GValueConstruct` with valid value for the “@graceful-disconnect@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTcpConnectionGracefulDisconnect :: (IsTcpConnection o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
    constructTcpConnectionGracefulDisconnect :: forall o (m :: * -> *).
    (IsTcpConnection o, MonadIO m) =>
    Bool -> m (GValueConstruct o)
    constructTcpConnectionGracefulDisconnect Bool
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Bool -> IO (GValueConstruct o)
    forall o. String -> Bool -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBool String
    "graceful-disconnect" Bool
    val

    #if defined(ENABLE_OVERLOADING)
    data TcpConnectionGracefulDisconnectPropertyInfo
    instance AttrInfo TcpConnectionGracefulDisconnectPropertyInfo where
        type AttrAllowedOps TcpConnectionGracefulDisconnectPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrBaseTypeConstraint TcpConnectionGracefulDisconnectPropertyInfo = IsTcpConnection
        type AttrSetTypeConstraint TcpConnectionGracefulDisconnectPropertyInfo = (~) Bool
        type AttrTransferTypeConstraint TcpConnectionGracefulDisconnectPropertyInfo = (~) Bool
        type AttrTransferType TcpConnectionGracefulDisconnectPropertyInfo = Bool
        type AttrGetType TcpConnectionGracefulDisconnectPropertyInfo = Bool
        type AttrLabel TcpConnectionGracefulDisconnectPropertyInfo = "graceful-disconnect"
        type AttrOrigin TcpConnectionGracefulDisconnectPropertyInfo = TcpConnection
        attrGet = getTcpConnectionGracefulDisconnect
        attrSet = setTcpConnectionGracefulDisconnect
        attrTransfer _ v = do
            return v
        attrConstruct = constructTcpConnectionGracefulDisconnect
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.TcpConnection.gracefulDisconnect"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-TcpConnection.html#g:attr:gracefulDisconnect"
            })
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList TcpConnection
    type instance O.AttributeList TcpConnection = TcpConnectionAttributeList
    type TcpConnectionAttributeList = ('[ '("closed", Gio.IOStream.IOStreamClosedPropertyInfo), '("gracefulDisconnect", TcpConnectionGracefulDisconnectPropertyInfo), '("inputStream", Gio.IOStream.IOStreamInputStreamPropertyInfo), '("outputStream", Gio.IOStream.IOStreamOutputStreamPropertyInfo), '("socket", Gio.SocketConnection.SocketConnectionSocketPropertyInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    tcpConnectionGracefulDisconnect :: AttrLabelProxy "gracefulDisconnect"
    tcpConnectionGracefulDisconnect = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList TcpConnection = TcpConnectionSignalList
    type TcpConnectionSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

    #endif

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

    foreign import ccall "g_tcp_connection_get_graceful_disconnect" g_tcp_connection_get_graceful_disconnect ::
        Ptr TcpConnection ->                    -- connection : TInterface (Name {namespace = "Gio", name = "TcpConnection"})
        IO CInt

    -- | Checks if graceful disconnects are used. See
    -- 'GI.Gio.Objects.TcpConnection.tcpConnectionSetGracefulDisconnect'.
    --
    -- /Since: 2.22/
    tcpConnectionGetGracefulDisconnect ::
        (B.CallStack.HasCallStack, MonadIO m, IsTcpConnection a) =>
        a
        -- ^ /@connection@/: a t'GI.Gio.Objects.TcpConnection.TcpConnection'
        -> m Bool
        -- ^ __Returns:__ 'P.True' if graceful disconnect is used on close, 'P.False' otherwise
    tcpConnectionGetGracefulDisconnect :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTcpConnection a) =>
    a -> m Bool
    tcpConnectionGetGracefulDisconnect a
    connection = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr TcpConnection
    connection' <- a -> IO (Ptr TcpConnection)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    connection
        CInt
    result <- Ptr TcpConnection -> IO CInt
    g_tcp_connection_get_graceful_disconnect Ptr TcpConnection
    connection'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    connection
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data TcpConnectionGetGracefulDisconnectMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsTcpConnection a) => O.OverloadedMethod TcpConnectionGetGracefulDisconnectMethodInfo a signature where
        overloadedMethod = tcpConnectionGetGracefulDisconnect

    instance O.OverloadedMethodInfo TcpConnectionGetGracefulDisconnectMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.TcpConnection.tcpConnectionGetGracefulDisconnect",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-TcpConnection.html#v:tcpConnectionGetGracefulDisconnect"
            })

    #endif

    -- method TcpConnection::set_graceful_disconnect
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "connection"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "TcpConnection" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GTcpConnection" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "graceful_disconnect"
    --           , argType = TBasicType TBoolean
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "Whether to do graceful disconnects or not"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_tcp_connection_set_graceful_disconnect" g_tcp_connection_set_graceful_disconnect ::
        Ptr TcpConnection ->                    -- connection : TInterface (Name {namespace = "Gio", name = "TcpConnection"})
        CInt ->                                 -- graceful_disconnect : TBasicType TBoolean
        IO ()

    -- | This enables graceful disconnects on close. A graceful disconnect
    -- means that we signal the receiving end that the connection is terminated
    -- and wait for it to close the connection before closing the connection.
    --
    -- A graceful disconnect means that we can be sure that we successfully sent
    -- all the outstanding data to the other end, or get an error reported.
    -- However, it also means we have to wait for all the data to reach the
    -- other side and for it to acknowledge this by closing the socket, which may
    -- take a while. For this reason it is disabled by default.
    --
    -- /Since: 2.22/
    tcpConnectionSetGracefulDisconnect ::
        (B.CallStack.HasCallStack, MonadIO m, IsTcpConnection a) =>
        a
        -- ^ /@connection@/: a t'GI.Gio.Objects.TcpConnection.TcpConnection'
        -> Bool
        -- ^ /@gracefulDisconnect@/: Whether to do graceful disconnects or not
        -> m ()
    tcpConnectionSetGracefulDisconnect :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTcpConnection a) =>
    a -> Bool -> m ()
    tcpConnectionSetGracefulDisconnect a
    connection Bool
    gracefulDisconnect = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr TcpConnection
    connection' <- a -> IO (Ptr TcpConnection)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    connection
        let gracefulDisconnect' :: CInt
    gracefulDisconnect' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    gracefulDisconnect
        Ptr TcpConnection -> CInt -> IO ()
    g_tcp_connection_set_graceful_disconnect Ptr TcpConnection
    connection' CInt
    gracefulDisconnect'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    connection
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data TcpConnectionSetGracefulDisconnectMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsTcpConnection a) => O.OverloadedMethod TcpConnectionSetGracefulDisconnectMethodInfo a signature where
        overloadedMethod = tcpConnectionSetGracefulDisconnect

    instance O.OverloadedMethodInfo TcpConnectionSetGracefulDisconnectMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Objects.TcpConnection.tcpConnectionSetGracefulDisconnect",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-TcpConnection.html#v:tcpConnectionSetGracefulDisconnect"
            })

    #endif