{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Represents the options used when doign a checkout.

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

module GI.Ggit.Objects.CheckoutOptions
    (

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


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

#if defined(ENABLE_OVERLOADING)
    ResolveCheckoutOptionsMethod            ,
#endif


-- ** getAncestorLabel #method:getAncestorLabel#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsGetAncestorLabelMethodInfo,
#endif
    checkoutOptionsGetAncestorLabel         ,


-- ** getBaseline #method:getBaseline#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsGetBaselineMethodInfo    ,
#endif
    checkoutOptionsGetBaseline              ,


-- ** getDirMode #method:getDirMode#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsGetDirModeMethodInfo     ,
#endif
    checkoutOptionsGetDirMode               ,


-- ** getDisableFilters #method:getDisableFilters#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsGetDisableFiltersMethodInfo,
#endif
    checkoutOptionsGetDisableFilters        ,


-- ** getFileMode #method:getFileMode#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsGetFileModeMethodInfo    ,
#endif
    checkoutOptionsGetFileMode              ,


-- ** getFileOpenFlags #method:getFileOpenFlags#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsGetFileOpenFlagsMethodInfo,
#endif
    checkoutOptionsGetFileOpenFlags         ,


-- ** getNotifyFlags #method:getNotifyFlags#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsGetNotifyFlagsMethodInfo ,
#endif
    checkoutOptionsGetNotifyFlags           ,


-- ** getOurLabel #method:getOurLabel#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsGetOurLabelMethodInfo    ,
#endif
    checkoutOptionsGetOurLabel              ,


-- ** getPaths #method:getPaths#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsGetPathsMethodInfo       ,
#endif
    checkoutOptionsGetPaths                 ,


-- ** getStrategy #method:getStrategy#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsGetStrategyMethodInfo    ,
#endif
    checkoutOptionsGetStrategy              ,


-- ** getTargetDirectory #method:getTargetDirectory#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsGetTargetDirectoryMethodInfo,
#endif
    checkoutOptionsGetTargetDirectory       ,


-- ** getTheirLabel #method:getTheirLabel#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsGetTheirLabelMethodInfo  ,
#endif
    checkoutOptionsGetTheirLabel            ,


-- ** new #method:new#

    checkoutOptionsNew                      ,


-- ** setAncestorLabel #method:setAncestorLabel#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsSetAncestorLabelMethodInfo,
#endif
    checkoutOptionsSetAncestorLabel         ,


-- ** setBaseline #method:setBaseline#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsSetBaselineMethodInfo    ,
#endif
    checkoutOptionsSetBaseline              ,


-- ** setDirMode #method:setDirMode#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsSetDirModeMethodInfo     ,
#endif
    checkoutOptionsSetDirMode               ,


-- ** setDisableFilters #method:setDisableFilters#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsSetDisableFiltersMethodInfo,
#endif
    checkoutOptionsSetDisableFilters        ,


-- ** setFileMode #method:setFileMode#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsSetFileModeMethodInfo    ,
#endif
    checkoutOptionsSetFileMode              ,


-- ** setFileOpenFlags #method:setFileOpenFlags#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsSetFileOpenFlagsMethodInfo,
#endif
    checkoutOptionsSetFileOpenFlags         ,


-- ** setNotifyFlags #method:setNotifyFlags#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsSetNotifyFlagsMethodInfo ,
#endif
    checkoutOptionsSetNotifyFlags           ,


-- ** setOurLabel #method:setOurLabel#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsSetOurLabelMethodInfo    ,
#endif
    checkoutOptionsSetOurLabel              ,


-- ** setPaths #method:setPaths#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsSetPathsMethodInfo       ,
#endif
    checkoutOptionsSetPaths                 ,


-- ** setStrategy #method:setStrategy#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsSetStrategyMethodInfo    ,
#endif
    checkoutOptionsSetStrategy              ,


-- ** setTargetDirectory #method:setTargetDirectory#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsSetTargetDirectoryMethodInfo,
#endif
    checkoutOptionsSetTargetDirectory       ,


-- ** setTheirLabel #method:setTheirLabel#

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsSetTheirLabelMethodInfo  ,
#endif
    checkoutOptionsSetTheirLabel            ,




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

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsAncestorLabelPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    checkoutOptionsAncestorLabel            ,
#endif
    clearCheckoutOptionsAncestorLabel       ,
    constructCheckoutOptionsAncestorLabel   ,
    getCheckoutOptionsAncestorLabel         ,
    setCheckoutOptionsAncestorLabel         ,


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

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsBaselinePropertyInfo     ,
#endif
#if defined(ENABLE_OVERLOADING)
    checkoutOptionsBaseline                 ,
#endif
    clearCheckoutOptionsBaseline            ,
    constructCheckoutOptionsBaseline        ,
    getCheckoutOptionsBaseline              ,
    setCheckoutOptionsBaseline              ,


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

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsDirModePropertyInfo      ,
#endif
#if defined(ENABLE_OVERLOADING)
    checkoutOptionsDirMode                  ,
#endif
    constructCheckoutOptionsDirMode         ,
    getCheckoutOptionsDirMode               ,
    setCheckoutOptionsDirMode               ,


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

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsDisableFiltersPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    checkoutOptionsDisableFilters           ,
#endif
    constructCheckoutOptionsDisableFilters  ,
    getCheckoutOptionsDisableFilters        ,
    setCheckoutOptionsDisableFilters        ,


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

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsFileModePropertyInfo     ,
#endif
#if defined(ENABLE_OVERLOADING)
    checkoutOptionsFileMode                 ,
#endif
    constructCheckoutOptionsFileMode        ,
    getCheckoutOptionsFileMode              ,
    setCheckoutOptionsFileMode              ,


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

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsFileOpenFlagsPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    checkoutOptionsFileOpenFlags            ,
#endif
    constructCheckoutOptionsFileOpenFlags   ,
    getCheckoutOptionsFileOpenFlags         ,
    setCheckoutOptionsFileOpenFlags         ,


-- ** notifyFlags #attr:notifyFlags#
-- | The checkout notify flags.

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsNotifyFlagsPropertyInfo  ,
#endif
#if defined(ENABLE_OVERLOADING)
    checkoutOptionsNotifyFlags              ,
#endif
    constructCheckoutOptionsNotifyFlags     ,
    getCheckoutOptionsNotifyFlags           ,
    setCheckoutOptionsNotifyFlags           ,


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

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsOurLabelPropertyInfo     ,
#endif
#if defined(ENABLE_OVERLOADING)
    checkoutOptionsOurLabel                 ,
#endif
    clearCheckoutOptionsOurLabel            ,
    constructCheckoutOptionsOurLabel        ,
    getCheckoutOptionsOurLabel              ,
    setCheckoutOptionsOurLabel              ,


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

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsStrategyPropertyInfo     ,
#endif
#if defined(ENABLE_OVERLOADING)
    checkoutOptionsStrategy                 ,
#endif
    constructCheckoutOptionsStrategy        ,
    getCheckoutOptionsStrategy              ,
    setCheckoutOptionsStrategy              ,


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

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsTargetDirectoryPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    checkoutOptionsTargetDirectory          ,
#endif
    clearCheckoutOptionsTargetDirectory     ,
    constructCheckoutOptionsTargetDirectory ,
    getCheckoutOptionsTargetDirectory       ,
    setCheckoutOptionsTargetDirectory       ,


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

#if defined(ENABLE_OVERLOADING)
    CheckoutOptionsTheirLabelPropertyInfo   ,
#endif
#if defined(ENABLE_OVERLOADING)
    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.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.Flags as Ggit.Flags
import {-# SOURCE #-} qualified GI.Ggit.Objects.Tree as Ggit.Tree

-- | Memory-managed wrapper type.
newtype CheckoutOptions = CheckoutOptions (ManagedPtr CheckoutOptions)
    deriving (Eq)
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


-- | Convert 'CheckoutOptions' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue CheckoutOptions where
    toGValue o = do
        gtype <- c_ggit_checkout_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 CheckoutOptions)
        B.ManagedPtr.newObject CheckoutOptions ptr



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

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

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

-- | A convenience alias for `Nothing` :: `Maybe` `CheckoutOptions`.
noCheckoutOptions :: Maybe CheckoutOptions
noCheckoutOptions = Nothing

#if defined(ENABLE_OVERLOADING)
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 "getv" o = GObject.Object.ObjectGetvMethodInfo
    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 "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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    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) => OL.IsLabel t (CheckoutOptions -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

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

-- | Get the value of the “@ancestor-label@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' checkoutOptions #ancestorLabel
-- @
getCheckoutOptionsAncestorLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe T.Text)
getCheckoutOptionsAncestorLabel obj = liftIO $ B.Properties.getObjectPropertyString obj "ancestor-label"

-- | Set the value of the “@ancestor-label@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' checkoutOptions [ #ancestorLabel 'Data.GI.Base.Attributes.:=' value ]
-- @
setCheckoutOptionsAncestorLabel :: (MonadIO m, IsCheckoutOptions o) => o -> T.Text -> m ()
setCheckoutOptionsAncestorLabel obj val = liftIO $ B.Properties.setObjectPropertyString obj "ancestor-label" (Just val)

-- | Construct a `GValueConstruct` with valid value for the “@ancestor-label@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCheckoutOptionsAncestorLabel :: (IsCheckoutOptions o) => T.Text -> IO (GValueConstruct o)
constructCheckoutOptionsAncestorLabel val = B.Properties.constructObjectPropertyString "ancestor-label" (Just val)

-- | Set the value of the “@ancestor-label@” 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' #ancestorLabel
-- @
clearCheckoutOptionsAncestorLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m ()
clearCheckoutOptionsAncestorLabel obj = liftIO $ B.Properties.setObjectPropertyString obj "ancestor-label" (Nothing :: Maybe T.Text)

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

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

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

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

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

-- | Set the value of the “@baseline@” 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' #baseline
-- @
clearCheckoutOptionsBaseline :: (MonadIO m, IsCheckoutOptions o) => o -> m ()
clearCheckoutOptionsBaseline obj = liftIO $ B.Properties.setObjectPropertyObject obj "baseline" (Nothing :: Maybe Ggit.Tree.Tree)

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

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

-- | Get the value of the “@dir-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' checkoutOptions #dirMode
-- @
getCheckoutOptionsDirMode :: (MonadIO m, IsCheckoutOptions o) => o -> m Word32
getCheckoutOptionsDirMode obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "dir-mode"

-- | Set the value of the “@dir-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' checkoutOptions [ #dirMode 'Data.GI.Base.Attributes.:=' value ]
-- @
setCheckoutOptionsDirMode :: (MonadIO m, IsCheckoutOptions o) => o -> Word32 -> m ()
setCheckoutOptionsDirMode obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "dir-mode" val

-- | Construct a `GValueConstruct` with valid value for the “@dir-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCheckoutOptionsDirMode :: (IsCheckoutOptions o) => Word32 -> IO (GValueConstruct o)
constructCheckoutOptionsDirMode val = B.Properties.constructObjectPropertyUInt32 "dir-mode" val

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

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

-- | Get the value of the “@disable-filters@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' checkoutOptions #disableFilters
-- @
getCheckoutOptionsDisableFilters :: (MonadIO m, IsCheckoutOptions o) => o -> m Bool
getCheckoutOptionsDisableFilters obj = liftIO $ B.Properties.getObjectPropertyBool obj "disable-filters"

-- | Set the value of the “@disable-filters@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' checkoutOptions [ #disableFilters 'Data.GI.Base.Attributes.:=' value ]
-- @
setCheckoutOptionsDisableFilters :: (MonadIO m, IsCheckoutOptions o) => o -> Bool -> m ()
setCheckoutOptionsDisableFilters obj val = liftIO $ B.Properties.setObjectPropertyBool obj "disable-filters" val

-- | Construct a `GValueConstruct` with valid value for the “@disable-filters@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCheckoutOptionsDisableFilters :: (IsCheckoutOptions o) => Bool -> IO (GValueConstruct o)
constructCheckoutOptionsDisableFilters val = B.Properties.constructObjectPropertyBool "disable-filters" val

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

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

-- | Get the value of the “@file-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' checkoutOptions #fileMode
-- @
getCheckoutOptionsFileMode :: (MonadIO m, IsCheckoutOptions o) => o -> m Word32
getCheckoutOptionsFileMode obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "file-mode"

-- | Set the value of the “@file-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' checkoutOptions [ #fileMode 'Data.GI.Base.Attributes.:=' value ]
-- @
setCheckoutOptionsFileMode :: (MonadIO m, IsCheckoutOptions o) => o -> Word32 -> m ()
setCheckoutOptionsFileMode obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "file-mode" val

-- | Construct a `GValueConstruct` with valid value for the “@file-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCheckoutOptionsFileMode :: (IsCheckoutOptions o) => Word32 -> IO (GValueConstruct o)
constructCheckoutOptionsFileMode val = B.Properties.constructObjectPropertyUInt32 "file-mode" val

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

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

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

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

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

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

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

-- | Get the value of the “@notify-flags@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' checkoutOptions #notifyFlags
-- @
getCheckoutOptionsNotifyFlags :: (MonadIO m, IsCheckoutOptions o) => o -> m [Ggit.Flags.CheckoutNotifyFlags]
getCheckoutOptionsNotifyFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "notify-flags"

-- | Set the value of the “@notify-flags@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' checkoutOptions [ #notifyFlags 'Data.GI.Base.Attributes.:=' value ]
-- @
setCheckoutOptionsNotifyFlags :: (MonadIO m, IsCheckoutOptions o) => o -> [Ggit.Flags.CheckoutNotifyFlags] -> m ()
setCheckoutOptionsNotifyFlags obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "notify-flags" val

-- | Construct a `GValueConstruct` with valid value for the “@notify-flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCheckoutOptionsNotifyFlags :: (IsCheckoutOptions o) => [Ggit.Flags.CheckoutNotifyFlags] -> IO (GValueConstruct o)
constructCheckoutOptionsNotifyFlags val = B.Properties.constructObjectPropertyFlags "notify-flags" val

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

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

-- | Get the value of the “@our-label@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' checkoutOptions #ourLabel
-- @
getCheckoutOptionsOurLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe T.Text)
getCheckoutOptionsOurLabel obj = liftIO $ B.Properties.getObjectPropertyString obj "our-label"

-- | Set the value of the “@our-label@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' checkoutOptions [ #ourLabel 'Data.GI.Base.Attributes.:=' value ]
-- @
setCheckoutOptionsOurLabel :: (MonadIO m, IsCheckoutOptions o) => o -> T.Text -> m ()
setCheckoutOptionsOurLabel obj val = liftIO $ B.Properties.setObjectPropertyString obj "our-label" (Just val)

-- | Construct a `GValueConstruct` with valid value for the “@our-label@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCheckoutOptionsOurLabel :: (IsCheckoutOptions o) => T.Text -> IO (GValueConstruct o)
constructCheckoutOptionsOurLabel val = B.Properties.constructObjectPropertyString "our-label" (Just val)

-- | Set the value of the “@our-label@” 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' #ourLabel
-- @
clearCheckoutOptionsOurLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m ()
clearCheckoutOptionsOurLabel obj = liftIO $ B.Properties.setObjectPropertyString obj "our-label" (Nothing :: Maybe T.Text)

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

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

-- | Get the value of the “@strategy@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' checkoutOptions #strategy
-- @
getCheckoutOptionsStrategy :: (MonadIO m, IsCheckoutOptions o) => o -> m [Ggit.Flags.CheckoutStrategy]
getCheckoutOptionsStrategy obj = liftIO $ B.Properties.getObjectPropertyFlags obj "strategy"

