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

Represents the options used when doign a checkout.
-}

module GI.Ggit.Objects.CheckoutOptions
    ( 

-- * Exported types
    CheckoutOptions(..)                     ,
    IsCheckoutOptions                       ,
    toCheckoutOptions                       ,
    noCheckoutOptions                       ,


 -- * Methods
-- ** getAncestorLabel #method:getAncestorLabel#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsGetAncestorLabelMethodInfo,
#endif
    checkoutOptionsGetAncestorLabel         ,


-- ** getBaseline #method:getBaseline#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsGetBaselineMethodInfo    ,
#endif
    checkoutOptionsGetBaseline              ,


-- ** getDirMode #method:getDirMode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsGetDirModeMethodInfo     ,
#endif
    checkoutOptionsGetDirMode               ,


-- ** getDisableFilters #method:getDisableFilters#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsGetDisableFiltersMethodInfo,
#endif
    checkoutOptionsGetDisableFilters        ,


-- ** getFileMode #method:getFileMode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsGetFileModeMethodInfo    ,
#endif
    checkoutOptionsGetFileMode              ,


-- ** getFileOpenFlags #method:getFileOpenFlags#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsGetFileOpenFlagsMethodInfo,
#endif
    checkoutOptionsGetFileOpenFlags         ,


-- ** getNotifyFlags #method:getNotifyFlags#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsGetNotifyFlagsMethodInfo ,
#endif
    checkoutOptionsGetNotifyFlags           ,


-- ** getOurLabel #method:getOurLabel#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsGetOurLabelMethodInfo    ,
#endif
    checkoutOptionsGetOurLabel              ,


-- ** getPaths #method:getPaths#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsGetPathsMethodInfo       ,
#endif
    checkoutOptionsGetPaths                 ,


-- ** getStrategy #method:getStrategy#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsGetStrategyMethodInfo    ,
#endif
    checkoutOptionsGetStrategy              ,


-- ** getTargetDirectory #method:getTargetDirectory#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsGetTargetDirectoryMethodInfo,
#endif
    checkoutOptionsGetTargetDirectory       ,


-- ** getTheirLabel #method:getTheirLabel#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsGetTheirLabelMethodInfo  ,
#endif
    checkoutOptionsGetTheirLabel            ,


-- ** new #method:new#
    checkoutOptionsNew                      ,


-- ** setAncestorLabel #method:setAncestorLabel#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsSetAncestorLabelMethodInfo,
#endif
    checkoutOptionsSetAncestorLabel         ,


-- ** setBaseline #method:setBaseline#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsSetBaselineMethodInfo    ,
#endif
    checkoutOptionsSetBaseline              ,


-- ** setDirMode #method:setDirMode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsSetDirModeMethodInfo     ,
#endif
    checkoutOptionsSetDirMode               ,


-- ** setDisableFilters #method:setDisableFilters#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsSetDisableFiltersMethodInfo,
#endif
    checkoutOptionsSetDisableFilters        ,


-- ** setFileMode #method:setFileMode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsSetFileModeMethodInfo    ,
#endif
    checkoutOptionsSetFileMode              ,


-- ** setFileOpenFlags #method:setFileOpenFlags#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsSetFileOpenFlagsMethodInfo,
#endif
    checkoutOptionsSetFileOpenFlags         ,


-- ** setNotifyFlags #method:setNotifyFlags#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsSetNotifyFlagsMethodInfo ,
#endif
    checkoutOptionsSetNotifyFlags           ,


-- ** setOurLabel #method:setOurLabel#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsSetOurLabelMethodInfo    ,
#endif
    checkoutOptionsSetOurLabel              ,


-- ** setPaths #method:setPaths#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsSetPathsMethodInfo       ,
#endif
    checkoutOptionsSetPaths                 ,


-- ** setStrategy #method:setStrategy#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsSetStrategyMethodInfo    ,
#endif
    checkoutOptionsSetStrategy              ,


-- ** setTargetDirectory #method:setTargetDirectory#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsSetTargetDirectoryMethodInfo,
#endif
    checkoutOptionsSetTargetDirectory       ,


-- ** setTheirLabel #method:setTheirLabel#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsSetTheirLabelMethodInfo  ,
#endif
    checkoutOptionsSetTheirLabel            ,




 -- * Properties
-- ** ancestorLabel #attr:ancestorLabel#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsAncestorLabelPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    checkoutOptionsAncestorLabel            ,
#endif
    clearCheckoutOptionsAncestorLabel       ,
    constructCheckoutOptionsAncestorLabel   ,
    getCheckoutOptionsAncestorLabel         ,
    setCheckoutOptionsAncestorLabel         ,


-- ** baseline #attr:baseline#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsBaselinePropertyInfo     ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    checkoutOptionsBaseline                 ,
#endif
    clearCheckoutOptionsBaseline            ,
    constructCheckoutOptionsBaseline        ,
    getCheckoutOptionsBaseline              ,
    setCheckoutOptionsBaseline              ,


-- ** dirMode #attr:dirMode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsDirModePropertyInfo      ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    checkoutOptionsDirMode                  ,
#endif
    constructCheckoutOptionsDirMode         ,
    getCheckoutOptionsDirMode               ,
    setCheckoutOptionsDirMode               ,


-- ** disableFilters #attr:disableFilters#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsDisableFiltersPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    checkoutOptionsDisableFilters           ,
#endif
    constructCheckoutOptionsDisableFilters  ,
    getCheckoutOptionsDisableFilters        ,
    setCheckoutOptionsDisableFilters        ,


-- ** fileMode #attr:fileMode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsFileModePropertyInfo     ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    checkoutOptionsFileMode                 ,
#endif
    constructCheckoutOptionsFileMode        ,
    getCheckoutOptionsFileMode              ,
    setCheckoutOptionsFileMode              ,


-- ** fileOpenFlags #attr:fileOpenFlags#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsFileOpenFlagsPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    checkoutOptionsFileOpenFlags            ,
#endif
    constructCheckoutOptionsFileOpenFlags   ,
    getCheckoutOptionsFileOpenFlags         ,
    setCheckoutOptionsFileOpenFlags         ,


-- ** notifyFlags #attr:notifyFlags#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsNotifyFlagsPropertyInfo  ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    checkoutOptionsNotifyFlags              ,
#endif
    constructCheckoutOptionsNotifyFlags     ,
    getCheckoutOptionsNotifyFlags           ,
    setCheckoutOptionsNotifyFlags           ,


-- ** ourLabel #attr:ourLabel#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsOurLabelPropertyInfo     ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    checkoutOptionsOurLabel                 ,
#endif
    clearCheckoutOptionsOurLabel            ,
    constructCheckoutOptionsOurLabel        ,
    getCheckoutOptionsOurLabel              ,
    setCheckoutOptionsOurLabel              ,


-- ** strategy #attr:strategy#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsStrategyPropertyInfo     ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    checkoutOptionsStrategy                 ,
#endif
    constructCheckoutOptionsStrategy        ,
    getCheckoutOptionsStrategy              ,
    setCheckoutOptionsStrategy              ,


-- ** targetDirectory #attr:targetDirectory#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsTargetDirectoryPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    checkoutOptionsTargetDirectory          ,
#endif
    clearCheckoutOptionsTargetDirectory     ,
    constructCheckoutOptionsTargetDirectory ,
    getCheckoutOptionsTargetDirectory       ,
    setCheckoutOptionsTargetDirectory       ,


-- ** theirLabel #attr:theirLabel#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    CheckoutOptionsTheirLabelPropertyInfo   ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    checkoutOptionsTheirLabel               ,
#endif
    clearCheckoutOptionsTheirLabel          ,
    constructCheckoutOptionsTheirLabel      ,
    getCheckoutOptionsTheirLabel            ,
    setCheckoutOptionsTheirLabel            ,




    ) 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
