    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- GFileOutputStream provides output streams that write their
    -- content to a file.
    --
    -- GFileOutputStream implements t'GI.Gio.Interfaces.Seekable.Seekable', which allows the output
    -- stream to jump to arbitrary positions in the file and to truncate
    -- the file, provided the filesystem of the file supports these
    -- operations.
    --
    -- To find the position of a file output stream, use 'GI.Gio.Interfaces.Seekable.seekableTell'.
    -- To find out if a file output stream supports seeking, use
    -- 'GI.Gio.Interfaces.Seekable.seekableCanSeek'.To position a file output stream, use
    -- 'GI.Gio.Interfaces.Seekable.seekableSeek'. To find out if a file output stream supports
    -- truncating, use 'GI.Gio.Interfaces.Seekable.seekableCanTruncate'. To truncate a file output
    -- stream, use 'GI.Gio.Interfaces.Seekable.seekableTruncate'.

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

    module GI.Gio.Objects.FileOutputStream
        (

    -- * Exported types
        FileOutputStream(..)                    ,
        IsFileOutputStream                      ,
        toFileOutputStream                      ,

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

    #if defined(ENABLE_OVERLOADING)
        ResolveFileOutputStreamMethod           ,
    #endif

    -- ** getEtag #method:getEtag#

    #if defined(ENABLE_OVERLOADING)
        FileOutputStreamGetEtagMethodInfo       ,
    #endif
        fileOutputStreamGetEtag                 ,

    -- ** queryInfo #method:queryInfo#

    #if defined(ENABLE_OVERLOADING)
        FileOutputStreamQueryInfoMethodInfo     ,
    #endif
        fileOutputStreamQueryInfo               ,

    -- ** queryInfoAsync #method:queryInfoAsync#

    #if defined(ENABLE_OVERLOADING)
        FileOutputStreamQueryInfoAsyncMethodInfo,
    #endif
        fileOutputStreamQueryInfoAsync          ,

    -- ** queryInfoFinish #method:queryInfoFinish#

    #if defined(ENABLE_OVERLOADING)
        FileOutputStreamQueryInfoFinishMethodInfo,
    #endif
        fileOutputStreamQueryInfoFinish         ,

        ) where

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

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

    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gio.Callbacks as Gio.Callbacks
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.Seekable as Gio.Seekable
    import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
    import {-# SOURCE #-} qualified GI.Gio.Objects.FileInfo as Gio.FileInfo
    import {-# SOURCE #-} qualified GI.Gio.Objects.OutputStream as Gio.OutputStream

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

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

    foreign import ccall "g_file_output_stream_get_type"
        c_g_file_output_stream_get_type :: IO B.Types.GType

    instance B.Types.TypedObject FileOutputStream where
        glibType :: IO GType
    glibType = IO GType
    c_g_file_output_stream_get_type

    instance B.Types.GObject FileOutputStream

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

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

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

    instance O.HasParentTypes FileOutputStream
    type instance O.ParentTypes FileOutputStream = '[Gio.OutputStream.OutputStream, GObject.Object.Object, Gio.Seekable.Seekable]

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

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

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

    #endif

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

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    #endif

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

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

    -- | Gets the entity tag for the file when it has been written.
    -- This must be called after the stream has been written
    -- and closed, as the etag can change while writing.
    fileOutputStreamGetEtag ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileOutputStream a) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.FileOutputStream.FileOutputStream'.
        -> m T.Text
        -- ^ __Returns:__ the entity tag for the stream.
    fileOutputStreamGetEtag :: a -> m Text
    fileOutputStreamGetEtag stream :: a
    stream = IO Text -> m Text
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr FileOutputStream
    stream' <- a -> IO (Ptr FileOutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        CString
    result <- Ptr FileOutputStream -> IO CString
    g_file_output_stream_get_etag Ptr FileOutputStream
    stream'
        Text -> CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "fileOutputStreamGetEtag" CString
    result
        Text
    result' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    stream
        Text -> IO Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    result'

    #if defined(ENABLE_OVERLOADING)
    data FileOutputStreamGetEtagMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsFileOutputStream a) => O.MethodInfo FileOutputStreamGetEtagMethodInfo a signature where
        overloadedMethod = fileOutputStreamGetEtag

    #endif

    -- method FileOutputStream::query_info
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "FileOutputStream" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GFileOutputStream."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "attributes"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a file attribute query string."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "optional #GCancellable object, %NULL to ignore."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gio" , name = "FileInfo" })
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_file_output_stream_query_info" g_file_output_stream_query_info ::
        Ptr FileOutputStream ->                 -- stream : TInterface (Name {namespace = "Gio", name = "FileOutputStream"})
        CString ->                              -- attributes : TBasicType TUTF8
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Gio.FileInfo.FileInfo)

    -- | Queries a file output stream for the given /@attributes@/.
    -- This function blocks while querying the stream. For the asynchronous
    -- version of this function, see 'GI.Gio.Objects.FileOutputStream.fileOutputStreamQueryInfoAsync'.
    -- While the stream is blocked, the stream will set the pending flag
    -- internally, and any other operations on the stream will fail with
    -- 'GI.Gio.Enums.IOErrorEnumPending'.
    --
    -- Can fail if the stream was already closed (with /@error@/ being set to
    -- 'GI.Gio.Enums.IOErrorEnumClosed'), the stream has pending operations (with /@error@/ being
    -- set to 'GI.Gio.Enums.IOErrorEnumPending'), or if querying info is not supported for
    -- the stream\'s interface (with /@error@/ being set to 'GI.Gio.Enums.IOErrorEnumNotSupported'). In
    -- all cases of failure, 'P.Nothing' will be returned.
    --
    -- 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 set, and 'P.Nothing' will
    -- be returned.
    fileOutputStreamQueryInfo ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.FileOutputStream.FileOutputStream'.
        -> T.Text
        -- ^ /@attributes@/: a file attribute query string.
        -> Maybe (b)
        -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
        -> m Gio.FileInfo.FileInfo
        -- ^ __Returns:__ a t'GI.Gio.Objects.FileInfo.FileInfo' for the /@stream@/, or 'P.Nothing' on error. /(Can throw 'Data.GI.Base.GError.GError')/
    fileOutputStreamQueryInfo :: a -> Text -> Maybe b -> m FileInfo
    fileOutputStreamQueryInfo stream :: a
    stream attributes :: Text
    attributes cancellable :: Maybe b
    cancellable = IO FileInfo -> m FileInfo
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO FileInfo -> m FileInfo) -> IO FileInfo -> m FileInfo
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr FileOutputStream
    stream' <- a -> IO (Ptr FileOutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        CString
    attributes' <- Text -> IO CString
    textToCString Text
    attributes
        Ptr Cancellable
    maybeCancellable <- case Maybe b
    cancellable of
            Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    nullPtr
            Just jCancellable :: b
    jCancellable -> do
                Ptr Cancellable
    jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                Ptr Cancellable -> IO (Ptr Cancellable)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    jCancellable'
        IO FileInfo -> IO () -> IO FileInfo
    forall a b. IO a -> IO b -> IO a
    onException (do
            Ptr FileInfo
    result <- (Ptr (Ptr GError) -> IO (Ptr FileInfo)) -> IO (Ptr FileInfo)
    forall a. (Ptr (Ptr GError) -> IO a) -> IO a
    propagateGError ((Ptr (Ptr GError) -> IO (Ptr FileInfo)) -> IO (Ptr FileInfo))
    -> (Ptr (Ptr GError) -> IO (Ptr FileInfo)) -> IO (Ptr FileInfo)
    forall a b. (a -> b) -> a -> b
    $ Ptr FileOutputStream
    -> CString
    -> Ptr Cancellable
    -> Ptr (Ptr GError)
    -> IO (Ptr FileInfo)
    g_file_output_stream_query_info Ptr FileOutputStream
    stream' CString
    attributes' Ptr Cancellable
    maybeCancellable
            Text -> Ptr FileInfo -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "fileOutputStreamQueryInfo" Ptr FileInfo
    result
            FileInfo
    result' <- ((ManagedPtr FileInfo -> FileInfo) -> Ptr FileInfo -> IO FileInfo
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr FileInfo -> FileInfo
    Gio.FileInfo.FileInfo) Ptr FileInfo
    result
            a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    stream
            Maybe b -> (b -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe b
    cancellable b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
            CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    attributes'
            FileInfo -> IO FileInfo
    forall (m :: * -> *) a. Monad m => a -> m a
    return FileInfo
    result'
         ) (do
            CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    attributes'
         )

    #if defined(ENABLE_OVERLOADING)
    data FileOutputStreamQueryInfoMethodInfo
    instance (signature ~ (T.Text -> Maybe (b) -> m Gio.FileInfo.FileInfo), MonadIO m, IsFileOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo FileOutputStreamQueryInfoMethodInfo a signature where
        overloadedMethod = fileOutputStreamQueryInfo

    #endif

    -- method FileOutputStream::query_info_async
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "stream"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "FileOutputStream" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GFileOutputStream."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "attributes"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a file attribute query string."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "io_priority"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the [I/O priority][gio-GIOScheduler] of the request"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "optional #GCancellable object, %NULL to ignore."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "callback"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "callback to call when the request is satisfied"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeAsync
    --           , argClosure = 5
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "user_data"
    --           , argType = TBasicType TPtr
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the data to pass to callback function"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_file_output_stream_query_info_async" g_file_output_stream_query_info_async ::
        Ptr FileOutputStream ->                 -- stream : TInterface (Name {namespace = "Gio", name = "FileOutputStream"})
        CString ->                              -- attributes : TBasicType TUTF8
        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 ()

    -- | Asynchronously queries the /@stream@/ for a t'GI.Gio.Objects.FileInfo.FileInfo'. When completed,
    -- /@callback@/ will be called with a t'GI.Gio.Interfaces.AsyncResult.AsyncResult' which can be used to
    -- finish the operation with 'GI.Gio.Objects.FileOutputStream.fileOutputStreamQueryInfoFinish'.
    --
    -- For the synchronous version of this function, see
    -- 'GI.Gio.Objects.FileOutputStream.fileOutputStreamQueryInfo'.
    fileOutputStreamQueryInfoAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.FileOutputStream.FileOutputStream'.
        -> T.Text
        -- ^ /@attributes@/: a file attribute query string.
        -> Int32
        -- ^ /@ioPriority@/: the [I\/O priority][gio-GIOScheduler] of the request
        -> Maybe (b)
        -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        -- ^ /@callback@/: callback to call when the request is satisfied
        -> m ()
    fileOutputStreamQueryInfoAsync :: a -> Text -> Int32 -> Maybe b -> Maybe AsyncReadyCallback -> m ()
    fileOutputStreamQueryInfoAsync stream :: a
    stream attributes :: Text
    attributes ioPriority :: Int32
    ioPriority cancellable :: Maybe b
    cancellable callback :: Maybe AsyncReadyCallback
    callback = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr FileOutputStream
    stream' <- a -> IO (Ptr FileOutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        CString
    attributes' <- Text -> IO CString
    textToCString Text
    attributes
        Ptr Cancellable
    maybeCancellable <- case Maybe b
    cancellable of
            Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    nullPtr
            Just jCancellable :: b
    jCancellable -> do
                Ptr Cancellable
    jCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCancellable
                Ptr Cancellable -> IO (Ptr Cancellable)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    jCancellable'
        FunPtr C_AsyncReadyCallback
    maybeCallback <- case Maybe AsyncReadyCallback
    callback of
            Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Ptr Any -> FunPtr C_AsyncReadyCallback
    forall a b. Ptr a -> FunPtr b
    castPtrToFunPtr Ptr Any
    forall a. Ptr a
    nullPtr)
            Just jCallback :: AsyncReadyCallback
    jCallback -> do
                Ptr (FunPtr C_AsyncReadyCallback)
    ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
    forall a. Storable a => IO (Ptr a)
    callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                FunPtr C_AsyncReadyCallback
    jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
    Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
    -> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
    Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
    -> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
    forall a. a -> Maybe a
    Just Ptr (FunPtr C_AsyncReadyCallback)
    ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
    Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
    jCallback))
                Ptr (FunPtr C_AsyncReadyCallback)
    -> FunPtr C_AsyncReadyCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke Ptr (FunPtr C_AsyncReadyCallback)
    ptrcallback FunPtr C_AsyncReadyCallback
    jCallback'
                FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
    forall (m :: * -> *) a. Monad m => a -> m a
    return FunPtr C_AsyncReadyCallback
    jCallback'
        let userData :: Ptr a
    userData = Ptr a
    forall a. Ptr a
    nullPtr
        Ptr FileOutputStream
    -> CString
    -> Int32
    -> Ptr Cancellable
    -> FunPtr C_AsyncReadyCallback
    -> Ptr ()
    -> IO ()
    g_file_output_stream_query_info_async Ptr FileOutputStream
    stream' CString
    attributes' Int32
    ioPriority Ptr Cancellable
    maybeCancellable FunPtr C_AsyncReadyCallback
    maybeCallback Ptr ()
    forall a. Ptr a
    userData
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    stream
        Maybe b -> (b -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe b
    cancellable b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    attributes'
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data FileOutputStreamQueryInfoAsyncMethodInfo
    instance (signature ~ (T.Text -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsFileOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo FileOutputStreamQueryInfoAsyncMethodInfo a signature where
        overloadedMethod = fileOutputStreamQueryInfoAsync

    #endif

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

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

    -- | Finalizes the asynchronous query started
    -- by 'GI.Gio.Objects.FileOutputStream.fileOutputStreamQueryInfoAsync'.
    fileOutputStreamQueryInfoFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        -- ^ /@stream@/: a t'GI.Gio.Objects.FileOutputStream.FileOutputStream'.
        -> b
        -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
        -> m Gio.FileInfo.FileInfo
        -- ^ __Returns:__ A t'GI.Gio.Objects.FileInfo.FileInfo' for the finished query. /(Can throw 'Data.GI.Base.GError.GError')/
    fileOutputStreamQueryInfoFinish :: a -> b -> m FileInfo
    fileOutputStreamQueryInfoFinish stream :: a
    stream result_ :: b
    result_ = IO FileInfo -> m FileInfo
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO FileInfo -> m FileInfo) -> IO FileInfo -> m FileInfo
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr FileOutputStream
    stream' <- a -> IO (Ptr FileOutputStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    stream
        Ptr AsyncResult
    result_' <- b -> IO (Ptr AsyncResult)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    result_
        IO FileInfo -> IO () -> IO FileInfo
    forall a b. IO a -> IO b -> IO a
    onException (do
            Ptr FileInfo
    result <- (Ptr (Ptr GError) -> IO (Ptr FileInfo)) -> IO (Ptr FileInfo)
    forall a. (Ptr (Ptr GError) -> IO a) -> IO a
    propagateGError ((Ptr (Ptr GError) -> IO (Ptr FileInfo)) -> IO (Ptr FileInfo))
    -> (Ptr (Ptr GError) -> IO (Ptr FileInfo)) -> IO (Ptr FileInfo)
    forall a b. (a -> b) -> a -> b
    $ Ptr FileOutputStream
    -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO (Ptr FileInfo)
    g_file_output_stream_query_info_finish Ptr FileOutputStream
    stream' Ptr AsyncResult
    result_'
            Text -> Ptr FileInfo -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "fileOutputStreamQueryInfoFinish" Ptr FileInfo
    result
            FileInfo
    result' <- ((ManagedPtr FileInfo -> FileInfo) -> Ptr FileInfo -> IO FileInfo
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr FileInfo -> FileInfo
    Gio.FileInfo.FileInfo) Ptr FileInfo
    result
            a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    stream
            b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    result_
            FileInfo -> IO FileInfo
    forall (m :: * -> *) a. Monad m => a -> m a
    return FileInfo
    result'
         ) (do
            () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data FileOutputStreamQueryInfoFinishMethodInfo
    instance (signature ~ (b -> m Gio.FileInfo.FileInfo), MonadIO m, IsFileOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo FileOutputStreamQueryInfoFinishMethodInfo a signature where
        overloadedMethod = fileOutputStreamQueryInfoFinish

    #endif