    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- As of GLib 2.46, @GSimpleAsyncResult@ is deprecated in favor of
    -- t'GI.Gio.Objects.Task.Task', which provides a simpler API.
    --
    -- @GSimpleAsyncResult@ implements t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
    --
    -- @GSimpleAsyncResult@ handles [type/@gio@/.AsyncReadyCallback]s, error
    -- reporting, operation cancellation and the final state of an operation,
    -- completely transparent to the application. Results can be returned
    -- as a pointer e.g. for functions that return data that is collected
    -- asynchronously, a boolean value for checking the success or failure
    -- of an operation, or a @gssize@ for operations which return the number
    -- of bytes modified by the operation; all of the simple return cases
    -- are covered.
    --
    -- Most of the time, an application will not need to know of the details
    -- of this API; it is handled transparently, and any necessary operations
    -- are handled by t'GI.Gio.Interfaces.AsyncResult.AsyncResult'’s interface. However, if implementing
    -- a new GIO module, for writing language bindings, or for complex
    -- applications that need better control of how asynchronous operations
    -- are completed, it is important to understand this functionality.
    --
    -- @GSimpleAsyncResult@s are tagged with the calling function to ensure
    -- that asynchronous functions and their finishing functions are used
    -- together correctly.
    --
    -- To create a new @GSimpleAsyncResult@, call 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultNew'.
    -- If the result needs to be created for a @GError@, use
    -- 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultNewFromError' or
    -- t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.@/new_take_error/@(). If a @GError@ is not available
    -- (e.g. the asynchronous operation doesn’t take a @GError@ argument),
    -- but the result still needs to be created for an error condition, use
    -- t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.@/new_error/@() (or
    -- t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.@/set_error_va/@() if your application or binding
    -- requires passing a variable argument list directly), and the error can then
    -- be propagated through the use of
    -- 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultPropagateError'.
    --
    -- An asynchronous operation can be made to ignore a cancellation event by
    -- calling 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultSetHandleCancellation' with a
    -- @GSimpleAsyncResult@ for the operation and @FALSE@. This is useful for
    -- operations that are dangerous to cancel, such as close (which would
    -- cause a leak if cancelled before being run).
    --
    -- @GSimpleAsyncResult@ can integrate into GLib’s event loop,
    -- [type/@gLib@/.MainLoop], or it can use [type/@gLib@/.Thread]s.
    -- 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultComplete' will finish an I\/O task directly
    -- from the point where it is called.
    -- 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultCompleteInIdle' will finish it from an idle
    -- handler in the  thread-default main context (see
    -- 'GI.GLib.Structs.MainContext.mainContextPushThreadDefault') where the @GSimpleAsyncResult@
    -- was created. t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.@/run_in_thread/@() will run the job in
    -- a separate thread and then use
    -- 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultCompleteInIdle' to deliver the result.
    --
    -- To set the results of an asynchronous function,
    -- t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.@/set_op_res_gpointer/@(),
    -- 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultSetOpResGboolean', and
    -- 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultSetOpResGssize'
    -- are provided, setting the operation\'s result to a @gpointer@, @gboolean@, or
    -- @gssize@, respectively.
    --
    -- Likewise, to get the result of an asynchronous function,
    -- t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.@/get_op_res_gpointer/@(),
    -- 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultGetOpResGboolean', and
    -- 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultGetOpResGssize' are
    -- provided, getting the operation’s result as a @gpointer@, @gboolean@, and
    -- @gssize@, respectively.
    --
    -- For the details of the requirements implementations must respect, see
    -- t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.  A typical implementation of an asynchronous
    -- operation using @GSimpleAsyncResult@ looks something like this:
    --
    --
    -- === /c code/
    -- >static void
    -- >baked_cb (Cake    *cake,
    -- >          gpointer user_data)
    -- >{
    -- >  // In this example, this callback is not given a reference to the cake,
    -- >  // so the GSimpleAsyncResult has to take a reference to it.
    -- >  GSimpleAsyncResult *result = user_data;
    -- >
    -- >  if (cake == NULL)
    -- >    g_simple_async_result_set_error (result,
    -- >                                     BAKER_ERRORS,
    -- >                                     BAKER_ERROR_NO_FLOUR,
    -- >                                     "Go to the supermarket");
    -- >  else
    -- >    g_simple_async_result_set_op_res_gpointer (result,
    -- >                                               g_object_ref (cake),
    -- >                                               g_object_unref);
    -- >
    -- >
    -- >  // In this example, we assume that baked_cb is called as a callback from
    -- >  // the mainloop, so it's safe to complete the operation synchronously here.
    -- >  // If, however, _baker_prepare_cake () might call its callback without
    -- >  // first returning to the mainloop — inadvisable, but some APIs do so —
    -- >  // we would need to use g_simple_async_result_complete_in_idle().
    -- >  g_simple_async_result_complete (result);
    -- >  g_object_unref (result);
    -- >}
    -- >
    -- >void
    -- >baker_bake_cake_async (Baker              *self,
    -- >                       guint               radius,
    -- >                       GAsyncReadyCallback callback,
    -- >                       gpointer            user_data)
    -- >{
    -- >  GSimpleAsyncResult *simple;
    -- >  Cake               *cake;
    -- >
    -- >  if (radius < 3)
    -- >    {
    -- >      g_simple_async_report_error_in_idle (G_OBJECT (self),
    -- >                                           callback,
    -- >                                           user_data,
    -- >                                           BAKER_ERRORS,
    -- >                                           BAKER_ERROR_TOO_SMALL,
    -- >                                           "%ucm radius cakes are silly",
    -- >                                           radius);
    -- >      return;
    -- >    }
    -- >
    -- >  simple = g_simple_async_result_new (G_OBJECT (self),
    -- >                                      callback,
    -- >                                      user_data,
    -- >                                      baker_bake_cake_async);
    -- >  cake = _baker_get_cached_cake (self, radius);
    -- >
    -- >  if (cake != NULL)
    -- >    {
    -- >      g_simple_async_result_set_op_res_gpointer (simple,
    -- >                                                 g_object_ref (cake),
    -- >                                                 g_object_unref);
    -- >      g_simple_async_result_complete_in_idle (simple);
    -- >      g_object_unref (simple);
    -- >      // Drop the reference returned by _baker_get_cached_cake();
    -- >      // the GSimpleAsyncResult has taken its own reference.
    -- >      g_object_unref (cake);
    -- >      return;
    -- >    }
    -- >
    -- >  _baker_prepare_cake (self, radius, baked_cb, simple);
    -- >}
    -- >
    -- >Cake *
    -- >baker_bake_cake_finish (Baker        *self,
    -- >                        GAsyncResult *result,
    -- >                        GError      **error)
    -- >{
    -- >  GSimpleAsyncResult *simple;
    -- >  Cake               *cake;
    -- >
    -- >  g_return_val_if_fail (g_simple_async_result_is_valid (result,
    -- >                                                        G_OBJECT (self),
    -- >                                                        baker_bake_cake_async),
    -- >                        NULL);
    -- >
    -- >  simple = (GSimpleAsyncResult *) result;
    -- >
    -- >  if (g_simple_async_result_propagate_error (simple, error))
    -- >    return NULL;
    -- >
    -- >  cake = CAKE (g_simple_async_result_get_op_res_gpointer (simple));
    -- >  return g_object_ref (cake);
    -- >}
    --

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

    module GI.Gio.Objects.SimpleAsyncResult
        (

    -- * Exported types
        SimpleAsyncResult(..)                   ,
        IsSimpleAsyncResult                     ,
        toSimpleAsyncResult                     ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [complete]("GI.Gio.Objects.SimpleAsyncResult#g:method:complete"), [completeInIdle]("GI.Gio.Objects.SimpleAsyncResult#g:method:completeInIdle"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isTagged]("GI.Gio.Interfaces.AsyncResult#g:method:isTagged"), [legacyPropagateError]("GI.Gio.Interfaces.AsyncResult#g:method:legacyPropagateError"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [propagateError]("GI.Gio.Objects.SimpleAsyncResult#g:method:propagateError"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
    --
    -- ==== Getters
    -- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getOpResGboolean]("GI.Gio.Objects.SimpleAsyncResult#g:method:getOpResGboolean"), [getOpResGssize]("GI.Gio.Objects.SimpleAsyncResult#g:method:getOpResGssize"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSourceObject]("GI.Gio.Interfaces.AsyncResult#g:method:getSourceObject"), [getUserData]("GI.Gio.Interfaces.AsyncResult#g:method:getUserData").
    --
    -- ==== Setters
    -- [setCheckCancellable]("GI.Gio.Objects.SimpleAsyncResult#g:method:setCheckCancellable"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setFromError]("GI.Gio.Objects.SimpleAsyncResult#g:method:setFromError"), [setHandleCancellation]("GI.Gio.Objects.SimpleAsyncResult#g:method:setHandleCancellation"), [setOpResGboolean]("GI.Gio.Objects.SimpleAsyncResult#g:method:setOpResGboolean"), [setOpResGssize]("GI.Gio.Objects.SimpleAsyncResult#g:method:setOpResGssize"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

    #if defined(ENABLE_OVERLOADING)
        ResolveSimpleAsyncResultMethod          ,
    #endif

    -- ** complete #method:complete#

    #if defined(ENABLE_OVERLOADING)
        SimpleAsyncResultCompleteMethodInfo     ,
    #endif
        simpleAsyncResultComplete               ,

    -- ** completeInIdle #method:completeInIdle#

    #if defined(ENABLE_OVERLOADING)
        SimpleAsyncResultCompleteInIdleMethodInfo,
    #endif
        simpleAsyncResultCompleteInIdle         ,

    -- ** getOpResGboolean #method:getOpResGboolean#

    #if defined(ENABLE_OVERLOADING)
        SimpleAsyncResultGetOpResGbooleanMethodInfo,
    #endif
        simpleAsyncResultGetOpResGboolean       ,

    -- ** getOpResGssize #method:getOpResGssize#

    #if defined(ENABLE_OVERLOADING)
        SimpleAsyncResultGetOpResGssizeMethodInfo,
    #endif
        simpleAsyncResultGetOpResGssize         ,

    -- ** isValid #method:isValid#

        simpleAsyncResultIsValid                ,

    -- ** new #method:new#

        simpleAsyncResultNew                    ,

    -- ** newFromError #method:newFromError#

        simpleAsyncResultNewFromError           ,

    -- ** propagateError #method:propagateError#

    #if defined(ENABLE_OVERLOADING)
        SimpleAsyncResultPropagateErrorMethodInfo,
    #endif
        simpleAsyncResultPropagateError         ,

    -- ** setCheckCancellable #method:setCheckCancellable#

    #if defined(ENABLE_OVERLOADING)
        SimpleAsyncResultSetCheckCancellableMethodInfo,
    #endif
        simpleAsyncResultSetCheckCancellable    ,

    -- ** setFromError #method:setFromError#

    #if defined(ENABLE_OVERLOADING)
        SimpleAsyncResultSetFromErrorMethodInfo ,
    #endif
        simpleAsyncResultSetFromError           ,

    -- ** setHandleCancellation #method:setHandleCancellation#

    #if defined(ENABLE_OVERLOADING)
        SimpleAsyncResultSetHandleCancellationMethodInfo,
    #endif
        simpleAsyncResultSetHandleCancellation  ,

    -- ** setOpResGboolean #method:setOpResGboolean#

    #if defined(ENABLE_OVERLOADING)
        SimpleAsyncResultSetOpResGbooleanMethodInfo,
    #endif
        simpleAsyncResultSetOpResGboolean       ,

    -- ** setOpResGssize #method:setOpResGssize#

    #if defined(ENABLE_OVERLOADING)
        SimpleAsyncResultSetOpResGssizeMethodInfo,
    #endif
        simpleAsyncResultSetOpResGssize         ,

        ) where

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

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

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

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

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

    foreign import ccall "g_simple_async_result_get_type"
        c_g_simple_async_result_get_type :: IO B.Types.GType

    instance B.Types.TypedObject SimpleAsyncResult where
        glibType :: IO GType
    glibType = IO GType
    c_g_simple_async_result_get_type

    instance B.Types.GObject SimpleAsyncResult

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

    instance O.HasParentTypes SimpleAsyncResult
    type instance O.ParentTypes SimpleAsyncResult = '[GObject.Object.Object, Gio.AsyncResult.AsyncResult]

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

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

    #if defined(ENABLE_OVERLOADING)
    type family ResolveSimpleAsyncResultMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveSimpleAsyncResultMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveSimpleAsyncResultMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveSimpleAsyncResultMethod "complete" o = SimpleAsyncResultCompleteMethodInfo
        ResolveSimpleAsyncResultMethod "completeInIdle" o = SimpleAsyncResultCompleteInIdleMethodInfo
        ResolveSimpleAsyncResultMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveSimpleAsyncResultMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveSimpleAsyncResultMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveSimpleAsyncResultMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveSimpleAsyncResultMethod "isTagged" o = Gio.AsyncResult.AsyncResultIsTaggedMethodInfo
        ResolveSimpleAsyncResultMethod "legacyPropagateError" o = Gio.AsyncResult.AsyncResultLegacyPropagateErrorMethodInfo
        ResolveSimpleAsyncResultMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveSimpleAsyncResultMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveSimpleAsyncResultMethod "propagateError" o = SimpleAsyncResultPropagateErrorMethodInfo
        ResolveSimpleAsyncResultMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveSimpleAsyncResultMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveSimpleAsyncResultMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveSimpleAsyncResultMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveSimpleAsyncResultMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveSimpleAsyncResultMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveSimpleAsyncResultMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveSimpleAsyncResultMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveSimpleAsyncResultMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveSimpleAsyncResultMethod "getOpResGboolean" o = SimpleAsyncResultGetOpResGbooleanMethodInfo
        ResolveSimpleAsyncResultMethod "getOpResGssize" o = SimpleAsyncResultGetOpResGssizeMethodInfo
        ResolveSimpleAsyncResultMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveSimpleAsyncResultMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveSimpleAsyncResultMethod "getSourceObject" o = Gio.AsyncResult.AsyncResultGetSourceObjectMethodInfo
        ResolveSimpleAsyncResultMethod "getUserData" o = Gio.AsyncResult.AsyncResultGetUserDataMethodInfo
        ResolveSimpleAsyncResultMethod "setCheckCancellable" o = SimpleAsyncResultSetCheckCancellableMethodInfo
        ResolveSimpleAsyncResultMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveSimpleAsyncResultMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveSimpleAsyncResultMethod "setFromError" o = SimpleAsyncResultSetFromErrorMethodInfo
        ResolveSimpleAsyncResultMethod "setHandleCancellation" o = SimpleAsyncResultSetHandleCancellationMethodInfo
        ResolveSimpleAsyncResultMethod "setOpResGboolean" o = SimpleAsyncResultSetOpResGbooleanMethodInfo
        ResolveSimpleAsyncResultMethod "setOpResGssize" o = SimpleAsyncResultSetOpResGssizeMethodInfo
        ResolveSimpleAsyncResultMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveSimpleAsyncResultMethod l o = O.MethodResolutionFailed l o

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

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

    #endif

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

    #endif

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

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    #endif

    -- method SimpleAsyncResult::new
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "source_object"
    --           , argType =
    --               TInterface Name { namespace = "GObject" , name = "Object" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GObject, or %NULL."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "callback"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GAsyncReadyCallback."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeAsync
    --           , argClosure = 2
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "user_data"
    --           , argType = TBasicType TPtr
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "user data passed to @callback."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "source_tag"
    --           , argType = TBasicType TPtr
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the asynchronous function."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface
    --                  Name { namespace = "Gio" , name = "SimpleAsyncResult" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_async_result_new" g_simple_async_result_new ::
        Ptr GObject.Object.Object ->            -- source_object : TInterface (Name {namespace = "GObject", name = "Object"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        Ptr () ->                               -- source_tag : TBasicType TPtr
        IO (Ptr SimpleAsyncResult)

    {-# DEPRECATED simpleAsyncResultNew ["(Since version 2.46)","Use 'GI.Gio.Objects.Task.taskNew' instead."] #-}
    -- | Creates a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.
    --
    -- The common convention is to create the t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult' in the
    -- function that starts the asynchronous operation and use that same
    -- function as the /@sourceTag@/.
    --
    -- If your operation supports cancellation with t'GI.Gio.Objects.Cancellable.Cancellable' (which it
    -- probably should) then you should provide the user\'s cancellable to
    -- 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultSetCheckCancellable' immediately after
    -- this function returns.
    simpleAsyncResultNew ::
        (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
        Maybe (a)
        -- ^ /@sourceObject@/: a t'GI.GObject.Objects.Object.Object', or 'P.Nothing'.
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'.
        -> Ptr ()
        -- ^ /@sourceTag@/: the asynchronous function.
        -> m SimpleAsyncResult
        -- ^ __Returns:__ a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.
    simpleAsyncResultNew :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    Maybe a
    -> Maybe AsyncReadyCallback -> Ptr () -> m SimpleAsyncResult
    simpleAsyncResultNew Maybe a
    sourceObject Maybe AsyncReadyCallback
    callback Ptr ()
    sourceTag = IO SimpleAsyncResult -> m SimpleAsyncResult
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SimpleAsyncResult -> m SimpleAsyncResult)
    -> IO SimpleAsyncResult -> m SimpleAsyncResult
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    maybeSourceObject <- case Maybe a
    sourceObject of
            Maybe a
    Nothing -> Ptr Object -> IO (Ptr Object)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Object
    forall a. Ptr a
    nullPtr
            Just a
    jSourceObject -> do
                Ptr Object
    jSourceObject' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    jSourceObject
                Ptr Object -> IO (Ptr Object)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Object
    jSourceObject'
        FunPtr C_AsyncReadyCallback
    maybeCallback <- case Maybe AsyncReadyCallback
    callback of
            Maybe AsyncReadyCallback
    Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Ptr Any -> FunPtr C_AsyncReadyCallback
    forall a b. Ptr a -> FunPtr b
    castPtrToFunPtr Ptr Any
    forall a. Ptr a
    nullPtr)
            Just 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 a. a -> IO a
    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 SimpleAsyncResult
    result <- Ptr Object
    -> FunPtr C_AsyncReadyCallback
    -> Ptr ()
    -> Ptr ()
    -> IO (Ptr SimpleAsyncResult)
    g_simple_async_result_new Ptr Object
    maybeSourceObject FunPtr C_AsyncReadyCallback
    maybeCallback Ptr ()
    forall a. Ptr a
    userData Ptr ()
    sourceTag
        Text -> Ptr SimpleAsyncResult -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "simpleAsyncResultNew" Ptr SimpleAsyncResult
    result
        SimpleAsyncResult
    result' <- ((ManagedPtr SimpleAsyncResult -> SimpleAsyncResult)
    -> Ptr SimpleAsyncResult -> IO SimpleAsyncResult
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr SimpleAsyncResult -> SimpleAsyncResult
    SimpleAsyncResult) Ptr SimpleAsyncResult
    result
        Maybe a -> (a -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe a
    sourceObject a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        SimpleAsyncResult -> IO SimpleAsyncResult
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return SimpleAsyncResult
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method SimpleAsyncResult::new_from_error
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "source_object"
    --           , argType =
    --               TInterface Name { namespace = "GObject" , name = "Object" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GObject, or %NULL."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "callback"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GAsyncReadyCallback."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeAsync
    --           , argClosure = 2
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "user_data"
    --           , argType = TBasicType TPtr
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "user data passed to @callback."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "error"
    --           , argType = TError
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GError" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface
    --                  Name { namespace = "Gio" , name = "SimpleAsyncResult" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_async_result_new_from_error" g_simple_async_result_new_from_error ::
        Ptr GObject.Object.Object ->            -- source_object : TInterface (Name {namespace = "GObject", name = "Object"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        Ptr GError ->                           -- error : TError
        IO (Ptr SimpleAsyncResult)

    {-# DEPRECATED simpleAsyncResultNewFromError ["(Since version 2.46)","Use 'GI.Gio.Objects.Task.taskNew' and 'GI.Gio.Objects.Task.taskReturnError' instead."] #-}
    -- | Creates a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult' from an error condition.
    simpleAsyncResultNewFromError ::
        (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
        Maybe (a)
        -- ^ /@sourceObject@/: a t'GI.GObject.Objects.Object.Object', or 'P.Nothing'.
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'.
        -> GError
        -- ^ /@error@/: a t'GError'
        -> m SimpleAsyncResult
        -- ^ __Returns:__ a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.
    simpleAsyncResultNewFromError :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsObject a) =>
    Maybe a
    -> Maybe AsyncReadyCallback -> GError -> m SimpleAsyncResult
    simpleAsyncResultNewFromError Maybe a
    sourceObject Maybe AsyncReadyCallback
    callback GError
    error_ = IO SimpleAsyncResult -> m SimpleAsyncResult
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SimpleAsyncResult -> m SimpleAsyncResult)
    -> IO SimpleAsyncResult -> m SimpleAsyncResult
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Object
    maybeSourceObject <- case Maybe a
    sourceObject of
            Maybe a
    Nothing -> Ptr Object -> IO (Ptr Object)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Object
    forall a. Ptr a
    nullPtr
            Just a
    jSourceObject -> do
                Ptr Object
    jSourceObject' <- a -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    jSourceObject
                Ptr Object -> IO (Ptr Object)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Object
    jSourceObject'
        FunPtr C_AsyncReadyCallback
    maybeCallback <- case Maybe AsyncReadyCallback
    callback of
            Maybe AsyncReadyCallback
    Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Ptr Any -> FunPtr C_AsyncReadyCallback
    forall a b. Ptr a -> FunPtr b
    castPtrToFunPtr Ptr Any
    forall a. Ptr a
    nullPtr)
            Just 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 a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return FunPtr C_AsyncReadyCallback
    jCallback'
        Ptr GError
    error_' <- GError -> IO (Ptr GError)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr GError
    error_
        let userData :: Ptr a
    userData = Ptr a
    forall a. Ptr a
    nullPtr
        Ptr SimpleAsyncResult
    result <- Ptr Object
    -> FunPtr C_AsyncReadyCallback
    -> Ptr ()
    -> Ptr GError
    -> IO (Ptr SimpleAsyncResult)
    g_simple_async_result_new_from_error Ptr Object
    maybeSourceObject FunPtr C_AsyncReadyCallback
    maybeCallback Ptr ()
    forall a. Ptr a
    userData Ptr GError
    error_'
        Text -> Ptr SimpleAsyncResult -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "simpleAsyncResultNewFromError" Ptr SimpleAsyncResult
    result
        SimpleAsyncResult
    result' <- ((ManagedPtr SimpleAsyncResult -> SimpleAsyncResult)
    -> Ptr SimpleAsyncResult -> IO SimpleAsyncResult
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr SimpleAsyncResult -> SimpleAsyncResult
    SimpleAsyncResult) Ptr SimpleAsyncResult
    result
        Maybe a -> (a -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe a
    sourceObject a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        GError -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr GError
    error_
        SimpleAsyncResult -> IO SimpleAsyncResult
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return SimpleAsyncResult
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method SimpleAsyncResult::complete
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "simple"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "SimpleAsyncResult" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSimpleAsyncResult."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_async_result_complete" g_simple_async_result_complete ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        IO ()

    {-# DEPRECATED simpleAsyncResultComplete ["(Since version 2.46)","Use t'GI.Gio.Objects.Task.Task' instead."] #-}
    -- | Completes an asynchronous I\/O job immediately. Must be called in
    -- the thread where the asynchronous result was to be delivered, as it
    -- invokes the callback directly. If you are in a different thread use
    -- 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultCompleteInIdle'.
    --
    -- Calling this function takes a reference to /@simple@/ for as long as
    -- is needed to complete the call.
    simpleAsyncResultComplete ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        -- ^ /@simple@/: a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.
        -> m ()
    simpleAsyncResultComplete :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
    a -> m ()
    simpleAsyncResultComplete a
    simple = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr SimpleAsyncResult
    simple' <- a -> IO (Ptr SimpleAsyncResult)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    simple
        Ptr SimpleAsyncResult -> IO ()
    g_simple_async_result_complete Ptr SimpleAsyncResult
    simple'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    simple
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data SimpleAsyncResultCompleteMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsSimpleAsyncResult a) => O.OverloadedMethod SimpleAsyncResultCompleteMethodInfo a signature where
        overloadedMethod = simpleAsyncResultComplete

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

    #endif

    -- method SimpleAsyncResult::complete_in_idle
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "simple"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "SimpleAsyncResult" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSimpleAsyncResult."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_async_result_complete_in_idle" g_simple_async_result_complete_in_idle ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        IO ()

    {-# DEPRECATED simpleAsyncResultCompleteInIdle ["(Since version 2.46)","Use t'GI.Gio.Objects.Task.Task' instead."] #-}
    -- | Completes an asynchronous function in an idle handler in the
    -- [thread-default main context][g-main-context-push-thread-default]
    -- of the thread that /@simple@/ was initially created in
    -- (and re-pushes that context around the invocation of the callback).
    --
    -- Calling this function takes a reference to /@simple@/ for as long as
    -- is needed to complete the call.
    simpleAsyncResultCompleteInIdle ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        -- ^ /@simple@/: a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.
        -> m ()
    simpleAsyncResultCompleteInIdle :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
    a -> m ()
    simpleAsyncResultCompleteInIdle a
    simple = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr SimpleAsyncResult
    simple' <- a -> IO (Ptr SimpleAsyncResult)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    simple
        Ptr SimpleAsyncResult -> IO ()
    g_simple_async_result_complete_in_idle Ptr SimpleAsyncResult
    simple'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    simple
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data SimpleAsyncResultCompleteInIdleMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsSimpleAsyncResult a) => O.OverloadedMethod SimpleAsyncResultCompleteInIdleMethodInfo a signature where
        overloadedMethod = simpleAsyncResultCompleteInIdle

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

    #endif

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

    foreign import ccall "g_simple_async_result_get_op_res_gboolean" g_simple_async_result_get_op_res_gboolean ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        IO CInt

    {-# DEPRECATED simpleAsyncResultGetOpResGboolean ["(Since version 2.46)","Use t'GI.Gio.Objects.Task.Task' and 'GI.Gio.Objects.Task.taskPropagateBoolean' instead."] #-}
    -- | Gets the operation result boolean from within the asynchronous result.
    simpleAsyncResultGetOpResGboolean ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        -- ^ /@simple@/: a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.
        -> m Bool
        -- ^ __Returns:__ 'P.True' if the operation\'s result was 'P.True', 'P.False'
        --     if the operation\'s result was 'P.False'.
    simpleAsyncResultGetOpResGboolean :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
    a -> m Bool
    simpleAsyncResultGetOpResGboolean a
    simple = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr SimpleAsyncResult
    simple' <- a -> IO (Ptr SimpleAsyncResult)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    simple
        CInt
    result <- Ptr SimpleAsyncResult -> IO CInt
    g_simple_async_result_get_op_res_gboolean Ptr SimpleAsyncResult
    simple'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    simple
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data SimpleAsyncResultGetOpResGbooleanMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsSimpleAsyncResult a) => O.OverloadedMethod SimpleAsyncResultGetOpResGbooleanMethodInfo a signature where
        overloadedMethod = simpleAsyncResultGetOpResGboolean

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

    #endif

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

    foreign import ccall "g_simple_async_result_get_op_res_gssize" g_simple_async_result_get_op_res_gssize ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        IO Int64

    {-# DEPRECATED simpleAsyncResultGetOpResGssize ["(Since version 2.46)","Use t'GI.Gio.Objects.Task.Task' and 'GI.Gio.Objects.Task.taskPropagateInt' instead."] #-}
    -- | Gets a gssize from the asynchronous result.
    simpleAsyncResultGetOpResGssize ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        -- ^ /@simple@/: a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.
        -> m Int64
        -- ^ __Returns:__ a gssize returned from the asynchronous function.
    simpleAsyncResultGetOpResGssize :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
    a -> m Int64
    simpleAsyncResultGetOpResGssize a
    simple = IO Int64 -> m Int64
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr SimpleAsyncResult
    simple' <- a -> IO (Ptr SimpleAsyncResult)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    simple
        Int64
    result <- Ptr SimpleAsyncResult -> IO Int64
    g_simple_async_result_get_op_res_gssize Ptr SimpleAsyncResult
    simple'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    simple
        Int64 -> IO Int64
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int64
    result

    #if defined(ENABLE_OVERLOADING)
    data SimpleAsyncResultGetOpResGssizeMethodInfo
    instance (signature ~ (m Int64), MonadIO m, IsSimpleAsyncResult a) => O.OverloadedMethod SimpleAsyncResultGetOpResGssizeMethodInfo a signature where
        overloadedMethod = simpleAsyncResultGetOpResGssize

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

    #endif

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

    foreign import ccall "g_simple_async_result_propagate_error" g_simple_async_result_propagate_error ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {-# DEPRECATED simpleAsyncResultPropagateError ["(Since version 2.46)","Use t'GI.Gio.Objects.Task.Task' instead."] #-}
    -- | Propagates an error from within the simple asynchronous result to
    -- a given destination.
    --
    -- If the t'GI.Gio.Objects.Cancellable.Cancellable' given to a prior call to
    -- 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultSetCheckCancellable' is cancelled then this
    -- function will return 'P.True' with /@dest@/ set appropriately.
    simpleAsyncResultPropagateError ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        -- ^ /@simple@/: a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.
        -> m ()
        -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
    simpleAsyncResultPropagateError :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
    a -> m ()
    simpleAsyncResultPropagateError a
    simple = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr SimpleAsyncResult
    simple' <- a -> IO (Ptr SimpleAsyncResult)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    simple
        IO () -> IO () -> IO ()
    forall a b. IO a -> IO b -> IO a
    onException (do
            CInt
    _ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
    forall a. (Ptr (Ptr GError) -> IO a) -> IO a
    propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
    -> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ Ptr SimpleAsyncResult -> Ptr (Ptr GError) -> IO CInt
    g_simple_async_result_propagate_error Ptr SimpleAsyncResult
    simple'
            a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    simple
            () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
         ) (do
            () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data SimpleAsyncResultPropagateErrorMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsSimpleAsyncResult a) => O.OverloadedMethod SimpleAsyncResultPropagateErrorMethodInfo a signature where
        overloadedMethod = simpleAsyncResultPropagateError

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

    #endif

    -- method SimpleAsyncResult::set_check_cancellable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "simple"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "SimpleAsyncResult" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSimpleAsyncResult"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "check_cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GCancellable to check, or %NULL to unset"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_async_result_set_check_cancellable" g_simple_async_result_set_check_cancellable ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        Ptr Gio.Cancellable.Cancellable ->      -- check_cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        IO ()

    {-# DEPRECATED simpleAsyncResultSetCheckCancellable ["(Since version 2.46)","Use t'GI.Gio.Objects.Task.Task' instead."] #-}
    -- | Sets a t'GI.Gio.Objects.Cancellable.Cancellable' to check before dispatching results.
    --
    -- This function has one very specific purpose: the provided cancellable
    -- is checked at the time of 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultPropagateError' If
    -- it is cancelled, these functions will return an \"Operation was
    -- cancelled\" error ('GI.Gio.Enums.IOErrorEnumCancelled').
    --
    -- Implementors of cancellable asynchronous functions should use this in
    -- order to provide a guarantee to their callers that cancelling an
    -- async operation will reliably result in an error being returned for
    -- that operation (even if a positive result for the operation has
    -- already been sent as an idle to the main context to be dispatched).
    --
    -- The checking described above is done regardless of any call to the
    -- unrelated 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultSetHandleCancellation' function.
    --
    -- /Since: 2.32/
    simpleAsyncResultSetCheckCancellable ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a, Gio.Cancellable.IsCancellable b) =>
        a
        -- ^ /@simple@/: a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'
        -> Maybe (b)
        -- ^ /@checkCancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable' to check, or 'P.Nothing' to unset
        -> m ()
    simpleAsyncResultSetCheckCancellable :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsSimpleAsyncResult a,
     IsCancellable b) =>
    a -> Maybe b -> m ()
    simpleAsyncResultSetCheckCancellable a
    simple Maybe b
    checkCancellable = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr SimpleAsyncResult
    simple' <- a -> IO (Ptr SimpleAsyncResult)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    simple
        Ptr Cancellable
    maybeCheckCancellable <- case Maybe b
    checkCancellable of
            Maybe b
    Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    nullPtr
            Just b
    jCheckCancellable -> do
                Ptr Cancellable
    jCheckCancellable' <- b -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCheckCancellable
                Ptr Cancellable -> IO (Ptr Cancellable)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    jCheckCancellable'
        Ptr SimpleAsyncResult -> Ptr Cancellable -> IO ()
    g_simple_async_result_set_check_cancellable Ptr SimpleAsyncResult
    simple' Ptr Cancellable
    maybeCheckCancellable
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    simple
        Maybe b -> (b -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe b
    checkCancellable b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

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

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

    #endif

    -- method SimpleAsyncResult::set_from_error
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "simple"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "SimpleAsyncResult" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSimpleAsyncResult."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "error"
    --           , argType = TError
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "#GError." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_async_result_set_from_error" g_simple_async_result_set_from_error ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        Ptr GError ->                           -- error : TError
        IO ()

    {-# DEPRECATED simpleAsyncResultSetFromError ["(Since version 2.46)","Use t'GI.Gio.Objects.Task.Task' and 'GI.Gio.Objects.Task.taskReturnError' instead."] #-}
    -- | Sets the result from a t'GError'.
    simpleAsyncResultSetFromError ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        -- ^ /@simple@/: a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.
        -> GError
        -- ^ /@error@/: t'GError'.
        -> m ()
    simpleAsyncResultSetFromError :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
    a -> GError -> m ()
    simpleAsyncResultSetFromError a
    simple GError
    error_ = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr SimpleAsyncResult
    simple' <- a -> IO (Ptr SimpleAsyncResult)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    simple
        Ptr GError
    error_' <- GError -> IO (Ptr GError)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr GError
    error_
        Ptr SimpleAsyncResult -> Ptr GError -> IO ()
    g_simple_async_result_set_from_error Ptr SimpleAsyncResult
    simple' Ptr GError
    error_'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    simple
        GError -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr GError
    error_
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data SimpleAsyncResultSetFromErrorMethodInfo
    instance (signature ~ (GError -> m ()), MonadIO m, IsSimpleAsyncResult a) => O.OverloadedMethod SimpleAsyncResultSetFromErrorMethodInfo a signature where
        overloadedMethod = simpleAsyncResultSetFromError

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

    #endif

    -- method SimpleAsyncResult::set_handle_cancellation
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "simple"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "SimpleAsyncResult" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSimpleAsyncResult."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "handle_cancellation"
    --           , argType = TBasicType TBoolean
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gboolean." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_async_result_set_handle_cancellation" g_simple_async_result_set_handle_cancellation ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        CInt ->                                 -- handle_cancellation : TBasicType TBoolean
        IO ()

    {-# DEPRECATED simpleAsyncResultSetHandleCancellation ["(Since version 2.46)"] #-}
    -- | Sets whether to handle cancellation within the asynchronous operation.
    --
    -- This function has nothing to do with
    -- 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultSetCheckCancellable'.  It only refers to the
    -- t'GI.Gio.Objects.Cancellable.Cancellable' passed to @/g_simple_async_result_run_in_thread()/@.
    simpleAsyncResultSetHandleCancellation ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        -- ^ /@simple@/: a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.
        -> Bool
        -- ^ /@handleCancellation@/: a t'P.Bool'.
        -> m ()
    simpleAsyncResultSetHandleCancellation :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
    a -> Bool -> m ()
    simpleAsyncResultSetHandleCancellation a
    simple Bool
    handleCancellation = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr SimpleAsyncResult
    simple' <- a -> IO (Ptr SimpleAsyncResult)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    simple
        let handleCancellation' :: CInt
    handleCancellation' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    handleCancellation
        Ptr SimpleAsyncResult -> CInt -> IO ()
    g_simple_async_result_set_handle_cancellation Ptr SimpleAsyncResult
    simple' CInt
    handleCancellation'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    simple
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data SimpleAsyncResultSetHandleCancellationMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsSimpleAsyncResult a) => O.OverloadedMethod SimpleAsyncResultSetHandleCancellationMethodInfo a signature where
        overloadedMethod = simpleAsyncResultSetHandleCancellation

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

    #endif

    -- method SimpleAsyncResult::set_op_res_gboolean
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "simple"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "SimpleAsyncResult" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSimpleAsyncResult."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "op_res"
    --           , argType = TBasicType TBoolean
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gboolean." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_async_result_set_op_res_gboolean" g_simple_async_result_set_op_res_gboolean ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        CInt ->                                 -- op_res : TBasicType TBoolean
        IO ()

    {-# DEPRECATED simpleAsyncResultSetOpResGboolean ["(Since version 2.46)","Use t'GI.Gio.Objects.Task.Task' and 'GI.Gio.Objects.Task.taskReturnBoolean' instead."] #-}
    -- | Sets the operation result to a boolean within the asynchronous result.
    simpleAsyncResultSetOpResGboolean ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        -- ^ /@simple@/: a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.
        -> Bool
        -- ^ /@opRes@/: a t'P.Bool'.
        -> m ()
    simpleAsyncResultSetOpResGboolean :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
    a -> Bool -> m ()
    simpleAsyncResultSetOpResGboolean a
    simple Bool
    opRes = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr SimpleAsyncResult
    simple' <- a -> IO (Ptr SimpleAsyncResult)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    simple
        let opRes' :: CInt
    opRes' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    opRes
        Ptr SimpleAsyncResult -> CInt -> IO ()
    g_simple_async_result_set_op_res_gboolean Ptr SimpleAsyncResult
    simple' CInt
    opRes'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    simple
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data SimpleAsyncResultSetOpResGbooleanMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsSimpleAsyncResult a) => O.OverloadedMethod SimpleAsyncResultSetOpResGbooleanMethodInfo a signature where
        overloadedMethod = simpleAsyncResultSetOpResGboolean

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

    #endif

    -- method SimpleAsyncResult::set_op_res_gssize
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "simple"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "SimpleAsyncResult" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GSimpleAsyncResult."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "op_res"
    --           , argType = TBasicType TInt64
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #gssize." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_async_result_set_op_res_gssize" g_simple_async_result_set_op_res_gssize ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        Int64 ->                                -- op_res : TBasicType TInt64
        IO ()

    {-# DEPRECATED simpleAsyncResultSetOpResGssize ["(Since version 2.46)","Use t'GI.Gio.Objects.Task.Task' and 'GI.Gio.Objects.Task.taskReturnInt' instead."] #-}
    -- | Sets the operation result within the asynchronous result to
    -- the given /@opRes@/.
    simpleAsyncResultSetOpResGssize ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        -- ^ /@simple@/: a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.
        -> Int64
        -- ^ /@opRes@/: a @/gssize/@.
        -> m ()
    simpleAsyncResultSetOpResGssize :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
    a -> Int64 -> m ()
    simpleAsyncResultSetOpResGssize a
    simple Int64
    opRes = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr SimpleAsyncResult
    simple' <- a -> IO (Ptr SimpleAsyncResult)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    simple
        Ptr SimpleAsyncResult -> Int64 -> IO ()
    g_simple_async_result_set_op_res_gssize Ptr SimpleAsyncResult
    simple' Int64
    opRes
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    simple
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data SimpleAsyncResultSetOpResGssizeMethodInfo
    instance (signature ~ (Int64 -> m ()), MonadIO m, IsSimpleAsyncResult a) => O.OverloadedMethod SimpleAsyncResultSetOpResGssizeMethodInfo a signature where
        overloadedMethod = simpleAsyncResultSetOpResGssize

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

    #endif

    -- method SimpleAsyncResult::is_valid
    -- method type : MemberFunction
    -- Args: [ Arg
    --           { argCName = "result"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the #GAsyncResult passed to the _finish function."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "source"
    --           , argType =
    --               TInterface Name { namespace = "GObject" , name = "Object" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #GObject passed to the _finish function."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "source_tag"
    --           , argType = TBasicType TPtr
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the asynchronous function."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_async_result_is_valid" g_simple_async_result_is_valid ::
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr GObject.Object.Object ->            -- source : TInterface (Name {namespace = "GObject", name = "Object"})
        Ptr () ->                               -- source_tag : TBasicType TPtr
        IO CInt

    {-# DEPRECATED simpleAsyncResultIsValid ["(Since version 2.46)","Use t'GI.Gio.Objects.Task.Task' and 'GI.Gio.Objects.Task.taskIsValid' instead."] #-}
    -- | Ensures that the data passed to the _finish function of an async
    -- operation is consistent.  Three checks are performed.
    --
    -- First, /@result@/ is checked to ensure that it is really a
    -- t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.  Second, /@source@/ is checked to ensure that it
    -- matches the source object of /@result@/.  Third, /@sourceTag@/ is
    -- checked to ensure that it is equal to the /@sourceTag@/ argument given
    -- to 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultNew' (which, by convention, is a pointer
    -- to the _async function corresponding to the _finish function from
    -- which this function is called).  (Alternatively, if either
    -- /@sourceTag@/ or /@result@/\'s source tag is 'P.Nothing', then the source tag
    -- check is skipped.)
    --
    -- /Since: 2.20/
    simpleAsyncResultIsValid ::
        (B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a, GObject.Object.IsObject b) =>
        a
        -- ^ /@result@/: the t'GI.Gio.Interfaces.AsyncResult.AsyncResult' passed to the _finish function.
        -> Maybe (b)
        -- ^ /@source@/: the t'GI.GObject.Objects.Object.Object' passed to the _finish function.
        -> Ptr ()
        -- ^ /@sourceTag@/: the asynchronous function.
        -> m Bool
        -- ^ __Returns:__ @/TRUE/@ if all checks passed or @/FALSE/@ if any failed.
    simpleAsyncResultIsValid :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsAsyncResult a, IsObject b) =>
    a -> Maybe b -> Ptr () -> m Bool
    simpleAsyncResultIsValid a
    result_ Maybe b
    source Ptr ()
    sourceTag = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr AsyncResult
    result_' <- a -> IO (Ptr AsyncResult)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    result_
        Ptr Object
    maybeSource <- case Maybe b
    source of
            Maybe b
    Nothing -> Ptr Object -> IO (Ptr Object)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Object
    forall a. Ptr a
    nullPtr
            Just b
    jSource -> do
                Ptr Object
    jSource' <- b -> IO (Ptr Object)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jSource
                Ptr Object -> IO (Ptr Object)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Object
    jSource'
        CInt
    result <- Ptr AsyncResult -> Ptr Object -> Ptr () -> IO CInt
    g_simple_async_result_is_valid Ptr AsyncResult
    result_' Ptr Object
    maybeSource Ptr ()
    sourceTag
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    result_
        Maybe b -> (b -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe b
    source b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif