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

Represents the options used when creating a 'GI.Ggit.Objects.Diff.Diff'.
-}

module GI.Ggit.Objects.DiffOptions
    ( 

-- * Exported types
    DiffOptions(..)                         ,
    IsDiffOptions                           ,
    toDiffOptions                           ,
    noDiffOptions                           ,


 -- * Methods
-- ** getFlags #method:getFlags#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsGetFlagsMethodInfo           ,
#endif
    diffOptionsGetFlags                     ,


-- ** getNContextLines #method:getNContextLines#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsGetNContextLinesMethodInfo   ,
#endif
    diffOptionsGetNContextLines             ,


-- ** getNInterhunkLines #method:getNInterhunkLines#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsGetNInterhunkLinesMethodInfo ,
#endif
    diffOptionsGetNInterhunkLines           ,


-- ** getNewPrefix #method:getNewPrefix#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsGetNewPrefixMethodInfo       ,
#endif
    diffOptionsGetNewPrefix                 ,


-- ** getOldPrefix #method:getOldPrefix#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsGetOldPrefixMethodInfo       ,
#endif
    diffOptionsGetOldPrefix                 ,


-- ** getPathspec #method:getPathspec#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsGetPathspecMethodInfo        ,
#endif
    diffOptionsGetPathspec                  ,


-- ** new #method:new#
    diffOptionsNew                          ,


-- ** setFlags #method:setFlags#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsSetFlagsMethodInfo           ,
#endif
    diffOptionsSetFlags                     ,


-- ** setNContextLines #method:setNContextLines#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsSetNContextLinesMethodInfo   ,
#endif
    diffOptionsSetNContextLines             ,


-- ** setNInterhunkLines #method:setNInterhunkLines#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsSetNInterhunkLinesMethodInfo ,
#endif
    diffOptionsSetNInterhunkLines           ,


-- ** setNewPrefix #method:setNewPrefix#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsSetNewPrefixMethodInfo       ,
#endif
    diffOptionsSetNewPrefix                 ,


-- ** setOldPrefix #method:setOldPrefix#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsSetOldPrefixMethodInfo       ,
#endif
    diffOptionsSetOldPrefix                 ,


-- ** setPathspec #method:setPathspec#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsSetPathspecMethodInfo        ,
#endif
    diffOptionsSetPathspec                  ,




 -- * Properties
-- ** flags #attr:flags#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsFlagsPropertyInfo            ,
#endif
    constructDiffOptionsFlags               ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    diffOptionsFlags                        ,
#endif
    getDiffOptionsFlags                     ,
    setDiffOptionsFlags                     ,


-- ** nContextLines #attr:nContextLines#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsNContextLinesPropertyInfo    ,
#endif
    constructDiffOptionsNContextLines       ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    diffOptionsNContextLines                ,
#endif
    getDiffOptionsNContextLines             ,
    setDiffOptionsNContextLines             ,


-- ** nInterhunkLines #attr:nInterhunkLines#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsNInterhunkLinesPropertyInfo  ,
#endif
    constructDiffOptionsNInterhunkLines     ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    diffOptionsNInterhunkLines              ,
#endif
    getDiffOptionsNInterhunkLines           ,
    setDiffOptionsNInterhunkLines           ,


-- ** newPrefix #attr:newPrefix#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsNewPrefixPropertyInfo        ,
#endif
    constructDiffOptionsNewPrefix           ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    diffOptionsNewPrefix                    ,
#endif
    getDiffOptionsNewPrefix                 ,
    setDiffOptionsNewPrefix                 ,


-- ** oldPrefix #attr:oldPrefix#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsOldPrefixPropertyInfo        ,
#endif
    constructDiffOptionsOldPrefix           ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    diffOptionsOldPrefix                    ,
#endif
    getDiffOptionsOldPrefix                 ,
    setDiffOptionsOldPrefix                 ,


-- ** pathspec #attr:pathspec#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffOptionsPathspecPropertyInfo         ,
#endif
    clearDiffOptionsPathspec                ,
    constructDiffOptionsPathspec            ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    diffOptionsPathspec                     ,
#endif
    getDiffOptionsPathspec                  ,
    setDiffOptionsPathspec                  ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Ggit.Flags as Ggit.Flags

newtype DiffOptions = DiffOptions (ManagedPtr DiffOptions)
foreign import ccall "ggit_diff_options_get_type"
    c_ggit_diff_options_get_type :: IO GType

instance GObject DiffOptions where
    gobjectType _ = c_ggit_diff_options_get_type
    

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

toDiffOptions :: (MonadIO m, IsDiffOptions o) => o -> m DiffOptions
toDiffOptions = liftIO . unsafeCastTo DiffOptions

noDiffOptions :: Maybe DiffOptions
noDiffOptions = Nothing

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveDiffOptionsMethod (t :: Symbol) (o :: *) :: * where
    ResolveDiffOptionsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDiffOptionsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDiffOptionsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDiffOptionsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDiffOptionsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDiffOptionsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDiffOptionsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDiffOptionsMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDiffOptionsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDiffOptionsMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveDiffOptionsMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveDiffOptionsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDiffOptionsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDiffOptionsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDiffOptionsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDiffOptionsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDiffOptionsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDiffOptionsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDiffOptionsMethod "getFlags" o = DiffOptionsGetFlagsMethodInfo
    ResolveDiffOptionsMethod "getNContextLines" o = DiffOptionsGetNContextLinesMethodInfo
    ResolveDiffOptionsMethod "getNInterhunkLines" o = DiffOptionsGetNInterhunkLinesMethodInfo
    ResolveDiffOptionsMethod "getNewPrefix" o = DiffOptionsGetNewPrefixMethodInfo
    ResolveDiffOptionsMethod "getOldPrefix" o = DiffOptionsGetOldPrefixMethodInfo
    ResolveDiffOptionsMethod "getPathspec" o = DiffOptionsGetPathspecMethodInfo
    ResolveDiffOptionsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDiffOptionsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDiffOptionsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDiffOptionsMethod "setFlags" o = DiffOptionsSetFlagsMethodInfo
    ResolveDiffOptionsMethod "setNContextLines" o = DiffOptionsSetNContextLinesMethodInfo
    ResolveDiffOptionsMethod "setNInterhunkLines" o = DiffOptionsSetNInterhunkLinesMethodInfo
    ResolveDiffOptionsMethod "setNewPrefix" o = DiffOptionsSetNewPrefixMethodInfo
    ResolveDiffOptionsMethod "setOldPrefix" o = DiffOptionsSetOldPrefixMethodInfo
    ResolveDiffOptionsMethod "setPathspec" o = DiffOptionsSetPathspecMethodInfo
    ResolveDiffOptionsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDiffOptionsMethod l o = O.MethodResolutionFailed l o

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

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

#endif

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

getDiffOptionsFlags :: (MonadIO m, IsDiffOptions o) => o -> m [Ggit.Flags.DiffOption]
getDiffOptionsFlags obj = liftIO $ getObjectPropertyFlags obj "flags"

setDiffOptionsFlags :: (MonadIO m, IsDiffOptions o) => o -> [Ggit.Flags.DiffOption] -> m ()
setDiffOptionsFlags obj val = liftIO $ setObjectPropertyFlags obj "flags" val

constructDiffOptionsFlags :: (IsDiffOptions o) => [Ggit.Flags.DiffOption] -> IO (GValueConstruct o)
constructDiffOptionsFlags val = constructObjectPropertyFlags "flags" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffOptionsFlagsPropertyInfo
instance AttrInfo DiffOptionsFlagsPropertyInfo where
    type AttrAllowedOps DiffOptionsFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DiffOptionsFlagsPropertyInfo = (~) [Ggit.Flags.DiffOption]
    type AttrBaseTypeConstraint DiffOptionsFlagsPropertyInfo = IsDiffOptions
    type AttrGetType DiffOptionsFlagsPropertyInfo = [Ggit.Flags.DiffOption]
    type AttrLabel DiffOptionsFlagsPropertyInfo = "flags"
    type AttrOrigin DiffOptionsFlagsPropertyInfo = DiffOptions
    attrGet _ = getDiffOptionsFlags
    attrSet _ = setDiffOptionsFlags
    attrConstruct _ = constructDiffOptionsFlags
    attrClear _ = undefined
#endif

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

getDiffOptionsNContextLines :: (MonadIO m, IsDiffOptions o) => o -> m Int32
getDiffOptionsNContextLines obj = liftIO $ getObjectPropertyInt32 obj "n-context-lines"

setDiffOptionsNContextLines :: (MonadIO m, IsDiffOptions o) => o -> Int32 -> m ()
setDiffOptionsNContextLines obj val = liftIO $ setObjectPropertyInt32 obj "n-context-lines" val

constructDiffOptionsNContextLines :: (IsDiffOptions o) => Int32 -> IO (GValueConstruct o)
constructDiffOptionsNContextLines val = constructObjectPropertyInt32 "n-context-lines" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffOptionsNContextLinesPropertyInfo
instance AttrInfo DiffOptionsNContextLinesPropertyInfo where
    type AttrAllowedOps DiffOptionsNContextLinesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DiffOptionsNContextLinesPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint DiffOptionsNContextLinesPropertyInfo = IsDiffOptions
    type AttrGetType DiffOptionsNContextLinesPropertyInfo = Int32
    type AttrLabel DiffOptionsNContextLinesPropertyInfo = "n-context-lines"
    type AttrOrigin DiffOptionsNContextLinesPropertyInfo = DiffOptions
    attrGet _ = getDiffOptionsNContextLines
    attrSet _ = setDiffOptionsNContextLines
    attrConstruct _ = constructDiffOptionsNContextLines
    attrClear _ = undefined
#endif

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

getDiffOptionsNInterhunkLines :: (MonadIO m, IsDiffOptions o) => o -> m Int32
getDiffOptionsNInterhunkLines obj = liftIO $ getObjectPropertyInt32 obj "n-interhunk-lines"

setDiffOptionsNInterhunkLines :: (MonadIO m, IsDiffOptions o) => o -> Int32 -> m ()
setDiffOptionsNInterhunkLines obj val = liftIO $ setObjectPropertyInt32 obj "n-interhunk-lines" val

constructDiffOptionsNInterhunkLines :: (IsDiffOptions o) => Int32 -> IO (GValueConstruct o)
constructDiffOptionsNInterhunkLines val = constructObjectPropertyInt32 "n-interhunk-lines" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffOptionsNInterhunkLinesPropertyInfo
instance AttrInfo DiffOptionsNInterhunkLinesPropertyInfo where
    type AttrAllowedOps DiffOptionsNInterhunkLinesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DiffOptionsNInterhunkLinesPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint DiffOptionsNInterhunkLinesPropertyInfo = IsDiffOptions
    type AttrGetType DiffOptionsNInterhunkLinesPropertyInfo = Int32
    type AttrLabel DiffOptionsNInterhunkLinesPropertyInfo = "n-interhunk-lines"
    type AttrOrigin DiffOptionsNInterhunkLinesPropertyInfo = DiffOptions
    attrGet _ = getDiffOptionsNInterhunkLines
    attrSet _ = setDiffOptionsNInterhunkLines
    attrConstruct _ = constructDiffOptionsNInterhunkLines
    attrClear _ = undefined
#endif

-- VVV Prop "new-prefix"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

getDiffOptionsNewPrefix :: (MonadIO m, IsDiffOptions o) => o -> m T.Text
getDiffOptionsNewPrefix obj = liftIO $ checkUnexpectedNothing "getDiffOptionsNewPrefix" $ getObjectPropertyString obj "new-prefix"

setDiffOptionsNewPrefix :: (MonadIO m, IsDiffOptions o) => o -> T.Text -> m ()
setDiffOptionsNewPrefix obj val = liftIO $ setObjectPropertyString obj "new-prefix" (Just val)

constructDiffOptionsNewPrefix :: (IsDiffOptions o) => T.Text -> IO (GValueConstruct o)
constructDiffOptionsNewPrefix val = constructObjectPropertyString "new-prefix" (Just val)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffOptionsNewPrefixPropertyInfo
instance AttrInfo DiffOptionsNewPrefixPropertyInfo where
    type AttrAllowedOps DiffOptionsNewPrefixPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DiffOptionsNewPrefixPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DiffOptionsNewPrefixPropertyInfo = IsDiffOptions
    type AttrGetType DiffOptionsNewPrefixPropertyInfo = T.Text
    type AttrLabel DiffOptionsNewPrefixPropertyInfo = "new-prefix"
    type AttrOrigin DiffOptionsNewPrefixPropertyInfo = DiffOptions
    attrGet _ = getDiffOptionsNewPrefix
    attrSet _ = setDiffOptionsNewPrefix
    attrConstruct _ = constructDiffOptionsNewPrefix
    attrClear _ = undefined
#endif

-- VVV Prop "old-prefix"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

getDiffOptionsOldPrefix :: (MonadIO m, IsDiffOptions o) => o -> m T.Text
getDiffOptionsOldPrefix obj = liftIO $ checkUnexpectedNothing "getDiffOptionsOldPrefix" $ getObjectPropertyString obj "old-prefix"

setDiffOptionsOldPrefix :: (MonadIO m, IsDiffOptions o) => o -> T.Text -> m ()
setDiffOptionsOldPrefix obj val = liftIO $ setObjectPropertyString obj "old-prefix" (Just val)

constructDiffOptionsOldPrefix :: (IsDiffOptions o) => T.Text -> IO (GValueConstruct o)
constructDiffOptionsOldPrefix val = constructObjectPropertyString "old-prefix" (Just val)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffOptionsOldPrefixPropertyInfo
instance AttrInfo DiffOptionsOldPrefixPropertyInfo where
    type AttrAllowedOps DiffOptionsOldPrefixPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DiffOptionsOldPrefixPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DiffOptionsOldPrefixPropertyInfo = IsDiffOptions
    type AttrGetType DiffOptionsOldPrefixPropertyInfo = T.Text
    type AttrLabel DiffOptionsOldPrefixPropertyInfo = "old-prefix"
    type AttrOrigin DiffOptionsOldPrefixPropertyInfo = DiffOptions
    attrGet _ = getDiffOptionsOldPrefix
    attrSet _ = setDiffOptionsOldPrefix
    attrConstruct _ = constructDiffOptionsOldPrefix
    attrClear _ = undefined
#endif

-- VVV Prop "pathspec"
   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just True)

