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

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

module GI.Ggit.Objects.DiffFindOptions
    ( 

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


 -- * Methods
-- ** getCopyThreshold #method:getCopyThreshold#

#if ENABLE_OVERLOADING
    DiffFindOptionsGetCopyThresholdMethodInfo,
#endif
    diffFindOptionsGetCopyThreshold         ,


-- ** getFlags #method:getFlags#

#if ENABLE_OVERLOADING
    DiffFindOptionsGetFlagsMethodInfo       ,
#endif
    diffFindOptionsGetFlags                 ,


-- ** getMetric #method:getMetric#

#if ENABLE_OVERLOADING
    DiffFindOptionsGetMetricMethodInfo      ,
#endif
    diffFindOptionsGetMetric                ,


-- ** getRenameFromRewriteThreshold #method:getRenameFromRewriteThreshold#

#if ENABLE_OVERLOADING
    DiffFindOptionsGetRenameFromRewriteThresholdMethodInfo,
#endif
    diffFindOptionsGetRenameFromRewriteThreshold,


-- ** getRenameLimit #method:getRenameLimit#

#if ENABLE_OVERLOADING
    DiffFindOptionsGetRenameLimitMethodInfo ,
#endif
    diffFindOptionsGetRenameLimit           ,


-- ** getRenameThreshold #method:getRenameThreshold#

#if ENABLE_OVERLOADING
    DiffFindOptionsGetRenameThresholdMethodInfo,
#endif
    diffFindOptionsGetRenameThreshold       ,


-- ** new #method:new#

    diffFindOptionsNew                      ,


-- ** setCopyThreshold #method:setCopyThreshold#

#if ENABLE_OVERLOADING
    DiffFindOptionsSetCopyThresholdMethodInfo,
#endif
    diffFindOptionsSetCopyThreshold         ,


-- ** setFlags #method:setFlags#

#if ENABLE_OVERLOADING
    DiffFindOptionsSetFlagsMethodInfo       ,
#endif
    diffFindOptionsSetFlags                 ,


-- ** setMetric #method:setMetric#

#if ENABLE_OVERLOADING
    DiffFindOptionsSetMetricMethodInfo      ,
#endif
    diffFindOptionsSetMetric                ,


-- ** setRenameFromRewriteThreshold #method:setRenameFromRewriteThreshold#

#if ENABLE_OVERLOADING
    DiffFindOptionsSetRenameFromRewriteThresholdMethodInfo,
#endif
    diffFindOptionsSetRenameFromRewriteThreshold,


-- ** setRenameLimit #method:setRenameLimit#

#if ENABLE_OVERLOADING
    DiffFindOptionsSetRenameLimitMethodInfo ,
#endif
    diffFindOptionsSetRenameLimit           ,


-- ** setRenameThreshold #method:setRenameThreshold#

#if ENABLE_OVERLOADING
    DiffFindOptionsSetRenameThresholdMethodInfo,
#endif
    diffFindOptionsSetRenameThreshold       ,




 -- * Properties
-- ** copyThreshold #attr:copyThreshold#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DiffFindOptionsCopyThresholdPropertyInfo,
#endif
    constructDiffFindOptionsCopyThreshold   ,
#if ENABLE_OVERLOADING
    diffFindOptionsCopyThreshold            ,
#endif
    getDiffFindOptionsCopyThreshold         ,
    setDiffFindOptionsCopyThreshold         ,


-- ** flags #attr:flags#
{- | The diff option flags.
-}
#if ENABLE_OVERLOADING
    DiffFindOptionsFlagsPropertyInfo        ,
#endif
    constructDiffFindOptionsFlags           ,
#if ENABLE_OVERLOADING
    diffFindOptionsFlags                    ,
#endif
    getDiffFindOptionsFlags                 ,
    setDiffFindOptionsFlags                 ,


-- ** metric #attr:metric#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DiffFindOptionsMetricPropertyInfo       ,
#endif
    constructDiffFindOptionsMetric          ,
#if ENABLE_OVERLOADING
    diffFindOptionsMetric                   ,
#endif
    getDiffFindOptionsMetric                ,
    setDiffFindOptionsMetric                ,


-- ** renameFromRewriteThreshold #attr:renameFromRewriteThreshold#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DiffFindOptionsRenameFromRewriteThresholdPropertyInfo,
#endif
    constructDiffFindOptionsRenameFromRewriteThreshold,
#if ENABLE_OVERLOADING
    diffFindOptionsRenameFromRewriteThreshold,
#endif
    getDiffFindOptionsRenameFromRewriteThreshold,
    setDiffFindOptionsRenameFromRewriteThreshold,


-- ** renameLimit #attr:renameLimit#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DiffFindOptionsRenameLimitPropertyInfo  ,
#endif
    constructDiffFindOptionsRenameLimit     ,
#if ENABLE_OVERLOADING
    diffFindOptionsRenameLimit              ,
#endif
    getDiffFindOptionsRenameLimit           ,
    setDiffFindOptionsRenameLimit           ,


-- ** renameThreshold #attr:renameThreshold#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DiffFindOptionsRenameThresholdPropertyInfo,
#endif
    constructDiffFindOptionsRenameThreshold ,
#if ENABLE_OVERLOADING
    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.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.Structs.DiffSimilarityMetric as Ggit.DiffSimilarityMetric

-- | Memory-managed wrapper type.
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
    

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

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

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

-- | A convenience alias for `Nothing` :: `Maybe` `DiffFindOptions`.
noDiffFindOptions :: Maybe DiffFindOptions
noDiffFindOptions = Nothing

#if ENABLE_OVERLOADING
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 "getv" o = GObject.Object.ObjectGetvMethodInfo
    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 "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) => OL.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

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

{- |
Get the value of the “@copy-threshold@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' diffFindOptions #copyThreshold
@
-}
getDiffFindOptionsCopyThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32
getDiffFindOptionsCopyThreshold obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "copy-threshold"

{- |
Set the value of the “@copy-threshold@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' diffFindOptions [ #copyThreshold 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDiffFindOptionsCopyThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m ()
setDiffFindOptionsCopyThreshold obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "copy-threshold" val

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

#if ENABLE_OVERLOADING
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)

{- |
Get the value of the “@flags@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' diffFindOptions #flags
@
-}
getDiffFindOptionsFlags :: (MonadIO m, IsDiffFindOptions o) => o -> m [Ggit.Flags.DiffFindFlags]
getDiffFindOptionsFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "flags"

{- |
Set the value of the “@flags@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' diffFindOptions [ #flags 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDiffFindOptionsFlags :: (MonadIO m, IsDiffFindOptions o) => o -> [Ggit.Flags.DiffFindFlags] -> m ()
setDiffFindOptionsFlags obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "flags" val

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

#if ENABLE_OVERLOADING
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 True,Just False)

{- |
Get the value of the “@metric@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' diffFindOptions #metric
@
-}
getDiffFindOptionsMetric :: (MonadIO m, IsDiffFindOptions o) => o -> m (Maybe Ggit.DiffSimilarityMetric.DiffSimilarityMetric)
getDiffFindOptionsMetric obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "metric" Ggit.DiffSimilarityMetric.DiffSimilarityMetric

{- |
Set the value of the “@metric@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' diffFindOptions [ #metric 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDiffFindOptionsMetric :: (MonadIO m, IsDiffFindOptions o) => o -> Ggit.DiffSimilarityMetric.DiffSimilarityMetric -> m ()
setDiffFindOptionsMetric obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "metric" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@metric@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDiffFindOptionsMetric :: (IsDiffFindOptions o) => Ggit.DiffSimilarityMetric.DiffSimilarityMetric -> IO (GValueConstruct o)
constructDiffFindOptionsMetric val = B.Properties.constructObjectPropertyBoxed "metric" (Just val)

#if ENABLE_OVERLOADING
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 = (Maybe 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)

{- |
Get the value of the “@rename-from-rewrite-threshold@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' diffFindOptions #renameFromRewriteThreshold
@
-}
getDiffFindOptionsRenameFromRewriteThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32
getDiffFindOptionsRenameFromRewriteThreshold obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "rename-from-rewrite-threshold"

{- |
Set the value of the “@rename-from-rewrite-threshold@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' diffFindOptions [ #renameFromRewriteThreshold 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDiffFindOptionsRenameFromRewriteThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m ()
setDiffFindOptionsRenameFromRewriteThreshold obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "rename-from-rewrite-threshold" val

{- |
Construct a `GValueConstruct` with valid value for the “@rename-from-rewrite-threshold@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDiffFindOptionsRenameFromRewriteThreshold :: (IsDiffFindOptions o) => Word32 -> IO (GValueConstruct o)
constructDiffFindOptionsRenameFromRewriteThreshold val = B.Properties.constructObjectPropertyUInt32 "rename-from-rewrite-threshold" val

#if ENABLE_OVERLOADING
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)

{- |
Get the value of the “@rename-limit@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' diffFindOptions #renameLimit
@
-}
getDiffFindOptionsRenameLimit :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32
getDiffFindOptionsRenameLimit obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "rename-limit"

{- |
Set the value of the “@rename-limit@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' diffFindOptions [ #renameLimit 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDiffFindOptionsRenameLimit :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m ()
setDiffFindOptionsRenameLimit obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "rename-limit" val

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

#if ENABLE_OVERLOADING
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)

{- |
Get the value of the “@rename-threshold@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' diffFindOptions #renameThreshold
@
-}
getDiffFindOptionsRenameThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32
getDiffFindOptionsRenameThreshold obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "rename-threshold"

{- |
Set the value of the “@rename-threshold@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' diffFindOptions [ #renameThreshold 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDiffFindOptionsRenameThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m ()
setDiffFindOptionsRenameThreshold obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "rename-threshold" val

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

#if ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
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 (Maybe DiffFindOptions)
    {- ^ __Returns:__ a newly allocated 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions' or 'Nothing'. -}
diffFindOptionsNew  = liftIO $ do
    result <- ggit_diff_find_options_new
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject DiffFindOptions) result'
        return result''
    return maybeResult

#if ENABLE_OVERLOADING
#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 ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
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 (Maybe 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'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newBoxed Ggit.DiffSimilarityMetric.DiffSimilarityMetric) result'
        return result''
    touchManagedPtr options
    return maybeResult

#if ENABLE_OVERLOADING
data DiffFindOptionsGetMetricMethodInfo
instance (signature ~ (m (Maybe 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 ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
data DiffFindOptionsSetRenameThresholdMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsSetRenameThresholdMethodInfo a signature where
    overloadedMethod _ = diffFindOptionsSetRenameThreshold

#endif