gi-ggit-1.0.4: GI/Ggit/Objects/CheckoutOptions.hs

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

Represents the options used when doign a checkout.
-}

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

module GI.Ggit.Objects.CheckoutOptions
    ( 

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


 -- * Methods
-- ** getAncestorLabel #method:getAncestorLabel#

#if ENABLE_OVERLOADING
    CheckoutOptionsGetAncestorLabelMethodInfo,
#endif
    checkoutOptionsGetAncestorLabel         ,


-- ** getBaseline #method:getBaseline#

#if ENABLE_OVERLOADING
    CheckoutOptionsGetBaselineMethodInfo    ,
#endif
    checkoutOptionsGetBaseline              ,


-- ** getDirMode #method:getDirMode#

#if ENABLE_OVERLOADING
    CheckoutOptionsGetDirModeMethodInfo     ,
#endif
    checkoutOptionsGetDirMode               ,


-- ** getDisableFilters #method:getDisableFilters#

#if ENABLE_OVERLOADING
    CheckoutOptionsGetDisableFiltersMethodInfo,
#endif
    checkoutOptionsGetDisableFilters        ,


-- ** getFileMode #method:getFileMode#

#if ENABLE_OVERLOADING
    CheckoutOptionsGetFileModeMethodInfo    ,
#endif
    checkoutOptionsGetFileMode              ,


-- ** getFileOpenFlags #method:getFileOpenFlags#

#if ENABLE_OVERLOADING
    CheckoutOptionsGetFileOpenFlagsMethodInfo,
#endif
    checkoutOptionsGetFileOpenFlags         ,


-- ** getNotifyFlags #method:getNotifyFlags#

#if ENABLE_OVERLOADING
    CheckoutOptionsGetNotifyFlagsMethodInfo ,
#endif
    checkoutOptionsGetNotifyFlags           ,


-- ** getOurLabel #method:getOurLabel#

#if ENABLE_OVERLOADING
    CheckoutOptionsGetOurLabelMethodInfo    ,
#endif
    checkoutOptionsGetOurLabel              ,


-- ** getPaths #method:getPaths#

#if ENABLE_OVERLOADING
    CheckoutOptionsGetPathsMethodInfo       ,
#endif
    checkoutOptionsGetPaths                 ,


-- ** getStrategy #method:getStrategy#

#if ENABLE_OVERLOADING
    CheckoutOptionsGetStrategyMethodInfo    ,
#endif
    checkoutOptionsGetStrategy              ,


-- ** getTargetDirectory #method:getTargetDirectory#

#if ENABLE_OVERLOADING
    CheckoutOptionsGetTargetDirectoryMethodInfo,
#endif
    checkoutOptionsGetTargetDirectory       ,


-- ** getTheirLabel #method:getTheirLabel#

#if ENABLE_OVERLOADING
    CheckoutOptionsGetTheirLabelMethodInfo  ,
#endif
    checkoutOptionsGetTheirLabel            ,


-- ** new #method:new#

    checkoutOptionsNew                      ,


-- ** setAncestorLabel #method:setAncestorLabel#

#if ENABLE_OVERLOADING
    CheckoutOptionsSetAncestorLabelMethodInfo,
#endif
    checkoutOptionsSetAncestorLabel         ,


-- ** setBaseline #method:setBaseline#

#if ENABLE_OVERLOADING
    CheckoutOptionsSetBaselineMethodInfo    ,
#endif
    checkoutOptionsSetBaseline              ,


-- ** setDirMode #method:setDirMode#

#if ENABLE_OVERLOADING
    CheckoutOptionsSetDirModeMethodInfo     ,
#endif
    checkoutOptionsSetDirMode               ,


-- ** setDisableFilters #method:setDisableFilters#

#if ENABLE_OVERLOADING
    CheckoutOptionsSetDisableFiltersMethodInfo,
#endif
    checkoutOptionsSetDisableFilters        ,


-- ** setFileMode #method:setFileMode#

#if ENABLE_OVERLOADING
    CheckoutOptionsSetFileModeMethodInfo    ,
#endif
    checkoutOptionsSetFileMode              ,


-- ** setFileOpenFlags #method:setFileOpenFlags#

#if ENABLE_OVERLOADING
    CheckoutOptionsSetFileOpenFlagsMethodInfo,
#endif
    checkoutOptionsSetFileOpenFlags         ,


-- ** setNotifyFlags #method:setNotifyFlags#

#if ENABLE_OVERLOADING
    CheckoutOptionsSetNotifyFlagsMethodInfo ,
#endif
    checkoutOptionsSetNotifyFlags           ,


-- ** setOurLabel #method:setOurLabel#

#if ENABLE_OVERLOADING
    CheckoutOptionsSetOurLabelMethodInfo    ,
#endif
    checkoutOptionsSetOurLabel              ,


-- ** setPaths #method:setPaths#

#if ENABLE_OVERLOADING
    CheckoutOptionsSetPathsMethodInfo       ,
#endif
    checkoutOptionsSetPaths                 ,


-- ** setStrategy #method:setStrategy#

#if ENABLE_OVERLOADING
    CheckoutOptionsSetStrategyMethodInfo    ,
#endif
    checkoutOptionsSetStrategy              ,


-- ** setTargetDirectory #method:setTargetDirectory#

#if ENABLE_OVERLOADING
    CheckoutOptionsSetTargetDirectoryMethodInfo,
#endif
    checkoutOptionsSetTargetDirectory       ,


-- ** setTheirLabel #method:setTheirLabel#

#if ENABLE_OVERLOADING
    CheckoutOptionsSetTheirLabelMethodInfo  ,
#endif
    checkoutOptionsSetTheirLabel            ,




 -- * Properties
-- ** ancestorLabel #attr:ancestorLabel#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CheckoutOptionsAncestorLabelPropertyInfo,
#endif
#if ENABLE_OVERLOADING
    checkoutOptionsAncestorLabel            ,
#endif
    clearCheckoutOptionsAncestorLabel       ,
    constructCheckoutOptionsAncestorLabel   ,
    getCheckoutOptionsAncestorLabel         ,
    setCheckoutOptionsAncestorLabel         ,


-- ** baseline #attr:baseline#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CheckoutOptionsBaselinePropertyInfo     ,
#endif
#if ENABLE_OVERLOADING
    checkoutOptionsBaseline                 ,
#endif
    clearCheckoutOptionsBaseline            ,
    constructCheckoutOptionsBaseline        ,
    getCheckoutOptionsBaseline              ,
    setCheckoutOptionsBaseline              ,


-- ** dirMode #attr:dirMode#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CheckoutOptionsDirModePropertyInfo      ,
#endif
#if ENABLE_OVERLOADING
    checkoutOptionsDirMode                  ,
#endif
    constructCheckoutOptionsDirMode         ,
    getCheckoutOptionsDirMode               ,
    setCheckoutOptionsDirMode               ,


-- ** disableFilters #attr:disableFilters#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CheckoutOptionsDisableFiltersPropertyInfo,
#endif
#if ENABLE_OVERLOADING
    checkoutOptionsDisableFilters           ,
#endif
    constructCheckoutOptionsDisableFilters  ,
    getCheckoutOptionsDisableFilters        ,
    setCheckoutOptionsDisableFilters        ,


-- ** fileMode #attr:fileMode#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CheckoutOptionsFileModePropertyInfo     ,
#endif
#if ENABLE_OVERLOADING
    checkoutOptionsFileMode                 ,
#endif
    constructCheckoutOptionsFileMode        ,
    getCheckoutOptionsFileMode              ,
    setCheckoutOptionsFileMode              ,


-- ** fileOpenFlags #attr:fileOpenFlags#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CheckoutOptionsFileOpenFlagsPropertyInfo,
#endif
#if ENABLE_OVERLOADING
    checkoutOptionsFileOpenFlags            ,
#endif
    constructCheckoutOptionsFileOpenFlags   ,
    getCheckoutOptionsFileOpenFlags         ,
    setCheckoutOptionsFileOpenFlags         ,


-- ** notifyFlags #attr:notifyFlags#
{- | The checkout notify flags.
-}
#if ENABLE_OVERLOADING
    CheckoutOptionsNotifyFlagsPropertyInfo  ,
#endif
#if ENABLE_OVERLOADING
    checkoutOptionsNotifyFlags              ,
#endif
    constructCheckoutOptionsNotifyFlags     ,
    getCheckoutOptionsNotifyFlags           ,
    setCheckoutOptionsNotifyFlags           ,


-- ** ourLabel #attr:ourLabel#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CheckoutOptionsOurLabelPropertyInfo     ,
#endif
#if ENABLE_OVERLOADING
    checkoutOptionsOurLabel                 ,
#endif
    clearCheckoutOptionsOurLabel            ,
    constructCheckoutOptionsOurLabel        ,
    getCheckoutOptionsOurLabel              ,
    setCheckoutOptionsOurLabel              ,


-- ** strategy #attr:strategy#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CheckoutOptionsStrategyPropertyInfo     ,
#endif
#if ENABLE_OVERLOADING
    checkoutOptionsStrategy                 ,
#endif
    constructCheckoutOptionsStrategy        ,
    getCheckoutOptionsStrategy              ,
    setCheckoutOptionsStrategy              ,


-- ** targetDirectory #attr:targetDirectory#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CheckoutOptionsTargetDirectoryPropertyInfo,
#endif
#if ENABLE_OVERLOADING
    checkoutOptionsTargetDirectory          ,
#endif
    clearCheckoutOptionsTargetDirectory     ,
    constructCheckoutOptionsTargetDirectory ,
    getCheckoutOptionsTargetDirectory       ,
    setCheckoutOptionsTargetDirectory       ,


-- ** theirLabel #attr:theirLabel#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CheckoutOptionsTheirLabelPropertyInfo   ,
#endif
#if 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.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)
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
    

-- | 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 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 "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 (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy 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 ENABLE_OVERLOADING
data CheckoutOptionsAncestorLabelPropertyInfo
instance AttrInfo CheckoutOptionsAncestorLabelPropertyInfo where
    type AttrAllowedOps CheckoutOptionsAncestorLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CheckoutOptionsAncestorLabelPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CheckoutOptionsAncestorLabelPropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsAncestorLabelPropertyInfo = (Maybe T.Text)
    type AttrLabel CheckoutOptionsAncestorLabelPropertyInfo = "ancestor-label"
    type AttrOrigin CheckoutOptionsAncestorLabelPropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsAncestorLabel
    attrSet _ = setCheckoutOptionsAncestorLabel
    attrConstruct _ = constructCheckoutOptionsAncestorLabel
    attrClear _ = clearCheckoutOptionsAncestorLabel
#endif

-- VVV Prop "baseline"
   -- Type: TInterface (Name {namespace = "Ggit", name = "Tree"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just 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 ENABLE_OVERLOADING
data CheckoutOptionsBaselinePropertyInfo
instance AttrInfo CheckoutOptionsBaselinePropertyInfo where
    type AttrAllowedOps CheckoutOptionsBaselinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CheckoutOptionsBaselinePropertyInfo = Ggit.Tree.IsTree
    type AttrBaseTypeConstraint CheckoutOptionsBaselinePropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsBaselinePropertyInfo = (Maybe Ggit.Tree.Tree)
    type AttrLabel CheckoutOptionsBaselinePropertyInfo = "baseline"
    type AttrOrigin CheckoutOptionsBaselinePropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsBaseline
    attrSet _ = setCheckoutOptionsBaseline
    attrConstruct _ = constructCheckoutOptionsBaseline
    attrClear _ = clearCheckoutOptionsBaseline
#endif

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

{- |
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 ENABLE_OVERLOADING
data CheckoutOptionsDirModePropertyInfo
instance AttrInfo CheckoutOptionsDirModePropertyInfo where
    type AttrAllowedOps CheckoutOptionsDirModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CheckoutOptionsDirModePropertyInfo = (~) Word32
    type AttrBaseTypeConstraint CheckoutOptionsDirModePropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsDirModePropertyInfo = Word32
    type AttrLabel CheckoutOptionsDirModePropertyInfo = "dir-mode"
    type AttrOrigin CheckoutOptionsDirModePropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsDirMode
    attrSet _ = setCheckoutOptionsDirMode
    attrConstruct _ = constructCheckoutOptionsDirMode
    attrClear _ = undefined
#endif

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

{- |
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 ENABLE_OVERLOADING
data CheckoutOptionsDisableFiltersPropertyInfo
instance AttrInfo CheckoutOptionsDisableFiltersPropertyInfo where
    type AttrAllowedOps CheckoutOptionsDisableFiltersPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CheckoutOptionsDisableFiltersPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint CheckoutOptionsDisableFiltersPropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsDisableFiltersPropertyInfo = Bool
    type AttrLabel CheckoutOptionsDisableFiltersPropertyInfo = "disable-filters"
    type AttrOrigin CheckoutOptionsDisableFiltersPropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsDisableFilters
    attrSet _ = setCheckoutOptionsDisableFilters
    attrConstruct _ = constructCheckoutOptionsDisableFilters
    attrClear _ = undefined
#endif

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

{- |
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 ENABLE_OVERLOADING
data CheckoutOptionsFileModePropertyInfo
instance AttrInfo CheckoutOptionsFileModePropertyInfo where
    type AttrAllowedOps CheckoutOptionsFileModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CheckoutOptionsFileModePropertyInfo = (~) Word32
    type AttrBaseTypeConstraint CheckoutOptionsFileModePropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsFileModePropertyInfo = Word32
    type AttrLabel CheckoutOptionsFileModePropertyInfo = "file-mode"
    type AttrOrigin CheckoutOptionsFileModePropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsFileMode
    attrSet _ = setCheckoutOptionsFileMode
    attrConstruct _ = constructCheckoutOptionsFileMode
    attrClear _ = undefined
#endif

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

{- |
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 ENABLE_OVERLOADING
data CheckoutOptionsFileOpenFlagsPropertyInfo
instance AttrInfo CheckoutOptionsFileOpenFlagsPropertyInfo where
    type AttrAllowedOps CheckoutOptionsFileOpenFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CheckoutOptionsFileOpenFlagsPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint CheckoutOptionsFileOpenFlagsPropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsFileOpenFlagsPropertyInfo = Int32
    type AttrLabel CheckoutOptionsFileOpenFlagsPropertyInfo = "file-open-flags"
    type AttrOrigin CheckoutOptionsFileOpenFlagsPropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsFileOpenFlags
    attrSet _ = setCheckoutOptionsFileOpenFlags
    attrConstruct _ = constructCheckoutOptionsFileOpenFlags
    attrClear _ = undefined
#endif

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

{- |
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 ENABLE_OVERLOADING
data CheckoutOptionsNotifyFlagsPropertyInfo
instance AttrInfo CheckoutOptionsNotifyFlagsPropertyInfo where
    type AttrAllowedOps CheckoutOptionsNotifyFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CheckoutOptionsNotifyFlagsPropertyInfo = (~) [Ggit.Flags.CheckoutNotifyFlags]
    type AttrBaseTypeConstraint CheckoutOptionsNotifyFlagsPropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsNotifyFlagsPropertyInfo = [Ggit.Flags.CheckoutNotifyFlags]
    type AttrLabel CheckoutOptionsNotifyFlagsPropertyInfo = "notify-flags"
    type AttrOrigin CheckoutOptionsNotifyFlagsPropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsNotifyFlags
    attrSet _ = setCheckoutOptionsNotifyFlags
    attrConstruct _ = constructCheckoutOptionsNotifyFlags
    attrClear _ = undefined
#endif

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

{- |
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 ENABLE_OVERLOADING
data CheckoutOptionsOurLabelPropertyInfo
instance AttrInfo CheckoutOptionsOurLabelPropertyInfo where
    type AttrAllowedOps CheckoutOptionsOurLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CheckoutOptionsOurLabelPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CheckoutOptionsOurLabelPropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsOurLabelPropertyInfo = (Maybe T.Text)
    type AttrLabel CheckoutOptionsOurLabelPropertyInfo = "our-label"
    type AttrOrigin CheckoutOptionsOurLabelPropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsOurLabel
    attrSet _ = setCheckoutOptionsOurLabel
    attrConstruct _ = constructCheckoutOptionsOurLabel
    attrClear _ = clearCheckoutOptionsOurLabel
#endif

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

{- |
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 ENABLE_OVERLOADING
data CheckoutOptionsStrategyPropertyInfo
instance AttrInfo CheckoutOptionsStrategyPropertyInfo where
    type AttrAllowedOps CheckoutOptionsStrategyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CheckoutOptionsStrategyPropertyInfo = (~) [Ggit.Flags.CheckoutStrategy]
    type AttrBaseTypeConstraint CheckoutOptionsStrategyPropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsStrategyPropertyInfo = [Ggit.Flags.CheckoutStrategy]
    type AttrLabel CheckoutOptionsStrategyPropertyInfo = "strategy"
    type AttrOrigin CheckoutOptionsStrategyPropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsStrategy
    attrSet _ = setCheckoutOptionsStrategy
    attrConstruct _ = constructCheckoutOptionsStrategy
    attrClear _ = undefined
#endif

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

{- |
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 ENABLE_OVERLOADING
data CheckoutOptionsTargetDirectoryPropertyInfo
instance AttrInfo CheckoutOptionsTargetDirectoryPropertyInfo where
    type AttrAllowedOps CheckoutOptionsTargetDirectoryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CheckoutOptionsTargetDirectoryPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CheckoutOptionsTargetDirectoryPropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsTargetDirectoryPropertyInfo = (Maybe T.Text)
    type AttrLabel CheckoutOptionsTargetDirectoryPropertyInfo = "target-directory"
    type AttrOrigin CheckoutOptionsTargetDirectoryPropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsTargetDirectory
    attrSet _ = setCheckoutOptionsTargetDirectory
    attrConstruct _ = constructCheckoutOptionsTargetDirectory
    attrClear _ = clearCheckoutOptionsTargetDirectory
#endif

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

{- |
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 ENABLE_OVERLOADING
data CheckoutOptionsTheirLabelPropertyInfo
instance AttrInfo CheckoutOptionsTheirLabelPropertyInfo where
    type AttrAllowedOps CheckoutOptionsTheirLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CheckoutOptionsTheirLabelPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CheckoutOptionsTheirLabelPropertyInfo = IsCheckoutOptions
    type AttrGetType CheckoutOptionsTheirLabelPropertyInfo = (Maybe T.Text)
    type AttrLabel CheckoutOptionsTheirLabelPropertyInfo = "their-label"
    type AttrOrigin CheckoutOptionsTheirLabelPropertyInfo = CheckoutOptions
    attrGet _ = getCheckoutOptionsTheirLabel
    attrSet _ = setCheckoutOptionsTheirLabel
    attrConstruct _ = constructCheckoutOptionsTheirLabel
    attrClear _ = clearCheckoutOptionsTheirLabel
#endif

#if 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 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 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 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions' or 'Nothing'. -}
checkoutOptionsNew  = liftIO $ do
    result <- ggit_checkout_options_new
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject CheckoutOptions) result'
        return result''
    return maybeResult

#if 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 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the checkout ancestor label or '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 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 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m (Maybe Ggit.Tree.Tree)
    {- ^ __Returns:__ a 'GI.Ggit.Objects.Tree.Tree' or '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 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 '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 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 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if filters are disabled, 'False' otherwise. -}
checkoutOptionsGetDisableFilters options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_disable_filters options'
    let result' = (/= 0) result
    touchManagedPtr options
    return result'

#if 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 '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 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 '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 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 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m [Ggit.Flags.CheckoutNotifyFlags]
    {- ^ __Returns:__ a 'GI.Ggit.Flags.CheckoutNotifyFlags'. -}
checkoutOptionsGetNotifyFlags options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_notify_flags options'
    let result' = wordToGFlags result
    touchManagedPtr options
    return result'

#if 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 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the checkout our label or '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 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 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m (Maybe [T.Text])
    {- ^ __Returns:__ a 'Nothing' terminated list of file paths, or 'Nothing'. -}
checkoutOptionsGetPaths options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_paths options'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- unpackZeroTerminatedUTF8CArray result'
        return result''
    touchManagedPtr options
    return maybeResult

#if 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 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m [Ggit.Flags.CheckoutStrategy]
    {- ^ __Returns:__ a 'GI.Ggit.Flags.CheckoutStrategy'. -}
checkoutOptionsGetStrategy options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_checkout_options_get_strategy options'
    let result' = wordToGFlags result
    touchManagedPtr options
    return result'

#if 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 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the checkout target directory or '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 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 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the checkout their label or '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 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 '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 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 'Nothing', the default (HEAD) will be used as the baseline.
-}
checkoutOptionsSetBaseline ::
    (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a, Ggit.Tree.IsTree b) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> Maybe (b)
    {- ^ /@tree@/: a 'GI.Ggit.Objects.Tree.Tree'. -}
    -> m ()
checkoutOptionsSetBaseline options tree = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    maybeTree <- case tree of
        Nothing -> return nullPtr
        Just jTree -> do
            jTree' <- unsafeManagedPtrCastPtr jTree
            return jTree'
    ggit_checkout_options_set_baseline options' maybeTree
    touchManagedPtr options
    whenJust tree touchManagedPtr
    return ()

#if 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 '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 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 '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 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 '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 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 '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 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 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> [Ggit.Flags.CheckoutNotifyFlags]
    {- ^ /@flags@/: a 'GI.Ggit.Flags.CheckoutNotifyFlags'. -}
    -> m ()
checkoutOptionsSetNotifyFlags options flags = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    let flags' = gflagsToWord flags
    ggit_checkout_options_set_notify_flags options' flags'
    touchManagedPtr options
    return ()

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

#if 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 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -}
    -> [Ggit.Flags.CheckoutStrategy]
    {- ^ /@strategy@/: a 'GI.Ggit.Flags.CheckoutStrategy'. -}
    -> m ()
checkoutOptionsSetStrategy options strategy = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    let strategy' = gflagsToWord strategy
    ggit_checkout_options_set_strategy options' strategy'
    touchManagedPtr options
    return ()

#if 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 '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 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 '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 ENABLE_OVERLOADING
data CheckoutOptionsSetTheirLabelMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetTheirLabelMethodInfo a signature where
    overloadedMethod _ = checkoutOptionsSetTheirLabel

#endif