{- |
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 options for finding diff similarity.
-}

module GI.Ggit.Objects.DiffFindOptions
    ( 

-- * Exported types
    DiffFindOptions(..)                     ,
    IsDiffFindOptions                       ,
    toDiffFindOptions                       ,
    noDiffFindOptions                       ,


 -- * Methods
-- ** getCopyThreshold #method:getCopyThreshold#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsGetCopyThresholdMethodInfo,
#endif
    diffFindOptionsGetCopyThreshold         ,


-- ** getFlags #method:getFlags#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsGetFlagsMethodInfo       ,
#endif
    diffFindOptionsGetFlags                 ,


-- ** getMetric #method:getMetric#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsGetMetricMethodInfo      ,
#endif
    diffFindOptionsGetMetric                ,


-- ** getRenameFromRewriteThreshold #method:getRenameFromRewriteThreshold#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsGetRenameFromRewriteThresholdMethodInfo,
#endif
    diffFindOptionsGetRenameFromRewriteThreshold,


-- ** getRenameLimit #method:getRenameLimit#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsGetRenameLimitMethodInfo ,
#endif
    diffFindOptionsGetRenameLimit           ,


-- ** getRenameThreshold #method:getRenameThreshold#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsGetRenameThresholdMethodInfo,
#endif
    diffFindOptionsGetRenameThreshold       ,


-- ** new #method:new#
    diffFindOptionsNew                      ,


-- ** setCopyThreshold #method:setCopyThreshold#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsSetCopyThresholdMethodInfo,
#endif
    diffFindOptionsSetCopyThreshold         ,


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


-- ** setMetric #method:setMetric#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsSetMetricMethodInfo      ,
#endif
    diffFindOptionsSetMetric                ,


-- ** setRenameFromRewriteThreshold #method:setRenameFromRewriteThreshold#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsSetRenameFromRewriteThresholdMethodInfo,
#endif
    diffFindOptionsSetRenameFromRewriteThreshold,


-- ** setRenameLimit #method:setRenameLimit#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsSetRenameLimitMethodInfo ,
#endif
    diffFindOptionsSetRenameLimit           ,


-- ** setRenameThreshold #method:setRenameThreshold#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsSetRenameThresholdMethodInfo,
#endif
    diffFindOptionsSetRenameThreshold       ,




 -- * Properties
-- ** copyThreshold #attr:copyThreshold#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsCopyThresholdPropertyInfo,
#endif
    constructDiffFindOptionsCopyThreshold   ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    diffFindOptionsCopyThreshold            ,
#endif
    getDiffFindOptionsCopyThreshold         ,
    setDiffFindOptionsCopyThreshold         ,


-- ** flags #attr:flags#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsFlagsPropertyInfo        ,
#endif
    constructDiffFindOptionsFlags           ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    diffFindOptionsFlags                    ,
#endif
    getDiffFindOptionsFlags                 ,
    setDiffFindOptionsFlags                 ,


-- ** metric #attr:metric#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsMetricPropertyInfo       ,
#endif
    constructDiffFindOptionsMetric          ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    diffFindOptionsMetric                   ,
#endif
    getDiffFindOptionsMetric                ,
    setDiffFindOptionsMetric                ,


-- ** renameFromRewriteThreshold #attr:renameFromRewriteThreshold#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsRenameFromRewriteThresholdPropertyInfo,
#endif
    constructDiffFindOptionsRenameFromRewriteThreshold,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    diffFindOptionsRenameFromRewriteThreshold,
#endif
    getDiffFindOptionsRenameFromRewriteThreshold,
    setDiffFindOptionsRenameFromRewriteThreshold,


-- ** renameLimit #attr:renameLimit#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsRenameLimitPropertyInfo  ,
#endif
    constructDiffFindOptionsRenameLimit     ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    diffFindOptionsRenameLimit              ,
#endif
    getDiffFindOptionsRenameLimit           ,
    setDiffFindOptionsRenameLimit           ,


-- ** renameThreshold #attr:renameThreshold#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiffFindOptionsRenameThresholdPropertyInfo,
#endif
    constructDiffFindOptionsRenameThreshold ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    diffFindOptionsRenameThreshold          ,
#endif
    getDiffFindOptionsRenameThreshold       ,
    setDiffFindOptionsRenameThreshold       ,




    ) where

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

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

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

newtype DiffFindOptions = DiffFindOptions (ManagedPtr DiffFindOptions)
foreign import ccall "ggit_diff_find_options_get_type"
    c_ggit_diff_find_options_get_type :: IO GType

instance GObject DiffFindOptions where
    gobjectType _ = c_ggit_diff_find_options_get_type
    

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

toDiffFindOptions :: (MonadIO m, IsDiffFindOptions o) => o -> m DiffFindOptions
toDiffFindOptions = liftIO . unsafeCastTo DiffFindOptions

noDiffFindOptions :: Maybe DiffFindOptions
noDiffFindOptions = Nothing

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveDiffFindOptionsMethod (t :: Symbol) (o :: *) :: * where
    ResolveDiffFindOptionsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDiffFindOptionsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDiffFindOptionsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDiffFindOptionsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDiffFindOptionsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDiffFindOptionsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDiffFindOptionsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDiffFindOptionsMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDiffFindOptionsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDiffFindOptionsMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveDiffFindOptionsMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveDiffFindOptionsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDiffFindOptionsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDiffFindOptionsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDiffFindOptionsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDiffFindOptionsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDiffFindOptionsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDiffFindOptionsMethod "getCopyThreshold" o = DiffFindOptionsGetCopyThresholdMethodInfo
    ResolveDiffFindOptionsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDiffFindOptionsMethod "getFlags" o = DiffFindOptionsGetFlagsMethodInfo
    ResolveDiffFindOptionsMethod "getMetric" o = DiffFindOptionsGetMetricMethodInfo
    ResolveDiffFindOptionsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDiffFindOptionsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDiffFindOptionsMethod "getRenameFromRewriteThreshold" o = DiffFindOptionsGetRenameFromRewriteThresholdMethodInfo
    ResolveDiffFindOptionsMethod "getRenameLimit" o = DiffFindOptionsGetRenameLimitMethodInfo
    ResolveDiffFindOptionsMethod "getRenameThreshold" o = DiffFindOptionsGetRenameThresholdMethodInfo
    ResolveDiffFindOptionsMethod "setCopyThreshold" o = DiffFindOptionsSetCopyThresholdMethodInfo
    ResolveDiffFindOptionsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDiffFindOptionsMethod "setFlags" o = DiffFindOptionsSetFlagsMethodInfo
    ResolveDiffFindOptionsMethod "setMetric" o = DiffFindOptionsSetMetricMethodInfo
    ResolveDiffFindOptionsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDiffFindOptionsMethod "setRenameFromRewriteThreshold" o = DiffFindOptionsSetRenameFromRewriteThresholdMethodInfo
    ResolveDiffFindOptionsMethod "setRenameLimit" o = DiffFindOptionsSetRenameLimitMethodInfo
    ResolveDiffFindOptionsMethod "setRenameThreshold" o = DiffFindOptionsSetRenameThresholdMethodInfo
    ResolveDiffFindOptionsMethod l o = O.MethodResolutionFailed l o

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

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveDiffFindOptionsMethod t DiffFindOptions, O.MethodInfo info DiffFindOptions p) => O.IsLabel t (DiffFindOptions -> 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 "copy-threshold"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getDiffFindOptionsCopyThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32
getDiffFindOptionsCopyThreshold obj = liftIO $ getObjectPropertyUInt32 obj "copy-threshold"

setDiffFindOptionsCopyThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m ()
setDiffFindOptionsCopyThreshold obj val = liftIO $ setObjectPropertyUInt32 obj "copy-threshold" val

constructDiffFindOptionsCopyThreshold :: (IsDiffFindOptions o) => Word32 -> IO (GValueConstruct o)
constructDiffFindOptionsCopyThreshold val = constructObjectPropertyUInt32 "copy-threshold" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffFindOptionsCopyThresholdPropertyInfo
instance AttrInfo DiffFindOptionsCopyThresholdPropertyInfo where
    type AttrAllowedOps DiffFindOptionsCopyThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DiffFindOptionsCopyThresholdPropertyInfo = (~) Word32
    type AttrBaseTypeConstraint DiffFindOptionsCopyThresholdPropertyInfo = IsDiffFindOptions
    type AttrGetType DiffFindOptionsCopyThresholdPropertyInfo = Word32
    type AttrLabel DiffFindOptionsCopyThresholdPropertyInfo = "copy-threshold"
    type AttrOrigin DiffFindOptionsCopyThresholdPropertyInfo = DiffFindOptions
    attrGet _ = getDiffFindOptionsCopyThreshold
    attrSet _ = setDiffFindOptionsCopyThreshold
    attrConstruct _ = constructDiffFindOptionsCopyThreshold
    attrClear _ = undefined
#endif

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

getDiffFindOptionsFlags :: (MonadIO m, IsDiffFindOptions o) => o -> m [Ggit.Flags.DiffFindFlags]
getDiffFindOptionsFlags obj = liftIO $ getObjectPropertyFlags obj "flags"

setDiffFindOptionsFlags :: (MonadIO m, IsDiffFindOptions o) => o -> [Ggit.Flags.DiffFindFlags] -> m ()
setDiffFindOptionsFlags obj val = liftIO $ setObjectPropertyFlags obj "flags" val

constructDiffFindOptionsFlags :: (IsDiffFindOptions o) => [Ggit.Flags.DiffFindFlags] -> IO (GValueConstruct o)
constructDiffFindOptionsFlags val = constructObjectPropertyFlags "flags" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffFindOptionsFlagsPropertyInfo
instance AttrInfo DiffFindOptionsFlagsPropertyInfo where
    type AttrAllowedOps DiffFindOptionsFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DiffFindOptionsFlagsPropertyInfo = (~) [Ggit.Flags.DiffFindFlags]
    type AttrBaseTypeConstraint DiffFindOptionsFlagsPropertyInfo = IsDiffFindOptions
    type AttrGetType DiffFindOptionsFlagsPropertyInfo = [Ggit.Flags.DiffFindFlags]
    type AttrLabel DiffFindOptionsFlagsPropertyInfo = "flags"
    type AttrOrigin DiffFindOptionsFlagsPropertyInfo = DiffFindOptions
    attrGet _ = getDiffFindOptionsFlags
    attrSet _ = setDiffFindOptionsFlags
    attrConstruct _ = constructDiffFindOptionsFlags
    attrClear _ = undefined
#endif

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

getDiffFindOptionsMetric :: (MonadIO m, IsDiffFindOptions o) => o -> m Ggit.DiffSimilarityMetric.DiffSimilarityMetric
getDiffFindOptionsMetric obj = liftIO $ checkUnexpectedNothing "getDiffFindOptionsMetric" $ getObjectPropertyBoxed obj "metric" Ggit.DiffSimilarityMetric.DiffSimilarityMetric

setDiffFindOptionsMetric :: (MonadIO m, IsDiffFindOptions o) => o -> Ggit.DiffSimilarityMetric.DiffSimilarityMetric -> m ()
setDiffFindOptionsMetric obj val = liftIO $ setObjectPropertyBoxed obj "metric" (Just val)

constructDiffFindOptionsMetric :: (IsDiffFindOptions o) => Ggit.DiffSimilarityMetric.DiffSimilarityMetric -> IO (GValueConstruct o)
constructDiffFindOptionsMetric val = constructObjectPropertyBoxed "metric" (Just val)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffFindOptionsMetricPropertyInfo
instance AttrInfo DiffFindOptionsMetricPropertyInfo where
    type AttrAllowedOps DiffFindOptionsMetricPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DiffFindOptionsMetricPropertyInfo = (~) Ggit.DiffSimilarityMetric.DiffSimilarityMetric
    type AttrBaseTypeConstraint DiffFindOptionsMetricPropertyInfo = IsDiffFindOptions
    type AttrGetType DiffFindOptionsMetricPropertyInfo = Ggit.DiffSimilarityMetric.DiffSimilarityMetric
    type AttrLabel DiffFindOptionsMetricPropertyInfo = "metric"
    type AttrOrigin DiffFindOptionsMetricPropertyInfo = DiffFindOptions
    attrGet _ = getDiffFindOptionsMetric
    attrSet _ = setDiffFindOptionsMetric
    attrConstruct _ = constructDiffFindOptionsMetric
    attrClear _ = undefined
#endif

-- VVV Prop "rename-from-rewrite-threshold"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getDiffFindOptionsRenameFromRewriteThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32
getDiffFindOptionsRenameFromRewriteThreshold obj = liftIO $ getObjectPropertyUInt32 obj "rename-from-rewrite-threshold"

setDiffFindOptionsRenameFromRewriteThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m ()
setDiffFindOptionsRenameFromRewriteThreshold obj val = liftIO $ setObjectPropertyUInt32 obj "rename-from-rewrite-threshold" val

constructDiffFindOptionsRenameFromRewriteThreshold :: (IsDiffFindOptions o) => Word32 -> IO (GValueConstruct o)
constructDiffFindOptionsRenameFromRewriteThreshold val = constructObjectPropertyUInt32 "rename-from-rewrite-threshold" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffFindOptionsRenameFromRewriteThresholdPropertyInfo
instance AttrInfo DiffFindOptionsRenameFromRewriteThresholdPropertyInfo where
    type AttrAllowedOps DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = (~) Word32
    type AttrBaseTypeConstraint DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = IsDiffFindOptions
    type AttrGetType DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = Word32
    type AttrLabel DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = "rename-from-rewrite-threshold"
    type AttrOrigin DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = DiffFindOptions
    attrGet _ = getDiffFindOptionsRenameFromRewriteThreshold
    attrSet _ = setDiffFindOptionsRenameFromRewriteThreshold
    attrConstruct _ = constructDiffFindOptionsRenameFromRewriteThreshold
    attrClear _ = undefined
#endif

-- VVV Prop "rename-limit"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getDiffFindOptionsRenameLimit :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32
getDiffFindOptionsRenameLimit obj = liftIO $ getObjectPropertyUInt32 obj "rename-limit"

setDiffFindOptionsRenameLimit :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m ()
setDiffFindOptionsRenameLimit obj val = liftIO $ setObjectPropertyUInt32 obj "rename-limit" val

constructDiffFindOptionsRenameLimit :: (IsDiffFindOptions o) => Word32 -> IO (GValueConstruct o)
constructDiffFindOptionsRenameLimit val = constructObjectPropertyUInt32 "rename-limit" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffFindOptionsRenameLimitPropertyInfo
instance AttrInfo DiffFindOptionsRenameLimitPropertyInfo where
    type AttrAllowedOps DiffFindOptionsRenameLimitPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DiffFindOptionsRenameLimitPropertyInfo = (~) Word32
    type AttrBaseTypeConstraint DiffFindOptionsRenameLimitPropertyInfo = IsDiffFindOptions
    type AttrGetType DiffFindOptionsRenameLimitPropertyInfo = Word32
    type AttrLabel DiffFindOptionsRenameLimitPropertyInfo = "rename-limit"
    type AttrOrigin DiffFindOptionsRenameLimitPropertyInfo = DiffFindOptions
    attrGet _ = getDiffFindOptionsRenameLimit
    attrSet _ = setDiffFindOptionsRenameLimit
    attrConstruct _ = constructDiffFindOptionsRenameLimit
    attrClear _ = undefined
#endif

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

getDiffFindOptionsRenameThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32
getDiffFindOptionsRenameThreshold obj = liftIO $ getObjectPropertyUInt32 obj "rename-threshold"

setDiffFindOptionsRenameThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m ()
setDiffFindOptionsRenameThreshold obj val = liftIO $ setObjectPropertyUInt32 obj "rename-threshold" val

constructDiffFindOptionsRenameThreshold :: (IsDiffFindOptions o) => Word32 -> IO (GValueConstruct o)
constructDiffFindOptionsRenameThreshold val = constructObjectPropertyUInt32 "rename-threshold" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffFindOptionsRenameThresholdPropertyInfo
instance AttrInfo DiffFindOptionsRenameThresholdPropertyInfo where
    type AttrAllowedOps DiffFindOptionsRenameThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DiffFindOptionsRenameThresholdPropertyInfo = (~) Word32
    type AttrBaseTypeConstraint DiffFindOptionsRenameThresholdPropertyInfo = IsDiffFindOptions
    type AttrGetType DiffFindOptionsRenameThresholdPropertyInfo = Word32
    type AttrLabel DiffFindOptionsRenameThresholdPropertyInfo = "rename-threshold"
    type AttrOrigin DiffFindOptionsRenameThresholdPropertyInfo = DiffFindOptions
    attrGet _ = getDiffFindOptionsRenameThreshold
    attrSet _ = setDiffFindOptionsRenameThreshold
    attrConstruct _ = constructDiffFindOptionsRenameThreshold
    attrClear _ = undefined
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList DiffFindOptions
type instance O.AttributeList DiffFindOptions = DiffFindOptionsAttributeList
type DiffFindOptionsAttributeList = ('[ '("copyThreshold", DiffFindOptionsCopyThresholdPropertyInfo), '("flags", DiffFindOptionsFlagsPropertyInfo), '("metric", DiffFindOptionsMetricPropertyInfo), '("renameFromRewriteThreshold", DiffFindOptionsRenameFromRewriteThresholdPropertyInfo), '("renameLimit", DiffFindOptionsRenameLimitPropertyInfo), '("renameThreshold", DiffFindOptionsRenameThresholdPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
diffFindOptionsCopyThreshold :: AttrLabelProxy "copyThreshold"
diffFindOptionsCopyThreshold = AttrLabelProxy

diffFindOptionsFlags :: AttrLabelProxy "flags"
diffFindOptionsFlags = AttrLabelProxy

diffFindOptionsMetric :: AttrLabelProxy "metric"
diffFindOptionsMetric = AttrLabelProxy

diffFindOptionsRenameFromRewriteThreshold :: AttrLabelProxy "renameFromRewriteThreshold"
diffFindOptionsRenameFromRewriteThreshold = AttrLabelProxy

diffFindOptionsRenameLimit :: AttrLabelProxy "renameLimit"
diffFindOptionsRenameLimit = AttrLabelProxy

diffFindOptionsRenameThreshold :: AttrLabelProxy "renameThreshold"
diffFindOptionsRenameThreshold = AttrLabelProxy

#endif

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

#endif

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

foreign import ccall "ggit_diff_find_options_new" ggit_diff_find_options_new :: 
    IO (Ptr DiffFindOptions)

{- |
Creates a new 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'.
-}
diffFindOptionsNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m DiffFindOptions
    {- ^ __Returns:__ a newly allocated 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -}
diffFindOptionsNew  = liftIO $ do
    result <- ggit_diff_find_options_new
    checkUnexpectedReturnNULL "diffFindOptionsNew" result
    result' <- (wrapObject DiffFindOptions) result
    return result'

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

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

{- |
Get the find options copy threshold.
-}
diffFindOptionsGetCopyThreshold ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -}
    -> m Word32
    {- ^ __Returns:__ the copy threshold. -}
diffFindOptionsGetCopyThreshold options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_find_options_get_copy_threshold options'
    touchManagedPtr options
    return result

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

#endif

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

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

{- |
Get the find options flags.
-}
diffFindOptionsGetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -}
    -> m [Ggit.Flags.DiffFindFlags]
    {- ^ __Returns:__ the find options flags. -}