getDiffOptionsPathspec :: (MonadIO m, IsDiffOptions o) => o -> m [T.Text]
getDiffOptionsPathspec obj = liftIO $ checkUnexpectedNothing "getDiffOptionsPathspec" $ getObjectPropertyStringArray obj "pathspec"

setDiffOptionsPathspec :: (MonadIO m, IsDiffOptions o) => o -> [T.Text] -> m ()
setDiffOptionsPathspec obj val = liftIO $ setObjectPropertyStringArray obj "pathspec" (Just val)

constructDiffOptionsPathspec :: (IsDiffOptions o) => [T.Text] -> IO (GValueConstruct o)
constructDiffOptionsPathspec val = constructObjectPropertyStringArray "pathspec" (Just val)

clearDiffOptionsPathspec :: (MonadIO m, IsDiffOptions o) => o -> m ()
clearDiffOptionsPathspec obj = liftIO $ setObjectPropertyStringArray obj "pathspec" (Nothing :: Maybe [T.Text])

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffOptionsPathspecPropertyInfo
instance AttrInfo DiffOptionsPathspecPropertyInfo where
    type AttrAllowedOps DiffOptionsPathspecPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DiffOptionsPathspecPropertyInfo = (~) [T.Text]
    type AttrBaseTypeConstraint DiffOptionsPathspecPropertyInfo = IsDiffOptions
    type AttrGetType DiffOptionsPathspecPropertyInfo = [T.Text]
    type AttrLabel DiffOptionsPathspecPropertyInfo = "pathspec"
    type AttrOrigin DiffOptionsPathspecPropertyInfo = DiffOptions
    attrGet _ = getDiffOptionsPathspec
    attrSet _ = setDiffOptionsPathspec
    attrConstruct _ = constructDiffOptionsPathspec
    attrClear _ = clearDiffOptionsPathspec
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList DiffOptions
type instance O.AttributeList DiffOptions = DiffOptionsAttributeList
type DiffOptionsAttributeList = ('[ '("flags", DiffOptionsFlagsPropertyInfo), '("nContextLines", DiffOptionsNContextLinesPropertyInfo), '("nInterhunkLines", DiffOptionsNInterhunkLinesPropertyInfo), '("newPrefix", DiffOptionsNewPrefixPropertyInfo), '("oldPrefix", DiffOptionsOldPrefixPropertyInfo), '("pathspec", DiffOptionsPathspecPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
diffOptionsFlags :: AttrLabelProxy "flags"
diffOptionsFlags = AttrLabelProxy

diffOptionsNContextLines :: AttrLabelProxy "nContextLines"
diffOptionsNContextLines = AttrLabelProxy

diffOptionsNInterhunkLines :: AttrLabelProxy "nInterhunkLines"
diffOptionsNInterhunkLines = AttrLabelProxy

diffOptionsNewPrefix :: AttrLabelProxy "newPrefix"
diffOptionsNewPrefix = AttrLabelProxy

diffOptionsOldPrefix :: AttrLabelProxy "oldPrefix"
diffOptionsOldPrefix = AttrLabelProxy

diffOptionsPathspec :: AttrLabelProxy "pathspec"
diffOptionsPathspec = AttrLabelProxy

#endif

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

#endif

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

foreign import ccall "ggit_diff_options_new" ggit_diff_options_new :: 
    IO (Ptr DiffOptions)

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

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

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

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

{- |
Get the diff flags.
-}
diffOptionsGetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -}
    -> m [Ggit.Flags.DiffOption]
    {- ^ __Returns:__ a 'GI.Ggit.Flags.DiffOption'. -}