-- | Set the value of the “@strategy@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' checkoutOptions [ #strategy 'Data.GI.Base.Attributes.:=' value ]
-- @
setCheckoutOptionsStrategy :: (MonadIO m, IsCheckoutOptions o) => o -> [Ggit.Flags.CheckoutStrategy] -> m ()
setCheckoutOptionsStrategy obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "strategy" val

-- | Construct a `GValueConstruct` with valid value for the “@strategy@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCheckoutOptionsStrategy :: (IsCheckoutOptions o) => [Ggit.Flags.CheckoutStrategy] -> IO (GValueConstruct o)
constructCheckoutOptionsStrategy val = B.Properties.constructObjectPropertyFlags "strategy" val

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

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

-- | Get the value of the “@target-directory@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' checkoutOptions #targetDirectory
-- @
getCheckoutOptionsTargetDirectory :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe T.Text)
getCheckoutOptionsTargetDirectory obj = liftIO $ B.Properties.getObjectPropertyString obj "target-directory"

-- | Set the value of the “@target-directory@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' checkoutOptions [ #targetDirectory 'Data.GI.Base.Attributes.:=' value ]
-- @
setCheckoutOptionsTargetDirectory :: (MonadIO m, IsCheckoutOptions o) => o -> T.Text -> m ()
setCheckoutOptionsTargetDirectory obj val = liftIO $ B.Properties.setObjectPropertyString obj "target-directory" (Just val)