diffFindOptionsGetFlags options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_find_options_get_flags options'
    let result' = wordToGFlags result
    touchManagedPtr options
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffFindOptionsGetFlagsMethodInfo
instance (signature ~ (m [Ggit.Flags.DiffFindFlags]), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsGetFlagsMethodInfo a signature where
    overloadedMethod _ = diffFindOptionsGetFlags

#endif

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

foreign import ccall "ggit_diff_find_options_get_metric" ggit_diff_find_options_get_metric :: 
    Ptr DiffFindOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"})
    IO (Ptr Ggit.DiffSimilarityMetric.DiffSimilarityMetric)

{- |
Get the find options metric.
-}
diffFindOptionsGetMetric ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -}
    -> m Ggit.DiffSimilarityMetric.DiffSimilarityMetric
    {- ^ __Returns:__ a 'GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric' or 'Nothing'. -}
diffFindOptionsGetMetric options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_find_options_get_metric options'
    checkUnexpectedReturnNULL "diffFindOptionsGetMetric" result
    result' <- (newBoxed Ggit.DiffSimilarityMetric.DiffSimilarityMetric) result
    touchManagedPtr options
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffFindOptionsGetMetricMethodInfo
instance (signature ~ (m Ggit.DiffSimilarityMetric.DiffSimilarityMetric), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsGetMetricMethodInfo a signature where
    overloadedMethod _ = diffFindOptionsGetMetric

#endif

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

{- |
Get the find options rename from rewrite threshold.
-}
diffFindOptionsGetRenameFromRewriteThreshold ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -}
    -> m Word32
    {- ^ __Returns:__ the rename from rewrite threshold. -}