diffOptionsGetFlags options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_options_get_flags options'
    let result' = wordToGFlags result
    touchManagedPtr options
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffOptionsGetFlagsMethodInfo
instance (signature ~ (m [Ggit.Flags.DiffOption]), MonadIO m, IsDiffOptions a) => O.MethodInfo DiffOptionsGetFlagsMethodInfo a signature where
    overloadedMethod _ = diffOptionsGetFlags

#endif

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

{- |
Get the number of context lines to include in the diff.
-}
diffOptionsGetNContextLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -}
    -> m Int32
    {- ^ __Returns:__ the number of context lines. -}
diffOptionsGetNContextLines options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_options_get_n_context_lines options'
    touchManagedPtr options
    return result

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

#endif

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

{- |
Get the number of interhunk lines to include in the diff.
-}
diffOptionsGetNInterhunkLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -}
    -> m Int32
    {- ^ __Returns:__ the number of lines. -}
diffOptionsGetNInterhunkLines options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_options_get_n_interhunk_lines options'
    touchManagedPtr options
    return result

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

#endif

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

{- |
Get the diff new-prefix string.
-}
diffOptionsGetNewPrefix ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -}
    -> m T.Text
    {- ^ __Returns:__ the new-prefix string. -}
diffOptionsGetNewPrefix options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_options_get_new_prefix options'
    checkUnexpectedReturnNULL "diffOptionsGetNewPrefix" result
    result' <- cstringToText result
    touchManagedPtr options
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffOptionsGetNewPrefixMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDiffOptions a) => O.MethodInfo DiffOptionsGetNewPrefixMethodInfo a signature where
    overloadedMethod _ = diffOptionsGetNewPrefix

