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

module GI.OSTree.Objects.AsyncProgress
    ( 

-- * Exported types
    AsyncProgress(..)                       ,
    IsAsyncProgress                         ,
    toAsyncProgress                         ,
    noAsyncProgress                         ,


 -- * Methods
-- ** finish #method:finish#
    AsyncProgressFinishMethodInfo           ,
    asyncProgressFinish                     ,


-- ** getStatus #method:getStatus#
    AsyncProgressGetStatusMethodInfo        ,
    asyncProgressGetStatus                  ,


-- ** getUint #method:getUint#
    AsyncProgressGetUintMethodInfo          ,
    asyncProgressGetUint                    ,


-- ** getUint64 #method:getUint64#
    AsyncProgressGetUint64MethodInfo        ,
    asyncProgressGetUint64                  ,


-- ** new #method:new#
    asyncProgressNew                        ,


-- ** newAndConnect #method:newAndConnect#
    asyncProgressNewAndConnect              ,


-- ** setStatus #method:setStatus#
    AsyncProgressSetStatusMethodInfo        ,
    asyncProgressSetStatus                  ,


-- ** setUint #method:setUint#
    AsyncProgressSetUintMethodInfo          ,
    asyncProgressSetUint                    ,


-- ** setUint64 #method:setUint64#
    AsyncProgressSetUint64MethodInfo        ,
    asyncProgressSetUint64                  ,




 -- * Signals
-- ** changed #signal:changed#
    AsyncProgressChangedCallback            ,
    AsyncProgressChangedSignalInfo          ,
    C_AsyncProgressChangedCallback          ,
    afterAsyncProgressChanged               ,
    genClosure_AsyncProgressChanged         ,
    mk_AsyncProgressChangedCallback         ,
    noAsyncProgressChangedCallback          ,
    onAsyncProgressChanged                  ,
    wrap_AsyncProgressChangedCallback       ,




    ) where

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

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

import qualified GI.GObject.Objects.Object as GObject.Object

newtype AsyncProgress = AsyncProgress (ManagedPtr AsyncProgress)
foreign import ccall "ostree_async_progress_get_type"
    c_ostree_async_progress_get_type :: IO GType

instance GObject AsyncProgress where
    gobjectType _ = c_ostree_async_progress_get_type
    

class GObject o => IsAsyncProgress o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError AsyncProgress a) =>
    IsAsyncProgress a
#endif
instance IsAsyncProgress AsyncProgress
instance GObject.Object.IsObject AsyncProgress

toAsyncProgress :: IsAsyncProgress o => o -> IO AsyncProgress
toAsyncProgress = unsafeCastTo AsyncProgress

noAsyncProgress :: Maybe AsyncProgress
noAsyncProgress = Nothing

type family ResolveAsyncProgressMethod (t :: Symbol) (o :: *) :: * where
    ResolveAsyncProgressMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveAsyncProgressMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveAsyncProgressMethod "finish" o = AsyncProgressFinishMethodInfo
    ResolveAsyncProgressMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveAsyncProgressMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveAsyncProgressMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveAsyncProgressMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveAsyncProgressMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveAsyncProgressMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveAsyncProgressMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveAsyncProgressMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveAsyncProgressMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveAsyncProgressMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveAsyncProgressMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveAsyncProgressMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveAsyncProgressMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveAsyncProgressMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveAsyncProgressMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveAsyncProgressMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveAsyncProgressMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveAsyncProgressMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveAsyncProgressMethod "getStatus" o = AsyncProgressGetStatusMethodInfo
    ResolveAsyncProgressMethod "getUint" o = AsyncProgressGetUintMethodInfo
    ResolveAsyncProgressMethod "getUint64" o = AsyncProgressGetUint64MethodInfo
    ResolveAsyncProgressMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveAsyncProgressMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveAsyncProgressMethod "setStatus" o = AsyncProgressSetStatusMethodInfo
    ResolveAsyncProgressMethod "setUint" o = AsyncProgressSetUintMethodInfo
    ResolveAsyncProgressMethod "setUint64" o = AsyncProgressSetUint64MethodInfo
    ResolveAsyncProgressMethod l o = O.MethodResolutionFailed l o

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

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

-- signal AsyncProgress::changed
type AsyncProgressChangedCallback =
    IO ()

noAsyncProgressChangedCallback :: Maybe AsyncProgressChangedCallback
noAsyncProgressChangedCallback = Nothing