diffFindOptionsGetRenameFromRewriteThreshold options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_find_options_get_rename_from_rewrite_threshold options'
    touchManagedPtr options
    return result

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

#endif

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

foreign import ccall "ggit_diff_find_options_get_rename_limit" ggit_diff_find_options_get_rename_limit :: 
    Ptr DiffFindOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"})
    IO Word64

{- |
Get the find options rename limit.
-}
diffFindOptionsGetRenameLimit ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -}
    -> m Word64
    {- ^ __Returns:__ the rename limit. -}
diffFindOptionsGetRenameLimit options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_find_options_get_rename_limit options'
    touchManagedPtr options
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffFindOptionsGetRenameLimitMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsGetRenameLimitMethodInfo a signature where
    overloadedMethod _ = diffFindOptionsGetRenameLimit

#endif

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

{- |
Get the find options rename threshold.
-}
diffFindOptionsGetRenameThreshold ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -}
    -> m Word32
    {- ^ __Returns:__ the rename threshold. -}
diffFindOptionsGetRenameThreshold options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_find_options_get_rename_threshold options'
    touchManagedPtr options
    return result

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

#endif

-- method DiffFindOptions::set_copy_threshold
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "threshold", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the threshold.", 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_find_options_set_copy_threshold" ggit_diff_find_options_set_copy_threshold :: 
    Ptr DiffFindOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"})
    Word32 ->                               -- threshold : TBasicType TUInt
    IO ()