#endif

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

{- |
Get the diff old-prefix string.
-}
diffOptionsGetOldPrefix ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -}
    -> m T.Text
    {- ^ __Returns:__ the old-prefix string. -}
diffOptionsGetOldPrefix options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_options_get_old_prefix options'
    checkUnexpectedReturnNULL "diffOptionsGetOldPrefix" result
    result' <- cstringToText result
    touchManagedPtr options
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffOptionsGetOldPrefixMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDiffOptions a) => O.MethodInfo DiffOptionsGetOldPrefixMethodInfo a signature where
    overloadedMethod _ = diffOptionsGetOldPrefix

#endif

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

{- |
Get the pathspec.
-}
diffOptionsGetPathspec ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -}
    -> m [T.Text]
    {- ^ __Returns:__ the pathspec. -}
diffOptionsGetPathspec options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_options_get_pathspec options'
    checkUnexpectedReturnNULL "diffOptionsGetPathspec" result
    result' <- unpackZeroTerminatedUTF8CArray result
    touchManagedPtr options
    return result'

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

#endif

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

foreign import ccall "ggit_diff_options_set_flags" ggit_diff_options_set_flags :: 
    Ptr DiffOptions ->                      -- options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Ggit", name = "DiffOption"})
    IO ()

{- |
Set the diff flags.
-}
diffOptionsSetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -}
    -> [Ggit.Flags.DiffOption]
    {- ^ /@flags@/: a 'GI.Ggit.Flags.DiffOption'. -}
    -> m ()