-- | Construct a `GValueConstruct` with valid value for the “@target-directory@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCheckoutOptionsTargetDirectory :: (IsCheckoutOptions o) => T.Text -> IO (GValueConstruct o)
constructCheckoutOptionsTargetDirectory val = B.Properties.constructObjectPropertyString "target-directory" (Just val)

-- | Set the value of the “@target-directory@” 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' #targetDirectory
-- @
clearCheckoutOptionsTargetDirectory :: (MonadIO m, IsCheckoutOptions o) => o -> m ()
clearCheckoutOptionsTargetDirectory obj = liftIO $ B.Properties.setObjectPropertyString obj "target-directory" (Nothing :: Maybe T.Text)

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

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

-- | Get the value of the “@their-label@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' checkoutOptions #theirLabel
-- @
getCheckoutOptionsTheirLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe T.Text)
getCheckoutOptionsTheirLabel obj = liftIO $ B.Properties.getObjectPropertyString obj "their-label"

-- | Set the value of the “@their-label@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' checkoutOptions [ #theirLabel 'Data.GI.Base.Attributes.:=' value ]
-- @
setCheckoutOptionsTheirLabel :: (MonadIO m, IsCheckoutOptions o) => o -> T.Text -> m ()
setCheckoutOptionsTheirLabel obj val = liftIO $ B.Properties.setObjectPropertyString obj "their-label" (Just val)

