    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- @GOutputStream@ is a base class for implementing streaming output.
    --
    -- It has functions to write to a stream ('GI.Gio.Objects.OutputStream.outputStreamWrite'),
    -- to close a stream ('GI.Gio.Objects.OutputStream.outputStreamClose') and to flush pending
    -- writes ('GI.Gio.Objects.OutputStream.outputStreamFlush').
    --
    -- 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 t'GI.Gio.Objects.IOStream.IOStream' for details of thread safety
    -- of streaming APIs.
    --
    -- All of these functions have async variants too.
    --
    -- All classes derived from @GOutputStream@ *should* implement synchronous
    -- writing, splicing, flushing and closing streams, but *may* implement
    -- asynchronous versions.

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

    module GI.Gio.Objects.OutputStream
        (

    -- * Exported types
        OutputStream(..)                        ,
        IsOutputStream                          ,
        toOutputStream                          ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [clearPending]("GI.Gio.Objects.OutputStream#g:method:clearPending"), [close]("GI.Gio.Objects.OutputStream#g:method:close"), [closeAsync]("GI.Gio.Objects.OutputStream#g:method:closeAsync"), [closeFinish]("GI.Gio.Objects.OutputStream#g:method:closeFinish"), [flush]("GI.Gio.Objects.OutputStream#g:method:flush"), [flushAsync]("GI.Gio.Objects.OutputStream#g:method:flushAsync"), [flushFinish]("GI.Gio.Objects.OutputStream#g:method:flushFinish"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hasPending]("GI.Gio.Objects.OutputStream#g:method:hasPending"), [isClosed]("GI.Gio.Objects.OutputStream#g:method:isClosed"), [isClosing]("GI.Gio.Objects.OutputStream#g:method:isClosing"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [splice]("GI.Gio.Objects.OutputStream#g:method:splice"), [spliceAsync]("GI.Gio.Objects.OutputStream#g:method:spliceAsync"), [spliceFinish]("GI.Gio.Objects.OutputStream#g:method:spliceFinish"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"), [write]("GI.Gio.Objects.OutputStream#g:method:write"), [writeAll]("GI.Gio.Objects.OutputStream#g:method:writeAll"), [writeAllAsync]("GI.Gio.Objects.OutputStream#g:method:writeAllAsync"), [writeAllFinish]("GI.Gio.Objects.OutputStream#g:method:writeAllFinish"), [writeAsync]("GI.Gio.Objects.OutputStream#g:method:writeAsync"), [writeBytes]("GI.Gio.Objects.OutputStream#g:method:writeBytes"), [writeBytesAsync]("GI.Gio.Objects.OutputStream#g:method:writeBytesAsync"), [writeBytesFinish]("GI.Gio.Objects.OutputStream#g:method:writeBytesFinish"), [writeFinish]("GI.Gio.Objects.OutputStream#g:method:writeFinish"), [writev]("GI.Gio.Objects.OutputStream#g:method:writev"), [writevAll]("GI.Gio.Objects.OutputStream#g:method:writevAll"), [writevAllAsync]("GI.Gio.Objects.OutputStream#g:method:writevAllAsync"), [writevAllFinish]("GI.Gio.Objects.OutputStream#g:method:writevAllFinish"), [writevAsync]("GI.Gio.Objects.OutputStream#g:method:writevAsync"), [writevFinish]("GI.Gio.Objects.OutputStream#g:method:writevFinish").
    --
    -- ==== Getters
    -- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
    --
    -- ==== Setters
    -- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setPending]("GI.Gio.Objects.OutputStream#g:method:setPending"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

    #if defined(ENABLE_OVERLOADING)
        ResolveOutputStreamMethod               ,
    #endif

    -- ** clearPending #method:clearPending#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamClearPendingMethodInfo      ,
    #endif
        outputStreamClearPending                ,

    -- ** close #method:close#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamCloseMethodInfo             ,
    #endif
        outputStreamClose                       ,

    -- ** closeAsync #method:closeAsync#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamCloseAsyncMethodInfo        ,
    #endif
        outputStreamCloseAsync                  ,

    -- ** closeFinish #method:closeFinish#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamCloseFinishMethodInfo       ,
    #endif
        outputStreamCloseFinish                 ,

    -- ** flush #method:flush#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamFlushMethodInfo             ,
    #endif
        outputStreamFlush                       ,

    -- ** flushAsync #method:flushAsync#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamFlushAsyncMethodInfo        ,
    #endif
        outputStreamFlushAsync                  ,

    -- ** flushFinish #method:flushFinish#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamFlushFinishMethodInfo       ,
    #endif
        outputStreamFlushFinish                 ,

    -- ** hasPending #method:hasPending#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamHasPendingMethodInfo        ,
    #endif
        outputStreamHasPending                  ,

    -- ** isClosed #method:isClosed#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamIsClosedMethodInfo          ,
    #endif
        outputStreamIsClosed                    ,

    -- ** isClosing #method:isClosing#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamIsClosingMethodInfo         ,
    #endif
        outputStreamIsClosing                   ,

    -- ** setPending #method:setPending#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamSetPendingMethodInfo        ,
    #endif
        outputStreamSetPending                  ,

    -- ** splice #method:splice#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamSpliceMethodInfo            ,
    #endif
        outputStreamSplice                      ,

    -- ** spliceAsync #method:spliceAsync#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamSpliceAsyncMethodInfo       ,
    #endif
        outputStreamSpliceAsync                 ,

    -- ** spliceFinish #method:spliceFinish#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamSpliceFinishMethodInfo      ,
    #endif
        outputStreamSpliceFinish                ,

    -- ** write #method:write#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamWriteMethodInfo             ,
    #endif
        outputStreamWrite                       ,

    -- ** writeAll #method:writeAll#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamWriteAllMethodInfo          ,
    #endif
        outputStreamWriteAll                    ,

    -- ** writeAllAsync #method:writeAllAsync#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamWriteAllAsyncMethodInfo     ,
    #endif
        outputStreamWriteAllAsync               ,

    -- ** writeAllFinish #method:writeAllFinish#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamWriteAllFinishMethodInfo    ,
    #endif
        outputStreamWriteAllFinish              ,

    -- ** writeAsync #method:writeAsync#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamWriteAsyncMethodInfo        ,
    #endif
        outputStreamWriteAsync                  ,

    -- ** writeBytes #method:writeBytes#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamWriteBytesMethodInfo        ,
    #endif
        outputStreamWriteBytes                  ,

    -- ** writeBytesAsync #method:writeBytesAsync#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamWriteBytesAsyncMethodInfo   ,
    #endif
        outputStreamWriteBytesAsync             ,

    -- ** writeBytesFinish #method:writeBytesFinish#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamWriteBytesFinishMethodInfo  ,
    #endif
        outputStreamWriteBytesFinish            ,

    -- ** writeFinish #method:writeFinish#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamWriteFinishMethodInfo       ,
    #endif
        outputStreamWriteFinish                 ,

    -- ** writev #method:writev#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamWritevMethodInfo            ,
    #endif
        outputStreamWritev                      ,

    -- ** writevAll #method:writevAll#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamWritevAllMethodInfo         ,
    #endif
        outputStreamWritevAll                   ,

    -- ** writevAllAsync #method:writevAllAsync#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamWritevAllAsyncMethodInfo    ,
    #endif
        outputStreamWritevAllAsync              ,

    -- ** writevAllFinish #method:writevAllFinish#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamWritevAllFinishMethodInfo   ,
    #endif
        outputStreamWritevAllFinish             ,

    -- ** writevAsync #method:writevAsync#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamWritevAsyncMethodInfo       ,
    #endif
        outputStreamWritevAsync                 ,

    -- ** writevFinish #method:writevFinish#

    #if defined(ENABLE_OVERLOADING)
        OutputStreamWritevFinishMethodInfo      ,
    #endif
        outputStreamWritevFinish                ,

        ) where

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

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

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import qualified GI.GLib.Callbacks as GLib.Callbacks
    import qualified GI.GLib.Structs.Bytes as GLib.Bytes
    import qualified GI.GLib.Structs.PollFD as GLib.PollFD
    import qualified GI.GLib.Structs.Source as GLib.Source
    import qualified GI.GObject.Callbacks as GObject.Callbacks
    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.Structs.OutputVector as Gio.OutputVector

    #else
    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.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.Structs.OutputVector as Gio.OutputVector

    #endif

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

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

    foreign import ccall "g_output_stream_get_type"
        c_g_output_stream_get_type :: IO B.Types.GType

    instance B.Types.TypedObject OutputStream where
        glibType :: IO GType
    glibType = IO GType
    c_g_output_stream_get_type

    instance B.Types.GObject OutputStream

    -- | Type class for types which can be safely cast to t'OutputStream', for instance with `toOutputStream`.
    class (SP.GObject o, O.IsDescendantOf OutputStream o) => IsOutputStream o
    instance (SP.GObject o, O.IsDescendantOf OutputStream o) => IsOutputStream o

    instance O.HasParentTypes OutputStream
    type instance O.ParentTypes OutputStream = '[GObject.Object.Object]

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

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

    #if defined(ENABLE_OVERLOADING)
    type family ResolveOutputStreamMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveOutputStreamMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveOutputStreamMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveOutputStreamMethod "clearPending" o = OutputStreamClearPendingMethodInfo
        ResolveOutputStreamMethod "close" o = OutputStreamCloseMethodInfo
        ResolveOutputStreamMethod "closeAsync" o = OutputStreamCloseAsyncMethodInfo
        ResolveOutputStreamMethod "closeFinish" o = OutputStreamCloseFinishMethodInfo
        ResolveOutputStreamMethod "flush" o = OutputStreamFlushMethodInfo
        ResolveOutputStreamMethod "flushAsync" o = OutputStreamFlushAsyncMethodInfo
        ResolveOutputStreamMethod "flushFinish" o = OutputStreamFlushFinishMethodInfo
        ResolveOutputStreamMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveOutputStreamMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveOutputStreamMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveOutputStreamMethod "hasPending" o = OutputStreamHasPendingMethodInfo
        ResolveOutputStreamMethod "isClosed" o = OutputStreamIsClosedMethodInfo
        ResolveOutputStreamMethod "isClosing" o = OutputStreamIsClosingMethodInfo
        ResolveOutputStreamMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveOutputStreamMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveOutputStreamMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveOutputStreamMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveOutputStreamMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveOutputStreamMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveOutputStreamMethod "splice" o = OutputStreamSpliceMethodInfo
        ResolveOutputStreamMethod "spliceAsync" o = OutputStreamSpliceAsyncMethodInfo
        ResolveOutputStreamMethod "spliceFinish" o = OutputStreamSpliceFinishMethodInfo
        ResolveOutputStreamMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveOutputStreamMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveOutputStreamMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveOutputStreamMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveOutputStreamMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveOutputStreamMethod "write" o = OutputStreamWriteMethodInfo
        ResolveOutputStreamMethod "writeAll" o = OutputStreamWriteAllMethodInfo
        ResolveOutputStreamMethod "writeAllAsync" o = OutputStreamWriteAllAsyncMethodInfo
        ResolveOutputStreamMethod "writeAllFinish" o = OutputStreamWriteAllFinishMethodInfo
        ResolveOutputStreamMethod "writeAsync" o = OutputStreamWriteAsyncMethodInfo
        ResolveOutputStreamMethod "writeBytes" o = OutputStreamWriteBytesMethodInfo
        ResolveOutputStreamMethod "writeBytesAsync" o = OutputStreamWriteBytesAsyncMethodInfo
        ResolveOutputStreamMethod "writeBytesFinish" o = OutputStreamWriteBytesFinishMethodInfo
        ResolveOutputStreamMethod "writeFinish" o = OutputStreamWriteFinishMethodInfo
        ResolveOutputStreamMethod "writev" o = OutputStreamWritevMethodInfo
        ResolveOutputStreamMethod "writevAll" o = OutputStreamWritevAllMethodInfo
        ResolveOutputStreamMethod "writevAllAsync" o = OutputStreamWritevAllAsyncMethodInfo
        ResolveOutputStreamMethod "writevAllFinish" o = OutputStreamWritevAllFinishMethodInfo
        ResolveOutputStreamMethod "writevAsync" o = OutputStreamWritevAsyncMethodInfo
        ResolveOutputStreamMethod "writevFinish" o = OutputStreamWritevFinishMethodInfo
        ResolveOutputStreamMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveOutputStreamMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveOutputStreamMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveOutputStreamMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveOutputStreamMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveOutputStreamMethod "setPending" o = OutputStreamSetPendingMethodInfo
        ResolveOutputStreamMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveOutputStreamMethod l o = O.MethodResolutionFailed l o

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

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

    #endif

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

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList OutputStream
    type instance O.AttributeList OutputStream = OutputStreamAttributeList
    type OutputStreamAttributeList = ('[ ] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    #endif

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

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

    -- | Clears the pending flag on /@stream@/.
    outputStreamClearPending ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a) =>
        a
        -- ^ /@stream@/: output stream
        -> m ()
    outputStreamClearPending :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsOutputStream a) =>
    a -> m ()
    outputStreamClearPending a
    stream = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        g_output_stream_clear_pending stream'
        touchManagedPtr stream
        return ()

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamClearPendingMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsOutputStream a) => O.OverloadedMethod OutputStreamClearPendingMethodInfo a signature where
        overloadedMethod = outputStreamClearPending

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

    #endif

    -- method OutputStream::close
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GOutputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , argCType = Just "GCancellable*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "optional cancellable object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_close" g_output_stream_close ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        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.
    --
    -- 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 'P.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 there some streams
    -- can use a faster close that doesn\'t block to e.g. check errors. On
    -- cancellation (as with any error) there is no guarantee that all written
    -- data will reach the target.
    outputStreamClose ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@stream@/: A t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> Maybe (b)
        -- ^ /@cancellable@/: optional cancellable object
        -> m ()
        -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamClose :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsCancellable b) =>
    a -> Maybe b -> m ()
    outputStreamClose a
    stream Maybe b
    cancellable = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        maybeCancellable <- case cancellable of
            Maybe b
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    FP.nullPtr
            Just b
    jCancellable -> do
                jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_output_stream_close stream' maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            return ()
         ) (do
            return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamCloseMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod OutputStreamCloseMethodInfo a signature where
        overloadedMethod = outputStreamClose

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

    #endif

    -- method OutputStream::close_async
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GOutputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "io_priority"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the io priority of the request."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , argCType = Just "GCancellable*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "optional cancellable object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "callback"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
    --           , argCType = Just "GAsyncReadyCallback"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a #GAsyncReadyCallback\n  to call when the request is satisfied"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeAsync
    --           , argClosure = 4
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "user_data"
    --           , argType = TBasicType TPtr
    --           , argCType = Just "gpointer"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_output_stream_close_async" g_output_stream_close_async ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        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.OutputStream.outputStreamCloseFinish' to get
    -- the result of the operation.
    --
    -- For behaviour details see 'GI.Gio.Objects.OutputStream.outputStreamClose'.
    --
    -- 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.
    outputStreamCloseAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@stream@/: A t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> Int32
        -- ^ /@ioPriority@/: the io priority of the request.
        -> Maybe (b)
        -- ^ /@cancellable@/: optional cancellable object
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
        --   to call when the request is satisfied
        -> m ()
    outputStreamCloseAsync :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsCancellable b) =>
    a -> Int32 -> Maybe b -> Maybe AsyncReadyCallback -> m ()
    outputStreamCloseAsync a
    stream Int32
    ioPriority Maybe b
    cancellable Maybe AsyncReadyCallback
    callback = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        maybeCancellable <- case cancellable of
            Maybe b
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    FP.nullPtr
            Just b
    jCancellable -> do
                jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Maybe AsyncReadyCallback
    Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return FunPtr C_AsyncReadyCallback
    forall a. FunPtr a
    FP.nullFunPtr
            Just AsyncReadyCallback
    jCallback -> do
                ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
    forall a. Storable a => IO (Ptr a)
    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 = Ptr a
    forall a. Ptr a
    nullPtr
        g_output_stream_close_async stream' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamCloseAsyncMethodInfo
    instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod OutputStreamCloseAsyncMethodInfo a signature where
        overloadedMethod = outputStreamCloseAsync

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

    #endif

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

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

    -- | Closes an output stream.
    outputStreamCloseFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> b
        -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
        -> m ()
        -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamCloseFinish :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsAsyncResult b) =>
    a -> b -> m ()
    outputStreamCloseFinish a
    stream b
    result_ = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            _ <- propagateGError $ g_output_stream_close_finish stream' result_'
            touchManagedPtr stream
            touchManagedPtr result_
            return ()
         ) (do
            return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamCloseFinishMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod OutputStreamCloseFinishMethodInfo a signature where
        overloadedMethod = outputStreamCloseFinish

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

    #endif

    -- method OutputStream::flush
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GOutputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , argCType = Just "GCancellable*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "optional cancellable object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

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

    -- | Forces a write of all user-space buffered data for the given
    -- /@stream@/. Will block during the operation. Closing the stream will
    -- implicitly cause a flush.
    --
    -- This function is optional for inherited classes.
    --
    -- If /@cancellable@/ is not 'P.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.
    outputStreamFlush ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> Maybe (b)
        -- ^ /@cancellable@/: optional cancellable object
        -> m ()
        -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamFlush :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsCancellable b) =>
    a -> Maybe b -> m ()
    outputStreamFlush a
    stream Maybe b
    cancellable = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        maybeCancellable <- case cancellable of
            Maybe b
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    FP.nullPtr
            Just b
    jCancellable -> do
                jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_output_stream_flush stream' maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            return ()
         ) (do
            return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamFlushMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod OutputStreamFlushMethodInfo a signature where
        overloadedMethod = outputStreamFlush

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

    #endif

    -- method OutputStream::flush_async
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GOutputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "io_priority"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the io priority of the request."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , argCType = Just "GCancellable*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "optional #GCancellable object, %NULL to ignore."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "callback"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
    --           , argCType = Just "GAsyncReadyCallback"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a #GAsyncReadyCallback\n  to call when the request is satisfied"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeAsync
    --           , argClosure = 4
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "user_data"
    --           , argType = TBasicType TPtr
    --           , argCType = Just "gpointer"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_output_stream_flush_async" g_output_stream_flush_async ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        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 ()

    -- | Forces an asynchronous write of all user-space buffered data for
    -- the given /@stream@/.
    -- For behaviour details see 'GI.Gio.Objects.OutputStream.outputStreamFlush'.
    --
    -- When the operation is finished /@callback@/ will be
    -- called. You can then call 'GI.Gio.Objects.OutputStream.outputStreamFlushFinish' to get the
    -- result of the operation.
    outputStreamFlushAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> Int32
        -- ^ /@ioPriority@/: the io priority of the request.
        -> Maybe (b)
        -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
        --   to call when the request is satisfied
        -> m ()
    outputStreamFlushAsync :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsCancellable b) =>
    a -> Int32 -> Maybe b -> Maybe AsyncReadyCallback -> m ()
    outputStreamFlushAsync a
    stream Int32
    ioPriority Maybe b
    cancellable Maybe AsyncReadyCallback
    callback = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        maybeCancellable <- case cancellable of
            Maybe b
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    FP.nullPtr
            Just b
    jCancellable -> do
                jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Maybe AsyncReadyCallback
    Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return FunPtr C_AsyncReadyCallback
    forall a. FunPtr a
    FP.nullFunPtr
            Just AsyncReadyCallback
    jCallback -> do
                ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
    forall a. Storable a => IO (Ptr a)
    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 = Ptr a
    forall a. Ptr a
    nullPtr
        g_output_stream_flush_async stream' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamFlushAsyncMethodInfo
    instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod OutputStreamFlushAsyncMethodInfo a signature where
        overloadedMethod = outputStreamFlushAsync

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

    #endif

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

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

    -- | Finishes flushing an output stream.
    outputStreamFlushFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> b
        -- ^ /@result@/: a GAsyncResult.
        -> m ()
        -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamFlushFinish :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsAsyncResult b) =>
    a -> b -> m ()
    outputStreamFlushFinish a
    stream b
    result_ = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            _ <- propagateGError $ g_output_stream_flush_finish stream' result_'
            touchManagedPtr stream
            touchManagedPtr result_
            return ()
         ) (do
            return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamFlushFinishMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod OutputStreamFlushFinishMethodInfo a signature where
        overloadedMethod = outputStreamFlushFinish

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

    #endif

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

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

    -- | Checks if an output stream has pending actions.
    outputStreamHasPending ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> m Bool
        -- ^ __Returns:__ 'P.True' if /@stream@/ has pending actions.
    outputStreamHasPending :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsOutputStream a) =>
    a -> m Bool
    outputStreamHasPending a
    stream = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        result <- g_output_stream_has_pending stream'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr stream
        return result'

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamHasPendingMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsOutputStream a) => O.OverloadedMethod OutputStreamHasPendingMethodInfo a signature where
        overloadedMethod = outputStreamHasPending

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

    #endif

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

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

    -- | Checks if an output stream has already been closed.
    outputStreamIsClosed ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> m Bool
        -- ^ __Returns:__ 'P.True' if /@stream@/ is closed. 'P.False' otherwise.
    outputStreamIsClosed :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsOutputStream a) =>
    a -> m Bool
    outputStreamIsClosed a
    stream = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        result <- g_output_stream_is_closed stream'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr stream
        return result'

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamIsClosedMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsOutputStream a) => O.OverloadedMethod OutputStreamIsClosedMethodInfo a signature where
        overloadedMethod = outputStreamIsClosed

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

    #endif

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

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

    -- | Checks if an output stream is being closed. This can be
    -- used inside e.g. a flush implementation to see if the
    -- flush (or other i\/o operation) is called from within
    -- the closing operation.
    --
    -- /Since: 2.24/
    outputStreamIsClosing ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> m Bool
        -- ^ __Returns:__ 'P.True' if /@stream@/ is being closed. 'P.False' otherwise.
    outputStreamIsClosing :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsOutputStream a) =>
    a -> m Bool
    outputStreamIsClosing a
    stream = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        result <- g_output_stream_is_closing stream'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr stream
        return result'

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamIsClosingMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsOutputStream a) => O.OverloadedMethod OutputStreamIsClosingMethodInfo a signature where
        overloadedMethod = outputStreamIsClosing

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

    #endif

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

    foreign import ccall "g_output_stream_set_pending" g_output_stream_set_pending ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        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 'P.False' and set
    -- /@error@/.
    outputStreamSetPending ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> m ()
        -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamSetPending :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsOutputStream a) =>
    a -> m ()
    outputStreamSetPending a
    stream = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        onException (do
            _ <- propagateGError $ g_output_stream_set_pending stream'
            touchManagedPtr stream
            return ()
         ) (do
            return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamSetPendingMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsOutputStream a) => O.OverloadedMethod OutputStreamSetPendingMethodInfo a signature where
        overloadedMethod = outputStreamSetPending

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

    #endif

    -- method OutputStream::splice
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GOutputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "source"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "InputStream" }
    --           , argCType = Just "GInputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GInputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gio" , name = "OutputStreamSpliceFlags" }
    --           , argCType = Just "GOutputStreamSpliceFlags"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a set of #GOutputStreamSpliceFlags."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , argCType = Just "GCancellable*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "optional #GCancellable object, %NULL to ignore."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TSSize)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_splice" g_output_stream_splice ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.InputStream.InputStream ->      -- source : TInterface (Name {namespace = "Gio", name = "InputStream"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "OutputStreamSpliceFlags"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO DI.Int64

    -- | Splices an input stream into an output stream.
    outputStreamSplice ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> b
        -- ^ /@source@/: a t'GI.Gio.Objects.InputStream.InputStream'.
        -> [Gio.Flags.OutputStreamSpliceFlags]
        -- ^ /@flags@/: a set of t'GI.Gio.Flags.OutputStreamSpliceFlags'.
        -> Maybe (c)
        -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
        -> m DI.Int64
        -- ^ __Returns:__ a @/gssize/@ containing the size of the data spliced, or
        --     -1 if an error occurred. Note that if the number of bytes
        --     spliced is greater than @/G_MAXSSIZE/@, then that will be
        --     returned, and there is no way to determine the actual number
        --     of bytes spliced. /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamSplice :: forall (m :: * -> *) a b c.
    (HasCallStack, MonadIO m, IsOutputStream a, IsInputStream b,
     IsCancellable c) =>
    a -> b -> [OutputStreamSpliceFlags] -> Maybe c -> m Int64
    outputStreamSplice a
    stream b
    source [OutputStreamSpliceFlags]
    flags Maybe c
    cancellable = IO Int64 -> m Int64
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        source' <- unsafeManagedPtrCastPtr source
        let flags' = [OutputStreamSpliceFlags] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [OutputStreamSpliceFlags]
    flags
        maybeCancellable <- case cancellable of
            Maybe c
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    FP.nullPtr
            Just c
    jCancellable -> do
                jCancellable' <- c -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr c
    jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_output_stream_splice stream' source' flags' maybeCancellable
            touchManagedPtr stream
            touchManagedPtr source
            whenJust cancellable touchManagedPtr
            return result
         ) (do
            return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamSpliceMethodInfo
    instance (signature ~ (b -> [Gio.Flags.OutputStreamSpliceFlags] -> Maybe (c) -> m DI.Int64), MonadIO m, IsOutputStream a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod OutputStreamSpliceMethodInfo a signature where
        overloadedMethod = outputStreamSplice

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

    #endif

    -- method OutputStream::splice_async
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GOutputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "source"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "InputStream" }
    --           , argCType = Just "GInputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GInputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gio" , name = "OutputStreamSpliceFlags" }
    --           , argCType = Just "GOutputStreamSpliceFlags"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a set of #GOutputStreamSpliceFlags."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "io_priority"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the io priority of the request."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , argCType = Just "GCancellable*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "optional #GCancellable object, %NULL to ignore."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "callback"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
    --           , argCType = Just "GAsyncReadyCallback"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a #GAsyncReadyCallback\n  to call when the request is satisfied"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeAsync
    --           , argClosure = 6
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "user_data"
    --           , argType = TBasicType TPtr
    --           , argCType = Just "gpointer"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_output_stream_splice_async" g_output_stream_splice_async ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.InputStream.InputStream ->      -- source : TInterface (Name {namespace = "Gio", name = "InputStream"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "OutputStreamSpliceFlags"})
        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 ()

    -- | Splices a stream asynchronously.
    -- When the operation is finished /@callback@/ will be called.
    -- You can then call 'GI.Gio.Objects.OutputStream.outputStreamSpliceFinish' to get the
    -- result of the operation.
    --
    -- For the synchronous, blocking version of this function, see
    -- 'GI.Gio.Objects.OutputStream.outputStreamSplice'.
    outputStreamSpliceAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> b
        -- ^ /@source@/: a t'GI.Gio.Objects.InputStream.InputStream'.
        -> [Gio.Flags.OutputStreamSpliceFlags]
        -- ^ /@flags@/: a set of t'GI.Gio.Flags.OutputStreamSpliceFlags'.
        -> Int32
        -- ^ /@ioPriority@/: the io priority of the request.
        -> Maybe (c)
        -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
        --   to call when the request is satisfied
        -> m ()
    outputStreamSpliceAsync :: forall (m :: * -> *) a b c.
    (HasCallStack, MonadIO m, IsOutputStream a, IsInputStream b,
     IsCancellable c) =>
    a
    -> b
    -> [OutputStreamSpliceFlags]
    -> Int32
    -> Maybe c
    -> Maybe AsyncReadyCallback
    -> m ()
    outputStreamSpliceAsync a
    stream b
    source [OutputStreamSpliceFlags]
    flags Int32
    ioPriority Maybe c
    cancellable Maybe AsyncReadyCallback
    callback = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        source' <- unsafeManagedPtrCastPtr source
        let flags' = [OutputStreamSpliceFlags] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [OutputStreamSpliceFlags]
    flags
        maybeCancellable <- case cancellable of
            Maybe c
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    FP.nullPtr
            Just c
    jCancellable -> do
                jCancellable' <- c -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr c
    jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Maybe AsyncReadyCallback
    Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return FunPtr C_AsyncReadyCallback
    forall a. FunPtr a
    FP.nullFunPtr
            Just AsyncReadyCallback
    jCallback -> do
                ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
    forall a. Storable a => IO (Ptr a)
    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 = Ptr a
    forall a. Ptr a
    nullPtr
        g_output_stream_splice_async stream' source' flags' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        touchManagedPtr source
        whenJust cancellable touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamSpliceAsyncMethodInfo
    instance (signature ~ (b -> [Gio.Flags.OutputStreamSpliceFlags] -> Int32 -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsOutputStream a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod OutputStreamSpliceAsyncMethodInfo a signature where
        overloadedMethod = outputStreamSpliceAsync

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

    #endif

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

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

    -- | Finishes an asynchronous stream splice operation.
    outputStreamSpliceFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> b
        -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
        -> m DI.Int64
        -- ^ __Returns:__ a @/gssize/@ of the number of bytes spliced. Note that if the
        --     number of bytes spliced is greater than @/G_MAXSSIZE/@, then that
        --     will be returned, and there is no way to determine the actual
        --     number of bytes spliced. /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamSpliceFinish :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsAsyncResult b) =>
    a -> b -> m Int64
    outputStreamSpliceFinish a
    stream b
    result_ = IO Int64 -> m Int64
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            result <- propagateGError $ g_output_stream_splice_finish stream' result_'
            touchManagedPtr stream
            touchManagedPtr result_
            return result
         ) (do
            return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamSpliceFinishMethodInfo
    instance (signature ~ (b -> m DI.Int64), MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod OutputStreamSpliceFinishMethodInfo a signature where
        overloadedMethod = outputStreamSpliceFinish

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

    #endif

    -- method OutputStream::write
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GOutputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "buffer"
    --           , argType = TCArray False (-1) 2 (TBasicType TUInt8)
    --           , argCType = Just "void*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the buffer containing the data to write."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "count"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the number of bytes to write"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , argCType = Just "GCancellable*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "optional cancellable object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "count"
    --              , argType = TBasicType TSize
    --              , argCType = Just "gsize"
    --              , direction = DirectionIn
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText = Just "the number of bytes to write"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , argCallbackUserData = False
    --              , transfer = TransferNothing
    --              }
    --          ]
    -- returnType: Just (TBasicType TSSize)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_write" g_output_stream_write ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)
        FCT.CSize ->                            -- count : TBasicType TSize
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO DI.Int64

    -- | Tries to write /@count@/ bytes from /@buffer@/ into the stream. Will block
    -- during the operation.
    --
    -- If count is 0, returns 0 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 written to the stream is returned.
    -- It is not an error if this is not the same as the requested size, as it
    -- can happen e.g. on a partial I\/O error, or if there is not enough
    -- storage in the stream. All writes block until at least one byte
    -- is written or an error occurs; 0 is never returned (unless
    -- /@count@/ is 0).
    --
    -- If /@cancellable@/ is not 'P.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.
    outputStreamWrite ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> ByteString
        -- ^ /@buffer@/: the buffer containing the data to write.
        -> Maybe (b)
        -- ^ /@cancellable@/: optional cancellable object
        -> m DI.Int64
        -- ^ __Returns:__ Number of bytes written, or -1 on error /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamWrite :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsCancellable b) =>
    a -> ByteString -> Maybe b -> m Int64
    outputStreamWrite a
    stream ByteString
    buffer Maybe b
    cancellable = IO Int64 -> m Int64
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
    forall a b. (a -> b) -> a -> b
    $ do
        let count :: CSize
    count = Int -> CSize
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CSize) -> Int -> CSize
    forall a b. (a -> b) -> a -> b
    $ ByteString -> Int
    B.length ByteString
    buffer
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        buffer' <- packByteString buffer
        maybeCancellable <- case cancellable of
            Maybe b
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    FP.nullPtr
            Just b
    jCancellable -> do
                jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_output_stream_write stream' buffer' count maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            freeMem buffer'
            return result
         ) (do
            freeMem buffer'
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamWriteMethodInfo
    instance (signature ~ (ByteString -> Maybe (b) -> m DI.Int64), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod OutputStreamWriteMethodInfo a signature where
        overloadedMethod = outputStreamWrite

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

    #endif

    -- method OutputStream::write_all
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GOutputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "buffer"
    --           , argType = TCArray False (-1) 2 (TBasicType TUInt8)
    --           , argCType = Just "void*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the buffer containing the data to write."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "count"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the number of bytes to write"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "bytes_written"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "location to store the number of bytes that was\n    written to the stream"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , argCType = Just "GCancellable*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "optional #GCancellable object, %NULL to ignore."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "count"
    --              , argType = TBasicType TSize
    --              , argCType = Just "gsize"
    --              , direction = DirectionIn
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText = Just "the number of bytes to write"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , argCallbackUserData = False
    --              , transfer = TransferNothing
    --              }
    --          ]
    -- returnType: Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_write_all" g_output_stream_write_all ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)
        FCT.CSize ->                            -- count : TBasicType TSize
        Ptr FCT.CSize ->                        -- bytes_written : TBasicType TSize
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    -- | Tries to write /@count@/ bytes from /@buffer@/ into the stream. Will block
    -- during the operation.
    --
    -- This function is similar to 'GI.Gio.Objects.OutputStream.outputStreamWrite', except it tries to
    -- write as many bytes as requested, only stopping on an error.
    --
    -- On a successful write of /@count@/ bytes, 'P.True' is returned, and /@bytesWritten@/
    -- is set to /@count@/.
    --
    -- If there is an error during the operation 'P.False' is returned and /@error@/
    -- is set to indicate the error status.
    --
    -- As a special exception to the normal conventions for functions that
    -- use t'GError', if this function returns 'P.False' (and sets /@error@/) then
    -- /@bytesWritten@/ will be set to the number of bytes that were
    -- successfully written 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.OutputStream.outputStreamWrite'.
    outputStreamWriteAll ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> ByteString
        -- ^ /@buffer@/: the buffer containing the data to write.
        -> Maybe (b)
        -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
        -> m (FCT.CSize)
        -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamWriteAll :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsCancellable b) =>
    a -> ByteString -> Maybe b -> m CSize
    outputStreamWriteAll a
    stream ByteString
    buffer Maybe b
    cancellable = IO CSize -> m CSize
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
    forall a b. (a -> b) -> a -> b
    $ do
        let count :: CSize
    count = Int -> CSize
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CSize) -> Int -> CSize
    forall a b. (a -> b) -> a -> b
    $ ByteString -> Int
    B.length ByteString
    buffer
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        buffer' <- packByteString buffer
        bytesWritten <- allocMem :: IO (Ptr FCT.CSize)
        maybeCancellable <- case cancellable of
            Maybe b
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    FP.nullPtr
            Just b
    jCancellable -> do
                jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_output_stream_write_all stream' buffer' count bytesWritten maybeCancellable
            bytesWritten' <- peek bytesWritten
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            freeMem buffer'
            freeMem bytesWritten
            return bytesWritten'
         ) (do
            freeMem buffer'
            freeMem bytesWritten
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamWriteAllMethodInfo
    instance (signature ~ (ByteString -> Maybe (b) -> m (FCT.CSize)), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod OutputStreamWriteAllMethodInfo a signature where
        overloadedMethod = outputStreamWriteAll

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

    #endif

    -- method OutputStream::write_all_async
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GOutputStream" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "buffer"
    --           , argType = TCArray False (-1) 2 (TBasicType TUInt8)
    --           , argCType = Just "void*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the buffer containing the data to write"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "count"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the number of bytes to write"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "io_priority"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the io priority of the request"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , argCType = Just "GCancellable*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "optional #GCancellable object, %NULL to ignore"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "callback"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
    --           , argCType = Just "GAsyncReadyCallback"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a #GAsyncReadyCallback\n    to call when the request is satisfied"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeAsync
    --           , argClosure = 6
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "user_data"
    --           , argType = TBasicType TPtr
    --           , argCType = Just "gpointer"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "count"
    --              , argType = TBasicType TSize
    --              , argCType = Just "gsize"
    --              , direction = DirectionIn
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText = Just "the number of bytes to write"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , argCallbackUserData = False
    --              , transfer = TransferNothing
    --              }
    --          ]
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_output_stream_write_all_async" g_output_stream_write_all_async ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)
        FCT.CSize ->                            -- count : TBasicType TSize
        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 write of /@count@/ bytes from /@buffer@/ into
    -- the stream. When the operation is finished /@callback@/ will be called.
    -- You can then call 'GI.Gio.Objects.OutputStream.outputStreamWriteAllFinish' to get the result of the
    -- operation.
    --
    -- This is the asynchronous version of 'GI.Gio.Objects.OutputStream.outputStreamWriteAll'.
    --
    -- Call 'GI.Gio.Objects.OutputStream.outputStreamWriteAllFinish' 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'.
    --
    -- Note that no copy of /@buffer@/ will be made, so it must stay valid
    -- until /@callback@/ is called.
    --
    -- /Since: 2.44/
    outputStreamWriteAllAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@stream@/: A t'GI.Gio.Objects.OutputStream.OutputStream'
        -> ByteString
        -- ^ /@buffer@/: the buffer containing the data to write
        -> Int32
        -- ^ /@ioPriority@/: the io priority of the request
        -> Maybe (b)
        -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
        --     to call when the request is satisfied
        -> m ()
    outputStreamWriteAllAsync :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsCancellable b) =>
    a
    -> ByteString
    -> Int32
    -> Maybe b
    -> Maybe AsyncReadyCallback
    -> m ()
    outputStreamWriteAllAsync a
    stream ByteString
    buffer Int32
    ioPriority Maybe b
    cancellable Maybe AsyncReadyCallback
    callback = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        let count :: CSize
    count = Int -> CSize
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CSize) -> Int -> CSize
    forall a b. (a -> b) -> a -> b
    $ ByteString -> Int
    B.length ByteString
    buffer
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        buffer' <- packByteString buffer
        maybeCancellable <- case cancellable of
            Maybe b
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    FP.nullPtr
            Just b
    jCancellable -> do
                jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Maybe AsyncReadyCallback
    Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return FunPtr C_AsyncReadyCallback
    forall a. FunPtr a
    FP.nullFunPtr
            Just AsyncReadyCallback
    jCallback -> do
                ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
    forall a. Storable a => IO (Ptr a)
    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 = Ptr a
    forall a. Ptr a
    nullPtr
        g_output_stream_write_all_async stream' buffer' count ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        freeMem buffer'
        return ()

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamWriteAllAsyncMethodInfo
    instance (signature ~ (ByteString -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod OutputStreamWriteAllAsyncMethodInfo a signature where
        overloadedMethod = outputStreamWriteAllAsync

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

    #endif

    -- method OutputStream::write_all_finish
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GOutputStream" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "result"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
    --           , argCType = Just "GAsyncResult*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GAsyncResult" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "bytes_written"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "location to store the number of bytes that was written to the stream"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_write_all_finish" g_output_stream_write_all_finish ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr FCT.CSize ->                        -- bytes_written : TBasicType TSize
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    -- | Finishes an asynchronous stream write operation started with
    -- 'GI.Gio.Objects.OutputStream.outputStreamWriteAllAsync'.
    --
    -- As a special exception to the normal conventions for functions that
    -- use t'GError', if this function returns 'P.False' (and sets /@error@/) then
    -- /@bytesWritten@/ will be set to the number of bytes that were
    -- successfully written 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.OutputStream.outputStreamWriteAsync'.
    --
    -- /Since: 2.44/
    outputStreamWriteAllFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'
        -> b
        -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'
        -> m (FCT.CSize)
        -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamWriteAllFinish :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsAsyncResult b) =>
    a -> b -> m CSize
    outputStreamWriteAllFinish a
    stream b
    result_ = IO CSize -> m CSize
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        result_' <- unsafeManagedPtrCastPtr result_
        bytesWritten <- allocMem :: IO (Ptr FCT.CSize)
        onException (do
            _ <- propagateGError $ g_output_stream_write_all_finish stream' result_' bytesWritten
            bytesWritten' <- peek bytesWritten
            touchManagedPtr stream
            touchManagedPtr result_
            freeMem bytesWritten
            return bytesWritten'
         ) (do
            freeMem bytesWritten
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamWriteAllFinishMethodInfo
    instance (signature ~ (b -> m (FCT.CSize)), MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod OutputStreamWriteAllFinishMethodInfo a signature where
        overloadedMethod = outputStreamWriteAllFinish

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

    #endif

    -- method OutputStream::write_async
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GOutputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "buffer"
    --           , argType = TCArray False (-1) 2 (TBasicType TUInt8)
    --           , argCType = Just "void*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the buffer containing the data to write."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "count"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the number of bytes to write"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "io_priority"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the io priority of the request."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , argCType = Just "GCancellable*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "optional #GCancellable object, %NULL to ignore."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "callback"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
    --           , argCType = Just "GAsyncReadyCallback"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a #GAsyncReadyCallback\n    to call when the request is satisfied"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeAsync
    --           , argClosure = 6
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "user_data"
    --           , argType = TBasicType TPtr
    --           , argCType = Just "gpointer"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "count"
    --              , argType = TBasicType TSize
    --              , argCType = Just "gsize"
    --              , direction = DirectionIn
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText = Just "the number of bytes to write"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , argCallbackUserData = False
    --              , transfer = TransferNothing
    --              }
    --          ]
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_output_stream_write_async" g_output_stream_write_async ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)
        FCT.CSize ->                            -- count : TBasicType TSize
        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 write of /@count@/ bytes from /@buffer@/ into
    -- the stream. When the operation is finished /@callback@/ will be called.
    -- You can then call 'GI.Gio.Objects.OutputStream.outputStreamWriteFinish' 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 written 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. on a partial I\/O error,
    -- but generally we try to write as many bytes as requested.
    --
    -- You are guaranteed that this method will never fail with
    -- 'GI.Gio.Enums.IOErrorEnumWouldBlock' - if /@stream@/ can\'t accept more data, the
    -- method will just wait until this changes.
    --
    -- 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.
    --
    -- For the synchronous, blocking version of this function, see
    -- 'GI.Gio.Objects.OutputStream.outputStreamWrite'.
    --
    -- Note that no copy of /@buffer@/ will be made, so it must stay valid
    -- until /@callback@/ is called. See 'GI.Gio.Objects.OutputStream.outputStreamWriteBytesAsync'
    -- for a t'GI.GLib.Structs.Bytes.Bytes' version that will automatically hold a reference to
    -- the contents (without copying) for the duration of the call.
    outputStreamWriteAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@stream@/: A t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> Maybe (ByteString)
        -- ^ /@buffer@/: the buffer containing the data to write.
        -> Int32
        -- ^ /@ioPriority@/: the io priority of the request.
        -> Maybe (b)
        -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
        --     to call when the request is satisfied
        -> m ()
    outputStreamWriteAsync :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsCancellable b) =>
    a
    -> Maybe ByteString
    -> Int32
    -> Maybe b
    -> Maybe AsyncReadyCallback
    -> m ()
    outputStreamWriteAsync a
    stream Maybe ByteString
    buffer Int32
    ioPriority Maybe b
    cancellable Maybe AsyncReadyCallback
    callback = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        let count :: CSize
    count = case Maybe ByteString
    buffer of
                Maybe ByteString
    Nothing -> CSize
    0
                Just ByteString
    jBuffer -> Int -> CSize
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CSize) -> Int -> CSize
    forall a b. (a -> b) -> a -> b
    $ ByteString -> Int
    B.length ByteString
    jBuffer
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        maybeBuffer <- case buffer of
            Maybe ByteString
    Nothing -> Ptr Word8 -> IO (Ptr Word8)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Word8
    forall a. Ptr a
    FP.nullPtr
            Just ByteString
    jBuffer -> do
                jBuffer' <- ByteString -> IO (Ptr Word8)
    packByteString ByteString
    jBuffer
                return jBuffer'
        maybeCancellable <- case cancellable of
            Maybe b
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    FP.nullPtr
            Just b
    jCancellable -> do
                jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Maybe AsyncReadyCallback
    Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return FunPtr C_AsyncReadyCallback
    forall a. FunPtr a
    FP.nullFunPtr
            Just AsyncReadyCallback
    jCallback -> do
                ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
    forall a. Storable a => IO (Ptr a)
    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 = Ptr a
    forall a. Ptr a
    nullPtr
        g_output_stream_write_async stream' maybeBuffer count ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        freeMem maybeBuffer
        return ()

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamWriteAsyncMethodInfo
    instance (signature ~ (Maybe (ByteString) -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod OutputStreamWriteAsyncMethodInfo a signature where
        overloadedMethod = outputStreamWriteAsync

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

    #endif

    -- method OutputStream::write_bytes
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GOutputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "bytes"
    --           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
    --           , argCType = Just "GBytes*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #GBytes to write"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , argCType = Just "GCancellable*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "optional cancellable object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TSSize)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_write_bytes" g_output_stream_write_bytes ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr GLib.Bytes.Bytes ->                 -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO DI.Int64

    -- | A wrapper function for 'GI.Gio.Objects.OutputStream.outputStreamWrite' which takes a
    -- t'GI.GLib.Structs.Bytes.Bytes' as input.  This can be more convenient for use by language
    -- bindings or in other cases where the refcounted nature of t'GI.GLib.Structs.Bytes.Bytes'
    -- is helpful over a bare pointer interface.
    --
    -- However, note that this function may still perform partial writes,
    -- just like 'GI.Gio.Objects.OutputStream.outputStreamWrite'.  If that occurs, to continue
    -- writing, you will need to create a new t'GI.GLib.Structs.Bytes.Bytes' containing just the
    -- remaining bytes, using 'GI.GLib.Structs.Bytes.bytesNewFromBytes'. Passing the same
    -- t'GI.GLib.Structs.Bytes.Bytes' instance multiple times potentially can result in duplicated
    -- data in the output stream.
    outputStreamWriteBytes ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> GLib.Bytes.Bytes
        -- ^ /@bytes@/: the t'GI.GLib.Structs.Bytes.Bytes' to write
        -> Maybe (b)
        -- ^ /@cancellable@/: optional cancellable object
        -> m DI.Int64
        -- ^ __Returns:__ Number of bytes written, or -1 on error /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamWriteBytes :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsCancellable b) =>
    a -> Bytes -> Maybe b -> m Int64
    outputStreamWriteBytes a
    stream Bytes
    bytes Maybe b
    cancellable = IO Int64 -> m Int64
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        bytes' <- unsafeManagedPtrGetPtr bytes
        maybeCancellable <- case cancellable of
            Maybe b
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    FP.nullPtr
            Just b
    jCancellable -> do
                jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_output_stream_write_bytes stream' bytes' maybeCancellable
            touchManagedPtr stream
            touchManagedPtr bytes
            whenJust cancellable touchManagedPtr
            return result
         ) (do
            return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamWriteBytesMethodInfo
    instance (signature ~ (GLib.Bytes.Bytes -> Maybe (b) -> m DI.Int64), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod OutputStreamWriteBytesMethodInfo a signature where
        overloadedMethod = outputStreamWriteBytes

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

    #endif

    -- method OutputStream::write_bytes_async
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GOutputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "bytes"
    --           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
    --           , argCType = Just "GBytes*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The bytes to write" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "io_priority"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the io priority of the request."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , argCType = Just "GCancellable*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "optional #GCancellable object, %NULL to ignore."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "callback"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
    --           , argCType = Just "GAsyncReadyCallback"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a #GAsyncReadyCallback\n  to call when the request is satisfied"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeAsync
    --           , argClosure = 5
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "user_data"
    --           , argType = TBasicType TPtr
    --           , argCType = Just "gpointer"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_output_stream_write_bytes_async" g_output_stream_write_bytes_async ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr GLib.Bytes.Bytes ->                 -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
        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 ()

    -- | This function is similar to 'GI.Gio.Objects.OutputStream.outputStreamWriteAsync', but
    -- takes a t'GI.GLib.Structs.Bytes.Bytes' as input.  Due to the refcounted nature of t'GI.GLib.Structs.Bytes.Bytes',
    -- this allows the stream to avoid taking a copy of the data.
    --
    -- However, note that this function may still perform partial writes,
    -- just like 'GI.Gio.Objects.OutputStream.outputStreamWriteAsync'. If that occurs, to continue
    -- writing, you will need to create a new t'GI.GLib.Structs.Bytes.Bytes' containing just the
    -- remaining bytes, using 'GI.GLib.Structs.Bytes.bytesNewFromBytes'. Passing the same
    -- t'GI.GLib.Structs.Bytes.Bytes' instance multiple times potentially can result in duplicated
    -- data in the output stream.
    --
    -- For the synchronous, blocking version of this function, see
    -- 'GI.Gio.Objects.OutputStream.outputStreamWriteBytes'.
    outputStreamWriteBytesAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@stream@/: A t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> GLib.Bytes.Bytes
        -- ^ /@bytes@/: The bytes to write
        -> Int32
        -- ^ /@ioPriority@/: the io priority of the request.
        -> Maybe (b)
        -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
        --   to call when the request is satisfied
        -> m ()
    outputStreamWriteBytesAsync :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsCancellable b) =>
    a -> Bytes -> Int32 -> Maybe b -> Maybe AsyncReadyCallback -> m ()
    outputStreamWriteBytesAsync a
    stream Bytes
    bytes Int32
    ioPriority Maybe b
    cancellable Maybe AsyncReadyCallback
    callback = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        bytes' <- unsafeManagedPtrGetPtr bytes
        maybeCancellable <- case cancellable of
            Maybe b
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    FP.nullPtr
            Just b
    jCancellable -> do
                jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Maybe AsyncReadyCallback
    Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return FunPtr C_AsyncReadyCallback
    forall a. FunPtr a
    FP.nullFunPtr
            Just AsyncReadyCallback
    jCallback -> do
                ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
    forall a. Storable a => IO (Ptr a)
    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 = Ptr a
    forall a. Ptr a
    nullPtr
        g_output_stream_write_bytes_async stream' bytes' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        touchManagedPtr bytes
        whenJust cancellable touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamWriteBytesAsyncMethodInfo
    instance (signature ~ (GLib.Bytes.Bytes -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod OutputStreamWriteBytesAsyncMethodInfo a signature where
        overloadedMethod = outputStreamWriteBytesAsync

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

    #endif

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

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

    -- | Finishes a stream write-from-t'GI.GLib.Structs.Bytes.Bytes' operation.
    outputStreamWriteBytesFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> b
        -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
        -> m DI.Int64
        -- ^ __Returns:__ a @/gssize/@ containing the number of bytes written to the stream. /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamWriteBytesFinish :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsAsyncResult b) =>
    a -> b -> m Int64
    outputStreamWriteBytesFinish a
    stream b
    result_ = IO Int64 -> m Int64
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            result <- propagateGError $ g_output_stream_write_bytes_finish stream' result_'
            touchManagedPtr stream
            touchManagedPtr result_
            return result
         ) (do
            return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamWriteBytesFinishMethodInfo
    instance (signature ~ (b -> m DI.Int64), MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod OutputStreamWriteBytesFinishMethodInfo a signature where
        overloadedMethod = outputStreamWriteBytesFinish

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

    #endif

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

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

    -- | Finishes a stream write operation.
    outputStreamWriteFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> b
        -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
        -> m DI.Int64
        -- ^ __Returns:__ a @/gssize/@ containing the number of bytes written to the stream. /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamWriteFinish :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsAsyncResult b) =>
    a -> b -> m Int64
    outputStreamWriteFinish a
    stream b
    result_ = IO Int64 -> m Int64
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            result <- propagateGError $ g_output_stream_write_finish stream' result_'
            touchManagedPtr stream
            touchManagedPtr result_
            return result
         ) (do
            return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamWriteFinishMethodInfo
    instance (signature ~ (b -> m DI.Int64), MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod OutputStreamWriteFinishMethodInfo a signature where
        overloadedMethod = outputStreamWriteFinish

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

    #endif

    -- method OutputStream::writev
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GOutputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "vectors"
    --           , argType =
    --               TCArray
    --                 False
    --                 (-1)
    --                 2
    --                 (TInterface Name { namespace = "Gio" , name = "OutputVector" })
    --           , argCType = Just "const GOutputVector*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the buffer containing the #GOutputVectors to write."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "n_vectors"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the number of vectors to write"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "bytes_written"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "location to store the number of bytes that were\n    written to the stream"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , argCType = Just "GCancellable*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "optional cancellable object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "n_vectors"
    --              , argType = TBasicType TSize
    --              , argCType = Just "gsize"
    --              , direction = DirectionIn
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText = Just "the number of vectors to write"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , argCallbackUserData = False
    --              , transfer = TransferNothing
    --              }
    --          ]
    -- returnType: Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_writev" g_output_stream_writev ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.OutputVector.OutputVector ->    -- vectors : TCArray False (-1) 2 (TInterface (Name {namespace = "Gio", name = "OutputVector"}))
        FCT.CSize ->                            -- n_vectors : TBasicType TSize
        Ptr FCT.CSize ->                        -- bytes_written : TBasicType TSize
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    -- | Tries to write the bytes contained in the /@nVectors@/ /@vectors@/ into the
    -- stream. Will block during the operation.
    --
    -- If /@nVectors@/ is 0 or the sum of all bytes in /@vectors@/ is 0, returns 0 and
    -- does nothing.
    --
    -- On success, the number of bytes written to the stream is returned.
    -- It is not an error if this is not the same as the requested size, as it
    -- can happen e.g. on a partial I\/O error, or if there is not enough
    -- storage in the stream. All writes block until at least one byte
    -- is written or an error occurs; 0 is never returned (unless
    -- /@nVectors@/ is 0 or the sum of all bytes in /@vectors@/ is 0).
    --
    -- If /@cancellable@/ is not 'P.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.
    --
    -- Some implementations of 'GI.Gio.Objects.OutputStream.outputStreamWritev' may have limitations on the
    -- aggregate buffer size, and will return 'GI.Gio.Enums.IOErrorEnumInvalidArgument' if these
    -- are exceeded. For example, when writing to a local file on UNIX platforms,
    -- the aggregate buffer size must not exceed @/G_MAXSSIZE/@ bytes.
    --
    -- /Since: 2.60/
    outputStreamWritev ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> [Gio.OutputVector.OutputVector]
        -- ^ /@vectors@/: the buffer containing the @/GOutputVectors/@ to write.
        -> Maybe (b)
        -- ^ /@cancellable@/: optional cancellable object
        -> m (FCT.CSize)
        -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamWritev :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsCancellable b) =>
    a -> [OutputVector] -> Maybe b -> m CSize
    outputStreamWritev a
    stream [OutputVector]
    vectors Maybe b
    cancellable = IO CSize -> m CSize
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
    forall a b. (a -> b) -> a -> b
    $ do
        let nVectors :: CSize
    nVectors = Int -> CSize
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CSize) -> Int -> CSize
    forall a b. (a -> b) -> a -> b
    $ [OutputVector] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    P.length [OutputVector]
    vectors
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        vectors' <- mapM unsafeManagedPtrGetPtr vectors
        vectors'' <- packBlockArray 16 vectors'
        bytesWritten <- allocMem :: IO (Ptr FCT.CSize)
        maybeCancellable <- case cancellable of
            Maybe b
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    FP.nullPtr
            Just b
    jCancellable -> do
                jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_output_stream_writev stream' vectors'' nVectors bytesWritten maybeCancellable
            bytesWritten' <- peek bytesWritten
            touchManagedPtr stream
            mapM_ touchManagedPtr vectors
            whenJust cancellable touchManagedPtr
            freeMem vectors''
            freeMem bytesWritten
            return bytesWritten'
         ) (do
            freeMem vectors''
            freeMem bytesWritten
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamWritevMethodInfo
    instance (signature ~ ([Gio.OutputVector.OutputVector] -> Maybe (b) -> m (FCT.CSize)), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod OutputStreamWritevMethodInfo a signature where
        overloadedMethod = outputStreamWritev

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

    #endif

    -- method OutputStream::writev_all
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GOutputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "vectors"
    --           , argType =
    --               TCArray
    --                 False
    --                 (-1)
    --                 2
    --                 (TInterface Name { namespace = "Gio" , name = "OutputVector" })
    --           , argCType = Just "GOutputVector*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the buffer containing the #GOutputVectors to write."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "n_vectors"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the number of vectors to write"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "bytes_written"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "location to store the number of bytes that were\n    written to the stream"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , argCType = Just "GCancellable*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "optional #GCancellable object, %NULL to ignore."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "n_vectors"
    --              , argType = TBasicType TSize
    --              , argCType = Just "gsize"
    --              , direction = DirectionIn
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText = Just "the number of vectors to write"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , argCallbackUserData = False
    --              , transfer = TransferNothing
    --              }
    --          ]
    -- returnType: Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_writev_all" g_output_stream_writev_all ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.OutputVector.OutputVector ->    -- vectors : TCArray False (-1) 2 (TInterface (Name {namespace = "Gio", name = "OutputVector"}))
        FCT.CSize ->                            -- n_vectors : TBasicType TSize
        Ptr FCT.CSize ->                        -- bytes_written : TBasicType TSize
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    -- | Tries to write the bytes contained in the /@nVectors@/ /@vectors@/ into the
    -- stream. Will block during the operation.
    --
    -- This function is similar to 'GI.Gio.Objects.OutputStream.outputStreamWritev', except it tries to
    -- write as many bytes as requested, only stopping on an error.
    --
    -- On a successful write of all /@nVectors@/ vectors, 'P.True' is returned, and
    -- /@bytesWritten@/ is set to the sum of all the sizes of /@vectors@/.
    --
    -- If there is an error during the operation 'P.False' is returned and /@error@/
    -- is set to indicate the error status.
    --
    -- As a special exception to the normal conventions for functions that
    -- use t'GError', if this function returns 'P.False' (and sets /@error@/) then
    -- /@bytesWritten@/ will be set to the number of bytes that were
    -- successfully written 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.OutputStream.outputStreamWrite'.
    --
    -- The content of the individual elements of /@vectors@/ might be changed by this
    -- function.
    --
    -- /Since: 2.60/
    outputStreamWritevAll ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> [Gio.OutputVector.OutputVector]
        -- ^ /@vectors@/: the buffer containing the @/GOutputVectors/@ to write.
        -> Maybe (b)
        -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
        -> m (FCT.CSize)
        -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamWritevAll :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsCancellable b) =>
    a -> [OutputVector] -> Maybe b -> m CSize
    outputStreamWritevAll a
    stream [OutputVector]
    vectors Maybe b
    cancellable = IO CSize -> m CSize
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
    forall a b. (a -> b) -> a -> b
    $ do
        let nVectors :: CSize
    nVectors = Int -> CSize
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CSize) -> Int -> CSize
    forall a b. (a -> b) -> a -> b
    $ [OutputVector] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    P.length [OutputVector]
    vectors
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        vectors' <- mapM unsafeManagedPtrGetPtr vectors
        vectors'' <- packBlockArray 16 vectors'
        bytesWritten <- allocMem :: IO (Ptr FCT.CSize)
        maybeCancellable <- case cancellable of
            Maybe b
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    FP.nullPtr
            Just b
    jCancellable -> do
                jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_output_stream_writev_all stream' vectors'' nVectors bytesWritten maybeCancellable
            bytesWritten' <- peek bytesWritten
            touchManagedPtr stream
            mapM_ touchManagedPtr vectors
            whenJust cancellable touchManagedPtr
            freeMem vectors''
            freeMem bytesWritten
            return bytesWritten'
         ) (do
            freeMem vectors''
            freeMem bytesWritten
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamWritevAllMethodInfo
    instance (signature ~ ([Gio.OutputVector.OutputVector] -> Maybe (b) -> m (FCT.CSize)), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod OutputStreamWritevAllMethodInfo a signature where
        overloadedMethod = outputStreamWritevAll

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

    #endif

    -- method OutputStream::writev_all_async
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GOutputStream" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "vectors"
    --           , argType =
    --               TCArray
    --                 False
    --                 (-1)
    --                 2
    --                 (TInterface Name { namespace = "Gio" , name = "OutputVector" })
    --           , argCType = Just "GOutputVector*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the buffer containing the #GOutputVectors to write."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "n_vectors"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the number of vectors to write"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "io_priority"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the I/O priority of the request"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , argCType = Just "GCancellable*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "optional #GCancellable object, %NULL to ignore"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "callback"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
    --           , argCType = Just "GAsyncReadyCallback"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a #GAsyncReadyCallback\n    to call when the request is satisfied"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeAsync
    --           , argClosure = 6
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "user_data"
    --           , argType = TBasicType TPtr
    --           , argCType = Just "gpointer"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "n_vectors"
    --              , argType = TBasicType TSize
    --              , argCType = Just "gsize"
    --              , direction = DirectionIn
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText = Just "the number of vectors to write"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , argCallbackUserData = False
    --              , transfer = TransferNothing
    --              }
    --          ]
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_output_stream_writev_all_async" g_output_stream_writev_all_async ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.OutputVector.OutputVector ->    -- vectors : TCArray False (-1) 2 (TInterface (Name {namespace = "Gio", name = "OutputVector"}))
        FCT.CSize ->                            -- n_vectors : TBasicType TSize
        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 write of the bytes contained in the /@nVectors@/ /@vectors@/ into
    -- the stream. When the operation is finished /@callback@/ will be called.
    -- You can then call 'GI.Gio.Objects.OutputStream.outputStreamWritevAllFinish' to get the result of the
    -- operation.
    --
    -- This is the asynchronous version of 'GI.Gio.Objects.OutputStream.outputStreamWritevAll'.
    --
    -- Call 'GI.Gio.Objects.OutputStream.outputStreamWritevAllFinish' 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'.
    --
    -- Note that no copy of /@vectors@/ will be made, so it must stay valid
    -- until /@callback@/ is called. The content of the individual elements
    -- of /@vectors@/ might be changed by this function.
    --
    -- /Since: 2.60/
    outputStreamWritevAllAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@stream@/: A t'GI.Gio.Objects.OutputStream.OutputStream'
        -> [Gio.OutputVector.OutputVector]
        -- ^ /@vectors@/: the buffer containing the @/GOutputVectors/@ to write.
        -> Int32
        -- ^ /@ioPriority@/: the I\/O priority of the request
        -> Maybe (b)
        -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
        --     to call when the request is satisfied
        -> m ()
    outputStreamWritevAllAsync :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsCancellable b) =>
    a
    -> [OutputVector]
    -> Int32
    -> Maybe b
    -> Maybe AsyncReadyCallback
    -> m ()
    outputStreamWritevAllAsync a
    stream [OutputVector]
    vectors Int32
    ioPriority Maybe b
    cancellable Maybe AsyncReadyCallback
    callback = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        let nVectors :: CSize
    nVectors = Int -> CSize
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CSize) -> Int -> CSize
    forall a b. (a -> b) -> a -> b
    $ [OutputVector] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    P.length [OutputVector]
    vectors
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        vectors' <- mapM unsafeManagedPtrGetPtr vectors
        vectors'' <- packBlockArray 16 vectors'
        maybeCancellable <- case cancellable of
            Maybe b
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    FP.nullPtr
            Just b
    jCancellable -> do
                jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Maybe AsyncReadyCallback
    Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return FunPtr C_AsyncReadyCallback
    forall a. FunPtr a
    FP.nullFunPtr
            Just AsyncReadyCallback
    jCallback -> do
                ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
    forall a. Storable a => IO (Ptr a)
    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 = Ptr a
    forall a. Ptr a
    nullPtr
        g_output_stream_writev_all_async stream' vectors'' nVectors ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        mapM_ touchManagedPtr vectors
        whenJust cancellable touchManagedPtr
        freeMem vectors''
        return ()

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamWritevAllAsyncMethodInfo
    instance (signature ~ ([Gio.OutputVector.OutputVector] -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod OutputStreamWritevAllAsyncMethodInfo a signature where
        overloadedMethod = outputStreamWritevAllAsync

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

    #endif

    -- method OutputStream::writev_all_finish
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GOutputStream" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "result"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
    --           , argCType = Just "GAsyncResult*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GAsyncResult" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "bytes_written"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "location to store the number of bytes that were written to the stream"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_writev_all_finish" g_output_stream_writev_all_finish ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr FCT.CSize ->                        -- bytes_written : TBasicType TSize
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    -- | Finishes an asynchronous stream write operation started with
    -- 'GI.Gio.Objects.OutputStream.outputStreamWritevAllAsync'.
    --
    -- As a special exception to the normal conventions for functions that
    -- use t'GError', if this function returns 'P.False' (and sets /@error@/) then
    -- /@bytesWritten@/ will be set to the number of bytes that were
    -- successfully written 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.OutputStream.outputStreamWritevAsync'.
    --
    -- /Since: 2.60/
    outputStreamWritevAllFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'
        -> b
        -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'
        -> m (FCT.CSize)
        -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamWritevAllFinish :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsAsyncResult b) =>
    a -> b -> m CSize
    outputStreamWritevAllFinish a
    stream b
    result_ = IO CSize -> m CSize
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        result_' <- unsafeManagedPtrCastPtr result_
        bytesWritten <- allocMem :: IO (Ptr FCT.CSize)
        onException (do
            _ <- propagateGError $ g_output_stream_writev_all_finish stream' result_' bytesWritten
            bytesWritten' <- peek bytesWritten
            touchManagedPtr stream
            touchManagedPtr result_
            freeMem bytesWritten
            return bytesWritten'
         ) (do
            freeMem bytesWritten
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamWritevAllFinishMethodInfo
    instance (signature ~ (b -> m (FCT.CSize)), MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod OutputStreamWritevAllFinishMethodInfo a signature where
        overloadedMethod = outputStreamWritevAllFinish

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

    #endif

    -- method OutputStream::writev_async
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GOutputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "vectors"
    --           , argType =
    --               TCArray
    --                 False
    --                 (-1)
    --                 2
    --                 (TInterface Name { namespace = "Gio" , name = "OutputVector" })
    --           , argCType = Just "const GOutputVector*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the buffer containing the #GOutputVectors to write."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "n_vectors"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the number of vectors to write"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "io_priority"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the I/O priority of the request."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , argCType = Just "GCancellable*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "optional #GCancellable object, %NULL to ignore."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "callback"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
    --           , argCType = Just "GAsyncReadyCallback"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a #GAsyncReadyCallback\n    to call when the request is satisfied"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeAsync
    --           , argClosure = 6
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "user_data"
    --           , argType = TBasicType TPtr
    --           , argCType = Just "gpointer"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "n_vectors"
    --              , argType = TBasicType TSize
    --              , argCType = Just "gsize"
    --              , direction = DirectionIn
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText = Just "the number of vectors to write"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , argCallbackUserData = False
    --              , transfer = TransferNothing
    --              }
    --          ]
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_output_stream_writev_async" g_output_stream_writev_async ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.OutputVector.OutputVector ->    -- vectors : TCArray False (-1) 2 (TInterface (Name {namespace = "Gio", name = "OutputVector"}))
        FCT.CSize ->                            -- n_vectors : TBasicType TSize
        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 write of the bytes contained in /@nVectors@/ /@vectors@/ into
    -- the stream. When the operation is finished /@callback@/ will be called.
    -- You can then call 'GI.Gio.Objects.OutputStream.outputStreamWritevFinish' 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.
    --
    -- On success, the number of bytes written 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. on a partial I\/O error,
    -- but generally we try to write as many bytes as requested.
    --
    -- You are guaranteed that this method will never fail with
    -- 'GI.Gio.Enums.IOErrorEnumWouldBlock' — if /@stream@/ can\'t accept more data, the
    -- method will just wait until this changes.
    --
    -- 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.
    --
    -- For the synchronous, blocking version of this function, see
    -- 'GI.Gio.Objects.OutputStream.outputStreamWritev'.
    --
    -- Note that no copy of /@vectors@/ will be made, so it must stay valid
    -- until /@callback@/ is called.
    --
    -- /Since: 2.60/
    outputStreamWritevAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@stream@/: A t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> [Gio.OutputVector.OutputVector]
        -- ^ /@vectors@/: the buffer containing the @/GOutputVectors/@ to write.
        -> Int32
        -- ^ /@ioPriority@/: the I\/O priority of the request.
        -> Maybe (b)
        -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
        --     to call when the request is satisfied
        -> m ()
    outputStreamWritevAsync :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsCancellable b) =>
    a
    -> [OutputVector]
    -> Int32
    -> Maybe b
    -> Maybe AsyncReadyCallback
    -> m ()
    outputStreamWritevAsync a
    stream [OutputVector]
    vectors Int32
    ioPriority Maybe b
    cancellable Maybe AsyncReadyCallback
    callback = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        let nVectors :: CSize
    nVectors = Int -> CSize
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CSize) -> Int -> CSize
    forall a b. (a -> b) -> a -> b
    $ [OutputVector] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    P.length [OutputVector]
    vectors
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        vectors' <- mapM unsafeManagedPtrGetPtr vectors
        vectors'' <- packBlockArray 16 vectors'
        maybeCancellable <- case cancellable of
            Maybe b
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    FP.nullPtr
            Just b
    jCancellable -> do
                jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Maybe AsyncReadyCallback
    Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return FunPtr C_AsyncReadyCallback
    forall a. FunPtr a
    FP.nullFunPtr
            Just AsyncReadyCallback
    jCallback -> do
                ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
    forall a. Storable a => IO (Ptr a)
    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 = Ptr a
    forall a. Ptr a
    nullPtr
        g_output_stream_writev_async stream' vectors'' nVectors ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        mapM_ touchManagedPtr vectors
        whenJust cancellable touchManagedPtr
        freeMem vectors''
        return ()

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamWritevAsyncMethodInfo
    instance (signature ~ ([Gio.OutputVector.OutputVector] -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod OutputStreamWritevAsyncMethodInfo a signature where
        overloadedMethod = outputStreamWritevAsync

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

    #endif

    -- method OutputStream::writev_finish
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "OutputStream" }
    --           , argCType = Just "GOutputStream*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GOutputStream." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "result"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
    --           , argCType = Just "GAsyncResult*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GAsyncResult." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "bytes_written"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "location to store the number of bytes that were written to the stream"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_writev_finish" g_output_stream_writev_finish ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr FCT.CSize ->                        -- bytes_written : TBasicType TSize
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    -- | Finishes a stream writev operation.
    --
    -- /Since: 2.60/
    outputStreamWritevFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'.
        -> b
        -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
        -> m (FCT.CSize)
        -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
    outputStreamWritevFinish :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsOutputStream a, IsAsyncResult b) =>
    a -> b -> m CSize
    outputStreamWritevFinish a
    stream b
    result_ = IO CSize -> m CSize
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
    forall a b. (a -> b) -> a -> b
    $ do
        stream' <- a -> IO (Ptr OutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        result_' <- unsafeManagedPtrCastPtr result_
        bytesWritten <- allocMem :: IO (Ptr FCT.CSize)
        onException (do
            _ <- propagateGError $ g_output_stream_writev_finish stream' result_' bytesWritten
            bytesWritten' <- peek bytesWritten
            touchManagedPtr stream
            touchManagedPtr result_
            freeMem bytesWritten
            return bytesWritten'
         ) (do
            freeMem bytesWritten
         )

    #if defined(ENABLE_OVERLOADING)
    data OutputStreamWritevFinishMethodInfo
    instance (signature ~ (b -> m (FCT.CSize)), MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod OutputStreamWritevFinishMethodInfo a signature where
        overloadedMethod = outputStreamWritevFinish

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

    #endif