{- |
Set the find options copy threshold.
-}
diffFindOptionsSetCopyThreshold ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -}
    -> Word32
    {- ^ /@threshold@/: the threshold. -}
    -> m ()
diffFindOptionsSetCopyThreshold options threshold = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    ggit_diff_find_options_set_copy_threshold options' threshold
    touchManagedPtr options
    return ()

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

#endif

-- method DiffFindOptions::set_flags
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindFlags.", 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_find_options_set_flags" ggit_diff_find_options_set_flags :: 
    Ptr DiffFindOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Ggit", name = "DiffFindFlags"})
    IO ()

{- |
Set the find options flags.
-}
diffFindOptionsSetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -}
    -> [Ggit.Flags.DiffFindFlags]
    {- ^ /@flags@/: a 'GI.Ggit.Flags.DiffFindFlags'. -}
    -> m ()
diffFindOptionsSetFlags options flags = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    let flags' = gflagsToWord flags
    ggit_diff_find_options_set_flags options' flags'
    touchManagedPtr options
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffFindOptionsSetFlagsMethodInfo
instance (signature ~ ([Ggit.Flags.DiffFindFlags] -> m ()), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsSetFlagsMethodInfo a signature where
    overloadedMethod _ = diffFindOptionsSetFlags

#endif

-- method DiffFindOptions::set_metric
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "metric", argType = TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetric"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffSimilarityMetric.", 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_find_options_set_metric" ggit_diff_find_options_set_metric :: 
    Ptr DiffFindOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"})
    Ptr Ggit.DiffSimilarityMetric.DiffSimilarityMetric -> -- metric : TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetric"})
    IO ()

{- |
Set the find options metric.
-}
diffFindOptionsSetMetric ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -}
    -> Ggit.DiffSimilarityMetric.DiffSimilarityMetric
    {- ^ /@metric@/: a 'GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric'. -}
    -> m ()
