{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Represents a git push options.

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

module GI.Ggit.Objects.PushOptions
    (

-- * Exported types
    PushOptions(..)                         ,
    IsPushOptions                           ,
    toPushOptions                           ,
    noPushOptions                           ,


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

#if defined(ENABLE_OVERLOADING)
    ResolvePushOptionsMethod                ,
#endif


-- ** getParallelism #method:getParallelism#

#if defined(ENABLE_OVERLOADING)
    PushOptionsGetParallelismMethodInfo     ,
#endif
    pushOptionsGetParallelism               ,


-- ** getRemoteCallbacks #method:getRemoteCallbacks#

#if defined(ENABLE_OVERLOADING)
    PushOptionsGetRemoteCallbacksMethodInfo ,
#endif
    pushOptionsGetRemoteCallbacks           ,


-- ** new #method:new#

    pushOptionsNew                          ,


-- ** setParallelism #method:setParallelism#

#if defined(ENABLE_OVERLOADING)
    PushOptionsSetParallelismMethodInfo     ,
#endif
    pushOptionsSetParallelism               ,


-- ** setRemoteCallbacks #method:setRemoteCallbacks#

#if defined(ENABLE_OVERLOADING)
    PushOptionsSetRemoteCallbacksMethodInfo ,
#endif
    pushOptionsSetRemoteCallbacks           ,




 -- * Properties
-- ** callbacks #attr:callbacks#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    PushOptionsCallbacksPropertyInfo        ,
#endif
    clearPushOptionsCallbacks               ,
    constructPushOptionsCallbacks           ,
    getPushOptionsCallbacks                 ,
#if defined(ENABLE_OVERLOADING)
    pushOptionsCallbacks                    ,
#endif
    setPushOptionsCallbacks                 ,


-- ** parallelism #attr:parallelism#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    PushOptionsParallelismPropertyInfo      ,
#endif
    constructPushOptionsParallelism         ,
    getPushOptionsParallelism               ,
#if defined(ENABLE_OVERLOADING)
    pushOptionsParallelism                  ,
#endif
    setPushOptionsParallelism               ,




    ) 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.GI.Base.Signals as B.Signals
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.Objects.RemoteCallbacks as Ggit.RemoteCallbacks

-- | Memory-managed wrapper type.
newtype PushOptions = PushOptions (ManagedPtr PushOptions)
    deriving (Eq)
foreign import ccall "ggit_push_options_get_type"
    c_ggit_push_options_get_type :: IO GType

instance GObject PushOptions where
    gobjectType = c_ggit_push_options_get_type


-- | Convert 'PushOptions' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue PushOptions where
    toGValue o = do
        gtype <- c_ggit_push_options_get_type
        B.ManagedPtr.withManagedPtr o (B.GValue.buildGValue gtype B.GValue.set_object)

    fromGValue gv = do
        ptr <- B.GValue.get_object gv :: IO (Ptr PushOptions)
        B.ManagedPtr.newObject PushOptions ptr



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

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

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

-- | A convenience alias for `Nothing` :: `Maybe` `PushOptions`.
noPushOptions :: Maybe PushOptions
noPushOptions = Nothing

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

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

#endif

-- VVV Prop "callbacks"
   -- Type: TInterface (Name {namespace = "Ggit", name = "RemoteCallbacks"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@callbacks@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pushOptions #callbacks
-- @
getPushOptionsCallbacks :: (MonadIO m, IsPushOptions o) => o -> m (Maybe Ggit.RemoteCallbacks.RemoteCallbacks)
getPushOptionsCallbacks obj = liftIO $ B.Properties.getObjectPropertyObject obj "callbacks" Ggit.RemoteCallbacks.RemoteCallbacks

-- | Set the value of the “@callbacks@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pushOptions [ #callbacks 'Data.GI.Base.Attributes.:=' value ]
-- @
setPushOptionsCallbacks :: (MonadIO m, IsPushOptions o, Ggit.RemoteCallbacks.IsRemoteCallbacks a) => o -> a -> m ()
setPushOptionsCallbacks obj val = liftIO $ B.Properties.setObjectPropertyObject obj "callbacks" (Just val)

-- | Construct a `GValueConstruct` with valid value for the “@callbacks@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPushOptionsCallbacks :: (IsPushOptions o, Ggit.RemoteCallbacks.IsRemoteCallbacks a) => a -> IO (GValueConstruct o)
constructPushOptionsCallbacks val = B.Properties.constructObjectPropertyObject "callbacks" (Just val)

-- | Set the value of the “@callbacks@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #callbacks
-- @
clearPushOptionsCallbacks :: (MonadIO m, IsPushOptions o) => o -> m ()
clearPushOptionsCallbacks obj = liftIO $ B.Properties.setObjectPropertyObject obj "callbacks" (Nothing :: Maybe Ggit.RemoteCallbacks.RemoteCallbacks)

#if defined(ENABLE_OVERLOADING)
data PushOptionsCallbacksPropertyInfo
instance AttrInfo PushOptionsCallbacksPropertyInfo where
    type AttrAllowedOps PushOptionsCallbacksPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint PushOptionsCallbacksPropertyInfo = IsPushOptions
    type AttrSetTypeConstraint PushOptionsCallbacksPropertyInfo = Ggit.RemoteCallbacks.IsRemoteCallbacks
    type AttrTransferTypeConstraint PushOptionsCallbacksPropertyInfo = Ggit.RemoteCallbacks.IsRemoteCallbacks
    type AttrTransferType PushOptionsCallbacksPropertyInfo = Ggit.RemoteCallbacks.RemoteCallbacks
    type AttrGetType PushOptionsCallbacksPropertyInfo = (Maybe Ggit.RemoteCallbacks.RemoteCallbacks)
    type AttrLabel PushOptionsCallbacksPropertyInfo = "callbacks"
    type AttrOrigin PushOptionsCallbacksPropertyInfo = PushOptions
    attrGet = getPushOptionsCallbacks
    attrSet = setPushOptionsCallbacks
    attrTransfer _ v = do
        unsafeCastTo Ggit.RemoteCallbacks.RemoteCallbacks v
    attrConstruct = constructPushOptionsCallbacks
    attrClear = clearPushOptionsCallbacks
#endif

-- VVV Prop "parallelism"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@parallelism@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pushOptions #parallelism
-- @
getPushOptionsParallelism :: (MonadIO m, IsPushOptions o) => o -> m Int32
getPushOptionsParallelism obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "parallelism"

-- | Set the value of the “@parallelism@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pushOptions [ #parallelism 'Data.GI.Base.Attributes.:=' value ]
-- @
setPushOptionsParallelism :: (MonadIO m, IsPushOptions o) => o -> Int32 -> m ()
setPushOptionsParallelism obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "parallelism" val

-- | Construct a `GValueConstruct` with valid value for the “@parallelism@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPushOptionsParallelism :: (IsPushOptions o) => Int32 -> IO (GValueConstruct o)
constructPushOptionsParallelism val = B.Properties.constructObjectPropertyInt32 "parallelism" val

#if defined(ENABLE_OVERLOADING)
data PushOptionsParallelismPropertyInfo
instance AttrInfo PushOptionsParallelismPropertyInfo where
    type AttrAllowedOps PushOptionsParallelismPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint PushOptionsParallelismPropertyInfo = IsPushOptions
    type AttrSetTypeConstraint PushOptionsParallelismPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint PushOptionsParallelismPropertyInfo = (~) Int32
    type AttrTransferType PushOptionsParallelismPropertyInfo = Int32
    type AttrGetType PushOptionsParallelismPropertyInfo = Int32
    type AttrLabel PushOptionsParallelismPropertyInfo = "parallelism"
    type AttrOrigin PushOptionsParallelismPropertyInfo = PushOptions
    attrGet = getPushOptionsParallelism
    attrSet = setPushOptionsParallelism
    attrTransfer _ v = do
        return v
    attrConstruct = constructPushOptionsParallelism
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList PushOptions
type instance O.AttributeList PushOptions = PushOptionsAttributeList
type PushOptionsAttributeList = ('[ '("callbacks", PushOptionsCallbacksPropertyInfo), '("parallelism", PushOptionsParallelismPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
pushOptionsCallbacks :: AttrLabelProxy "callbacks"
pushOptionsCallbacks = AttrLabelProxy

pushOptionsParallelism :: AttrLabelProxy "parallelism"
pushOptionsParallelism = AttrLabelProxy

#endif

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

#endif

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

foreign import ccall "ggit_push_options_new" ggit_push_options_new ::
    IO (Ptr PushOptions)

-- | Create a new push options object.
pushOptionsNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m (Maybe PushOptions)
    -- ^ __Returns:__ a t'GI.Ggit.Objects.PushOptions.PushOptions' or 'P.Nothing'.
pushOptionsNew  = liftIO $ do
    result <- ggit_push_options_new
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject PushOptions) result'
        return result''
    return maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "ggit_push_options_get_parallelism" ggit_push_options_get_parallelism ::
    Ptr PushOptions ->                      -- options : TInterface (Name {namespace = "Ggit", name = "PushOptions"})
    IO Int32

-- | Get the number of parallel threads to use when creating the pack file
-- to push. The special value 0 indicates that the number of threads will
-- be automatically detected.
pushOptionsGetParallelism ::
    (B.CallStack.HasCallStack, MonadIO m, IsPushOptions a) =>
    a
    -- ^ /@options@/: a t'GI.Ggit.Objects.PushOptions.PushOptions'.
    -> m Int32
    -- ^ __Returns:__ the number of parallel threads, or 0 for auto-detect.
pushOptionsGetParallelism options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_push_options_get_parallelism options'
    touchManagedPtr options
    return result

#if defined(ENABLE_OVERLOADING)
data PushOptionsGetParallelismMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsPushOptions a) => O.MethodInfo PushOptionsGetParallelismMethodInfo a signature where
    overloadedMethod = pushOptionsGetParallelism

#endif

-- method PushOptions::get_remote_callbacks
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "options"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "PushOptions" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitPushOptions."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Ggit" , name = "RemoteCallbacks" })
-- throws : False
-- Skip return : False

foreign import ccall "ggit_push_options_get_remote_callbacks" ggit_push_options_get_remote_callbacks ::
    Ptr PushOptions ->                      -- options : TInterface (Name {namespace = "Ggit", name = "PushOptions"})
    IO (Ptr Ggit.RemoteCallbacks.RemoteCallbacks)

-- | gets the remote callbacks object
pushOptionsGetRemoteCallbacks ::
    (B.CallStack.HasCallStack, MonadIO m, IsPushOptions a) =>
    a
    -- ^ /@options@/: a t'GI.Ggit.Objects.PushOptions.PushOptions'.
    -> m (Maybe Ggit.RemoteCallbacks.RemoteCallbacks)
    -- ^ __Returns:__ the object\'s id or 'P.Nothing'.
pushOptionsGetRemoteCallbacks options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_push_options_get_remote_callbacks options'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Ggit.RemoteCallbacks.RemoteCallbacks) result'
        return result''
    touchManagedPtr options
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data PushOptionsGetRemoteCallbacksMethodInfo
instance (signature ~ (m (Maybe Ggit.RemoteCallbacks.RemoteCallbacks)), MonadIO m, IsPushOptions a) => O.MethodInfo PushOptionsGetRemoteCallbacksMethodInfo a signature where
    overloadedMethod = pushOptionsGetRemoteCallbacks

#endif

-- method PushOptions::set_parallelism
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "options"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "PushOptions" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitPushOptions."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parallelism"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of threads, or 0 for auto-detect."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_push_options_set_parallelism" ggit_push_options_set_parallelism ::
    Ptr PushOptions ->                      -- options : TInterface (Name {namespace = "Ggit", name = "PushOptions"})
    Int32 ->                                -- parallelism : TBasicType TInt
    IO ()

-- | Set the number of parallel threads to use when creating the pack file
-- to push. The special value 0 can be specified for /@parallelism@/ indicating that
-- the number of threads will be automatically detected.
pushOptionsSetParallelism ::
    (B.CallStack.HasCallStack, MonadIO m, IsPushOptions a) =>
    a
    -- ^ /@options@/: a t'GI.Ggit.Objects.PushOptions.PushOptions'.
    -> Int32
    -- ^ /@parallelism@/: the number of threads, or 0 for auto-detect.
    -> m ()
pushOptionsSetParallelism options parallelism = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    ggit_push_options_set_parallelism options' parallelism
    touchManagedPtr options
    return ()

#if defined(ENABLE_OVERLOADING)
data PushOptionsSetParallelismMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsPushOptions a) => O.MethodInfo PushOptionsSetParallelismMethodInfo a signature where
    overloadedMethod = pushOptionsSetParallelism

#endif

-- method PushOptions::set_remote_callbacks
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "options"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "PushOptions" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitPushOptions."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callbacks"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "RemoteCallbacks" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GgitRemoteCallbacks"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_push_options_set_remote_callbacks" ggit_push_options_set_remote_callbacks ::
    Ptr PushOptions ->                      -- options : TInterface (Name {namespace = "Ggit", name = "PushOptions"})
    Ptr Ggit.RemoteCallbacks.RemoteCallbacks -> -- callbacks : TInterface (Name {namespace = "Ggit", name = "RemoteCallbacks"})
    IO ()

-- | Set the remote callbacks for the push options
pushOptionsSetRemoteCallbacks ::
    (B.CallStack.HasCallStack, MonadIO m, IsPushOptions a, Ggit.RemoteCallbacks.IsRemoteCallbacks b) =>
    a
    -- ^ /@options@/: a t'GI.Ggit.Objects.PushOptions.PushOptions'.
    -> b
    -- ^ /@callbacks@/: the t'GI.Ggit.Objects.RemoteCallbacks.RemoteCallbacks'
    -> m ()
pushOptionsSetRemoteCallbacks options callbacks = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    callbacks' <- unsafeManagedPtrCastPtr callbacks
    ggit_push_options_set_remote_callbacks options' callbacks'
    touchManagedPtr options
    touchManagedPtr callbacks
    return ()

#if defined(ENABLE_OVERLOADING)
data PushOptionsSetRemoteCallbacksMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsPushOptions a, Ggit.RemoteCallbacks.IsRemoteCallbacks b) => O.MethodInfo PushOptionsSetRemoteCallbacksMethodInfo a signature where
    overloadedMethod = pushOptionsSetRemoteCallbacks

#endif