type C_AsyncProgressChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_AsyncProgressChangedCallback :: C_AsyncProgressChangedCallback -> IO (FunPtr C_AsyncProgressChangedCallback)

genClosure_AsyncProgressChanged :: AsyncProgressChangedCallback -> IO Closure
genClosure_AsyncProgressChanged cb = do
    let cb' = wrap_AsyncProgressChangedCallback cb
    mk_AsyncProgressChangedCallback cb' >>= newCClosure


wrap_AsyncProgressChangedCallback ::
    AsyncProgressChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_AsyncProgressChangedCallback _cb _ _ = do
    _cb 


onAsyncProgressChanged :: (IsAsyncProgress a, MonadIO m) => a -> AsyncProgressChangedCallback -> m SignalHandlerId
onAsyncProgressChanged obj cb = liftIO $ do
    let cb' = wrap_AsyncProgressChangedCallback cb
    cb'' <- mk_AsyncProgressChangedCallback cb'
    connectSignalFunPtr obj "changed" cb'' SignalConnectBefore

afterAsyncProgressChanged :: (IsAsyncProgress a, MonadIO m) => a -> AsyncProgressChangedCallback -> m SignalHandlerId
afterAsyncProgressChanged obj cb = liftIO $ do
    let cb' = wrap_AsyncProgressChangedCallback cb
    cb'' <- mk_AsyncProgressChangedCallback cb'
    connectSignalFunPtr obj "changed" cb'' SignalConnectAfter


instance O.HasAttributeList AsyncProgress
type instance O.AttributeList AsyncProgress = AsyncProgressAttributeList
type AsyncProgressAttributeList = ('[ ] :: [(Symbol, *)])

data AsyncProgressChangedSignalInfo
instance SignalInfo AsyncProgressChangedSignalInfo where
    type HaskellCallbackType AsyncProgressChangedSignalInfo = AsyncProgressChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_AsyncProgressChangedCallback cb
        cb'' <- mk_AsyncProgressChangedCallback cb'
        connectSignalFunPtr obj "changed" cb'' connectMode

type instance O.SignalList AsyncProgress = AsyncProgressSignalList
type AsyncProgressSignalList = ('[ '("changed", AsyncProgressChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method AsyncProgress::new
-- method type : Constructor
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}))
-- throws : False
-- Skip return : False

foreign import ccall "ostree_async_progress_new" ostree_async_progress_new :: 
    IO (Ptr AsyncProgress)

{- |
/No description available in the introspection data./
-}
asyncProgressNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m AsyncProgress
    {- ^ __Returns:__ A new progress object -}
asyncProgressNew  = liftIO $ do
    result <- ostree_async_progress_new
    checkUnexpectedReturnNULL "asyncProgressNew" result
    result' <- (wrapObject AsyncProgress) result
    return result'

-- method AsyncProgress::new_and_connect
-- method type : Constructor
-- Args : [Arg {argCName = "changed", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}))
-- throws : False
-- Skip return : False

foreign import ccall "ostree_async_progress_new_and_connect" ostree_async_progress_new_and_connect :: 
    Ptr () ->                               -- changed : TBasicType TPtr
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO (Ptr AsyncProgress)

{- |
/No description available in the introspection data./
-}
asyncProgressNewAndConnect ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Ptr ()
    -> Ptr ()
    -> m AsyncProgress
asyncProgressNewAndConnect changed userData = liftIO $ do
    result <- ostree_async_progress_new_and_connect changed userData
    checkUnexpectedReturnNULL "asyncProgressNewAndConnect" result
    result' <- (wrapObject AsyncProgress) result
    return result'

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

foreign import ccall "ostree_async_progress_finish" ostree_async_progress_finish :: 
    Ptr AsyncProgress ->                    -- self : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"})
    IO ()

{- |
Process any pending signals, ensuring the main context is cleared
of sources used by this object.  Also ensures that no further
events will be queued.
-}
asyncProgressFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) =>
    a
    {- ^ /@self@/: Self -}
    -> m ()
asyncProgressFinish self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    ostree_async_progress_finish self'
    touchManagedPtr self
    return ()

data AsyncProgressFinishMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressFinishMethodInfo a signature where
    overloadedMethod _ = asyncProgressFinish

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

foreign import ccall "ostree_async_progress_get_status" ostree_async_progress_get_status :: 
    Ptr AsyncProgress ->                    -- self : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"})
    IO CString