diffOptionsSetFlags options flags = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    let flags' = gflagsToWord flags
    ggit_diff_options_set_flags options' flags'
    touchManagedPtr options
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffOptionsSetFlagsMethodInfo
instance (signature ~ ([Ggit.Flags.DiffOption] -> m ()), MonadIO m, IsDiffOptions a) => O.MethodInfo DiffOptionsSetFlagsMethodInfo a signature where
    overloadedMethod _ = diffOptionsSetFlags

#endif

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

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

{- |
Set the number of context lines to include in the diff.
-}
diffOptionsSetNContextLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -}
    -> Int32
    {- ^ /@n@/: the number of lines. -}
    -> m ()
diffOptionsSetNContextLines options n = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    ggit_diff_options_set_n_context_lines options' n
    touchManagedPtr options
    return ()

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

#endif

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

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

{- |
Set the number of interhunk lines to include in the diff.
-}
diffOptionsSetNInterhunkLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -}
    -> Int32
    {- ^ /@n@/: the number of lines. -}
    -> m ()
diffOptionsSetNInterhunkLines options n = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    ggit_diff_options_set_n_interhunk_lines options' n
    touchManagedPtr options
    return ()

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

#endif

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

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

{- |
Set the diff new-prefix string.
-}
diffOptionsSetNewPrefix ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -}
    -> T.Text
    {- ^ /@prefix@/: the prefix. -}
    -> m ()
