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

Represents a git remote callbacks.
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.Ggit.Objects.RemoteCallbacks
    ( 

-- * Exported types
    RemoteCallbacks(..)                     ,
    IsRemoteCallbacks                       ,
    toRemoteCallbacks                       ,
    noRemoteCallbacks                       ,


 -- * Signals
-- ** completion #signal:completion#

    C_RemoteCallbacksCompletionCallback     ,
    RemoteCallbacksCompletionCallback       ,
#if ENABLE_OVERLOADING
    RemoteCallbacksCompletionSignalInfo     ,
#endif
    afterRemoteCallbacksCompletion          ,
    genClosure_RemoteCallbacksCompletion    ,
    mk_RemoteCallbacksCompletionCallback    ,
    noRemoteCallbacksCompletionCallback     ,
    onRemoteCallbacksCompletion             ,
    wrap_RemoteCallbacksCompletionCallback  ,


-- ** progress #signal:progress#

    C_RemoteCallbacksProgressCallback       ,
    RemoteCallbacksProgressCallback         ,
#if ENABLE_OVERLOADING
    RemoteCallbacksProgressSignalInfo       ,
#endif
    afterRemoteCallbacksProgress            ,
    genClosure_RemoteCallbacksProgress      ,
    mk_RemoteCallbacksProgressCallback      ,
    noRemoteCallbacksProgressCallback       ,
    onRemoteCallbacksProgress               ,
    wrap_RemoteCallbacksProgressCallback    ,


-- ** transferProgress #signal:transferProgress#

    C_RemoteCallbacksTransferProgressCallback,
    RemoteCallbacksTransferProgressCallback ,
#if ENABLE_OVERLOADING
    RemoteCallbacksTransferProgressSignalInfo,
#endif
    afterRemoteCallbacksTransferProgress    ,
    genClosure_RemoteCallbacksTransferProgress,
    mk_RemoteCallbacksTransferProgressCallback,
    noRemoteCallbacksTransferProgressCallback,
    onRemoteCallbacksTransferProgress       ,
    wrap_RemoteCallbacksTransferProgressCallback,


-- ** updateTips #signal:updateTips#

    C_RemoteCallbacksUpdateTipsCallback     ,
    RemoteCallbacksUpdateTipsCallback       ,
#if ENABLE_OVERLOADING
    RemoteCallbacksUpdateTipsSignalInfo     ,
#endif
    afterRemoteCallbacksUpdateTips          ,
    genClosure_RemoteCallbacksUpdateTips    ,
    mk_RemoteCallbacksUpdateTipsCallback    ,
    noRemoteCallbacksUpdateTipsCallback     ,
    onRemoteCallbacksUpdateTips             ,
    wrap_RemoteCallbacksUpdateTipsCallback  ,




    ) 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.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId
import {-# SOURCE #-} qualified GI.Ggit.Structs.TransferProgress as Ggit.TransferProgress

-- | Memory-managed wrapper type.
newtype RemoteCallbacks = RemoteCallbacks (ManagedPtr RemoteCallbacks)
foreign import ccall "ggit_remote_callbacks_get_type"
    c_ggit_remote_callbacks_get_type :: IO GType

instance GObject RemoteCallbacks where
    gobjectType = c_ggit_remote_callbacks_get_type
    

-- | Type class for types which can be safely cast to `RemoteCallbacks`, for instance with `toRemoteCallbacks`.
class (GObject o, O.IsDescendantOf RemoteCallbacks o) => IsRemoteCallbacks o
instance (GObject o, O.IsDescendantOf RemoteCallbacks o) => IsRemoteCallbacks o

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

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

-- | A convenience alias for `Nothing` :: `Maybe` `RemoteCallbacks`.
noRemoteCallbacks :: Maybe RemoteCallbacks
noRemoteCallbacks = Nothing

#if ENABLE_OVERLOADING
type family ResolveRemoteCallbacksMethod (t :: Symbol) (o :: *) :: * where
    ResolveRemoteCallbacksMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveRemoteCallbacksMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveRemoteCallbacksMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveRemoteCallbacksMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveRemoteCallbacksMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveRemoteCallbacksMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveRemoteCallbacksMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveRemoteCallbacksMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveRemoteCallbacksMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveRemoteCallbacksMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveRemoteCallbacksMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveRemoteCallbacksMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveRemoteCallbacksMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveRemoteCallbacksMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveRemoteCallbacksMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveRemoteCallbacksMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveRemoteCallbacksMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveRemoteCallbacksMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveRemoteCallbacksMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveRemoteCallbacksMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveRemoteCallbacksMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveRemoteCallbacksMethod l o = O.MethodResolutionFailed l o

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

#endif

-- signal RemoteCallbacks::completion
{- |
/No description available in the introspection data./
-}
type RemoteCallbacksCompletionCallback =
    Ggit.Enums.RemoteCompletionType
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `RemoteCallbacksCompletionCallback`@.
noRemoteCallbacksCompletionCallback :: Maybe RemoteCallbacksCompletionCallback
noRemoteCallbacksCompletionCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_RemoteCallbacksCompletionCallback =
    Ptr () ->                               -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_RemoteCallbacksCompletionCallback`.
foreign import ccall "wrapper"
    mk_RemoteCallbacksCompletionCallback :: C_RemoteCallbacksCompletionCallback -> IO (FunPtr C_RemoteCallbacksCompletionCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_RemoteCallbacksCompletion :: MonadIO m => RemoteCallbacksCompletionCallback -> m (GClosure C_RemoteCallbacksCompletionCallback)
genClosure_RemoteCallbacksCompletion cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksCompletionCallback cb
    mk_RemoteCallbacksCompletionCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `RemoteCallbacksCompletionCallback` into a `C_RemoteCallbacksCompletionCallback`.
wrap_RemoteCallbacksCompletionCallback ::
    RemoteCallbacksCompletionCallback ->
    C_RemoteCallbacksCompletionCallback
wrap_RemoteCallbacksCompletionCallback _cb _ object _ = do
    let object' = (toEnum . fromIntegral) object
    _cb  object'


{- |
Connect a signal handler for the “@completion@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' remoteCallbacks #completion callback
@
-}
onRemoteCallbacksCompletion :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksCompletionCallback -> m SignalHandlerId
onRemoteCallbacksCompletion obj cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksCompletionCallback cb
    cb'' <- mk_RemoteCallbacksCompletionCallback cb'
    connectSignalFunPtr obj "completion" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@completion@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' remoteCallbacks #completion callback
@
-}
afterRemoteCallbacksCompletion :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksCompletionCallback -> m SignalHandlerId
afterRemoteCallbacksCompletion obj cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksCompletionCallback cb
    cb'' <- mk_RemoteCallbacksCompletionCallback cb'
    connectSignalFunPtr obj "completion" cb'' SignalConnectAfter


-- signal RemoteCallbacks::progress
{- |
/No description available in the introspection data./
-}
type RemoteCallbacksProgressCallback =
    T.Text
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `RemoteCallbacksProgressCallback`@.
noRemoteCallbacksProgressCallback :: Maybe RemoteCallbacksProgressCallback
noRemoteCallbacksProgressCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_RemoteCallbacksProgressCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_RemoteCallbacksProgressCallback`.
foreign import ccall "wrapper"
    mk_RemoteCallbacksProgressCallback :: C_RemoteCallbacksProgressCallback -> IO (FunPtr C_RemoteCallbacksProgressCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_RemoteCallbacksProgress :: MonadIO m => RemoteCallbacksProgressCallback -> m (GClosure C_RemoteCallbacksProgressCallback)
genClosure_RemoteCallbacksProgress cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksProgressCallback cb
    mk_RemoteCallbacksProgressCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `RemoteCallbacksProgressCallback` into a `C_RemoteCallbacksProgressCallback`.
wrap_RemoteCallbacksProgressCallback ::
    RemoteCallbacksProgressCallback ->
    C_RemoteCallbacksProgressCallback
wrap_RemoteCallbacksProgressCallback _cb _ object _ = do
    object' <- cstringToText object
    _cb  object'


{- |
Connect a signal handler for the “@progress@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' remoteCallbacks #progress callback
@
-}
onRemoteCallbacksProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksProgressCallback -> m SignalHandlerId
onRemoteCallbacksProgress obj cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksProgressCallback cb
    cb'' <- mk_RemoteCallbacksProgressCallback cb'
    connectSignalFunPtr obj "progress" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@progress@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' remoteCallbacks #progress callback
@
-}
afterRemoteCallbacksProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksProgressCallback -> m SignalHandlerId
afterRemoteCallbacksProgress obj cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksProgressCallback cb
    cb'' <- mk_RemoteCallbacksProgressCallback cb'
    connectSignalFunPtr obj "progress" cb'' SignalConnectAfter


-- signal RemoteCallbacks::transfer-progress
{- |
/No description available in the introspection data./
-}
type RemoteCallbacksTransferProgressCallback =
    Ggit.TransferProgress.TransferProgress
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `RemoteCallbacksTransferProgressCallback`@.
noRemoteCallbacksTransferProgressCallback :: Maybe RemoteCallbacksTransferProgressCallback
noRemoteCallbacksTransferProgressCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_RemoteCallbacksTransferProgressCallback =
    Ptr () ->                               -- object
    Ptr Ggit.TransferProgress.TransferProgress ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_RemoteCallbacksTransferProgressCallback`.
foreign import ccall "wrapper"
    mk_RemoteCallbacksTransferProgressCallback :: C_RemoteCallbacksTransferProgressCallback -> IO (FunPtr C_RemoteCallbacksTransferProgressCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_RemoteCallbacksTransferProgress :: MonadIO m => RemoteCallbacksTransferProgressCallback -> m (GClosure C_RemoteCallbacksTransferProgressCallback)
genClosure_RemoteCallbacksTransferProgress cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksTransferProgressCallback cb
    mk_RemoteCallbacksTransferProgressCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `RemoteCallbacksTransferProgressCallback` into a `C_RemoteCallbacksTransferProgressCallback`.
wrap_RemoteCallbacksTransferProgressCallback ::
    RemoteCallbacksTransferProgressCallback ->
    C_RemoteCallbacksTransferProgressCallback
wrap_RemoteCallbacksTransferProgressCallback _cb _ object _ = do
    B.ManagedPtr.withTransient Ggit.TransferProgress.TransferProgress object $ \object' -> do
        _cb  object'


{- |
Connect a signal handler for the “@transfer-progress@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' remoteCallbacks #transferProgress callback
@
-}
onRemoteCallbacksTransferProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksTransferProgressCallback -> m SignalHandlerId
onRemoteCallbacksTransferProgress obj cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksTransferProgressCallback cb
    cb'' <- mk_RemoteCallbacksTransferProgressCallback cb'
    connectSignalFunPtr obj "transfer-progress" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@transfer-progress@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' remoteCallbacks #transferProgress callback
@
-}
afterRemoteCallbacksTransferProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksTransferProgressCallback -> m SignalHandlerId
afterRemoteCallbacksTransferProgress obj cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksTransferProgressCallback cb
    cb'' <- mk_RemoteCallbacksTransferProgressCallback cb'
    connectSignalFunPtr obj "transfer-progress" cb'' SignalConnectAfter


-- signal RemoteCallbacks::update-tips
{- |
/No description available in the introspection data./
-}
type RemoteCallbacksUpdateTipsCallback =
    T.Text
    -> Ggit.OId.OId
    -> Ggit.OId.OId
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `RemoteCallbacksUpdateTipsCallback`@.
noRemoteCallbacksUpdateTipsCallback :: Maybe RemoteCallbacksUpdateTipsCallback
noRemoteCallbacksUpdateTipsCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_RemoteCallbacksUpdateTipsCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr Ggit.OId.OId ->
    Ptr Ggit.OId.OId ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_RemoteCallbacksUpdateTipsCallback`.
foreign import ccall "wrapper"
    mk_RemoteCallbacksUpdateTipsCallback :: C_RemoteCallbacksUpdateTipsCallback -> IO (FunPtr C_RemoteCallbacksUpdateTipsCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_RemoteCallbacksUpdateTips :: MonadIO m => RemoteCallbacksUpdateTipsCallback -> m (GClosure C_RemoteCallbacksUpdateTipsCallback)
genClosure_RemoteCallbacksUpdateTips cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksUpdateTipsCallback cb
    mk_RemoteCallbacksUpdateTipsCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `RemoteCallbacksUpdateTipsCallback` into a `C_RemoteCallbacksUpdateTipsCallback`.
wrap_RemoteCallbacksUpdateTipsCallback ::
    RemoteCallbacksUpdateTipsCallback ->
    C_RemoteCallbacksUpdateTipsCallback
wrap_RemoteCallbacksUpdateTipsCallback _cb _ object p0 p1 _ = do
    object' <- cstringToText object
    B.ManagedPtr.withTransient Ggit.OId.OId p0 $ \p0' -> do
        B.ManagedPtr.withTransient Ggit.OId.OId p1 $ \p1' -> do
            _cb  object' p0' p1'


{- |
Connect a signal handler for the “@update-tips@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' remoteCallbacks #updateTips callback
@
-}
onRemoteCallbacksUpdateTips :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksUpdateTipsCallback -> m SignalHandlerId
onRemoteCallbacksUpdateTips obj cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksUpdateTipsCallback cb
    cb'' <- mk_RemoteCallbacksUpdateTipsCallback cb'
    connectSignalFunPtr obj "update-tips" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@update-tips@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' remoteCallbacks #updateTips callback
@
-}
afterRemoteCallbacksUpdateTips :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksUpdateTipsCallback -> m SignalHandlerId
afterRemoteCallbacksUpdateTips obj cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksUpdateTipsCallback cb
    cb'' <- mk_RemoteCallbacksUpdateTipsCallback cb'
    connectSignalFunPtr obj "update-tips" cb'' SignalConnectAfter


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

#if ENABLE_OVERLOADING
#endif

#if ENABLE_OVERLOADING
data RemoteCallbacksCompletionSignalInfo
instance SignalInfo RemoteCallbacksCompletionSignalInfo where
    type HaskellCallbackType RemoteCallbacksCompletionSignalInfo = RemoteCallbacksCompletionCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_RemoteCallbacksCompletionCallback cb
        cb'' <- mk_RemoteCallbacksCompletionCallback cb'
        connectSignalFunPtr obj "completion" cb'' connectMode

data RemoteCallbacksProgressSignalInfo
instance SignalInfo RemoteCallbacksProgressSignalInfo where
    type HaskellCallbackType RemoteCallbacksProgressSignalInfo = RemoteCallbacksProgressCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_RemoteCallbacksProgressCallback cb
        cb'' <- mk_RemoteCallbacksProgressCallback cb'
        connectSignalFunPtr obj "progress" cb'' connectMode

data RemoteCallbacksTransferProgressSignalInfo
instance SignalInfo RemoteCallbacksTransferProgressSignalInfo where
    type HaskellCallbackType RemoteCallbacksTransferProgressSignalInfo = RemoteCallbacksTransferProgressCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_RemoteCallbacksTransferProgressCallback cb
        cb'' <- mk_RemoteCallbacksTransferProgressCallback cb'
        connectSignalFunPtr obj "transfer-progress" cb'' connectMode

data RemoteCallbacksUpdateTipsSignalInfo
instance SignalInfo RemoteCallbacksUpdateTipsSignalInfo where
    type HaskellCallbackType RemoteCallbacksUpdateTipsSignalInfo = RemoteCallbacksUpdateTipsCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_RemoteCallbacksUpdateTipsCallback cb
        cb'' <- mk_RemoteCallbacksUpdateTipsCallback cb'
        connectSignalFunPtr obj "update-tips" cb'' connectMode

type instance O.SignalList RemoteCallbacks = RemoteCallbacksSignalList
type RemoteCallbacksSignalList = ('[ '("completion", RemoteCallbacksCompletionSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("progress", RemoteCallbacksProgressSignalInfo), '("transferProgress", RemoteCallbacksTransferProgressSignalInfo), '("updateTips", RemoteCallbacksUpdateTipsSignalInfo)] :: [(Symbol, *)])

#endif