-- | Construct a `GValueConstruct` with valid value for the “@their-label@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCheckoutOptionsTheirLabel :: (IsCheckoutOptions o) => T.Text -> IO (GValueConstruct o)
constructCheckoutOptionsTheirLabel val = B.Properties.constructObjectPropertyString "their-label" (Just val)

-- | Set the value of the “@their-label@” 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' #theirLabel
-- @
clearCheckoutOptionsTheirLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m ()
clearCheckoutOptionsTheirLabel obj = liftIO $ B.Properties.setObjectPropertyString obj "their-label" (Nothing :: Maybe T.Text)

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

#if defined(ENABLE_OVERLOADING)
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)
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)
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 (Maybe CheckoutOptions)
    -- ^ __Returns:__ a t'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions' or 'P.Nothing'.
checkoutOptionsNew  = liftIO $ do
    result <- ggit_checkout_options_new
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject CheckoutOptions) result'
        return result''
    return maybeResult

#if defined(ENABLE_OVERLOADING)
#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 t'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the checkout ancestor label or 'P.Nothing'.
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)
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 t'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'.
    -> m (Maybe Ggit.Tree.Tree)
    -- ^ __Returns:__ a t'GI.Ggit.Objects.Tree.Tree' or 'P.Nothing'.
checkoutOptionsGetBaseline options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_baseline options'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Ggit.Tree.Tree) result'
        return result''
    touchManagedPtr options
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data CheckoutOptionsGetBaselineMethodInfo
instance (signature ~ (m (Maybe 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 t'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)
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 t'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if filters are disabled, 'P.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)
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 t'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)
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 t'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)
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 t'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'.
    -> m [Ggit.Flags.CheckoutNotifyFlags]
    -- ^ __Returns:__ a t'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)
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 t'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the checkout our label or 'P.Nothing'.
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)
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 t'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'.
    -> m (Maybe [T.Text])
    -- ^ __Returns:__ a 'P.Nothing' terminated list of file paths, or 'P.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)
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 t'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'.
    -> m [Ggit.Flags.CheckoutStrategy]
    -- ^ __Returns:__ a t'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)
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 t'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the checkout target directory or 'P.Nothing'.
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)
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 t'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the checkout their label or 'P.Nothing'.
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)
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 t'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)
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 'P.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 t'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'.
    -> Maybe (b)
    -- ^ /@tree@/: a t'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)
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 t'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)
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 t'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)
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 t'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)
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 t'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)
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 t'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'.
    -> [Ggit.Flags.CheckoutNotifyFlags]
    -- ^ /@flags@/: a t'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)
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 t'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)
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 'P.Nothing', then all files
-- will be checked out.
checkoutOptionsSetPaths ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) =>
    a
    -- ^ /@options@/: a t'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'.
    -> Maybe ([T.Text])
    -- ^ /@paths@/: a 'P.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)
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 t'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'.
    -> [Ggit.Flags.CheckoutStrategy]
    -- ^ /@strategy@/: a t'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)
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 t'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)
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 t'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)
data CheckoutOptionsSetTheirLabelMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetTheirLabelMethodInfo a signature where
    overloadedMethod = checkoutOptionsSetTheirLabel

#endif