{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Represents options for finding diff similarity.

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

module GI.Ggit.Objects.DiffFindOptions
    (

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


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

#if defined(ENABLE_OVERLOADING)
    ResolveDiffFindOptionsMethod            ,
#endif


-- ** getCopyThreshold #method:getCopyThreshold#

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsGetCopyThresholdMethodInfo,
#endif
    diffFindOptionsGetCopyThreshold         ,


-- ** getFlags #method:getFlags#

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsGetFlagsMethodInfo       ,
#endif
    diffFindOptionsGetFlags                 ,


-- ** getMetric #method:getMetric#

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsGetMetricMethodInfo      ,
#endif
    diffFindOptionsGetMetric                ,


-- ** getRenameFromRewriteThreshold #method:getRenameFromRewriteThreshold#

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsGetRenameFromRewriteThresholdMethodInfo,
#endif
    diffFindOptionsGetRenameFromRewriteThreshold,


-- ** getRenameLimit #method:getRenameLimit#

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsGetRenameLimitMethodInfo ,
#endif
    diffFindOptionsGetRenameLimit           ,


-- ** getRenameThreshold #method:getRenameThreshold#

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsGetRenameThresholdMethodInfo,
#endif
    diffFindOptionsGetRenameThreshold       ,


-- ** new #method:new#

    diffFindOptionsNew                      ,


-- ** setCopyThreshold #method:setCopyThreshold#

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsSetCopyThresholdMethodInfo,
#endif
    diffFindOptionsSetCopyThreshold         ,


-- ** setFlags #method:setFlags#

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsSetFlagsMethodInfo       ,
#endif
    diffFindOptionsSetFlags                 ,


-- ** setMetric #method:setMetric#

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsSetMetricMethodInfo      ,
#endif
    diffFindOptionsSetMetric                ,


-- ** setRenameFromRewriteThreshold #method:setRenameFromRewriteThreshold#

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsSetRenameFromRewriteThresholdMethodInfo,
#endif
    diffFindOptionsSetRenameFromRewriteThreshold,


-- ** setRenameLimit #method:setRenameLimit#

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsSetRenameLimitMethodInfo ,
#endif
    diffFindOptionsSetRenameLimit           ,


-- ** setRenameThreshold #method:setRenameThreshold#

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsSetRenameThresholdMethodInfo,
#endif
    diffFindOptionsSetRenameThreshold       ,




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

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsCopyThresholdPropertyInfo,
#endif
    constructDiffFindOptionsCopyThreshold   ,
#if defined(ENABLE_OVERLOADING)
    diffFindOptionsCopyThreshold            ,
#endif
    getDiffFindOptionsCopyThreshold         ,
    setDiffFindOptionsCopyThreshold         ,


-- ** flags #attr:flags#
-- | The diff option flags.

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsFlagsPropertyInfo        ,
#endif
    constructDiffFindOptionsFlags           ,
#if defined(ENABLE_OVERLOADING)
    diffFindOptionsFlags                    ,
#endif
    getDiffFindOptionsFlags                 ,
    setDiffFindOptionsFlags                 ,


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

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsMetricPropertyInfo       ,
#endif
    constructDiffFindOptionsMetric          ,
#if defined(ENABLE_OVERLOADING)
    diffFindOptionsMetric                   ,
#endif
    getDiffFindOptionsMetric                ,
    setDiffFindOptionsMetric                ,


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

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsRenameFromRewriteThresholdPropertyInfo,
#endif
    constructDiffFindOptionsRenameFromRewriteThreshold,
#if defined(ENABLE_OVERLOADING)
    diffFindOptionsRenameFromRewriteThreshold,
#endif
    getDiffFindOptionsRenameFromRewriteThreshold,
    setDiffFindOptionsRenameFromRewriteThreshold,


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

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsRenameLimitPropertyInfo  ,
#endif
    constructDiffFindOptionsRenameLimit     ,
#if defined(ENABLE_OVERLOADING)
    diffFindOptionsRenameLimit              ,
#endif
    getDiffFindOptionsRenameLimit           ,
    setDiffFindOptionsRenameLimit           ,


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

#if defined(ENABLE_OVERLOADING)
    DiffFindOptionsRenameThresholdPropertyInfo,
#endif
    constructDiffFindOptionsRenameThreshold ,
#if defined(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.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

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

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


-- | Convert 'DiffFindOptions' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue DiffFindOptions where
    toGValue o = do
        gtype <- c_ggit_diff_find_options_get_type
        B.ManagedPtr.withManagedPtr o (B.GValue.buildGValue gtype B.GValue.set_object)

    fromGValue gv = do
        ptr <- B.GValue.get_object gv :: IO (Ptr DiffFindOptions)
        B.ManagedPtr.newObject DiffFindOptions ptr



-- | 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 defined(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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    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 @info
#else
    fromLabel _ = O.overloadedMethod @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 defined(ENABLE_OVERLOADING)
data DiffFindOptionsCopyThresholdPropertyInfo
instance AttrInfo DiffFindOptionsCopyThresholdPropertyInfo where
    type AttrAllowedOps DiffFindOptionsCopyThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DiffFindOptionsCopyThresholdPropertyInfo = IsDiffFindOptions
    type AttrSetTypeConstraint DiffFindOptionsCopyThresholdPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint DiffFindOptionsCopyThresholdPropertyInfo = (~) Word32
    type AttrTransferType DiffFindOptionsCopyThresholdPropertyInfo = Word32
    type AttrGetType DiffFindOptionsCopyThresholdPropertyInfo = Word32
    type AttrLabel DiffFindOptionsCopyThresholdPropertyInfo = "copy-threshold"
    type AttrOrigin DiffFindOptionsCopyThresholdPropertyInfo = DiffFindOptions
    attrGet = getDiffFindOptionsCopyThreshold
    attrSet = setDiffFindOptionsCopyThreshold
    attrTransfer _ v = do
        return v
    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 defined(ENABLE_OVERLOADING)
data DiffFindOptionsFlagsPropertyInfo
instance AttrInfo DiffFindOptionsFlagsPropertyInfo where
    type AttrAllowedOps DiffFindOptionsFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DiffFindOptionsFlagsPropertyInfo = IsDiffFindOptions
    type AttrSetTypeConstraint DiffFindOptionsFlagsPropertyInfo = (~) [Ggit.Flags.DiffFindFlags]
    type AttrTransferTypeConstraint DiffFindOptionsFlagsPropertyInfo = (~) [Ggit.Flags.DiffFindFlags]
    type AttrTransferType DiffFindOptionsFlagsPropertyInfo = [Ggit.Flags.DiffFindFlags]
    type AttrGetType DiffFindOptionsFlagsPropertyInfo = [Ggit.Flags.DiffFindFlags]
    type AttrLabel DiffFindOptionsFlagsPropertyInfo = "flags"
    type AttrOrigin DiffFindOptionsFlagsPropertyInfo = DiffFindOptions
    attrGet = getDiffFindOptionsFlags
    attrSet = setDiffFindOptionsFlags
    attrTransfer _ v = do
        return v
    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 defined(ENABLE_OVERLOADING)
data DiffFindOptionsMetricPropertyInfo
instance AttrInfo DiffFindOptionsMetricPropertyInfo where
    type AttrAllowedOps DiffFindOptionsMetricPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DiffFindOptionsMetricPropertyInfo = IsDiffFindOptions
    type AttrSetTypeConstraint DiffFindOptionsMetricPropertyInfo = (~) Ggit.DiffSimilarityMetric.DiffSimilarityMetric
    type AttrTransferTypeConstraint DiffFindOptionsMetricPropertyInfo = (~) Ggit.DiffSimilarityMetric.DiffSimilarityMetric
    type AttrTransferType DiffFindOptionsMetricPropertyInfo = Ggit.DiffSimilarityMetric.DiffSimilarityMetric
    type AttrGetType DiffFindOptionsMetricPropertyInfo = (Maybe Ggit.DiffSimilarityMetric.DiffSimilarityMetric)
    type AttrLabel DiffFindOptionsMetricPropertyInfo = "metric"
    type AttrOrigin DiffFindOptionsMetricPropertyInfo = DiffFindOptions
    attrGet = getDiffFindOptionsMetric
    attrSet = setDiffFindOptionsMetric
    attrTransfer _ v = do
        return v
    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 defined(ENABLE_OVERLOADING)
data DiffFindOptionsRenameFromRewriteThresholdPropertyInfo
instance AttrInfo DiffFindOptionsRenameFromRewriteThresholdPropertyInfo where
    type AttrAllowedOps DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = IsDiffFindOptions
    type AttrSetTypeConstraint DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = (~) Word32
    type AttrTransferType DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = Word32
    type AttrGetType DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = Word32
    type AttrLabel DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = "rename-from-rewrite-threshold"
    type AttrOrigin DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = DiffFindOptions
    attrGet = getDiffFindOptionsRenameFromRewriteThreshold
    attrSet = setDiffFindOptionsRenameFromRewriteThreshold
    attrTransfer _ v = do
        return v
    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 defined(ENABLE_OVERLOADING)
data DiffFindOptionsRenameLimitPropertyInfo
instance AttrInfo DiffFindOptionsRenameLimitPropertyInfo where
    type AttrAllowedOps DiffFindOptionsRenameLimitPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DiffFindOptionsRenameLimitPropertyInfo = IsDiffFindOptions
    type AttrSetTypeConstraint DiffFindOptionsRenameLimitPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint DiffFindOptionsRenameLimitPropertyInfo = (~) Word32
    type AttrTransferType DiffFindOptionsRenameLimitPropertyInfo = Word32
    type AttrGetType DiffFindOptionsRenameLimitPropertyInfo = Word32
    type AttrLabel DiffFindOptionsRenameLimitPropertyInfo = "rename-limit"
    type AttrOrigin DiffFindOptionsRenameLimitPropertyInfo = DiffFindOptions
    attrGet = getDiffFindOptionsRenameLimit
    attrSet = setDiffFindOptionsRenameLimit
    attrTransfer _ v = do
        return v
    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 defined(ENABLE_OVERLOADING)
data DiffFindOptionsRenameThresholdPropertyInfo
instance AttrInfo DiffFindOptionsRenameThresholdPropertyInfo where
    type AttrAllowedOps DiffFindOptionsRenameThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DiffFindOptionsRenameThresholdPropertyInfo = IsDiffFindOptions
    type AttrSetTypeConstraint DiffFindOptionsRenameThresholdPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint DiffFindOptionsRenameThresholdPropertyInfo = (~) Word32
    type AttrTransferType DiffFindOptionsRenameThresholdPropertyInfo = Word32
    type AttrGetType DiffFindOptionsRenameThresholdPropertyInfo = Word32
    type AttrLabel DiffFindOptionsRenameThresholdPropertyInfo = "rename-threshold"
    type AttrOrigin DiffFindOptionsRenameThresholdPropertyInfo = DiffFindOptions
    attrGet = getDiffFindOptionsRenameThreshold
    attrSet = setDiffFindOptionsRenameThreshold
    attrTransfer _ v = do
        return v
    attrConstruct = constructDiffFindOptionsRenameThreshold
    attrClear = undefined
#endif

#if defined(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 defined(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 defined(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 t'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'.
diffFindOptionsNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m (Maybe DiffFindOptions)
    -- ^ __Returns:__ a newly allocated t'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions' or 'P.Nothing'.
diffFindOptionsNew  = liftIO $ do
    result <- ggit_diff_find_options_new
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject DiffFindOptions) result'
        return result''
    return maybeResult

#if defined(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 t'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)
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 t'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)
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 t'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'.
    -> m (Maybe Ggit.DiffSimilarityMetric.DiffSimilarityMetric)
    -- ^ __Returns:__ a t'GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric' or 'P.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 defined(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 t'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)
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 t'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)
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 t'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)
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 t'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)
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 t'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'.
    -> [Ggit.Flags.DiffFindFlags]
    -- ^ /@flags@/: a t'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)
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 t'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'.
    -> Ggit.DiffSimilarityMetric.DiffSimilarityMetric
    -- ^ /@metric@/: a t'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)
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 t'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)
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 t'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)
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 t'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)
data DiffFindOptionsSetRenameThresholdMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsSetRenameThresholdMethodInfo a signature where
    overloadedMethod = diffFindOptionsSetRenameThreshold

#endif