{- |
/No description available in the introspection data./
-}
asyncProgressGetStatus ::
    (B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) =>
    a
    -> m T.Text
asyncProgressGetStatus self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- ostree_async_progress_get_status self'
    checkUnexpectedReturnNULL "asyncProgressGetStatus" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data AsyncProgressGetStatusMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressGetStatusMethodInfo a signature where
    overloadedMethod _ = asyncProgressGetStatus

-- method AsyncProgress::get_uint
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "ostree_async_progress_get_uint" ostree_async_progress_get_uint :: 
    Ptr AsyncProgress ->                    -- self : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"})
    CString ->                              -- key : TBasicType TUTF8
    IO Word32

{- |
/No description available in the introspection data./
-}
asyncProgressGetUint ::
    (B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) =>
    a
    -> T.Text
    -> m Word32
asyncProgressGetUint self key = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    key' <- textToCString key
    result <- ostree_async_progress_get_uint self' key'
    touchManagedPtr self
    freeMem key'
    return result

data AsyncProgressGetUintMethodInfo
instance (signature ~ (T.Text -> m Word32), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressGetUintMethodInfo a signature where
    overloadedMethod _ = asyncProgressGetUint

-- method AsyncProgress::get_uint64
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "ostree_async_progress_get_uint64" ostree_async_progress_get_uint64 :: 
    Ptr AsyncProgress ->                    -- self : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"})
    CString ->                              -- key : TBasicType TUTF8
    IO Word64

{- |
/No description available in the introspection data./
-}
asyncProgressGetUint64 ::
    (B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) =>
    a
    -> T.Text
    -> m Word64
asyncProgressGetUint64 self key = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    key' <- textToCString key
    result <- ostree_async_progress_get_uint64 self' key'
    touchManagedPtr self
    freeMem key'
    return result

data AsyncProgressGetUint64MethodInfo
instance (signature ~ (T.Text -> m Word64), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressGetUint64MethodInfo a signature where
    overloadedMethod _ = asyncProgressGetUint64

-- method AsyncProgress::set_status
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "status", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_async_progress_set_status" ostree_async_progress_set_status :: 
    Ptr AsyncProgress ->                    -- self : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"})
    CString ->                              -- status : TBasicType TUTF8
    IO ()

{- |
/No description available in the introspection data./
-}
asyncProgressSetStatus ::
    (B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) =>
    a
    -> T.Text
    -> m ()
asyncProgressSetStatus self status = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    status' <- textToCString status
    ostree_async_progress_set_status self' status'
    touchManagedPtr self
    freeMem status'
    return ()

data AsyncProgressSetStatusMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressSetStatusMethodInfo a signature where
    overloadedMethod _ = asyncProgressSetStatus

-- method AsyncProgress::set_uint
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_async_progress_set_uint" ostree_async_progress_set_uint :: 
    Ptr AsyncProgress ->                    -- self : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"})
    CString ->                              -- key : TBasicType TUTF8
    Word32 ->                               -- value : TBasicType TUInt
    IO ()

{- |
/No description available in the introspection data./
-}
asyncProgressSetUint ::
    (B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) =>
    a
    -> T.Text
    -> Word32
    -> m ()
asyncProgressSetUint self key value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    key' <- textToCString key
    ostree_async_progress_set_uint self' key' value
    touchManagedPtr self
    freeMem key'
    return ()

data AsyncProgressSetUintMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ()), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressSetUintMethodInfo a signature where
    overloadedMethod _ = asyncProgressSetUint

-- method AsyncProgress::set_uint64
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_async_progress_set_uint64" ostree_async_progress_set_uint64 :: 
    Ptr AsyncProgress ->                    -- self : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"})
    CString ->                              -- key : TBasicType TUTF8
    Word64 ->                               -- value : TBasicType TUInt64
    IO ()

{- |
/No description available in the introspection data./
-}
asyncProgressSetUint64 ::
    (B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) =>
    a
    -> T.Text
    -> Word64
    -> m ()
asyncProgressSetUint64 self key value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    key' <- textToCString key
    ostree_async_progress_set_uint64 self' key' value
    touchManagedPtr self
    freeMem key'
    return ()

data AsyncProgressSetUint64MethodInfo
instance (signature ~ (T.Text -> Word64 -> m ()), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressSetUint64MethodInfo a signature where
    overloadedMethod _ = asyncProgressSetUint64