diffOptionsSetNewPrefix options prefix = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    prefix' <- textToCString prefix
    ggit_diff_options_set_new_prefix options' prefix'
    touchManagedPtr options
    freeMem prefix'
    return ()

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

#endif

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

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

{- |
Get the diff old-prefix string.
-}
diffOptionsSetOldPrefix ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -}
    -> T.Text
    {- ^ /@prefix@/: the prefix. -}
    -> m ()
diffOptionsSetOldPrefix options prefix = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    prefix' <- textToCString prefix
    ggit_diff_options_set_old_prefix options' prefix'
    touchManagedPtr options
    freeMem prefix'
    return ()

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

#endif

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

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

{- |
Set the pathspec.
-}
diffOptionsSetPathspec ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -}
    -> Maybe ([T.Text])
    {- ^ /@pathspec@/: the pathspec. -}
    -> m ()
diffOptionsSetPathspec options pathspec = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    maybePathspec <- case pathspec of
        Nothing -> return nullPtr
        Just jPathspec -> do
            jPathspec' <- packZeroTerminatedUTF8CArray jPathspec
            return jPathspec'
    ggit_diff_options_set_pathspec options' maybePathspec
    touchManagedPtr options
    mapZeroTerminatedCArray freeMem maybePathspec
    freeMem maybePathspec
    return ()

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

#endif