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

    'GI.Gio.Objects.FileEnumerator.FileEnumerator' allows you to operate on a set of @/GFiles/@,
    returning a 'GI.Gio.Objects.FileInfo.FileInfo' structure for each file enumerated (e.g.
    'GI.Gio.Interfaces.File.fileEnumerateChildren' will return a 'GI.Gio.Objects.FileEnumerator.FileEnumerator' for each
    of the children within a directory).

    To get the next file\'s information from a 'GI.Gio.Objects.FileEnumerator.FileEnumerator', use
    'GI.Gio.Objects.FileEnumerator.fileEnumeratorNextFile' or its asynchronous version,
    'GI.Gio.Objects.FileEnumerator.fileEnumeratorNextFilesAsync'. Note that the asynchronous
    version will return a list of @/GFileInfos/@, whereas the
    synchronous will only return the next file in the enumerator.

    The ordering of returned files is unspecified for non-Unix
    platforms; for more information, see 'GI.GLib.Structs.Dir.dirReadName'.  On Unix,
    when operating on local files, returned files will be sorted by
    inode number.  Effectively you can assume that the ordering of
    returned files will be stable between successive calls (and
    applications) assuming the directory is unchanged.

    If your application needs a specific ordering, such as by name or
    modification time, you will have to implement that in your
    application code.

    To close a 'GI.Gio.Objects.FileEnumerator.FileEnumerator', use 'GI.Gio.Objects.FileEnumerator.fileEnumeratorClose', or
    its asynchronous version, 'GI.Gio.Objects.FileEnumerator.fileEnumeratorCloseAsync'. Once
    a 'GI.Gio.Objects.FileEnumerator.FileEnumerator' is closed, no further actions may be performed
    on it, and it should be freed with 'GI.GObject.Objects.Object.objectUnref'.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.FileEnumerator
        (

    -- * Exported types
        FileEnumerator(..)                      ,
        IsFileEnumerator                        ,
        toFileEnumerator                        ,
        noFileEnumerator                        ,

     -- * Methods
    -- ** close #method:close#

    #if ENABLE_OVERLOADING
        FileEnumeratorCloseMethodInfo           ,
    #endif
        fileEnumeratorClose                     ,

    -- ** closeAsync #method:closeAsync#

    #if ENABLE_OVERLOADING
        FileEnumeratorCloseAsyncMethodInfo      ,
    #endif
        fileEnumeratorCloseAsync                ,

    -- ** closeFinish #method:closeFinish#

    #if ENABLE_OVERLOADING
        FileEnumeratorCloseFinishMethodInfo     ,
    #endif
        fileEnumeratorCloseFinish               ,

    -- ** getChild #method:getChild#

    #if ENABLE_OVERLOADING
        FileEnumeratorGetChildMethodInfo        ,
    #endif
        fileEnumeratorGetChild                  ,

    -- ** getContainer #method:getContainer#

    #if ENABLE_OVERLOADING
        FileEnumeratorGetContainerMethodInfo    ,
    #endif
        fileEnumeratorGetContainer              ,

    -- ** hasPending #method:hasPending#

    #if ENABLE_OVERLOADING
        FileEnumeratorHasPendingMethodInfo      ,
    #endif
        fileEnumeratorHasPending                ,

    -- ** isClosed #method:isClosed#

    #if ENABLE_OVERLOADING
        FileEnumeratorIsClosedMethodInfo        ,
    #endif
        fileEnumeratorIsClosed                  ,

    -- ** iterate #method:iterate#

    #if ENABLE_OVERLOADING
        FileEnumeratorIterateMethodInfo         ,
    #endif
        fileEnumeratorIterate                   ,

    -- ** nextFile #method:nextFile#

    #if ENABLE_OVERLOADING
        FileEnumeratorNextFileMethodInfo        ,
    #endif
        fileEnumeratorNextFile                  ,

    -- ** nextFilesAsync #method:nextFilesAsync#

    #if ENABLE_OVERLOADING
        FileEnumeratorNextFilesAsyncMethodInfo  ,
    #endif
        fileEnumeratorNextFilesAsync            ,

    -- ** nextFilesFinish #method:nextFilesFinish#

    #if ENABLE_OVERLOADING
        FileEnumeratorNextFilesFinishMethodInfo ,
    #endif
        fileEnumeratorNextFilesFinish           ,

    -- ** setPending #method:setPending#

    #if ENABLE_OVERLOADING
        FileEnumeratorSetPendingMethodInfo      ,
    #endif
        fileEnumeratorSetPending                ,

     -- * Properties
    -- ** container #attr:container#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        FileEnumeratorContainerPropertyInfo     ,
    #endif
        constructFileEnumeratorContainer        ,
    #if ENABLE_OVERLOADING
        fileEnumeratorContainer                 ,
    #endif

        ) where

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

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

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

    -- | Memory-managed wrapper type.
    newtype FileEnumerator = FileEnumerator (ManagedPtr FileEnumerator)
    foreign import ccall "g_file_enumerator_get_type"
        c_g_file_enumerator_get_type :: IO GType

    instance GObject FileEnumerator where
        gobjectType _ = c_g_file_enumerator_get_type

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

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

    -- | A convenience alias for `Nothing` :: `Maybe` `FileEnumerator`.
    noFileEnumerator :: Maybe FileEnumerator
    noFileEnumerator = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveFileEnumeratorMethod (t :: Symbol) (o :: *) :: * where
        ResolveFileEnumeratorMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveFileEnumeratorMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveFileEnumeratorMethod "close" o = FileEnumeratorCloseMethodInfo
        ResolveFileEnumeratorMethod "closeAsync" o = FileEnumeratorCloseAsyncMethodInfo
        ResolveFileEnumeratorMethod "closeFinish" o = FileEnumeratorCloseFinishMethodInfo
        ResolveFileEnumeratorMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveFileEnumeratorMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveFileEnumeratorMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveFileEnumeratorMethod "hasPending" o = FileEnumeratorHasPendingMethodInfo
        ResolveFileEnumeratorMethod "isClosed" o = FileEnumeratorIsClosedMethodInfo
        ResolveFileEnumeratorMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveFileEnumeratorMethod "iterate" o = FileEnumeratorIterateMethodInfo
        ResolveFileEnumeratorMethod "nextFile" o = FileEnumeratorNextFileMethodInfo
        ResolveFileEnumeratorMethod "nextFilesAsync" o = FileEnumeratorNextFilesAsyncMethodInfo
        ResolveFileEnumeratorMethod "nextFilesFinish" o = FileEnumeratorNextFilesFinishMethodInfo
        ResolveFileEnumeratorMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveFileEnumeratorMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveFileEnumeratorMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveFileEnumeratorMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveFileEnumeratorMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveFileEnumeratorMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveFileEnumeratorMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveFileEnumeratorMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveFileEnumeratorMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveFileEnumeratorMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveFileEnumeratorMethod "getChild" o = FileEnumeratorGetChildMethodInfo
        ResolveFileEnumeratorMethod "getContainer" o = FileEnumeratorGetContainerMethodInfo
        ResolveFileEnumeratorMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveFileEnumeratorMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveFileEnumeratorMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveFileEnumeratorMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveFileEnumeratorMethod "setPending" o = FileEnumeratorSetPendingMethodInfo
        ResolveFileEnumeratorMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveFileEnumeratorMethod l o = O.MethodResolutionFailed l o

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

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

    #endif

    -- VVV Prop "container"
       -- Type: TInterface (Name {namespace = "Gio", name = "File"})
       -- Flags: [PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Just False,Nothing)

    {- |
    Construct a `GValueConstruct` with valid value for the “@container@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructFileEnumeratorContainer :: (IsFileEnumerator o, Gio.File.IsFile a) => a -> IO (GValueConstruct o)
    constructFileEnumeratorContainer val = constructObjectPropertyObject "container" (Just val)

    #if ENABLE_OVERLOADING
    data FileEnumeratorContainerPropertyInfo
    instance AttrInfo FileEnumeratorContainerPropertyInfo where
        type AttrAllowedOps FileEnumeratorContainerPropertyInfo = '[ 'AttrConstruct, 'AttrClear]
        type AttrSetTypeConstraint FileEnumeratorContainerPropertyInfo = Gio.File.IsFile
        type AttrBaseTypeConstraint FileEnumeratorContainerPropertyInfo = IsFileEnumerator
        type AttrGetType FileEnumeratorContainerPropertyInfo = ()
        type AttrLabel FileEnumeratorContainerPropertyInfo = "container"
        type AttrOrigin FileEnumeratorContainerPropertyInfo = FileEnumerator
        attrGet _ = undefined
        attrSet _ = undefined
        attrConstruct _ = constructFileEnumeratorContainer
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList FileEnumerator
    type instance O.AttributeList FileEnumerator = FileEnumeratorAttributeList
    type FileEnumeratorAttributeList = ('[ '("container", FileEnumeratorContainerPropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    fileEnumeratorContainer :: AttrLabelProxy "container"
    fileEnumeratorContainer = AttrLabelProxy

    #endif

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

    #endif

    -- method FileEnumerator::close
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "enumerator", argType = TInterface (Name {namespace = "Gio", name = "FileEnumerator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFileEnumerator.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

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

    {- |
    Releases all resources used by this enumerator, making the
    enumerator return 'GI.Gio.Enums.IOErrorEnumClosed' on all calls.

    This will be automatically called when the last reference
    is dropped, but you might want to call this function to make
    sure resources are released as early as possible.
    -}
    fileEnumeratorClose ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileEnumerator a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@enumerator@/: a 'GI.Gio.Objects.FileEnumerator.FileEnumerator'. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    fileEnumeratorClose enumerator cancellable = liftIO $ do
        enumerator' <- unsafeManagedPtrCastPtr enumerator
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_file_enumerator_close enumerator' maybeCancellable
            touchManagedPtr enumerator
            whenJust cancellable touchManagedPtr
            return ()
         ) (do
            return ()
         )

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

    #endif

    -- method FileEnumerator::close_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "enumerator", argType = TInterface (Name {namespace = "Gio", name = "FileEnumerator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFileEnumerator.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the [I/O priority][io-priority] of the request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_file_enumerator_close_async" g_file_enumerator_close_async ::
        Ptr FileEnumerator ->                   -- enumerator : TInterface (Name {namespace = "Gio", name = "FileEnumerator"})
        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 closes the file enumerator.

    If /@cancellable@/ is not 'Nothing', then the operation can be cancelled by
    triggering the cancellable object from another thread. If the operation
    was cancelled, the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned in
    'GI.Gio.Objects.FileEnumerator.fileEnumeratorCloseFinish'.
    -}
    fileEnumeratorCloseAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileEnumerator a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@enumerator@/: a 'GI.Gio.Objects.FileEnumerator.FileEnumerator'. -}
        -> Int32
        {- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied -}
        -> m ()
    fileEnumeratorCloseAsync enumerator ioPriority cancellable callback = liftIO $ do
        enumerator' <- unsafeManagedPtrCastPtr enumerator
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_file_enumerator_close_async enumerator' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr enumerator
        whenJust cancellable touchManagedPtr
        return ()

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

    #endif

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

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

    {- |
    Finishes closing a file enumerator, started from 'GI.Gio.Objects.FileEnumerator.fileEnumeratorCloseAsync'.

    If the file enumerator was already closed when 'GI.Gio.Objects.FileEnumerator.fileEnumeratorCloseAsync'
    was called, then this function will report 'GI.Gio.Enums.IOErrorEnumClosed' in /@error@/, and
    return 'False'. If the file enumerator had pending operation when the close
    operation was started, then this function will report 'GI.Gio.Enums.IOErrorEnumPending', and
    return 'False'.  If /@cancellable@/ was not 'Nothing', then the operation may have been
    cancelled by triggering the cancellable object from another thread. If the operation
    was cancelled, the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be set, and 'False' will be
    returned.
    -}
    fileEnumeratorCloseFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileEnumerator a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@enumerator@/: a 'GI.Gio.Objects.FileEnumerator.FileEnumerator'. -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    fileEnumeratorCloseFinish enumerator result_ = liftIO $ do
        enumerator' <- unsafeManagedPtrCastPtr enumerator
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            _ <- propagateGError $ g_file_enumerator_close_finish enumerator' result_'
            touchManagedPtr enumerator
            touchManagedPtr result_
            return ()
         ) (do
            return ()
         )

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

    #endif

    -- method FileEnumerator::get_child
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "enumerator", argType = TInterface (Name {namespace = "Gio", name = "FileEnumerator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFileEnumerator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFileInfo gotten from g_file_enumerator_next_file()\n  or the async equivalents.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_file_enumerator_get_child" g_file_enumerator_get_child ::
        Ptr FileEnumerator ->                   -- enumerator : TInterface (Name {namespace = "Gio", name = "FileEnumerator"})
        Ptr Gio.FileInfo.FileInfo ->            -- info : TInterface (Name {namespace = "Gio", name = "FileInfo"})
        IO (Ptr Gio.File.File)

    {- |
    Return a new 'GI.Gio.Interfaces.File.File' which refers to the file named by /@info@/ in the source
    directory of /@enumerator@/.  This function is primarily intended to be used
    inside loops with 'GI.Gio.Objects.FileEnumerator.fileEnumeratorNextFile'.

    This is a convenience method that\'s equivalent to:

    === /C code/
    >
    >  gchar *name = g_file_info_get_name (info);
    >  GFile *child = g_file_get_child (g_file_enumerator_get_container (enumr),
    >                                   name);

    /Since: 2.36/
    -}
    fileEnumeratorGetChild ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileEnumerator a, Gio.FileInfo.IsFileInfo b) =>
        a
        {- ^ /@enumerator@/: a 'GI.Gio.Objects.FileEnumerator.FileEnumerator' -}
        -> b
        {- ^ /@info@/: a 'GI.Gio.Objects.FileInfo.FileInfo' gotten from 'GI.Gio.Objects.FileEnumerator.fileEnumeratorNextFile'
      or the async equivalents. -}
        -> m Gio.File.File
        {- ^ __Returns:__ a 'GI.Gio.Interfaces.File.File' for the 'GI.Gio.Objects.FileInfo.FileInfo' passed it. -}
    fileEnumeratorGetChild enumerator info = liftIO $ do
        enumerator' <- unsafeManagedPtrCastPtr enumerator
        info' <- unsafeManagedPtrCastPtr info
        result <- g_file_enumerator_get_child enumerator' info'
        checkUnexpectedReturnNULL "fileEnumeratorGetChild" result
        result' <- (wrapObject Gio.File.File) result
        touchManagedPtr enumerator
        touchManagedPtr info
        return result'

    #if ENABLE_OVERLOADING
    data FileEnumeratorGetChildMethodInfo
    instance (signature ~ (b -> m Gio.File.File), MonadIO m, IsFileEnumerator a, Gio.FileInfo.IsFileInfo b) => O.MethodInfo FileEnumeratorGetChildMethodInfo a signature where
        overloadedMethod _ = fileEnumeratorGetChild

    #endif

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

    foreign import ccall "g_file_enumerator_get_container" g_file_enumerator_get_container ::
        Ptr FileEnumerator ->                   -- enumerator : TInterface (Name {namespace = "Gio", name = "FileEnumerator"})
        IO (Ptr Gio.File.File)

    {- |
    Get the 'GI.Gio.Interfaces.File.File' container which is being enumerated.

    /Since: 2.18/
    -}
    fileEnumeratorGetContainer ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileEnumerator a) =>
        a
        {- ^ /@enumerator@/: a 'GI.Gio.Objects.FileEnumerator.FileEnumerator' -}
        -> m Gio.File.File
        {- ^ __Returns:__ the 'GI.Gio.Interfaces.File.File' which is being enumerated. -}
    fileEnumeratorGetContainer enumerator = liftIO $ do
        enumerator' <- unsafeManagedPtrCastPtr enumerator
        result <- g_file_enumerator_get_container enumerator'
        checkUnexpectedReturnNULL "fileEnumeratorGetContainer" result
        result' <- (newObject Gio.File.File) result
        touchManagedPtr enumerator
        return result'

    #if ENABLE_OVERLOADING
    data FileEnumeratorGetContainerMethodInfo
    instance (signature ~ (m Gio.File.File), MonadIO m, IsFileEnumerator a) => O.MethodInfo FileEnumeratorGetContainerMethodInfo a signature where
        overloadedMethod _ = fileEnumeratorGetContainer

    #endif

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

    foreign import ccall "g_file_enumerator_has_pending" g_file_enumerator_has_pending ::
        Ptr FileEnumerator ->                   -- enumerator : TInterface (Name {namespace = "Gio", name = "FileEnumerator"})
        IO CInt

    {- |
    Checks if the file enumerator has pending operations.
    -}
    fileEnumeratorHasPending ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileEnumerator a) =>
        a
        {- ^ /@enumerator@/: a 'GI.Gio.Objects.FileEnumerator.FileEnumerator'. -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the /@enumerator@/ has pending operations. -}
    fileEnumeratorHasPending enumerator = liftIO $ do
        enumerator' <- unsafeManagedPtrCastPtr enumerator
        result <- g_file_enumerator_has_pending enumerator'
        let result' = (/= 0) result
        touchManagedPtr enumerator
        return result'

    #if ENABLE_OVERLOADING
    data FileEnumeratorHasPendingMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsFileEnumerator a) => O.MethodInfo FileEnumeratorHasPendingMethodInfo a signature where
        overloadedMethod _ = fileEnumeratorHasPending

    #endif

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

    foreign import ccall "g_file_enumerator_is_closed" g_file_enumerator_is_closed ::
        Ptr FileEnumerator ->                   -- enumerator : TInterface (Name {namespace = "Gio", name = "FileEnumerator"})
        IO CInt

    {- |
    Checks if the file enumerator has been closed.
    -}
    fileEnumeratorIsClosed ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileEnumerator a) =>
        a
        {- ^ /@enumerator@/: a 'GI.Gio.Objects.FileEnumerator.FileEnumerator'. -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the /@enumerator@/ is closed. -}
    fileEnumeratorIsClosed enumerator = liftIO $ do
        enumerator' <- unsafeManagedPtrCastPtr enumerator
        result <- g_file_enumerator_is_closed enumerator'
        let result' = (/= 0) result
        touchManagedPtr enumerator
        return result'

    #if ENABLE_OVERLOADING
    data FileEnumeratorIsClosedMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsFileEnumerator a) => O.MethodInfo FileEnumeratorIsClosedMethodInfo a signature where
        overloadedMethod _ = fileEnumeratorIsClosed

    #endif

    -- method FileEnumerator::iterate
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "direnum", argType = TInterface (Name {namespace = "Gio", name = "FileEnumerator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an open #GFileEnumerator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Output location for the next #GFileInfo, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_child", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Output location for the next #GFile, or %NULL", 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 "a #GCancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_file_enumerator_iterate" g_file_enumerator_iterate ::
        Ptr FileEnumerator ->                   -- direnum : TInterface (Name {namespace = "Gio", name = "FileEnumerator"})
        Ptr (Ptr Gio.FileInfo.FileInfo) ->      -- out_info : TInterface (Name {namespace = "Gio", name = "FileInfo"})
        Ptr (Ptr Gio.File.File) ->              -- out_child : TInterface (Name {namespace = "Gio", name = "File"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    This is a version of 'GI.Gio.Objects.FileEnumerator.fileEnumeratorNextFile' that\'s easier to
    use correctly from C programs.  With 'GI.Gio.Objects.FileEnumerator.fileEnumeratorNextFile',
    the gboolean return value signifies \"end of iteration or error\", which
    requires allocation of a temporary 'GError'.

    In contrast, with this function, a 'False' return from
    'GI.Gio.Objects.FileEnumerator.fileEnumeratorIterate' *always* means
    \"error\".  End of iteration is signaled by /@outInfo@/ or /@outChild@/ being 'Nothing'.

    Another crucial difference is that the references for /@outInfo@/ and
    /@outChild@/ are owned by /@direnum@/ (they are cached as hidden
    properties).  You must not unref them in your own code.  This makes
    memory management significantly easier for C code in combination
    with loops.

    Finally, this function optionally allows retrieving a 'GI.Gio.Interfaces.File.File' as
    well.

    You must specify at least one of /@outInfo@/ or /@outChild@/.

    The code pattern for correctly using 'GI.Gio.Objects.FileEnumerator.fileEnumeratorIterate' from C
    is:

    >
    >direnum = g_file_enumerate_children (file, ...);
    >while (TRUE)
    >  {
    >    GFileInfo *info;
    >    if (!g_file_enumerator_iterate (direnum, &info, NULL, cancellable, error))
    >      goto out;
    >    if (!info)
    >      break;
    >    ... do stuff with "info"; do not unref it! ...
    >  }
    >
    >out:
    >  g_object_unref (direnum); // Note: frees the last @info

    /Since: 2.44/
    -}
    fileEnumeratorIterate ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileEnumerator a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@direnum@/: an open 'GI.Gio.Objects.FileEnumerator.FileEnumerator' -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' -}
        -> m ((Gio.FileInfo.FileInfo, Gio.File.File))
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    fileEnumeratorIterate direnum cancellable = liftIO $ do
        direnum' <- unsafeManagedPtrCastPtr direnum
        outInfo <- allocMem :: IO (Ptr (Ptr Gio.FileInfo.FileInfo))
        outChild <- allocMem :: IO (Ptr (Ptr Gio.File.File))
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_file_enumerator_iterate direnum' outInfo outChild maybeCancellable
            outInfo' <- peek outInfo
            outInfo'' <- (newObject Gio.FileInfo.FileInfo) outInfo'
            outChild' <- peek outChild
            outChild'' <- (newObject Gio.File.File) outChild'
            touchManagedPtr direnum
            whenJust cancellable touchManagedPtr
            freeMem outInfo
            freeMem outChild
            return (outInfo'', outChild'')
         ) (do
            freeMem outInfo
            freeMem outChild
         )

    #if ENABLE_OVERLOADING
    data FileEnumeratorIterateMethodInfo
    instance (signature ~ (Maybe (b) -> m ((Gio.FileInfo.FileInfo, Gio.File.File))), MonadIO m, IsFileEnumerator a, Gio.Cancellable.IsCancellable b) => O.MethodInfo FileEnumeratorIterateMethodInfo a signature where
        overloadedMethod _ = fileEnumeratorIterate

    #endif

    -- method FileEnumerator::next_file
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "enumerator", argType = TInterface (Name {namespace = "Gio", name = "FileEnumerator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFileEnumerator.", 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_enumerator_next_file" g_file_enumerator_next_file ::
        Ptr FileEnumerator ->                   -- enumerator : TInterface (Name {namespace = "Gio", name = "FileEnumerator"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Gio.FileInfo.FileInfo)

    {- |
    Returns information for the next file in the enumerated object.
    Will block until the information is available. The 'GI.Gio.Objects.FileInfo.FileInfo'
    returned from this function will contain attributes that match the
    attribute string that was passed when the 'GI.Gio.Objects.FileEnumerator.FileEnumerator' was created.

    See the documentation of 'GI.Gio.Objects.FileEnumerator.FileEnumerator' for information about the
    order of returned files.

    On error, returns 'Nothing' and sets /@error@/ to the error. If the
    enumerator is at the end, 'Nothing' will be returned and /@error@/ will
    be unset.
    -}
    fileEnumeratorNextFile ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileEnumerator a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@enumerator@/: a 'GI.Gio.Objects.FileEnumerator.FileEnumerator'. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m (Maybe Gio.FileInfo.FileInfo)
        {- ^ __Returns:__ A 'GI.Gio.Objects.FileInfo.FileInfo' or 'Nothing' on error
       or end of enumerator.  Free the returned object with
       'GI.GObject.Objects.Object.objectUnref' when no longer needed. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    fileEnumeratorNextFile enumerator cancellable = liftIO $ do
        enumerator' <- unsafeManagedPtrCastPtr enumerator
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_file_enumerator_next_file enumerator' maybeCancellable
            maybeResult <- convertIfNonNull result $ \result' -> do
                result'' <- (wrapObject Gio.FileInfo.FileInfo) result'
                return result''
            touchManagedPtr enumerator
            whenJust cancellable touchManagedPtr
            return maybeResult
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data FileEnumeratorNextFileMethodInfo
    instance (signature ~ (Maybe (b) -> m (Maybe Gio.FileInfo.FileInfo)), MonadIO m, IsFileEnumerator a, Gio.Cancellable.IsCancellable b) => O.MethodInfo FileEnumeratorNextFileMethodInfo a signature where
        overloadedMethod _ = fileEnumeratorNextFile

    #endif

    -- method FileEnumerator::next_files_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "enumerator", argType = TInterface (Name {namespace = "Gio", name = "FileEnumerator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFileEnumerator.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num_files", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of file info objects to request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the [I/O priority][io-priority] of the request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback 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_enumerator_next_files_async" g_file_enumerator_next_files_async ::
        Ptr FileEnumerator ->                   -- enumerator : TInterface (Name {namespace = "Gio", name = "FileEnumerator"})
        Int32 ->                                -- num_files : TBasicType TInt
        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 information for a number of files from the enumerator asynchronously.
    When all i\/o for the operation is finished the /@callback@/ will be called with
    the requested information.

    See the documentation of 'GI.Gio.Objects.FileEnumerator.FileEnumerator' for information about the
    order of returned files.

    The callback can be called with less than /@numFiles@/ files in case of error
    or at the end of the enumerator. In case of a partial error the callback will
    be called with any succeeding items and no error, and on the next request the
    error will be reported. If a request is cancelled the callback will be called
    with 'GI.Gio.Enums.IOErrorEnumCancelled'.

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

    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'.
    -}
    fileEnumeratorNextFilesAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileEnumerator a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@enumerator@/: a 'GI.Gio.Objects.FileEnumerator.FileEnumerator'. -}
        -> Int32
        {- ^ /@numFiles@/: the number of file info objects to request -}
        -> Int32
        {- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied -}
        -> m ()
    fileEnumeratorNextFilesAsync enumerator numFiles ioPriority cancellable callback = liftIO $ do
        enumerator' <- unsafeManagedPtrCastPtr enumerator
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_file_enumerator_next_files_async enumerator' numFiles ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr enumerator
        whenJust cancellable touchManagedPtr
        return ()

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

    #endif

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

    foreign import ccall "g_file_enumerator_next_files_finish" g_file_enumerator_next_files_finish ::
        Ptr FileEnumerator ->                   -- enumerator : TInterface (Name {namespace = "Gio", name = "FileEnumerator"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr (GList (Ptr Gio.FileInfo.FileInfo)))

    {- |
    Finishes the asynchronous operation started with 'GI.Gio.Objects.FileEnumerator.fileEnumeratorNextFilesAsync'.
    -}
    fileEnumeratorNextFilesFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileEnumerator a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@enumerator@/: a 'GI.Gio.Objects.FileEnumerator.FileEnumerator'. -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m [Gio.FileInfo.FileInfo]
        {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of @/GFileInfos/@. You must free the list with
        @/g_list_free()/@ and unref the infos with 'GI.GObject.Objects.Object.objectUnref' when you\'re
        done with them. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    fileEnumeratorNextFilesFinish enumerator result_ = liftIO $ do
        enumerator' <- unsafeManagedPtrCastPtr enumerator
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            result <- propagateGError $ g_file_enumerator_next_files_finish enumerator' result_'
            result' <- unpackGList result
            result'' <- mapM (wrapObject Gio.FileInfo.FileInfo) result'
            g_list_free result
            touchManagedPtr enumerator
            touchManagedPtr result_
            return result''
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data FileEnumeratorNextFilesFinishMethodInfo
    instance (signature ~ (b -> m [Gio.FileInfo.FileInfo]), MonadIO m, IsFileEnumerator a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo FileEnumeratorNextFilesFinishMethodInfo a signature where
        overloadedMethod _ = fileEnumeratorNextFilesFinish

    #endif

    -- method FileEnumerator::set_pending
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "enumerator", argType = TInterface (Name {namespace = "Gio", name = "FileEnumerator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFileEnumerator.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pending", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a boolean value.", 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_enumerator_set_pending" g_file_enumerator_set_pending ::
        Ptr FileEnumerator ->                   -- enumerator : TInterface (Name {namespace = "Gio", name = "FileEnumerator"})
        CInt ->                                 -- pending : TBasicType TBoolean
        IO ()

    {- |
    Sets the file enumerator as having pending operations.
    -}
    fileEnumeratorSetPending ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileEnumerator a) =>
        a
        {- ^ /@enumerator@/: a 'GI.Gio.Objects.FileEnumerator.FileEnumerator'. -}
        -> Bool
        {- ^ /@pending@/: a boolean value. -}
        -> m ()
    fileEnumeratorSetPending enumerator pending = liftIO $ do
        enumerator' <- unsafeManagedPtrCastPtr enumerator
        let pending' = (fromIntegral . fromEnum) pending
        g_file_enumerator_set_pending enumerator' pending'
        touchManagedPtr enumerator
        return ()

    #if ENABLE_OVERLOADING
    data FileEnumeratorSetPendingMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsFileEnumerator a) => O.MethodInfo FileEnumeratorSetPendingMethodInfo a signature where
        overloadedMethod _ = fileEnumeratorSetPending

    #endif