import {-# SOURCE #-} qualified GI.Ggit.Flags as Ggit.Flags
import {-# SOURCE #-} qualified GI.Ggit.Objects.Tree as Ggit.Tree

newtype CheckoutOptions = CheckoutOptions (ManagedPtr CheckoutOptions)
foreign import ccall "ggit_checkout_options_get_type"
    c_ggit_checkout_options_get_type :: IO GType

instance GObject CheckoutOptions where
    gobjectType _ = c_ggit_checkout_options_get_type
    

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

toCheckoutOptions :: (MonadIO m, IsCheckoutOptions o) => o -> m CheckoutOptions
toCheckoutOptions = liftIO . unsafeCastTo CheckoutOptions

noCheckoutOptions :: Maybe CheckoutOptions
noCheckoutOptions = Nothing

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveCheckoutOptionsMethod (t :: Symbol) (o :: *) :: * where
    ResolveCheckoutOptionsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveCheckoutOptionsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveCheckoutOptionsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveCheckoutOptionsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveCheckoutOptionsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveCheckoutOptionsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveCheckoutOptionsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveCheckoutOptionsMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveCheckoutOptionsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveCheckoutOptionsMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveCheckoutOptionsMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveCheckoutOptionsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveCheckoutOptionsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveCheckoutOptionsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveCheckoutOptionsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveCheckoutOptionsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveCheckoutOptionsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveCheckoutOptionsMethod "getAncestorLabel" o = CheckoutOptionsGetAncestorLabelMethodInfo
    ResolveCheckoutOptionsMethod "getBaseline" o = CheckoutOptionsGetBaselineMethodInfo
    ResolveCheckoutOptionsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveCheckoutOptionsMethod "getDirMode" o = CheckoutOptionsGetDirModeMethodInfo
    ResolveCheckoutOptionsMethod "getDisableFilters" o = CheckoutOptionsGetDisableFiltersMethodInfo
    ResolveCheckoutOptionsMethod "getFileMode" o = CheckoutOptionsGetFileModeMethodInfo
    ResolveCheckoutOptionsMethod "getFileOpenFlags" o = CheckoutOptionsGetFileOpenFlagsMethodInfo
    ResolveCheckoutOptionsMethod "getNotifyFlags" o = CheckoutOptionsGetNotifyFlagsMethodInfo
    ResolveCheckoutOptionsMethod "getOurLabel" o = CheckoutOptionsGetOurLabelMethodInfo
    ResolveCheckoutOptionsMethod "getPaths" o = CheckoutOptionsGetPathsMethodInfo
    ResolveCheckoutOptionsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveCheckoutOptionsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveCheckoutOptionsMethod "getStrategy" o = CheckoutOptionsGetStrategyMethodInfo
    ResolveCheckoutOptionsMethod "getTargetDirectory" o = CheckoutOptionsGetTargetDirectoryMethodInfo
    ResolveCheckoutOptionsMethod "getTheirLabel" o = CheckoutOptionsGetTheirLabelMethodInfo
    ResolveCheckoutOptionsMethod "setAncestorLabel" o = CheckoutOptionsSetAncestorLabelMethodInfo
    ResolveCheckoutOptionsMethod "setBaseline" o = CheckoutOptionsSetBaselineMethodInfo
    ResolveCheckoutOptionsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveCheckoutOptionsMethod "setDirMode" o = CheckoutOptionsSetDirModeMethodInfo
    ResolveCheckoutOptionsMethod "setDisableFilters" o = CheckoutOptionsSetDisableFiltersMethodInfo
    ResolveCheckoutOptionsMethod "setFileMode" o = CheckoutOptionsSetFileModeMethodInfo
    ResolveCheckoutOptionsMethod "setFileOpenFlags" o = CheckoutOptionsSetFileOpenFlagsMethodInfo
    ResolveCheckoutOptionsMethod "setNotifyFlags" o = CheckoutOptionsSetNotifyFlagsMethodInfo
    ResolveCheckoutOptionsMethod "setOurLabel" o = CheckoutOptionsSetOurLabelMethodInfo
    ResolveCheckoutOptionsMethod "setPaths" o = CheckoutOptionsSetPathsMethodInfo
    ResolveCheckoutOptionsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveCheckoutOptionsMethod "setStrategy" o = CheckoutOptionsSetStrategyMethodInfo
    ResolveCheckoutOptionsMethod "setTargetDirectory" o = CheckoutOptionsSetTargetDirectoryMethodInfo
    ResolveCheckoutOptionsMethod "setTheirLabel" o = CheckoutOptionsSetTheirLabelMethodInfo
    ResolveCheckoutOptionsMethod l o = O.MethodResolutionFailed l o

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

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

#endif

-- VVV Prop "ancestor-label"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

getCheckoutOptionsAncestorLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe T.Text)
getCheckoutOptionsAncestorLabel obj = liftIO $ getObjectPropertyString obj "ancestor-label"

setCheckoutOptionsAncestorLabel :: (MonadIO m, IsCheckoutOptions o) => o -> T.Text -> m ()
setCheckoutOptionsAncestorLabel obj val = liftIO $ setObjectPropertyString obj "ancestor-label" (Just val)

constructCheckoutOptionsAncestorLabel :: (IsCheckoutOptions o) => T.Text -> IO (GValueConstruct o)
constructCheckoutOptionsAncestorLabel val = constructObjectPropertyString "ancestor-label" (Just val)

clearCheckoutOptionsAncestorLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m ()
clearCheckoutOptionsAncestorLabel obj = liftIO $ setObjectPropertyString obj "ancestor-label" (Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsAncestorLabelPropertyInfo
instance AttrInfo CheckoutOptionsAncestorLabelPropertyInfo where
    type AttrAllowedOps CheckoutOptionsAncestorLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CheckoutOptionsAncestorLabelPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CheckoutOptionsAncestorLabelPropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsAncestorLabelPropertyInfo = (Maybe T.Text)
    type AttrLabel CheckoutOptionsAncestorLabelPropertyInfo = "ancestor-label"
    type AttrOrigin CheckoutOptionsAncestorLabelPropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsAncestorLabel
    attrSet _ = setCheckoutOptionsAncestorLabel
    attrConstruct _ = constructCheckoutOptionsAncestorLabel
    attrClear _ = clearCheckoutOptionsAncestorLabel
#endif

-- VVV Prop "baseline"
   -- Type: TInterface (Name {namespace = "Ggit", name = "Tree"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just True)

getCheckoutOptionsBaseline :: (MonadIO m, IsCheckoutOptions o) => o -> m Ggit.Tree.Tree
getCheckoutOptionsBaseline obj = liftIO $ checkUnexpectedNothing "getCheckoutOptionsBaseline" $ getObjectPropertyObject obj "baseline" Ggit.Tree.Tree

setCheckoutOptionsBaseline :: (MonadIO m, IsCheckoutOptions o, Ggit.Tree.IsTree a) => o -> a -> m ()
setCheckoutOptionsBaseline obj val = liftIO $ setObjectPropertyObject obj "baseline" (Just val)

constructCheckoutOptionsBaseline :: (IsCheckoutOptions o, Ggit.Tree.IsTree a) => a -> IO (GValueConstruct o)
constructCheckoutOptionsBaseline val = constructObjectPropertyObject "baseline" (Just val)

clearCheckoutOptionsBaseline :: (MonadIO m, IsCheckoutOptions o) => o -> m ()
clearCheckoutOptionsBaseline obj = liftIO $ setObjectPropertyObject obj "baseline" (Nothing :: Maybe Ggit.Tree.Tree)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsBaselinePropertyInfo
instance AttrInfo CheckoutOptionsBaselinePropertyInfo where
    type AttrAllowedOps CheckoutOptionsBaselinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CheckoutOptionsBaselinePropertyInfo = Ggit.Tree.IsTree
    type AttrBaseTypeConstraint CheckoutOptionsBaselinePropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsBaselinePropertyInfo = Ggit.Tree.Tree
    type AttrLabel CheckoutOptionsBaselinePropertyInfo = "baseline"
    type AttrOrigin CheckoutOptionsBaselinePropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsBaseline
    attrSet _ = setCheckoutOptionsBaseline
    attrConstruct _ = constructCheckoutOptionsBaseline
    attrClear _ = clearCheckoutOptionsBaseline
#endif

-- VVV Prop "dir-mode"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getCheckoutOptionsDirMode :: (MonadIO m, IsCheckoutOptions o) => o -> m Word32
getCheckoutOptionsDirMode obj = liftIO $ getObjectPropertyUInt32 obj "dir-mode"

setCheckoutOptionsDirMode :: (MonadIO m, IsCheckoutOptions o) => o -> Word32 -> m ()
setCheckoutOptionsDirMode obj val = liftIO $ setObjectPropertyUInt32 obj "dir-mode" val

constructCheckoutOptionsDirMode :: (IsCheckoutOptions o) => Word32 -> IO (GValueConstruct o)
constructCheckoutOptionsDirMode val = constructObjectPropertyUInt32 "dir-mode" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsDirModePropertyInfo
instance AttrInfo CheckoutOptionsDirModePropertyInfo where
    type AttrAllowedOps CheckoutOptionsDirModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CheckoutOptionsDirModePropertyInfo = (~) Word32
    type AttrBaseTypeConstraint CheckoutOptionsDirModePropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsDirModePropertyInfo = Word32
    type AttrLabel CheckoutOptionsDirModePropertyInfo = "dir-mode"
    type AttrOrigin CheckoutOptionsDirModePropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsDirMode
    attrSet _ = setCheckoutOptionsDirMode
    attrConstruct _ = constructCheckoutOptionsDirMode
    attrClear _ = undefined
#endif

-- VVV Prop "disable-filters"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getCheckoutOptionsDisableFilters :: (MonadIO m, IsCheckoutOptions o) => o -> m Bool
getCheckoutOptionsDisableFilters obj = liftIO $ getObjectPropertyBool obj "disable-filters"

setCheckoutOptionsDisableFilters :: (MonadIO m, IsCheckoutOptions o) => o -> Bool -> m ()
setCheckoutOptionsDisableFilters obj val = liftIO $ setObjectPropertyBool obj "disable-filters" val

constructCheckoutOptionsDisableFilters :: (IsCheckoutOptions o) => Bool -> IO (GValueConstruct o)
constructCheckoutOptionsDisableFilters val = constructObjectPropertyBool "disable-filters" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsDisableFiltersPropertyInfo
instance AttrInfo CheckoutOptionsDisableFiltersPropertyInfo where
    type AttrAllowedOps CheckoutOptionsDisableFiltersPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CheckoutOptionsDisableFiltersPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint CheckoutOptionsDisableFiltersPropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsDisableFiltersPropertyInfo = Bool
    type AttrLabel CheckoutOptionsDisableFiltersPropertyInfo = "disable-filters"
    type AttrOrigin CheckoutOptionsDisableFiltersPropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsDisableFilters
    attrSet _ = setCheckoutOptionsDisableFilters
    attrConstruct _ = constructCheckoutOptionsDisableFilters
    attrClear _ = undefined
#endif

-- VVV Prop "file-mode"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getCheckoutOptionsFileMode :: (MonadIO m, IsCheckoutOptions o) => o -> m Word32
getCheckoutOptionsFileMode obj = liftIO $ getObjectPropertyUInt32 obj "file-mode"

setCheckoutOptionsFileMode :: (MonadIO m, IsCheckoutOptions o) => o -> Word32 -> m ()
setCheckoutOptionsFileMode obj val = liftIO $ setObjectPropertyUInt32 obj "file-mode" val

constructCheckoutOptionsFileMode :: (IsCheckoutOptions o) => Word32 -> IO (GValueConstruct o)
constructCheckoutOptionsFileMode val = constructObjectPropertyUInt32 "file-mode" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsFileModePropertyInfo
instance AttrInfo CheckoutOptionsFileModePropertyInfo where
    type AttrAllowedOps CheckoutOptionsFileModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CheckoutOptionsFileModePropertyInfo = (~) Word32
    type AttrBaseTypeConstraint CheckoutOptionsFileModePropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsFileModePropertyInfo = Word32
    type AttrLabel CheckoutOptionsFileModePropertyInfo = "file-mode"
    type AttrOrigin CheckoutOptionsFileModePropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsFileMode
    attrSet _ = setCheckoutOptionsFileMode
    attrConstruct _ = constructCheckoutOptionsFileMode
    attrClear _ = undefined
#endif

-- VVV Prop "file-open-flags"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getCheckoutOptionsFileOpenFlags :: (MonadIO m, IsCheckoutOptions o) => o -> m Int32
getCheckoutOptionsFileOpenFlags obj = liftIO $ getObjectPropertyInt32 obj "file-open-flags"

setCheckoutOptionsFileOpenFlags :: (MonadIO m, IsCheckoutOptions o) => o -> Int32 -> m ()
setCheckoutOptionsFileOpenFlags obj val = liftIO $ setObjectPropertyInt32 obj "file-open-flags" val

constructCheckoutOptionsFileOpenFlags :: (IsCheckoutOptions o) => Int32 -> IO (GValueConstruct o)
constructCheckoutOptionsFileOpenFlags val = constructObjectPropertyInt32 "file-open-flags" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsFileOpenFlagsPropertyInfo
instance AttrInfo CheckoutOptionsFileOpenFlagsPropertyInfo where
    type AttrAllowedOps CheckoutOptionsFileOpenFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CheckoutOptionsFileOpenFlagsPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint CheckoutOptionsFileOpenFlagsPropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsFileOpenFlagsPropertyInfo = Int32
    type AttrLabel CheckoutOptionsFileOpenFlagsPropertyInfo = "file-open-flags"
    type AttrOrigin CheckoutOptionsFileOpenFlagsPropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsFileOpenFlags
    attrSet _ = setCheckoutOptionsFileOpenFlags
    attrConstruct _ = constructCheckoutOptionsFileOpenFlags
    attrClear _ = undefined
#endif

-- VVV Prop "notify-flags"
   -- Type: TInterface (Name {namespace = "Ggit", name = "CheckoutNotifyFlags"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getCheckoutOptionsNotifyFlags :: (MonadIO m, IsCheckoutOptions o) => o -> m [Ggit.Flags.CheckoutNotifyFlags]
getCheckoutOptionsNotifyFlags obj = liftIO $ getObjectPropertyFlags obj "notify-flags"

setCheckoutOptionsNotifyFlags :: (MonadIO m, IsCheckoutOptions o) => o -> [Ggit.Flags.CheckoutNotifyFlags] -> m ()
setCheckoutOptionsNotifyFlags obj val = liftIO $ setObjectPropertyFlags obj "notify-flags" val

constructCheckoutOptionsNotifyFlags :: (IsCheckoutOptions o) => [Ggit.Flags.CheckoutNotifyFlags] -> IO (GValueConstruct o)
constructCheckoutOptionsNotifyFlags val = constructObjectPropertyFlags "notify-flags" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsNotifyFlagsPropertyInfo
instance AttrInfo CheckoutOptionsNotifyFlagsPropertyInfo where
    type AttrAllowedOps CheckoutOptionsNotifyFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CheckoutOptionsNotifyFlagsPropertyInfo = (~) [Ggit.Flags.CheckoutNotifyFlags]
    type AttrBaseTypeConstraint CheckoutOptionsNotifyFlagsPropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsNotifyFlagsPropertyInfo = [Ggit.Flags.CheckoutNotifyFlags]
    type AttrLabel CheckoutOptionsNotifyFlagsPropertyInfo = "notify-flags"
    type AttrOrigin CheckoutOptionsNotifyFlagsPropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsNotifyFlags
    attrSet _ = setCheckoutOptionsNotifyFlags
    attrConstruct _ = constructCheckoutOptionsNotifyFlags
    attrClear _ = undefined
#endif

-- VVV Prop "our-label"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

getCheckoutOptionsOurLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe T.Text)
getCheckoutOptionsOurLabel obj = liftIO $ getObjectPropertyString obj "our-label"

setCheckoutOptionsOurLabel :: (MonadIO m, IsCheckoutOptions o) => o -> T.Text -> m ()
setCheckoutOptionsOurLabel obj val = liftIO $ setObjectPropertyString obj "our-label" (Just val)

constructCheckoutOptionsOurLabel :: (IsCheckoutOptions o) => T.Text -> IO (GValueConstruct o)
constructCheckoutOptionsOurLabel val = constructObjectPropertyString "our-label" (Just val)

clearCheckoutOptionsOurLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m ()
clearCheckoutOptionsOurLabel obj = liftIO $ setObjectPropertyString obj "our-label" (Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsOurLabelPropertyInfo
instance AttrInfo CheckoutOptionsOurLabelPropertyInfo where
    type AttrAllowedOps CheckoutOptionsOurLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CheckoutOptionsOurLabelPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CheckoutOptionsOurLabelPropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsOurLabelPropertyInfo = (Maybe T.Text)
    type AttrLabel CheckoutOptionsOurLabelPropertyInfo = "our-label"
    type AttrOrigin CheckoutOptionsOurLabelPropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsOurLabel
    attrSet _ = setCheckoutOptionsOurLabel
    attrConstruct _ = constructCheckoutOptionsOurLabel
    attrClear _ = clearCheckoutOptionsOurLabel
#endif

-- VVV Prop "strategy"
   -- Type: TInterface (Name {namespace = "Ggit", name = "CheckoutStrategy"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getCheckoutOptionsStrategy :: (MonadIO m, IsCheckoutOptions o) => o -> m [Ggit.Flags.CheckoutStrategy]
getCheckoutOptionsStrategy obj = liftIO $ getObjectPropertyFlags obj "strategy"

setCheckoutOptionsStrategy :: (MonadIO m, IsCheckoutOptions o) => o -> [Ggit.Flags.CheckoutStrategy] -> m ()
setCheckoutOptionsStrategy obj val = liftIO $ setObjectPropertyFlags obj "strategy" val

constructCheckoutOptionsStrategy :: (IsCheckoutOptions o) => [Ggit.Flags.CheckoutStrategy] -> IO (GValueConstruct o)
constructCheckoutOptionsStrategy val = constructObjectPropertyFlags "strategy" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsStrategyPropertyInfo
instance AttrInfo CheckoutOptionsStrategyPropertyInfo where
    type AttrAllowedOps CheckoutOptionsStrategyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CheckoutOptionsStrategyPropertyInfo = (~) [Ggit.Flags.CheckoutStrategy]
    type AttrBaseTypeConstraint CheckoutOptionsStrategyPropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsStrategyPropertyInfo = [Ggit.Flags.CheckoutStrategy]
    type AttrLabel CheckoutOptionsStrategyPropertyInfo = "strategy"
    type AttrOrigin CheckoutOptionsStrategyPropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsStrategy
    attrSet _ = setCheckoutOptionsStrategy
    attrConstruct _ = constructCheckoutOptionsStrategy
    attrClear _ = undefined
#endif

-- VVV Prop "target-directory"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

getCheckoutOptionsTargetDirectory :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe T.Text)
getCheckoutOptionsTargetDirectory obj = liftIO $ getObjectPropertyString obj "target-directory"

setCheckoutOptionsTargetDirectory :: (MonadIO m, IsCheckoutOptions o) => o -> T.Text -> m ()
setCheckoutOptionsTargetDirectory obj val = liftIO $ setObjectPropertyString obj "target-directory" (Just val)

constructCheckoutOptionsTargetDirectory :: (IsCheckoutOptions o) => T.Text -> IO (GValueConstruct o)
constructCheckoutOptionsTargetDirectory val = constructObjectPropertyString "target-directory" (Just val)

clearCheckoutOptionsTargetDirectory :: (MonadIO m, IsCheckoutOptions o) => o -> m ()
clearCheckoutOptionsTargetDirectory obj = liftIO $ setObjectPropertyString obj "target-directory" (Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsTargetDirectoryPropertyInfo
instance AttrInfo CheckoutOptionsTargetDirectoryPropertyInfo where
    type AttrAllowedOps CheckoutOptionsTargetDirectoryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CheckoutOptionsTargetDirectoryPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CheckoutOptionsTargetDirectoryPropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsTargetDirectoryPropertyInfo = (Maybe T.Text)
    type AttrLabel CheckoutOptionsTargetDirectoryPropertyInfo = "target-directory"
    type AttrOrigin CheckoutOptionsTargetDirectoryPropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsTargetDirectory
    attrSet _ = setCheckoutOptionsTargetDirectory
    attrConstruct _ = constructCheckoutOptionsTargetDirectory
    attrClear _ = clearCheckoutOptionsTargetDirectory
#endif

-- VVV Prop "their-label"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

getCheckoutOptionsTheirLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe T.Text)
getCheckoutOptionsTheirLabel obj = liftIO $ getObjectPropertyString obj "their-label"

setCheckoutOptionsTheirLabel :: (MonadIO m, IsCheckoutOptions o) => o -> T.Text -> m ()
setCheckoutOptionsTheirLabel obj val = liftIO $ setObjectPropertyString obj "their-label" (Just val)

constructCheckoutOptionsTheirLabel :: (IsCheckoutOptions o) => T.Text -> IO (GValueConstruct o)
constructCheckoutOptionsTheirLabel val = constructObjectPropertyString "their-label" (Just val)

clearCheckoutOptionsTheirLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m ()
clearCheckoutOptionsTheirLabel obj = liftIO $ setObjectPropertyString obj "their-label" (Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsTheirLabelPropertyInfo
instance AttrInfo CheckoutOptionsTheirLabelPropertyInfo where
    type AttrAllowedOps CheckoutOptionsTheirLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CheckoutOptionsTheirLabelPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CheckoutOptionsTheirLabelPropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsTheirLabelPropertyInfo = (Maybe T.Text)
    type AttrLabel CheckoutOptionsTheirLabelPropertyInfo = "their-label"
    type AttrOrigin CheckoutOptionsTheirLabelPropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsTheirLabel
    attrSet _ = setCheckoutOptionsTheirLabel
    attrConstruct _ = constructCheckoutOptionsTheirLabel
    attrClear _ = clearCheckoutOptionsTheirLabel
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList CheckoutOptions
type instance O.AttributeList CheckoutOptions = CheckoutOptionsAttributeList
type CheckoutOptionsAttributeList = ('[ '("ancestorLabel", CheckoutOptionsAncestorLabelPropertyInfo), '("baseline", CheckoutOptionsBaselinePropertyInfo), '("dirMode", CheckoutOptionsDirModePropertyInfo), '("disableFilters", CheckoutOptionsDisableFiltersPropertyInfo), '("fileMode", CheckoutOptionsFileModePropertyInfo), '("fileOpenFlags", CheckoutOptionsFileOpenFlagsPropertyInfo), '("notifyFlags", CheckoutOptionsNotifyFlagsPropertyInfo), '("ourLabel", CheckoutOptionsOurLabelPropertyInfo), '("strategy", CheckoutOptionsStrategyPropertyInfo), '("targetDirectory", CheckoutOptionsTargetDirectoryPropertyInfo), '("theirLabel", CheckoutOptionsTheirLabelPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
checkoutOptionsAncestorLabel :: AttrLabelProxy "ancestorLabel"
checkoutOptionsAncestorLabel = AttrLabelProxy

checkoutOptionsBaseline :: AttrLabelProxy "baseline"
checkoutOptionsBaseline = AttrLabelProxy

checkoutOptionsDirMode :: AttrLabelProxy "dirMode"
checkoutOptionsDirMode = AttrLabelProxy

checkoutOptionsDisableFilters :: AttrLabelProxy "disableFilters"
checkoutOptionsDisableFilters = AttrLabelProxy

checkoutOptionsFileMode :: AttrLabelProxy "fileMode"
checkoutOptionsFileMode = AttrLabelProxy

checkoutOptionsFileOpenFlags :: AttrLabelProxy "fileOpenFlags"
checkoutOptionsFileOpenFlags = AttrLabelProxy

checkoutOptionsNotifyFlags :: AttrLabelProxy "notifyFlags"
checkoutOptionsNotifyFlags = AttrLabelProxy

checkoutOptionsOurLabel :: AttrLabelProxy "ourLabel"
checkoutOptionsOurLabel = AttrLabelProxy

checkoutOptionsStrategy :: AttrLabelProxy "strategy"
checkoutOptionsStrategy = AttrLabelProxy

checkoutOptionsTargetDirectory :: AttrLabelProxy "targetDirectory"
checkoutOptionsTargetDirectory = AttrLabelProxy

checkoutOptionsTheirLabel :: AttrLabelProxy "theirLabel"
checkoutOptionsTheirLabel = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type instance O.SignalList CheckoutOptions = CheckoutOptionsSignalList
type CheckoutOptionsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "ggit_checkout_options_new" ggit_checkout_options_new :: 
    IO (Ptr CheckoutOptions)

{- |
Create a new checkout options object.
-}
checkoutOptionsNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m CheckoutOptions
    {- ^ __Returns:__ a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
checkoutOptionsNew  = liftIO $ do
    result <- ggit_checkout_options_new
    checkUnexpectedReturnNULL "checkoutOptionsNew" result
    result' <- (wrapObject CheckoutOptions) result
    return result'

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

-- method CheckoutOptions::get_ancestor_label
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", 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 "ggit_checkout_options_get_ancestor_label" ggit_checkout_options_get_ancestor_label :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    IO CString

{- |
Get the checkout ancestor label.
-}
checkoutOptionsGetAncestorLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the checkout ancestor label. -}
checkoutOptionsGetAncestorLabel options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_ancestor_label options'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr options
    return maybeResult

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsGetAncestorLabelMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetAncestorLabelMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsGetAncestorLabel

#endif

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

foreign import ccall "ggit_checkout_options_get_baseline" ggit_checkout_options_get_baseline :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    IO (Ptr Ggit.Tree.Tree)

{- |
Get the baseline, i.e. the expected content of workdir. Defaults to HEAD.
-}
checkoutOptionsGetBaseline ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m Ggit.Tree.Tree
    {- ^ __Returns:__ a 'GI.Ggit.Objects.Tree.Tree'. -}
checkoutOptionsGetBaseline options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_baseline options'
    checkUnexpectedReturnNULL "checkoutOptionsGetBaseline" result
    result' <- (newObject Ggit.Tree.Tree) result
    touchManagedPtr options
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsGetBaselineMethodInfo
instance (signature ~ (m Ggit.Tree.Tree), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetBaselineMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsGetBaseline

#endif

-- method CheckoutOptions::get_dir_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", 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 "ggit_checkout_options_get_dir_mode" ggit_checkout_options_get_dir_mode :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    IO Word32

{- |
Get the default checkout directory mode.
-}
checkoutOptionsGetDirMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m Word32
    {- ^ __Returns:__ the default directory mode. -}
checkoutOptionsGetDirMode options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_dir_mode options'
    touchManagedPtr options
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsGetDirModeMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetDirModeMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsGetDirMode

#endif

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

foreign import ccall "ggit_checkout_options_get_disable_filters" ggit_checkout_options_get_disable_filters :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    IO CInt

{- |
Get whether filters are disabled.
-}
checkoutOptionsGetDisableFilters ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if filters are disabled, 'False' otherwise. -}
checkoutOptionsGetDisableFilters options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_disable_filters options'
    let result' = (/= 0) result
    touchManagedPtr options
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsGetDisableFiltersMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetDisableFiltersMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsGetDisableFilters

#endif

-- method CheckoutOptions::get_file_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", 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 "ggit_checkout_options_get_file_mode" ggit_checkout_options_get_file_mode :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    IO Word32

{- |
Get the default checkout file mode.
-}
checkoutOptionsGetFileMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m Word32
    {- ^ __Returns:__ the default checkout file mode. -}
checkoutOptionsGetFileMode options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_file_mode options'
    touchManagedPtr options
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsGetFileModeMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetFileModeMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsGetFileMode

#endif

-- method CheckoutOptions::get_file_open_flags
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", 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_checkout_options_get_file_open_flags" ggit_checkout_options_get_file_open_flags :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    IO Int32

{- |
Get the checkout file open flags. These flags are platform specific,
e.g. on Unix these would include O_CREAT, O_TRUNC, etc.
-}
checkoutOptionsGetFileOpenFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m Int32
    {- ^ __Returns:__ the checkout file open flags. -}
checkoutOptionsGetFileOpenFlags options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_file_open_flags options'
    touchManagedPtr options
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsGetFileOpenFlagsMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetFileOpenFlagsMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsGetFileOpenFlags

#endif

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

foreign import ccall "ggit_checkout_options_get_notify_flags" ggit_checkout_options_get_notify_flags :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    IO CUInt

{- |
Get the checkout notify flags.
-}
checkoutOptionsGetNotifyFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m [Ggit.Flags.CheckoutNotifyFlags]
    {- ^ __Returns:__ a 'GI.Ggit.Flags.CheckoutNotifyFlags'. -}
checkoutOptionsGetNotifyFlags options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_notify_flags options'
    let result' = wordToGFlags result
    touchManagedPtr options
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsGetNotifyFlagsMethodInfo
instance (signature ~ (m [Ggit.Flags.CheckoutNotifyFlags]), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetNotifyFlagsMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsGetNotifyFlags

#endif

-- method CheckoutOptions::get_our_label
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", 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 "ggit_checkout_options_get_our_label" ggit_checkout_options_get_our_label :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    IO CString

{- |
Get the checkout our label.
-}
checkoutOptionsGetOurLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the checkout our label. -}
checkoutOptionsGetOurLabel options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_our_label options'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr options
    return maybeResult

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsGetOurLabelMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetOurLabelMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsGetOurLabel

#endif

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

foreign import ccall "ggit_checkout_options_get_paths" ggit_checkout_options_get_paths :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    IO (Ptr CString)

{- |
Get the list of file paths to checkout.
-}
checkoutOptionsGetPaths ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m (Maybe [T.Text])
    {- ^ __Returns:__ a 'Nothing' terminated list of file paths, or 'Nothing'. -}
checkoutOptionsGetPaths options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_paths options'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- unpackZeroTerminatedUTF8CArray result'
        return result''
    touchManagedPtr options
    return maybeResult

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsGetPathsMethodInfo
instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetPathsMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsGetPaths

#endif

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

foreign import ccall "ggit_checkout_options_get_strategy" ggit_checkout_options_get_strategy :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    IO CUInt

{- |
Get the checkout strategy.
-}
checkoutOptionsGetStrategy ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m [Ggit.Flags.CheckoutStrategy]
    {- ^ __Returns:__ a 'GI.Ggit.Flags.CheckoutStrategy'. -}
checkoutOptionsGetStrategy options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_strategy options'
    let result' = wordToGFlags result
    touchManagedPtr options
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsGetStrategyMethodInfo
instance (signature ~ (m [Ggit.Flags.CheckoutStrategy]), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetStrategyMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsGetStrategy

#endif

-- method CheckoutOptions::get_target_directory
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", 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 "ggit_checkout_options_get_target_directory" ggit_checkout_options_get_target_directory :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    IO CString

{- |
Get the checkout target directory.
-}
checkoutOptionsGetTargetDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the checkout target directory. -}
checkoutOptionsGetTargetDirectory options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_target_directory options'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr options
    return maybeResult

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsGetTargetDirectoryMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetTargetDirectoryMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsGetTargetDirectory

#endif

-- method CheckoutOptions::get_their_label
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", 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 "ggit_checkout_options_get_their_label" ggit_checkout_options_get_their_label :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    IO CString

{- |
Get the checkout their label.
-}
checkoutOptionsGetTheirLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the checkout their label. -}
checkoutOptionsGetTheirLabel options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_their_label options'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr options
    return maybeResult

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsGetTheirLabelMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetTheirLabelMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsGetTheirLabel

#endif

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

foreign import ccall "ggit_checkout_options_set_ancestor_label" ggit_checkout_options_set_ancestor_label :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    CString ->                              -- label : TBasicType TUTF8
    IO ()

{- |
Set the checkout ancestor label.
-}
checkoutOptionsSetAncestorLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> Maybe (T.Text)
    {- ^ /@label@/: the ancestor label. -}
    -> m ()
checkoutOptionsSetAncestorLabel options label = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    maybeLabel <- case label of
        Nothing -> return nullPtr
        Just jLabel -> do
            jLabel' <- textToCString jLabel
            return jLabel'
    ggit_checkout_options_set_ancestor_label options' maybeLabel
    touchManagedPtr options
    freeMem maybeLabel
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsSetAncestorLabelMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetAncestorLabelMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsSetAncestorLabel

#endif

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

foreign import ccall "ggit_checkout_options_set_baseline" ggit_checkout_options_set_baseline :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    Ptr Ggit.Tree.Tree ->                   -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"})
    IO ()

{- |
Set the baseline, i.e. the expected content of workdir. If /@tree@/ is set
to 'Nothing', the default (HEAD) will be used as the baseline.
-}
checkoutOptionsSetBaseline ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a, Ggit.Tree.IsTree b) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> Maybe (b)
    {- ^ /@tree@/: a 'GI.Ggit.Objects.Tree.Tree'. -}
    -> m ()
checkoutOptionsSetBaseline options tree = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    maybeTree <- case tree of
        Nothing -> return nullPtr
        Just jTree -> do
            jTree' <- unsafeManagedPtrCastPtr jTree
            return jTree'
    ggit_checkout_options_set_baseline options' maybeTree
    touchManagedPtr options
    whenJust tree touchManagedPtr
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsSetBaselineMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsCheckoutOptions a, Ggit.Tree.IsTree b) => O.MethodInfo CheckoutOptionsSetBaselineMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsSetBaseline

#endif

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

foreign import ccall "ggit_checkout_options_set_dir_mode" ggit_checkout_options_set_dir_mode :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    Word32 ->                               -- dir_mode : TBasicType TUInt
    IO ()

{- |
Set the default checkout directory mode.
-}
checkoutOptionsSetDirMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> Word32
    {- ^ /@dirMode@/: the dir mode. -}
    -> m ()
checkoutOptionsSetDirMode options dirMode = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    ggit_checkout_options_set_dir_mode options' dirMode
    touchManagedPtr options
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsSetDirModeMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetDirModeMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsSetDirMode

#endif

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

foreign import ccall "ggit_checkout_options_set_disable_filters" ggit_checkout_options_set_disable_filters :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    CInt ->                                 -- disable : TBasicType TBoolean
    IO ()

{- |
Set whether to disable filters.
-}
checkoutOptionsSetDisableFilters ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> Bool
    {- ^ /@disable@/: disable filters. -}
    -> m ()
checkoutOptionsSetDisableFilters options disable = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    let disable' = (fromIntegral . fromEnum) disable
    ggit_checkout_options_set_disable_filters options' disable'
    touchManagedPtr options
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsSetDisableFiltersMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetDisableFiltersMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsSetDisableFilters

#endif

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

foreign import ccall "ggit_checkout_options_set_file_mode" ggit_checkout_options_set_file_mode :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    Word32 ->                               -- file_mode : TBasicType TUInt
    IO ()

{- |
Set the default checkout file mode.
-}
checkoutOptionsSetFileMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> Word32
    {- ^ /@fileMode@/: the file mode. -}
    -> m ()
checkoutOptionsSetFileMode options fileMode = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    ggit_checkout_options_set_file_mode options' fileMode
    touchManagedPtr options
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsSetFileModeMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetFileModeMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsSetFileMode

#endif

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

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

{- |
Set the checkout file open flags. These flags are platform dependent,
e.g. on Unix use O_CREAT, O_TRUNC, etc.
-}
checkoutOptionsSetFileOpenFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> Int32
    {- ^ /@flags@/: the file open flags. -}
    -> m ()
checkoutOptionsSetFileOpenFlags options flags = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    ggit_checkout_options_set_file_open_flags options' flags
    touchManagedPtr options
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsSetFileOpenFlagsMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetFileOpenFlagsMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsSetFileOpenFlags

#endif

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

foreign import ccall "ggit_checkout_options_set_notify_flags" ggit_checkout_options_set_notify_flags :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Ggit", name = "CheckoutNotifyFlags"})
    IO ()

{- |
Set the checkout notify flags.
-}
checkoutOptionsSetNotifyFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> [Ggit.Flags.CheckoutNotifyFlags]
    {- ^ /@flags@/: a 'GI.Ggit.Flags.CheckoutNotifyFlags'. -}
    -> m ()
checkoutOptionsSetNotifyFlags options flags = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    let flags' = gflagsToWord flags
    ggit_checkout_options_set_notify_flags options' flags'
    touchManagedPtr options
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsSetNotifyFlagsMethodInfo
instance (signature ~ ([Ggit.Flags.CheckoutNotifyFlags] -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetNotifyFlagsMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsSetNotifyFlags

#endif

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

foreign import ccall "ggit_checkout_options_set_our_label" ggit_checkout_options_set_our_label :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    CString ->                              -- label : TBasicType TUTF8
    IO ()

{- |
Set the checkout our label.
-}
checkoutOptionsSetOurLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> Maybe (T.Text)
    {- ^ /@label@/: the our label. -}
    -> m ()
checkoutOptionsSetOurLabel options label = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    maybeLabel <- case label of
        Nothing -> return nullPtr
        Just jLabel -> do
            jLabel' <- textToCString jLabel
            return jLabel'
    ggit_checkout_options_set_our_label options' maybeLabel
    touchManagedPtr options
    freeMem maybeLabel
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsSetOurLabelMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetOurLabelMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsSetOurLabel

#endif

-- method CheckoutOptions::set_paths
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "paths", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a %NULL terminated list of paths.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_checkout_options_set_paths" ggit_checkout_options_set_paths :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    Ptr CString ->                          -- paths : TCArray True (-1) (-1) (TBasicType TUTF8)
    IO ()

{- |
Set the list of file paths to checkout. If /@paths@/ is 'Nothing', then all files
will be checked out.
-}
checkoutOptionsSetPaths ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> Maybe ([T.Text])
    {- ^ /@paths@/: a 'Nothing' terminated list of paths. -}
    -> m ()
checkoutOptionsSetPaths options paths = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    maybePaths <- case paths of
        Nothing -> return nullPtr
        Just jPaths -> do
            jPaths' <- packZeroTerminatedUTF8CArray jPaths
            return jPaths'
    ggit_checkout_options_set_paths options' maybePaths
    touchManagedPtr options
    mapZeroTerminatedCArray freeMem maybePaths
    freeMem maybePaths
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsSetPathsMethodInfo
instance (signature ~ (Maybe ([T.Text]) -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetPathsMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsSetPaths

#endif

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

foreign import ccall "ggit_checkout_options_set_strategy" ggit_checkout_options_set_strategy :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    CUInt ->                                -- strategy : TInterface (Name {namespace = "Ggit", name = "CheckoutStrategy"})
    IO ()

{- |
Set the checkout strategy.
-}
checkoutOptionsSetStrategy ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> [Ggit.Flags.CheckoutStrategy]
    {- ^ /@strategy@/: a 'GI.Ggit.Flags.CheckoutStrategy'. -}
    -> m ()
checkoutOptionsSetStrategy options strategy = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    let strategy' = gflagsToWord strategy
    ggit_checkout_options_set_strategy options' strategy'
    touchManagedPtr options
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsSetStrategyMethodInfo
instance (signature ~ ([Ggit.Flags.CheckoutStrategy] -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetStrategyMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsSetStrategy

#endif

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

foreign import ccall "ggit_checkout_options_set_target_directory" ggit_checkout_options_set_target_directory :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    CString ->                              -- directory : TBasicType TUTF8
    IO ()

{- |
Set the checkout target directory.
-}
checkoutOptionsSetTargetDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> Maybe (T.Text)
    {- ^ /@directory@/: the target directory. -}
    -> m ()
checkoutOptionsSetTargetDirectory options directory = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    maybeDirectory <- case directory of
        Nothing -> return nullPtr
        Just jDirectory -> do
            jDirectory' <- textToCString jDirectory
            return jDirectory'
    ggit_checkout_options_set_target_directory options' maybeDirectory
    touchManagedPtr options
    freeMem maybeDirectory
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsSetTargetDirectoryMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetTargetDirectoryMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsSetTargetDirectory

#endif

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

foreign import ccall "ggit_checkout_options_set_their_label" ggit_checkout_options_set_their_label :: 
    Ptr CheckoutOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    CString ->                              -- label : TBasicType TUTF8
    IO ()

{- |
Set the checkout their label.
-}
checkoutOptionsSetTheirLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> Maybe (T.Text)
    {- ^ /@label@/: the their label. -}
    -> m ()
checkoutOptionsSetTheirLabel options label = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    maybeLabel <- case label of
        Nothing -> return nullPtr
        Just jLabel -> do
            jLabel' <- textToCString jLabel
            return jLabel'
    ggit_checkout_options_set_their_label options' maybeLabel
    touchManagedPtr options
    freeMem maybeLabel
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CheckoutOptionsSetTheirLabelMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetTheirLabelMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsSetTheirLabel

#endif