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

    'GI.Gio.Objects.InputStream.InputStream' has functions to read from a stream ('GI.Gio.Objects.InputStream.inputStreamRead'),
    to close a stream ('GI.Gio.Objects.InputStream.inputStreamClose') and to skip some content
    ('GI.Gio.Objects.InputStream.inputStreamSkip').

    To copy the content of an input stream to an output stream without
    manually handling the reads and writes, use 'GI.Gio.Objects.OutputStream.outputStreamSplice'.

    See the documentation for 'GI.Gio.Objects.IOStream.IOStream' for details of thread safety of
    streaming APIs.

    All of these functions have async variants too.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.InputStream
        (

    -- * Exported types
        InputStream(..)                         ,
        IsInputStream                           ,
        toInputStream                           ,
        noInputStream                           ,

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

    #if ENABLE_OVERLOADING
        InputStreamClearPendingMethodInfo       ,
    #endif
        inputStreamClearPending                 ,

    -- ** close #method:close#

    #if ENABLE_OVERLOADING
        InputStreamCloseMethodInfo              ,
    #endif
        inputStreamClose                        ,

    -- ** closeAsync #method:closeAsync#

    #if ENABLE_OVERLOADING
        InputStreamCloseAsyncMethodInfo         ,
    #endif
        inputStreamCloseAsync                   ,

    -- ** closeFinish #method:closeFinish#

    #if ENABLE_OVERLOADING
        InputStreamCloseFinishMethodInfo        ,
    #endif
        inputStreamCloseFinish                  ,

    -- ** hasPending #method:hasPending#

    #if ENABLE_OVERLOADING
        InputStreamHasPendingMethodInfo         ,
    #endif
        inputStreamHasPending                   ,

    -- ** isClosed #method:isClosed#

    #if ENABLE_OVERLOADING
        InputStreamIsClosedMethodInfo           ,
    #endif
        inputStreamIsClosed                     ,

    -- ** read #method:read#

    #if ENABLE_OVERLOADING
        InputStreamReadMethodInfo               ,
    #endif
        inputStreamRead                         ,

    -- ** readAll #method:readAll#

    #if ENABLE_OVERLOADING
        InputStreamReadAllMethodInfo            ,
    #endif
        inputStreamReadAll                      ,

    -- ** readAllAsync #method:readAllAsync#

    #if ENABLE_OVERLOADING
        InputStreamReadAllAsyncMethodInfo       ,
    #endif
        inputStreamReadAllAsync                 ,

    -- ** readAllFinish #method:readAllFinish#

    #if ENABLE_OVERLOADING
        InputStreamReadAllFinishMethodInfo      ,
    #endif
        inputStreamReadAllFinish                ,

    -- ** readAsync #method:readAsync#

    #if ENABLE_OVERLOADING
        InputStreamReadAsyncMethodInfo          ,
    #endif
        inputStreamReadAsync                    ,

    -- ** readBytes #method:readBytes#

    #if ENABLE_OVERLOADING
        InputStreamReadBytesMethodInfo          ,
    #endif
        inputStreamReadBytes                    ,

    -- ** readBytesAsync #method:readBytesAsync#

    #if ENABLE_OVERLOADING
        InputStreamReadBytesAsyncMethodInfo     ,
    #endif
        inputStreamReadBytesAsync               ,

    -- ** readBytesFinish #method:readBytesFinish#

    #if ENABLE_OVERLOADING
        InputStreamReadBytesFinishMethodInfo    ,
    #endif
        inputStreamReadBytesFinish              ,

    -- ** readFinish #method:readFinish#

    #if ENABLE_OVERLOADING
        InputStreamReadFinishMethodInfo         ,
    #endif
        inputStreamReadFinish                   ,

    -- ** setPending #method:setPending#

    #if ENABLE_OVERLOADING
        InputStreamSetPendingMethodInfo         ,
    #endif
        inputStreamSetPending                   ,

    -- ** skip #method:skip#

    #if ENABLE_OVERLOADING
        InputStreamSkipMethodInfo               ,
    #endif
        inputStreamSkip                         ,

    -- ** skipAsync #method:skipAsync#

    #if ENABLE_OVERLOADING
        InputStreamSkipAsyncMethodInfo          ,
    #endif
        inputStreamSkipAsync                    ,

    -- ** skipFinish #method:skipFinish#

    #if ENABLE_OVERLOADING
        InputStreamSkipFinishMethodInfo         ,
    #endif
        inputStreamSkipFinish                   ,

        ) 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.GLib.Structs.Bytes as GLib.Bytes
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gio.Callbacks as Gio.Callbacks
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
    import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable

    -- | Memory-managed wrapper type.
    newtype InputStream = InputStream (ManagedPtr InputStream)
    foreign import ccall "g_input_stream_get_type"
        c_g_input_stream_get_type :: IO GType

    instance GObject InputStream where
        gobjectType _ = c_g_input_stream_get_type

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

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

    -- | A convenience alias for `Nothing` :: `Maybe` `InputStream`.
    noInputStream :: Maybe InputStream
    noInputStream = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveInputStreamMethod (t :: Symbol) (o :: *) :: * where
        ResolveInputStreamMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveInputStreamMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveInputStreamMethod "clearPending" o = InputStreamClearPendingMethodInfo
        ResolveInputStreamMethod "close" o = InputStreamCloseMethodInfo
        ResolveInputStreamMethod "closeAsync" o = InputStreamCloseAsyncMethodInfo
        ResolveInputStreamMethod "closeFinish" o = InputStreamCloseFinishMethodInfo
        ResolveInputStreamMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveInputStreamMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveInputStreamMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveInputStreamMethod "hasPending" o = InputStreamHasPendingMethodInfo
        ResolveInputStreamMethod "isClosed" o = InputStreamIsClosedMethodInfo
        ResolveInputStreamMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveInputStreamMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveInputStreamMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveInputStreamMethod "read" o = InputStreamReadMethodInfo
        ResolveInputStreamMethod "readAll" o = InputStreamReadAllMethodInfo
        ResolveInputStreamMethod "readAllAsync" o = InputStreamReadAllAsyncMethodInfo
        ResolveInputStreamMethod "readAllFinish" o = InputStreamReadAllFinishMethodInfo
        ResolveInputStreamMethod "readAsync" o = InputStreamReadAsyncMethodInfo
        ResolveInputStreamMethod "readBytes" o = InputStreamReadBytesMethodInfo
        ResolveInputStreamMethod "readBytesAsync" o = InputStreamReadBytesAsyncMethodInfo
        ResolveInputStreamMethod "readBytesFinish" o = InputStreamReadBytesFinishMethodInfo
        ResolveInputStreamMethod "readFinish" o = InputStreamReadFinishMethodInfo
        ResolveInputStreamMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveInputStreamMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveInputStreamMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveInputStreamMethod "skip" o = InputStreamSkipMethodInfo
        ResolveInputStreamMethod "skipAsync" o = InputStreamSkipAsyncMethodInfo
        ResolveInputStreamMethod "skipFinish" o = InputStreamSkipFinishMethodInfo
        ResolveInputStreamMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveInputStreamMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveInputStreamMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveInputStreamMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveInputStreamMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveInputStreamMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveInputStreamMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveInputStreamMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveInputStreamMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveInputStreamMethod "setPending" o = InputStreamSetPendingMethodInfo
        ResolveInputStreamMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveInputStreamMethod l o = O.MethodResolutionFailed l o

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

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

    #endif

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

    #if ENABLE_OVERLOADING
    #endif

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

    #endif

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

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

    {- |
    Clears the pending flag on /@stream@/.
    -}
    inputStreamClearPending ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a) =>
        a
        {- ^ /@stream@/: input stream -}
        -> m ()
    inputStreamClearPending stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        g_input_stream_clear_pending stream'
        touchManagedPtr stream
        return ()

    #if ENABLE_OVERLOADING
    data InputStreamClearPendingMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsInputStream a) => O.MethodInfo InputStreamClearPendingMethodInfo a signature where
        overloadedMethod _ = inputStreamClearPending

    #endif

    -- method InputStream::close
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GInputStream.", 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_input_stream_close" g_input_stream_close ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        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.

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

    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.

    If /@cancellable@/ is not 'Nothing', 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.
    -}
    inputStreamClose ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: A 'GI.Gio.Objects.InputStream.InputStream'. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    inputStreamClose 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_input_stream_close stream' maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            return ()
         ) (do
            return ()
         )

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

    #endif

    -- method InputStream::close_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the [I/O priority][io-priority] of the request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "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_input_stream_close_async" g_input_stream_close_async ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        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 closes of the stream, releasing resources related to it.
    When the operation is finished /@callback@/ will be called.
    You can then call 'GI.Gio.Objects.InputStream.inputStreamCloseFinish' to get the result of the
    operation.

    For behaviour details see 'GI.Gio.Objects.InputStream.inputStreamClose'.

    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.
    -}
    inputStreamCloseAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: A 'GI.Gio.Objects.InputStream.InputStream'. -}
        -> Int32
        {- ^ /@ioPriority@/: the [I\/O priority][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 ()
    inputStreamCloseAsync 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_input_stream_close_async stream' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        return ()

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

    #endif

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

    {- |
    Finishes closing a stream asynchronously, started from 'GI.Gio.Objects.InputStream.inputStreamCloseAsync'.
    -}
    inputStreamCloseFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream'. -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    inputStreamCloseFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            _ <- propagateGError $ g_input_stream_close_finish stream' result_'
            touchManagedPtr stream
            touchManagedPtr result_
            return ()
         ) (do
            return ()
         )

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

    #endif

    -- method InputStream::has_pending
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "input stream.", 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_input_stream_has_pending" g_input_stream_has_pending ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        IO CInt

    {- |
    Checks if an input stream has pending actions.
    -}
    inputStreamHasPending ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a) =>
        a
        {- ^ /@stream@/: input stream. -}
        -> m Bool
        {- ^ __Returns:__ 'True' if /@stream@/ has pending actions. -}
    inputStreamHasPending stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result <- g_input_stream_has_pending stream'
        let result' = (/= 0) result
        touchManagedPtr stream
        return result'

    #if ENABLE_OVERLOADING
    data InputStreamHasPendingMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsInputStream a) => O.MethodInfo InputStreamHasPendingMethodInfo a signature where
        overloadedMethod _ = inputStreamHasPending

    #endif

    -- method InputStream::is_closed
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "input stream.", 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_input_stream_is_closed" g_input_stream_is_closed ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        IO CInt

    {- |
    Checks if an input stream is closed.
    -}
    inputStreamIsClosed ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a) =>
        a
        {- ^ /@stream@/: input stream. -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the stream is closed. -}
    inputStreamIsClosed stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result <- g_input_stream_is_closed stream'
        let result' = (/= 0) result
        touchManagedPtr stream
        return result'

    #if ENABLE_OVERLOADING
    data InputStreamIsClosedMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsInputStream a) => O.MethodInfo InputStreamIsClosedMethodInfo a signature where
        overloadedMethod _ = inputStreamIsClosed

    #endif

    -- method InputStream::read
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a buffer to\n    read data into (which should be at least count bytes long).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes that will be read from the stream", 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 : [Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes that will be read from the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Just (TBasicType TInt64)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_input_stream_read" g_input_stream_read ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)
        Word64 ->                               -- count : TBasicType TUInt64
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO Int64

    {- |
    Tries to read /@count@/ bytes from the stream into the buffer starting at
    /@buffer@/. Will block during this read.

    If count is zero returns zero and does nothing. A value of /@count@/
    larger than @/G_MAXSSIZE/@ will cause a 'GI.Gio.Enums.IOErrorEnumInvalidArgument' error.

    On success, the number of bytes read into the buffer is returned.
    It is not an error if this is not the same as the requested size, as it
    can happen e.g. near the end of a file. Zero is returned on end of file
    (or if /@count@/ is zero),  but never otherwise.

    The returned /@buffer@/ is not a nul-terminated string, it can contain nul bytes
    at any position, and this function doesn\'t nul-terminate the /@buffer@/.

    If /@cancellable@/ is not 'Nothing', 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. If an
    operation was partially finished when the operation was cancelled the
    partial result will be returned, without an error.

    On error -1 is returned and /@error@/ is set accordingly.
    -}
    inputStreamRead ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream'. -}
        -> ByteString
        {- ^ /@buffer@/: a buffer to
        read data into (which should be at least count bytes long). -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m Int64
        {- ^ __Returns:__ Number of bytes read, or -1 on error, or 0 on end of file. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    inputStreamRead stream buffer cancellable = liftIO $ do
        let count = fromIntegral $ B.length buffer
        stream' <- unsafeManagedPtrCastPtr stream
        buffer' <- packByteString buffer
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_input_stream_read stream' buffer' count maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            freeMem buffer'
            return result
         ) (do
            freeMem buffer'
         )

    #if ENABLE_OVERLOADING
    data InputStreamReadMethodInfo
    instance (signature ~ (ByteString -> Maybe (b) -> m Int64), MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo InputStreamReadMethodInfo a signature where
        overloadedMethod _ = inputStreamRead

    #endif

    -- method InputStream::read_all
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a buffer to\n    read data into (which should be at least count bytes long).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes that will be read from the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes_read", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the number of bytes that was read from the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},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 : [Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes that will be read from the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_input_stream_read_all" g_input_stream_read_all ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)
        Word64 ->                               -- count : TBasicType TUInt64
        Ptr Word64 ->                           -- bytes_read : TBasicType TUInt64
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Tries to read /@count@/ bytes from the stream into the buffer starting at
    /@buffer@/. Will block during this read.

    This function is similar to 'GI.Gio.Objects.InputStream.inputStreamRead', except it tries to
    read as many bytes as requested, only stopping on an error or end of stream.

    On a successful read of /@count@/ bytes, or if we reached the end of the
    stream,  'True' is returned, and /@bytesRead@/ is set to the number of bytes
    read into /@buffer@/.

    If there is an error during the operation 'False' is returned and /@error@/
    is set to indicate the error status.

    As a special exception to the normal conventions for functions that
    use 'GError', if this function returns 'False' (and sets /@error@/) then
    /@bytesRead@/ will be set to the number of bytes that were successfully
    read before the error was encountered.  This functionality is only
    available from C.  If you need it from another language then you must
    write your own loop around 'GI.Gio.Objects.InputStream.inputStreamRead'.
    -}
    inputStreamReadAll ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream'. -}
        -> ByteString
        {- ^ /@buffer@/: a buffer to
        read data into (which should be at least count bytes long). -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m (Word64)
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    inputStreamReadAll stream buffer cancellable = liftIO $ do
        let count = fromIntegral $ B.length buffer
        stream' <- unsafeManagedPtrCastPtr stream
        buffer' <- packByteString buffer
        bytesRead <- allocMem :: IO (Ptr Word64)
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_input_stream_read_all stream' buffer' count bytesRead maybeCancellable
            bytesRead' <- peek bytesRead
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            freeMem buffer'
            freeMem bytesRead
            return bytesRead'
         ) (do
            freeMem buffer'
            freeMem bytesRead
         )

    #if ENABLE_OVERLOADING
    data InputStreamReadAllMethodInfo
    instance (signature ~ (ByteString -> Maybe (b) -> m (Word64)), MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo InputStreamReadAllMethodInfo a signature where
        overloadedMethod _ = inputStreamReadAll

    #endif

    -- method InputStream::read_all_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GInputStream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a buffer to\n    read data into (which should be at least count bytes long)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes that will be read from the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the [I/O priority][io-priority] of the request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "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 "callback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : [Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes that will be read from the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_input_stream_read_all_async" g_input_stream_read_all_async ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)
        Word64 ->                               -- count : TBasicType TUInt64
        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 ()

    {- |
    Request an asynchronous read of /@count@/ bytes from the stream into the
    buffer starting at /@buffer@/.

    This is the asynchronous equivalent of 'GI.Gio.Objects.InputStream.inputStreamReadAll'.

    Call 'GI.Gio.Objects.InputStream.inputStreamReadAllFinish' to collect the result.

    Any outstanding I\/O request with higher priority (lower numerical
    value) will be executed before an outstanding request with lower
    priority. Default priority is 'GI.GLib.Constants.PRIORITY_DEFAULT'.

    /Since: 2.44/
    -}
    inputStreamReadAllAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: A 'GI.Gio.Objects.InputStream.InputStream' -}
        -> ByteString
        {- ^ /@buffer@/: a buffer to
        read data into (which should be at least count bytes long) -}
        -> Int32
        {- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the request is satisfied -}
        -> m ()
    inputStreamReadAllAsync stream buffer ioPriority cancellable callback = liftIO $ do
        let count = fromIntegral $ B.length buffer
        stream' <- unsafeManagedPtrCastPtr stream
        buffer' <- packByteString buffer
        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_input_stream_read_all_async stream' buffer' count ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        freeMem buffer'
        return ()

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

    #endif

    -- method InputStream::read_all_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream", 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},Arg {argCName = "bytes_read", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the number of bytes that was read from the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_input_stream_read_all_finish" g_input_stream_read_all_finish ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr Word64 ->                           -- bytes_read : TBasicType TUInt64
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Finishes an asynchronous stream read operation started with
    'GI.Gio.Objects.InputStream.inputStreamReadAllAsync'.

    As a special exception to the normal conventions for functions that
    use 'GError', if this function returns 'False' (and sets /@error@/) then
    /@bytesRead@/ will be set to the number of bytes that were successfully
    read before the error was encountered.  This functionality is only
    available from C.  If you need it from another language then you must
    write your own loop around 'GI.Gio.Objects.InputStream.inputStreamReadAsync'.

    /Since: 2.44/
    -}
    inputStreamReadAllFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream' -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
        -> m (Word64)
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    inputStreamReadAllFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        bytesRead <- allocMem :: IO (Ptr Word64)
        onException (do
            _ <- propagateGError $ g_input_stream_read_all_finish stream' result_' bytesRead
            bytesRead' <- peek bytesRead
            touchManagedPtr stream
            touchManagedPtr result_
            freeMem bytesRead
            return bytesRead'
         ) (do
            freeMem bytesRead
         )

    #if ENABLE_OVERLOADING
    data InputStreamReadAllFinishMethodInfo
    instance (signature ~ (b -> m (Word64)), MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo InputStreamReadAllFinishMethodInfo a signature where
        overloadedMethod _ = inputStreamReadAllFinish

    #endif

    -- method InputStream::read_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a buffer to\n    read data into (which should be at least count bytes long).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes that will be read from the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the [I/O priority][io-priority]\nof 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 "callback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : [Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes that will be read from the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_input_stream_read_async" g_input_stream_read_async ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)
        Word64 ->                               -- count : TBasicType TUInt64
        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 ()

    {- |
    Request an asynchronous read of /@count@/ bytes from the stream into the buffer
    starting at /@buffer@/. When the operation is finished /@callback@/ will be called.
    You can then call 'GI.Gio.Objects.InputStream.inputStreamReadFinish' to get the result of the
    operation.

    During an async request no other sync and async calls are allowed on /@stream@/, and will
    result in 'GI.Gio.Enums.IOErrorEnumPending' errors.

    A value of /@count@/ larger than @/G_MAXSSIZE/@ will cause a 'GI.Gio.Enums.IOErrorEnumInvalidArgument' error.

    On success, the number of bytes read into the buffer will be passed to the
    callback. It is not an error if this is not the same as the requested size, as it
    can happen e.g. near the end of a file, but generally we try to read
    as many bytes as requested. Zero is returned on end of file
    (or if /@count@/ is zero),  but never otherwise.

    Any outstanding i\/o request with higher priority (lower numerical value) will
    be executed before an outstanding request with lower priority. Default
    priority is 'GI.GLib.Constants.PRIORITY_DEFAULT'.

    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.
    -}
    inputStreamReadAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: A 'GI.Gio.Objects.InputStream.InputStream'. -}
        -> Maybe (ByteString)
        {- ^ /@buffer@/: a buffer to
        read data into (which should be at least count bytes long). -}
        -> Int32
        {- ^ /@ioPriority@/: the [I\/O priority][io-priority]
    of the request. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the request is satisfied -}
        -> m ()
    inputStreamReadAsync stream buffer ioPriority cancellable callback = liftIO $ do
        let count = case buffer of
                Nothing -> 0
                Just jBuffer -> fromIntegral $ B.length jBuffer
        stream' <- unsafeManagedPtrCastPtr stream
        maybeBuffer <- case buffer of
            Nothing -> return nullPtr
            Just jBuffer -> do
                jBuffer' <- packByteString jBuffer
                return jBuffer'
        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_input_stream_read_async stream' maybeBuffer count ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        freeMem maybeBuffer
        return ()

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

    #endif

    -- method InputStream::read_bytes
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "maximum number of bytes that will be read from the stream. Common\nvalues include 4096 and 8192.", 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 (TInterface (Name {namespace = "GLib", name = "Bytes"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_input_stream_read_bytes" g_input_stream_read_bytes ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        Word64 ->                               -- count : TBasicType TUInt64
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr GLib.Bytes.Bytes)

    {- |
    Like 'GI.Gio.Objects.InputStream.inputStreamRead', this tries to read /@count@/ bytes from
    the stream in a blocking fashion. However, rather than reading into
    a user-supplied buffer, this will create a new 'GI.GLib.Structs.Bytes.Bytes' containing
    the data that was read. This may be easier to use from language
    bindings.

    If count is zero, returns a zero-length 'GI.GLib.Structs.Bytes.Bytes' and does nothing. A
    value of /@count@/ larger than @/G_MAXSSIZE/@ will cause a
    'GI.Gio.Enums.IOErrorEnumInvalidArgument' error.

    On success, a new 'GI.GLib.Structs.Bytes.Bytes' is returned. It is not an error if the
    size of this object is not the same as the requested size, as it
    can happen e.g. near the end of a file. A zero-length 'GI.GLib.Structs.Bytes.Bytes' is
    returned on end of file (or if /@count@/ is zero), but never
    otherwise.

    If /@cancellable@/ is not 'Nothing', 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. If an
    operation was partially finished when the operation was cancelled the
    partial result will be returned, without an error.

    On error 'Nothing' is returned and /@error@/ is set accordingly.

    /Since: 2.34/
    -}
    inputStreamReadBytes ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream'. -}
        -> Word64
        {- ^ /@count@/: maximum number of bytes that will be read from the stream. Common
    values include 4096 and 8192. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m GLib.Bytes.Bytes
        {- ^ __Returns:__ a new 'GI.GLib.Structs.Bytes.Bytes', or 'Nothing' on error /(Can throw 'Data.GI.Base.GError.GError')/ -}
    inputStreamReadBytes stream count cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_input_stream_read_bytes stream' count maybeCancellable
            checkUnexpectedReturnNULL "inputStreamReadBytes" result
            result' <- (wrapBoxed GLib.Bytes.Bytes) result
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            return result'
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data InputStreamReadBytesMethodInfo
    instance (signature ~ (Word64 -> Maybe (b) -> m GLib.Bytes.Bytes), MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo InputStreamReadBytesMethodInfo a signature where
        overloadedMethod _ = inputStreamReadBytes

    #endif

    -- method InputStream::read_bytes_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes that will be read from the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the [I/O priority][io-priority] of the request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "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 "callback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, 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_input_stream_read_bytes_async" g_input_stream_read_bytes_async ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        Word64 ->                               -- count : TBasicType TUInt64
        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 ()

    {- |
    Request an asynchronous read of /@count@/ bytes from the stream into a
    new 'GI.GLib.Structs.Bytes.Bytes'. When the operation is finished /@callback@/ will be
    called. You can then call 'GI.Gio.Objects.InputStream.inputStreamReadBytesFinish' to get the
    result of the operation.

    During an async request no other sync and async calls are allowed
    on /@stream@/, and will result in 'GI.Gio.Enums.IOErrorEnumPending' errors.

    A value of /@count@/ larger than @/G_MAXSSIZE/@ will cause a
    'GI.Gio.Enums.IOErrorEnumInvalidArgument' error.

    On success, the new 'GI.GLib.Structs.Bytes.Bytes' will be passed to the callback. It is
    not an error if this is smaller than the requested size, as it can
    happen e.g. near the end of a file, but generally we try to read as
    many bytes as requested. Zero is returned on end of file (or if
    /@count@/ is zero), but never otherwise.

    Any outstanding I\/O request with higher priority (lower numerical
    value) will be executed before an outstanding request with lower
    priority. Default priority is 'GI.GLib.Constants.PRIORITY_DEFAULT'.

    /Since: 2.34/
    -}
    inputStreamReadBytesAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: A 'GI.Gio.Objects.InputStream.InputStream'. -}
        -> Word64
        {- ^ /@count@/: the number of bytes that will be read from the stream -}
        -> Int32
        {- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the request is satisfied -}
        -> m ()
    inputStreamReadBytesAsync stream count 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_input_stream_read_bytes_async stream' count ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        return ()

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

    #endif

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

    foreign import ccall "g_input_stream_read_bytes_finish" g_input_stream_read_bytes_finish ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr GLib.Bytes.Bytes)

    {- |
    Finishes an asynchronous stream read-into-'GI.GLib.Structs.Bytes.Bytes' operation.

    /Since: 2.34/
    -}
    inputStreamReadBytesFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream'. -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m GLib.Bytes.Bytes
        {- ^ __Returns:__ the newly-allocated 'GI.GLib.Structs.Bytes.Bytes', or 'Nothing' on error /(Can throw 'Data.GI.Base.GError.GError')/ -}
    inputStreamReadBytesFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            result <- propagateGError $ g_input_stream_read_bytes_finish stream' result_'
            checkUnexpectedReturnNULL "inputStreamReadBytesFinish" result
            result' <- (wrapBoxed GLib.Bytes.Bytes) result
            touchManagedPtr stream
            touchManagedPtr result_
            return result'
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data InputStreamReadBytesFinishMethodInfo
    instance (signature ~ (b -> m GLib.Bytes.Bytes), MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo InputStreamReadBytesFinishMethodInfo a signature where
        overloadedMethod _ = inputStreamReadBytesFinish

    #endif

    -- method InputStream::read_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream.", 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 TInt64)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_input_stream_read_finish" g_input_stream_read_finish ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO Int64

    {- |
    Finishes an asynchronous stream read operation.
    -}
    inputStreamReadFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream'. -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m Int64
        {- ^ __Returns:__ number of bytes read in, or -1 on error, or 0 on end of file. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    inputStreamReadFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            result <- propagateGError $ g_input_stream_read_finish stream' result_'
            touchManagedPtr stream
            touchManagedPtr result_
            return result
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data InputStreamReadFinishMethodInfo
    instance (signature ~ (b -> m Int64), MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo InputStreamReadFinishMethodInfo a signature where
        overloadedMethod _ = inputStreamReadFinish

    #endif

    -- method InputStream::set_pending
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "input stream", 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_input_stream_set_pending" g_input_stream_set_pending ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        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@/.
    -}
    inputStreamSetPending ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a) =>
        a
        {- ^ /@stream@/: input stream -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    inputStreamSetPending stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        onException (do
            _ <- propagateGError $ g_input_stream_set_pending stream'
            touchManagedPtr stream
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data InputStreamSetPendingMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsInputStream a) => O.MethodInfo InputStreamSetPendingMethodInfo a signature where
        overloadedMethod _ = inputStreamSetPending

    #endif

    -- method InputStream::skip
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes that will be skipped from the stream", 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 TInt64)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_input_stream_skip" g_input_stream_skip ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        Word64 ->                               -- count : TBasicType TUInt64
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO Int64

    {- |
    Tries to skip /@count@/ bytes from the stream. Will block during the operation.

    This is identical to 'GI.Gio.Objects.InputStream.inputStreamRead', from a behaviour standpoint,
    but the bytes that are skipped are not returned to the user. Some
    streams have an implementation that is more efficient than reading the data.

    This function is optional for inherited classes, as the default implementation
    emulates it using read.

    If /@cancellable@/ is not 'Nothing', 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. If an
    operation was partially finished when the operation was cancelled the
    partial result will be returned, without an error.
    -}
    inputStreamSkip ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream'. -}
        -> Word64
        {- ^ /@count@/: the number of bytes that will be skipped from the stream -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m Int64
        {- ^ __Returns:__ Number of bytes skipped, or -1 on error /(Can throw 'Data.GI.Base.GError.GError')/ -}
    inputStreamSkip stream count cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_input_stream_skip stream' count maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            return result
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data InputStreamSkipMethodInfo
    instance (signature ~ (Word64 -> Maybe (b) -> m Int64), MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo InputStreamSkipMethodInfo a signature where
        overloadedMethod _ = inputStreamSkip

    #endif

    -- method InputStream::skip_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes that will be skipped from the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the [I/O priority][io-priority] of the request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "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 "callback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, 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_input_stream_skip_async" g_input_stream_skip_async ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        Word64 ->                               -- count : TBasicType TUInt64
        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 ()

    {- |
    Request an asynchronous skip of /@count@/ bytes from the stream.
    When the operation is finished /@callback@/ will be called.
    You can then call 'GI.Gio.Objects.InputStream.inputStreamSkipFinish' to get the result
    of the operation.

    During an async request no other sync and async calls are allowed,
    and will result in 'GI.Gio.Enums.IOErrorEnumPending' errors.

    A value of /@count@/ larger than @/G_MAXSSIZE/@ will cause a 'GI.Gio.Enums.IOErrorEnumInvalidArgument' error.

    On success, the number of bytes skipped will be passed to the callback.
    It is not an error if this is not the same as the requested size, as it
    can happen e.g. near the end of a file, but generally we try to skip
    as many bytes as requested. Zero is returned on end of file
    (or if /@count@/ is zero), but never otherwise.

    Any outstanding i\/o request with higher priority (lower numerical value)
    will be executed before an outstanding request with lower priority.
    Default priority is 'GI.GLib.Constants.PRIORITY_DEFAULT'.

    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.
    -}
    inputStreamSkipAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: A 'GI.Gio.Objects.InputStream.InputStream'. -}
        -> Word64
        {- ^ /@count@/: the number of bytes that will be skipped from the stream -}
        -> Int32
        {- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the request is satisfied -}
        -> m ()
    inputStreamSkipAsync stream count 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_input_stream_skip_async stream' count ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        return ()

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

    #endif

    -- method InputStream::skip_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream.", 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 TInt64)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_input_stream_skip_finish" g_input_stream_skip_finish ::
        Ptr InputStream ->                      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO Int64

    {- |
    Finishes a stream skip operation.
    -}
    inputStreamSkipFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream'. -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m Int64
        {- ^ __Returns:__ the size of the bytes skipped, or %-1 on error. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    inputStreamSkipFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            result <- propagateGError $ g_input_stream_skip_finish stream' result_'
            touchManagedPtr stream
            touchManagedPtr result_
            return result
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data InputStreamSkipFinishMethodInfo
    instance (signature ~ (b -> m Int64), MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo InputStreamSkipFinishMethodInfo a signature where
        overloadedMethod _ = inputStreamSkipFinish

    #endif