    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A t'GI.Gio.Objects.TcpWrapperConnection.TcpWrapperConnection' can be used to wrap a t'GI.Gio.Objects.IOStream.IOStream' that is
    -- based on a t'GI.Gio.Objects.Socket.Socket', but which is not actually a
    -- t'GI.Gio.Objects.SocketConnection.SocketConnection'. This is used by t'GI.Gio.Objects.SocketClient.SocketClient' so that it can
    -- always return a t'GI.Gio.Objects.SocketConnection.SocketConnection', even when the connection it has
    -- actually created is not directly a t'GI.Gio.Objects.SocketConnection.SocketConnection'.
    --
    -- /Since: 2.28/

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

    module GI.Gio.Objects.TcpWrapperConnection
        (

    -- * Exported types
        TcpWrapperConnection(..)                ,
        IsTcpWrapperConnection                  ,
        toTcpWrapperConnection                  ,

     -- * Methods
    -- ** Overloaded methods #method:Overloaded methods#

    #if defined(ENABLE_OVERLOADING)
        ResolveTcpWrapperConnectionMethod       ,
    #endif

    -- ** getBaseIoStream #method:getBaseIoStream#

    #if defined(ENABLE_OVERLOADING)
        TcpWrapperConnectionGetBaseIoStreamMethodInfo,
    #endif
        tcpWrapperConnectionGetBaseIoStream     ,

    -- ** new #method:new#

        tcpWrapperConnectionNew                 ,

     -- * Properties
    -- ** baseIoStream #attr:baseIoStream#
    -- | /No description available in the introspection data./

    #if defined(ENABLE_OVERLOADING)
        TcpWrapperConnectionBaseIoStreamPropertyInfo,
    #endif
        constructTcpWrapperConnectionBaseIoStream,
        getTcpWrapperConnectionBaseIoStream     ,
    #if defined(ENABLE_OVERLOADING)
        tcpWrapperConnectionBaseIoStream        ,
    #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.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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL

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

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

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

    foreign import ccall "g_tcp_wrapper_connection_get_type"
        c_g_tcp_wrapper_connection_get_type :: IO B.Types.GType

    instance B.Types.TypedObject TcpWrapperConnection where
        glibType :: IO GType
    glibType = IO GType
    c_g_tcp_wrapper_connection_get_type

    instance B.Types.GObject TcpWrapperConnection

    -- | Convert 'TcpWrapperConnection' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue TcpWrapperConnection where
        toGValue :: TcpWrapperConnection -> IO GValue
    toGValue o :: TcpWrapperConnection
    o = do
            GType
    gtype <- IO GType
    c_g_tcp_wrapper_connection_get_type
            TcpWrapperConnection
    -> (Ptr TcpWrapperConnection -> IO GValue) -> IO GValue
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr TcpWrapperConnection
    o (GType
    -> (GValue -> Ptr TcpWrapperConnection -> IO ())
    -> Ptr TcpWrapperConnection
    -> IO GValue
    forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
    B.GValue.buildGValue GType
    gtype GValue -> Ptr TcpWrapperConnection -> IO ()
    forall a. GObject a => GValue -> Ptr a -> IO ()
    B.GValue.set_object)

        fromGValue :: GValue -> IO TcpWrapperConnection
    fromGValue gv :: GValue
    gv = do
            Ptr TcpWrapperConnection
    ptr <- GValue -> IO (Ptr TcpWrapperConnection)
    forall b. GObject b => GValue -> IO (Ptr b)
    B.GValue.get_object GValue
    gv :: IO (Ptr TcpWrapperConnection)
            (ManagedPtr TcpWrapperConnection -> TcpWrapperConnection)
    -> Ptr TcpWrapperConnection -> IO TcpWrapperConnection
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    B.ManagedPtr.newObject ManagedPtr TcpWrapperConnection -> TcpWrapperConnection
    TcpWrapperConnection Ptr TcpWrapperConnection
    ptr

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

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

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

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

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

    #endif

    -- VVV Prop "base-io-stream"
       -- Type: TInterface (Name {namespace = "Gio", name = "IOStream"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Just False,Nothing)

    -- | Get the value of the “@base-io-stream@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' tcpWrapperConnection #baseIoStream
    -- @
    getTcpWrapperConnectionBaseIoStream :: (MonadIO m, IsTcpWrapperConnection o) => o -> m Gio.IOStream.IOStream
    getTcpWrapperConnectionBaseIoStream :: o -> m IOStream
    getTcpWrapperConnectionBaseIoStream obj :: o
    obj = IO IOStream -> m IOStream
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO IOStream -> m IOStream) -> IO IOStream -> m IOStream
    forall a b. (a -> b) -> a -> b
    $ Text -> IO (Maybe IOStream) -> IO IOStream
    forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
    checkUnexpectedNothing "getTcpWrapperConnectionBaseIoStream" (IO (Maybe IOStream) -> IO IOStream)
    -> IO (Maybe IOStream) -> IO IOStream
    forall a b. (a -> b) -> a -> b
    $ o
    -> String
    -> (ManagedPtr IOStream -> IOStream)
    -> IO (Maybe IOStream)
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyObject o
    obj "base-io-stream" ManagedPtr IOStream -> IOStream
    Gio.IOStream.IOStream

    -- | Construct a `GValueConstruct` with valid value for the “@base-io-stream@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructTcpWrapperConnectionBaseIoStream :: (IsTcpWrapperConnection o, MIO.MonadIO m, Gio.IOStream.IsIOStream a) => a -> m (GValueConstruct o)
    constructTcpWrapperConnectionBaseIoStream :: a -> m (GValueConstruct o)
    constructTcpWrapperConnectionBaseIoStream val :: a
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    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
    $ String -> Maybe a -> IO (GValueConstruct o)
    forall a o.
    GObject a =>
    String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyObject "base-io-stream" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    val)

    #if defined(ENABLE_OVERLOADING)
    data TcpWrapperConnectionBaseIoStreamPropertyInfo
    instance AttrInfo TcpWrapperConnectionBaseIoStreamPropertyInfo where
        type AttrAllowedOps TcpWrapperConnectionBaseIoStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint TcpWrapperConnectionBaseIoStreamPropertyInfo = IsTcpWrapperConnection
        type AttrSetTypeConstraint TcpWrapperConnectionBaseIoStreamPropertyInfo = Gio.IOStream.IsIOStream
        type AttrTransferTypeConstraint TcpWrapperConnectionBaseIoStreamPropertyInfo = Gio.IOStream.IsIOStream
        type AttrTransferType TcpWrapperConnectionBaseIoStreamPropertyInfo = Gio.IOStream.IOStream
        type AttrGetType TcpWrapperConnectionBaseIoStreamPropertyInfo = Gio.IOStream.IOStream
        type AttrLabel TcpWrapperConnectionBaseIoStreamPropertyInfo = "base-io-stream"
        type AttrOrigin TcpWrapperConnectionBaseIoStreamPropertyInfo = TcpWrapperConnection
        attrGet = getTcpWrapperConnectionBaseIoStream
        attrSet = undefined
        attrTransfer _ v = do
            unsafeCastTo Gio.IOStream.IOStream v
        attrConstruct = constructTcpWrapperConnectionBaseIoStream
        attrClear = undefined
    #endif

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

    #if defined(ENABLE_OVERLOADING)
    tcpWrapperConnectionBaseIoStream :: AttrLabelProxy "baseIoStream"
    tcpWrapperConnectionBaseIoStream = AttrLabelProxy

    #endif

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

    #endif

    -- method TcpWrapperConnection::new
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "base_io_stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "IOStream" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #GIOStream to wrap"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "socket"
    --           , argType = TInterface Name { namespace = "Gio" , name = "Socket" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #GSocket associated with @base_io_stream"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface
    --                  Name { namespace = "Gio" , name = "TcpWrapperConnection" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_tcp_wrapper_connection_new" g_tcp_wrapper_connection_new ::
        Ptr Gio.IOStream.IOStream ->            -- base_io_stream : TInterface (Name {namespace = "Gio", name = "IOStream"})
        Ptr Gio.Socket.Socket ->                -- socket : TInterface (Name {namespace = "Gio", name = "Socket"})
        IO (Ptr TcpWrapperConnection)

    -- | Wraps /@baseIoStream@/ and /@socket@/ together as a t'GI.Gio.Objects.SocketConnection.SocketConnection'.
    --
    -- /Since: 2.28/
    tcpWrapperConnectionNew ::
        (B.CallStack.HasCallStack, MonadIO m, Gio.IOStream.IsIOStream a, Gio.Socket.IsSocket b) =>
        a
        -- ^ /@baseIoStream@/: the t'GI.Gio.Objects.IOStream.IOStream' to wrap
        -> b
        -- ^ /@socket@/: the t'GI.Gio.Objects.Socket.Socket' associated with /@baseIoStream@/
        -> m TcpWrapperConnection
        -- ^ __Returns:__ the new t'GI.Gio.Objects.SocketConnection.SocketConnection'.
    tcpWrapperConnectionNew :: a -> b -> m TcpWrapperConnection
    tcpWrapperConnectionNew baseIoStream :: a
    baseIoStream socket :: b
    socket = IO TcpWrapperConnection -> m TcpWrapperConnection
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO TcpWrapperConnection -> m TcpWrapperConnection)
    -> IO TcpWrapperConnection -> m TcpWrapperConnection
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr IOStream
    baseIoStream' <- a -> IO (Ptr IOStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    baseIoStream
        Ptr Socket
    socket' <- b -> IO (Ptr Socket)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    socket
        Ptr TcpWrapperConnection
    result <- Ptr IOStream -> Ptr Socket -> IO (Ptr TcpWrapperConnection)
    g_tcp_wrapper_connection_new Ptr IOStream
    baseIoStream' Ptr Socket
    socket'
        Text -> Ptr TcpWrapperConnection -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "tcpWrapperConnectionNew" Ptr TcpWrapperConnection
    result
        TcpWrapperConnection
    result' <- ((ManagedPtr TcpWrapperConnection -> TcpWrapperConnection)
    -> Ptr TcpWrapperConnection -> IO TcpWrapperConnection
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr TcpWrapperConnection -> TcpWrapperConnection
    TcpWrapperConnection) Ptr TcpWrapperConnection
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    baseIoStream
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    socket
        TcpWrapperConnection -> IO TcpWrapperConnection
    forall (m :: * -> *) a. Monad m => a -> m a
    return TcpWrapperConnection
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    foreign import ccall "g_tcp_wrapper_connection_get_base_io_stream" g_tcp_wrapper_connection_get_base_io_stream ::
        Ptr TcpWrapperConnection ->             -- conn : TInterface (Name {namespace = "Gio", name = "TcpWrapperConnection"})
        IO (Ptr Gio.IOStream.IOStream)

    -- | Gets /@conn@/\'s base t'GI.Gio.Objects.IOStream.IOStream'
    tcpWrapperConnectionGetBaseIoStream ::
        (B.CallStack.HasCallStack, MonadIO m, IsTcpWrapperConnection a) =>
        a
        -- ^ /@conn@/: a t'GI.Gio.Objects.TcpWrapperConnection.TcpWrapperConnection'
        -> m Gio.IOStream.IOStream
        -- ^ __Returns:__ /@conn@/\'s base t'GI.Gio.Objects.IOStream.IOStream'
    tcpWrapperConnectionGetBaseIoStream :: a -> m IOStream
    tcpWrapperConnectionGetBaseIoStream conn :: a
    conn = IO IOStream -> m IOStream
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO IOStream -> m IOStream) -> IO IOStream -> m IOStream
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr TcpWrapperConnection
    conn' <- a -> IO (Ptr TcpWrapperConnection)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    conn
        Ptr IOStream
    result <- Ptr TcpWrapperConnection -> IO (Ptr IOStream)
    g_tcp_wrapper_connection_get_base_io_stream Ptr TcpWrapperConnection
    conn'
        Text -> Ptr IOStream -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "tcpWrapperConnectionGetBaseIoStream" Ptr IOStream
    result
        IOStream
    result' <- ((ManagedPtr IOStream -> IOStream) -> Ptr IOStream -> IO IOStream
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr IOStream -> IOStream
    Gio.IOStream.IOStream) Ptr IOStream
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    conn
        IOStream -> IO IOStream
    forall (m :: * -> *) a. Monad m => a -> m a
    return IOStream
    result'

    #if defined(ENABLE_OVERLOADING)
    data TcpWrapperConnectionGetBaseIoStreamMethodInfo
    instance (signature ~ (m Gio.IOStream.IOStream), MonadIO m, IsTcpWrapperConnection a) => O.MethodInfo TcpWrapperConnectionGetBaseIoStreamMethodInfo a signature where
        overloadedMethod = tcpWrapperConnectionGetBaseIoStream

    #endif