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

    GIOStream represents an object that has both read and write streams.
    Generally the two streams act as separate input and output streams,
    but they share some common resources and state. For instance, for
    seekable streams, both streams may use the same position.

    Examples of 'GI.Gio.Objects.IOStream.IOStream' objects are 'GI.Gio.Objects.SocketConnection.SocketConnection', which represents
    a two-way network connection; and 'GI.Gio.Objects.FileIOStream.FileIOStream', which represents a
    file handle opened in read-write mode.

    To do the actual reading and writing you need to get the substreams
    with 'GI.Gio.Objects.IOStream.iOStreamGetInputStream' and 'GI.Gio.Objects.IOStream.iOStreamGetOutputStream'.

    The 'GI.Gio.Objects.IOStream.IOStream' object owns the input and the output streams, not the other
    way around, so keeping the substreams alive will not keep the 'GI.Gio.Objects.IOStream.IOStream'
    object alive. If the 'GI.Gio.Objects.IOStream.IOStream' object is freed it will be closed, thus
    closing the substreams, so even if the substreams stay alive they will
    always return 'GI.Gio.Enums.IOErrorEnumClosed' for all operations.

    To close a stream use 'GI.Gio.Objects.IOStream.iOStreamClose' which will close the common
    stream object and also the individual substreams. You can also close
    the substreams themselves. In most cases this only marks the
    substream as closed, so further I\/O on it fails but common state in the
    'GI.Gio.Objects.IOStream.IOStream' may still be open. However, some streams may support
    \"half-closed\" states where one direction of the stream is actually shut down.

    Operations on @/GIOStreams/@ cannot be started while another operation on the
    'GI.Gio.Objects.IOStream.IOStream' or its substreams is in progress. Specifically, an application can
    read from the 'GI.Gio.Objects.InputStream.InputStream' and write to the 'GI.Gio.Objects.OutputStream.OutputStream' simultaneously
    (either in separate threads, or as asynchronous operations in the same
    thread), but an application cannot start any 'GI.Gio.Objects.IOStream.IOStream' operation while there
    is a 'GI.Gio.Objects.IOStream.IOStream', 'GI.Gio.Objects.InputStream.InputStream' or 'GI.Gio.Objects.OutputStream.OutputStream' operation in progress, and
    an application can’t start any 'GI.Gio.Objects.InputStream.InputStream' or 'GI.Gio.Objects.OutputStream.OutputStream' operation
    while there is a 'GI.Gio.Objects.IOStream.IOStream' operation in progress.

    This is a product of individual stream operations being associated with a
    given 'GI.GLib.Structs.MainContext.MainContext' (the thread-default context at the time the operation was
    started), rather than entire streams being associated with a single
    'GI.GLib.Structs.MainContext.MainContext'.

    GIO may run operations on @/GIOStreams/@ from other (worker) threads, and this
    may be exposed to application code in the behaviour of wrapper streams, such
    as 'GI.Gio.Objects.BufferedInputStream.BufferedInputStream' or 'GI.Gio.Objects.TlsConnection.TlsConnection'. With such wrapper APIs,
    application code may only run operations on the base (wrapped) stream when
    the wrapper stream is idle. Note that the semantics of such operations may
    not be well-defined due to the state the wrapper stream leaves the base
    stream in (though they are guaranteed not to crash).

    /Since: 2.22/
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.IOStream
        (

    -- * Exported types
        IOStream(..)                            ,
        IsIOStream                              ,
        toIOStream                              ,
        noIOStream                              ,

     -- * Methods
    -- ** clearPending #method:clearPending#

    #if ENABLE_OVERLOADING
        IOStreamClearPendingMethodInfo          ,
    #endif
        iOStreamClearPending                    ,

    -- ** close #method:close#

    #if ENABLE_OVERLOADING
        IOStreamCloseMethodInfo                 ,
    #endif
        iOStreamClose                           ,

    -- ** closeAsync #method:closeAsync#

    #if ENABLE_OVERLOADING
        IOStreamCloseAsyncMethodInfo            ,
    #endif
        iOStreamCloseAsync                      ,

    -- ** closeFinish #method:closeFinish#

    #if ENABLE_OVERLOADING
        IOStreamCloseFinishMethodInfo           ,
    #endif
        iOStreamCloseFinish                     ,

    -- ** getInputStream #method:getInputStream#

    #if ENABLE_OVERLOADING
        IOStreamGetInputStreamMethodInfo        ,
    #endif
        iOStreamGetInputStream                  ,

    -- ** getOutputStream #method:getOutputStream#

    #if ENABLE_OVERLOADING
        IOStreamGetOutputStreamMethodInfo       ,
    #endif
        iOStreamGetOutputStream                 ,

    -- ** hasPending #method:hasPending#

    #if ENABLE_OVERLOADING
        IOStreamHasPendingMethodInfo            ,
    #endif
        iOStreamHasPending                      ,

    -- ** isClosed #method:isClosed#

    #if ENABLE_OVERLOADING
        IOStreamIsClosedMethodInfo              ,
    #endif
        iOStreamIsClosed                        ,

    -- ** setPending #method:setPending#

    #if ENABLE_OVERLOADING
        IOStreamSetPendingMethodInfo            ,
    #endif
        iOStreamSetPending                      ,

    -- ** spliceAsync #method:spliceAsync#

    #if ENABLE_OVERLOADING
        IOStreamSpliceAsyncMethodInfo           ,
    #endif
        iOStreamSpliceAsync                     ,

    -- ** spliceFinish #method:spliceFinish#

        iOStreamSpliceFinish                    ,

     -- * Properties
    -- ** closed #attr:closed#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        IOStreamClosedPropertyInfo              ,
    #endif
        getIOStreamClosed                       ,
    #if ENABLE_OVERLOADING
        iOStreamClosed                          ,
    #endif

    -- ** inputStream #attr:inputStream#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        IOStreamInputStreamPropertyInfo         ,
    #endif
        getIOStreamInputStream                  ,
    #if ENABLE_OVERLOADING
        iOStreamInputStream                     ,
    #endif

    -- ** outputStream #attr:outputStream#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        IOStreamOutputStreamPropertyInfo        ,
    #endif
        getIOStreamOutputStream                 ,
    #if ENABLE_OVERLOADING
        iOStreamOutputStream                    ,
    #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.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.Flags as Gio.Flags
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
    import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
    import {-# SOURCE #-} qualified GI.Gio.Objects.InputStream as Gio.InputStream
    import {-# SOURCE #-} qualified GI.Gio.Objects.OutputStream as Gio.OutputStream

    -- | Memory-managed wrapper type.
    newtype IOStream = IOStream (ManagedPtr IOStream)
    foreign import ccall "g_io_stream_get_type"
        c_g_io_stream_get_type :: IO GType

    instance GObject IOStream where
        gobjectType _ = c_g_io_stream_get_type

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

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

    -- | A convenience alias for `Nothing` :: `Maybe` `IOStream`.
    noIOStream :: Maybe IOStream
    noIOStream = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveIOStreamMethod (t :: Symbol) (o :: *) :: * where
        ResolveIOStreamMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveIOStreamMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveIOStreamMethod "clearPending" o = IOStreamClearPendingMethodInfo
        ResolveIOStreamMethod "close" o = IOStreamCloseMethodInfo
        ResolveIOStreamMethod "closeAsync" o = IOStreamCloseAsyncMethodInfo
        ResolveIOStreamMethod "closeFinish" o = IOStreamCloseFinishMethodInfo
        ResolveIOStreamMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveIOStreamMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveIOStreamMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveIOStreamMethod "hasPending" o = IOStreamHasPendingMethodInfo
        ResolveIOStreamMethod "isClosed" o = IOStreamIsClosedMethodInfo
        ResolveIOStreamMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveIOStreamMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveIOStreamMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveIOStreamMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveIOStreamMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveIOStreamMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveIOStreamMethod "spliceAsync" o = IOStreamSpliceAsyncMethodInfo
        ResolveIOStreamMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveIOStreamMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveIOStreamMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveIOStreamMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveIOStreamMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveIOStreamMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveIOStreamMethod "getInputStream" o = IOStreamGetInputStreamMethodInfo
        ResolveIOStreamMethod "getOutputStream" o = IOStreamGetOutputStreamMethodInfo
        ResolveIOStreamMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveIOStreamMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveIOStreamMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveIOStreamMethod "setPending" o = IOStreamSetPendingMethodInfo
        ResolveIOStreamMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveIOStreamMethod l o = O.MethodResolutionFailed l o

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

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

    -- VVV Prop "closed"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' iOStream #closed
    @
    -}
    getIOStreamClosed :: (MonadIO m, IsIOStream o) => o -> m Bool
    getIOStreamClosed obj = liftIO $ getObjectPropertyBool obj "closed"

    #if ENABLE_OVERLOADING
    data IOStreamClosedPropertyInfo
    instance AttrInfo IOStreamClosedPropertyInfo where
        type AttrAllowedOps IOStreamClosedPropertyInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint IOStreamClosedPropertyInfo = (~) ()
        type AttrBaseTypeConstraint IOStreamClosedPropertyInfo = IsIOStream
        type AttrGetType IOStreamClosedPropertyInfo = Bool
        type AttrLabel IOStreamClosedPropertyInfo = "closed"
        type AttrOrigin IOStreamClosedPropertyInfo = IOStream
        attrGet _ = getIOStreamClosed
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

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

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

    @
    'Data.GI.Base.Attributes.get' iOStream #inputStream
    @
    -}
    getIOStreamInputStream :: (MonadIO m, IsIOStream o) => o -> m Gio.InputStream.InputStream
    getIOStreamInputStream obj = liftIO $ checkUnexpectedNothing "getIOStreamInputStream" $ getObjectPropertyObject obj "input-stream" Gio.InputStream.InputStream

    #if ENABLE_OVERLOADING
    data IOStreamInputStreamPropertyInfo
    instance AttrInfo IOStreamInputStreamPropertyInfo where
        type AttrAllowedOps IOStreamInputStreamPropertyInfo = '[ 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint IOStreamInputStreamPropertyInfo = (~) ()
        type AttrBaseTypeConstraint IOStreamInputStreamPropertyInfo = IsIOStream
        type AttrGetType IOStreamInputStreamPropertyInfo = Gio.InputStream.InputStream
        type AttrLabel IOStreamInputStreamPropertyInfo = "input-stream"
        type AttrOrigin IOStreamInputStreamPropertyInfo = IOStream
        attrGet _ = getIOStreamInputStream
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

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

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

    @
    'Data.GI.Base.Attributes.get' iOStream #outputStream
    @
    -}
    getIOStreamOutputStream :: (MonadIO m, IsIOStream o) => o -> m Gio.OutputStream.OutputStream
    getIOStreamOutputStream obj = liftIO $ checkUnexpectedNothing "getIOStreamOutputStream" $ getObjectPropertyObject obj "output-stream" Gio.OutputStream.OutputStream

    #if ENABLE_OVERLOADING
    data IOStreamOutputStreamPropertyInfo
    instance AttrInfo IOStreamOutputStreamPropertyInfo where
        type AttrAllowedOps IOStreamOutputStreamPropertyInfo = '[ 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint IOStreamOutputStreamPropertyInfo = (~) ()
        type AttrBaseTypeConstraint IOStreamOutputStreamPropertyInfo = IsIOStream
        type AttrGetType IOStreamOutputStreamPropertyInfo = Gio.OutputStream.OutputStream
        type AttrLabel IOStreamOutputStreamPropertyInfo = "output-stream"
        type AttrOrigin IOStreamOutputStreamPropertyInfo = IOStream
        attrGet _ = getIOStreamOutputStream
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList IOStream
    type instance O.AttributeList IOStream = IOStreamAttributeList
    type IOStreamAttributeList = ('[ '("closed", IOStreamClosedPropertyInfo), '("inputStream", IOStreamInputStreamPropertyInfo), '("outputStream", IOStreamOutputStreamPropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    iOStreamClosed :: AttrLabelProxy "closed"
    iOStreamClosed = AttrLabelProxy

    iOStreamInputStream :: AttrLabelProxy "inputStream"
    iOStreamInputStream = AttrLabelProxy

    iOStreamOutputStream :: AttrLabelProxy "outputStream"
    iOStreamOutputStream = AttrLabelProxy

    #endif

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

    #endif

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

    foreign import ccall "g_io_stream_clear_pending" g_io_stream_clear_pending ::
        Ptr IOStream ->                         -- stream : TInterface (Name {namespace = "Gio", name = "IOStream"})
        IO ()

    {- |
    Clears the pending flag on /@stream@/.

    /Since: 2.22/
    -}
    iOStreamClearPending ::
        (B.CallStack.HasCallStack, MonadIO m, IsIOStream a) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.IOStream.IOStream' -}
        -> m ()
    iOStreamClearPending stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        g_io_stream_clear_pending stream'
        touchManagedPtr stream
        return ()

    #if ENABLE_OVERLOADING
    data IOStreamClearPendingMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsIOStream a) => O.MethodInfo IOStreamClearPendingMethodInfo a signature where
        overloadedMethod _ = iOStreamClearPending

    #endif

    -- method IOStream::close
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "IOStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOStream", 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 "optional #GCancellable object, %NULL to ignore", 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_io_stream_close" g_io_stream_close ::
        Ptr IOStream ->                         -- stream : TInterface (Name {namespace = "Gio", name = "IOStream"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Closes the stream, releasing resources related to it. This will also
    close the individual input and output streams, if they are not already
    closed.

    Once the stream is closed, all other operations will return
    'GI.Gio.Enums.IOErrorEnumClosed'. Closing a stream multiple times will not
    return an error.

    Closing a stream will automatically flush any outstanding buffers
    in the stream.

    Streams 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.

    Some streams might keep the backing store of the stream (e.g. a file
    descriptor) open after the stream is closed. See the documentation for
    the individual stream for details.

    On failure the first error that happened will be reported, but the
    close operation will finish as much as possible. A stream that failed
    to close will still return 'GI.Gio.Enums.IOErrorEnumClosed' for all operations.
    Still, it is important to check and report the error to the user,
    otherwise there might be a loss of data as all data might not be written.

    If /@cancellable@/ is not NULL, then the operation can be cancelled by
    triggering the cancellable object from another thread. If the operation
    was cancelled, the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned.
    Cancelling a close will still leave the stream closed, but some streams
    can use a faster close that doesn\'t block to e.g. check errors.

    The default implementation of this method just calls close on the
    individual input\/output streams.

    /Since: 2.22/
    -}
    iOStreamClose ::
        (B.CallStack.HasCallStack, MonadIO m, IsIOStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.IOStream.IOStream' -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    iOStreamClose stream cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_io_stream_close stream' maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            return ()
         ) (do
            return ()
         )

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

    #endif

    -- method IOStream::close_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "IOStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOStream", 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 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 "optional cancellable object", 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 request is satisfied", 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 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_io_stream_close_async" g_io_stream_close_async ::
        Ptr IOStream ->                         -- stream : TInterface (Name {namespace = "Gio", name = "IOStream"})
        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 ()

    {- |
    Requests an asynchronous close of the stream, releasing resources
    related to it. When the operation is finished /@callback@/ will be
    called. You can then call 'GI.Gio.Objects.IOStream.iOStreamCloseFinish' to get
    the result of the operation.

    For behaviour details see 'GI.Gio.Objects.IOStream.iOStreamClose'.

    The asynchronous methods have a default fallback that uses threads
    to implement asynchronicity, so they are optional for inheriting
    classes. However, if you override one you must override all.

    /Since: 2.22/
    -}
    iOStreamCloseAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsIOStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.IOStream.IOStream' -}
        -> Int32
        {- ^ /@ioPriority@/: the io priority of the request -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional cancellable object -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the request is satisfied -}
        -> m ()
    iOStreamCloseAsync stream ioPriority cancellable callback = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        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_io_stream_close_async stream' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        return ()

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

    #endif

    -- method IOStream::close_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "IOStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOStream", 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_io_stream_close_finish" g_io_stream_close_finish ::
        Ptr IOStream ->                         -- stream : TInterface (Name {namespace = "Gio", name = "IOStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Closes a stream.

    /Since: 2.22/
    -}
    iOStreamCloseFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsIOStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.IOStream.IOStream' -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    iOStreamCloseFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            _ <- propagateGError $ g_io_stream_close_finish stream' result_'
            touchManagedPtr stream
            touchManagedPtr result_
            return ()
         ) (do
            return ()
         )

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

    #endif

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

    foreign import ccall "g_io_stream_get_input_stream" g_io_stream_get_input_stream ::
        Ptr IOStream ->                         -- stream : TInterface (Name {namespace = "Gio", name = "IOStream"})
        IO (Ptr Gio.InputStream.InputStream)

    {- |
    Gets the input stream for this object. This is used
    for reading.

    /Since: 2.22/
    -}
    iOStreamGetInputStream ::
        (B.CallStack.HasCallStack, MonadIO m, IsIOStream a) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.IOStream.IOStream' -}
        -> m Gio.InputStream.InputStream
        {- ^ __Returns:__ a 'GI.Gio.Objects.InputStream.InputStream', owned by the 'GI.Gio.Objects.IOStream.IOStream'.
    Do not free. -}
    iOStreamGetInputStream stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result <- g_io_stream_get_input_stream stream'
        checkUnexpectedReturnNULL "iOStreamGetInputStream" result
        result' <- (newObject Gio.InputStream.InputStream) result
        touchManagedPtr stream
        return result'

    #if ENABLE_OVERLOADING
    data IOStreamGetInputStreamMethodInfo
    instance (signature ~ (m Gio.InputStream.InputStream), MonadIO m, IsIOStream a) => O.MethodInfo IOStreamGetInputStreamMethodInfo a signature where
        overloadedMethod _ = iOStreamGetInputStream

    #endif

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

    foreign import ccall "g_io_stream_get_output_stream" g_io_stream_get_output_stream ::
        Ptr IOStream ->                         -- stream : TInterface (Name {namespace = "Gio", name = "IOStream"})
        IO (Ptr Gio.OutputStream.OutputStream)

    {- |
    Gets the output stream for this object. This is used for
    writing.

    /Since: 2.22/
    -}
    iOStreamGetOutputStream ::
        (B.CallStack.HasCallStack, MonadIO m, IsIOStream a) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.IOStream.IOStream' -}
        -> m Gio.OutputStream.OutputStream
        {- ^ __Returns:__ a 'GI.Gio.Objects.OutputStream.OutputStream', owned by the 'GI.Gio.Objects.IOStream.IOStream'.
    Do not free. -}
    iOStreamGetOutputStream stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result <- g_io_stream_get_output_stream stream'
        checkUnexpectedReturnNULL "iOStreamGetOutputStream" result
        result' <- (newObject Gio.OutputStream.OutputStream) result
        touchManagedPtr stream
        return result'

    #if ENABLE_OVERLOADING
    data IOStreamGetOutputStreamMethodInfo
    instance (signature ~ (m Gio.OutputStream.OutputStream), MonadIO m, IsIOStream a) => O.MethodInfo IOStreamGetOutputStreamMethodInfo a signature where
        overloadedMethod _ = iOStreamGetOutputStream

    #endif

    -- method IOStream::has_pending
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "IOStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOStream", 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_io_stream_has_pending" g_io_stream_has_pending ::
        Ptr IOStream ->                         -- stream : TInterface (Name {namespace = "Gio", name = "IOStream"})
        IO CInt

    {- |
    Checks if a stream has pending actions.

    /Since: 2.22/
    -}
    iOStreamHasPending ::
        (B.CallStack.HasCallStack, MonadIO m, IsIOStream a) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.IOStream.IOStream' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if /@stream@/ has pending actions. -}
    iOStreamHasPending stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result <- g_io_stream_has_pending stream'
        let result' = (/= 0) result
        touchManagedPtr stream
        return result'

    #if ENABLE_OVERLOADING
    data IOStreamHasPendingMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsIOStream a) => O.MethodInfo IOStreamHasPendingMethodInfo a signature where
        overloadedMethod _ = iOStreamHasPending

    #endif

    -- method IOStream::is_closed
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "IOStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOStream", 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_io_stream_is_closed" g_io_stream_is_closed ::
        Ptr IOStream ->                         -- stream : TInterface (Name {namespace = "Gio", name = "IOStream"})
        IO CInt

    {- |
    Checks if a stream is closed.

    /Since: 2.22/
    -}
    iOStreamIsClosed ::
        (B.CallStack.HasCallStack, MonadIO m, IsIOStream a) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.IOStream.IOStream' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the stream is closed. -}
    iOStreamIsClosed stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result <- g_io_stream_is_closed stream'
        let result' = (/= 0) result
        touchManagedPtr stream
        return result'

    #if ENABLE_OVERLOADING
    data IOStreamIsClosedMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsIOStream a) => O.MethodInfo IOStreamIsClosedMethodInfo a signature where
        overloadedMethod _ = iOStreamIsClosed

    #endif

    -- method IOStream::set_pending
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "IOStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOStream", 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_io_stream_set_pending" g_io_stream_set_pending ::
        Ptr IOStream ->                         -- stream : TInterface (Name {namespace = "Gio", name = "IOStream"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Sets /@stream@/ to have actions pending. If the pending flag is
    already set or /@stream@/ is closed, it will return 'False' and set
    /@error@/.

    /Since: 2.22/
    -}
    iOStreamSetPending ::
        (B.CallStack.HasCallStack, MonadIO m, IsIOStream a) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.IOStream.IOStream' -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    iOStreamSetPending stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        onException (do
            _ <- propagateGError $ g_io_stream_set_pending stream'
            touchManagedPtr stream
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data IOStreamSetPendingMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsIOStream a) => O.MethodInfo IOStreamSetPendingMethodInfo a signature where
        overloadedMethod _ = iOStreamSetPending

    #endif

    -- method IOStream::splice_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream1", argType = TInterface (Name {namespace = "Gio", name = "IOStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream2", argType = TInterface (Name {namespace = "Gio", name = "IOStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "IOStreamSpliceFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a set of #GIOStreamSpliceFlags.", 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 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 "optional #GCancellable object, %NULL to ignore.", 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 "a #GAsyncReadyCallback.", 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 "user data passed to @callback.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_io_stream_splice_async" g_io_stream_splice_async ::
        Ptr IOStream ->                         -- stream1 : TInterface (Name {namespace = "Gio", name = "IOStream"})
        Ptr IOStream ->                         -- stream2 : TInterface (Name {namespace = "Gio", name = "IOStream"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "IOStreamSpliceFlags"})
        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 ()

    {- |
    Asyncronously splice the output stream of /@stream1@/ to the input stream of
    /@stream2@/, and splice the output stream of /@stream2@/ to the input stream of
    /@stream1@/.

    When the operation is finished /@callback@/ will be called.
    You can then call 'GI.Gio.Objects.IOStream.iOStreamSpliceFinish' to get the
    result of the operation.

    /Since: 2.28/
    -}
    iOStreamSpliceAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsIOStream a, IsIOStream b, Gio.Cancellable.IsCancellable c) =>
        a
        {- ^ /@stream1@/: a 'GI.Gio.Objects.IOStream.IOStream'. -}
        -> b
        {- ^ /@stream2@/: a 'GI.Gio.Objects.IOStream.IOStream'. -}
        -> [Gio.Flags.IOStreamSpliceFlags]
        {- ^ /@flags@/: a set of 'GI.Gio.Flags.IOStreamSpliceFlags'. -}
        -> Int32
        {- ^ /@ioPriority@/: the io priority of the request. -}
        -> Maybe (c)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback'. -}
        -> m ()
    iOStreamSpliceAsync stream1 stream2 flags ioPriority cancellable callback = liftIO $ do
        stream1' <- unsafeManagedPtrCastPtr stream1
        stream2' <- unsafeManagedPtrCastPtr stream2
        let flags' = gflagsToWord flags
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_io_stream_splice_async stream1' stream2' flags' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream1
        touchManagedPtr stream2
        whenJust cancellable touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data IOStreamSpliceAsyncMethodInfo
    instance (signature ~ (b -> [Gio.Flags.IOStreamSpliceFlags] -> Int32 -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsIOStream a, IsIOStream b, Gio.Cancellable.IsCancellable c) => O.MethodInfo IOStreamSpliceAsyncMethodInfo a signature where
        overloadedMethod _ = iOStreamSpliceAsync

    #endif

    -- method IOStream::splice_finish
    -- method type : MemberFunction
    -- Args : [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_io_stream_splice_finish" g_io_stream_splice_finish ::
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Finishes an asynchronous io stream splice operation.

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

    #if ENABLE_OVERLOADING
    #endif