diffFindOptionsSetMetric options metric = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    metric' <- unsafeManagedPtrGetPtr metric
    ggit_diff_find_options_set_metric options' metric'
    touchManagedPtr options
    touchManagedPtr metric
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffFindOptionsSetMetricMethodInfo
instance (signature ~ (Ggit.DiffSimilarityMetric.DiffSimilarityMetric -> m ()), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsSetMetricMethodInfo a signature where
    overloadedMethod _ = diffFindOptionsSetMetric

#endif

-- method DiffFindOptions::set_rename_from_rewrite_threshold
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "threshold", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the threshold.", 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_find_options_set_rename_from_rewrite_threshold" ggit_diff_find_options_set_rename_from_rewrite_threshold :: 
    Ptr DiffFindOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"})
    Word32 ->                               -- threshold : TBasicType TUInt
    IO ()

{- |
Set the find options rename from rewrite threshold.
-}
diffFindOptionsSetRenameFromRewriteThreshold ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -}
    -> Word32
    {- ^ /@threshold@/: the threshold. -}
    -> m ()
diffFindOptionsSetRenameFromRewriteThreshold options threshold = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    ggit_diff_find_options_set_rename_from_rewrite_threshold options' threshold
    touchManagedPtr options
    return ()

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

#endif

-- method DiffFindOptions::set_rename_limit
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "limit", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the limit.", 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_find_options_set_rename_limit" ggit_diff_find_options_set_rename_limit :: 
    Ptr DiffFindOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"})
    Word64 ->                               -- limit : TBasicType TUInt64
    IO ()

{- |
Set the find options rename limit.
-}
diffFindOptionsSetRenameLimit ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -}
    -> Word64
    {- ^ /@limit@/: the limit. -}
    -> m ()
diffFindOptionsSetRenameLimit options limit = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    ggit_diff_find_options_set_rename_limit options' limit
    touchManagedPtr options
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiffFindOptionsSetRenameLimitMethodInfo
instance (signature ~ (Word64 -> m ()), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsSetRenameLimitMethodInfo a signature where
    overloadedMethod _ = diffFindOptionsSetRenameLimit

#endif

-- method DiffFindOptions::set_rename_threshold
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "threshold", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the threshold.", 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_find_options_set_rename_threshold" ggit_diff_find_options_set_rename_threshold :: 
    Ptr DiffFindOptions ->                  -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"})
    Word32 ->                               -- threshold : TBasicType TUInt
    IO ()

{- |
Set the find options rename threshold.
-}
diffFindOptionsSetRenameThreshold ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -}
    -> Word32
    {- ^ /@threshold@/: the threshold. -}
    -> m ()
diffFindOptionsSetRenameThreshold options threshold = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    ggit_diff_find_options_set_rename_threshold options' threshold
    touchManagedPtr options
    return ()

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

#endif