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

/No description available in the introspection data./
-}

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

module GI.Ggit.Objects.DiffFormatEmailOptions
    ( 

-- * Exported types
    DiffFormatEmailOptions(..)              ,
    IsDiffFormatEmailOptions                ,
    toDiffFormatEmailOptions                ,
    noDiffFormatEmailOptions                ,


 -- * Methods
-- ** getAuthor #method:getAuthor#

#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsGetAuthorMethodInfo,
#endif
    diffFormatEmailOptionsGetAuthor         ,


-- ** getBody #method:getBody#

#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsGetBodyMethodInfo ,
#endif
    diffFormatEmailOptionsGetBody           ,


-- ** getFlags #method:getFlags#

#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsGetFlagsMethodInfo,
#endif
    diffFormatEmailOptionsGetFlags          ,


-- ** getId #method:getId#

#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsGetIdMethodInfo   ,
#endif
    diffFormatEmailOptionsGetId             ,


-- ** getPatchNumber #method:getPatchNumber#

#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsGetPatchNumberMethodInfo,
#endif
    diffFormatEmailOptionsGetPatchNumber    ,


-- ** getSummary #method:getSummary#

#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsGetSummaryMethodInfo,
#endif
    diffFormatEmailOptionsGetSummary        ,


-- ** getTotalPatches #method:getTotalPatches#

#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsGetTotalPatchesMethodInfo,
#endif
    diffFormatEmailOptionsGetTotalPatches   ,


-- ** new #method:new#

    diffFormatEmailOptionsNew               ,


-- ** setAuthor #method:setAuthor#

#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsSetAuthorMethodInfo,
#endif
    diffFormatEmailOptionsSetAuthor         ,


-- ** setBody #method:setBody#

#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsSetBodyMethodInfo ,
#endif
    diffFormatEmailOptionsSetBody           ,


-- ** setFlags #method:setFlags#

#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsSetFlagsMethodInfo,
#endif
    diffFormatEmailOptionsSetFlags          ,


-- ** setId #method:setId#

#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsSetIdMethodInfo   ,
#endif
    diffFormatEmailOptionsSetId             ,


-- ** setPatchNumber #method:setPatchNumber#

#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsSetPatchNumberMethodInfo,
#endif
    diffFormatEmailOptionsSetPatchNumber    ,


-- ** setSummary #method:setSummary#

#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsSetSummaryMethodInfo,
#endif
    diffFormatEmailOptionsSetSummary        ,


-- ** setTotalPatches #method:setTotalPatches#

#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsSetTotalPatchesMethodInfo,
#endif
    diffFormatEmailOptionsSetTotalPatches   ,




 -- * Properties
-- ** author #attr:author#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsAuthorPropertyInfo,
#endif
    clearDiffFormatEmailOptionsAuthor       ,
    constructDiffFormatEmailOptionsAuthor   ,
#if ENABLE_OVERLOADING
    diffFormatEmailOptionsAuthor            ,
#endif
    getDiffFormatEmailOptionsAuthor         ,
    setDiffFormatEmailOptionsAuthor         ,


-- ** body #attr:body#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsBodyPropertyInfo  ,
#endif
    clearDiffFormatEmailOptionsBody         ,
    constructDiffFormatEmailOptionsBody     ,
#if ENABLE_OVERLOADING
    diffFormatEmailOptionsBody              ,
#endif
    getDiffFormatEmailOptionsBody           ,
    setDiffFormatEmailOptionsBody           ,


-- ** flags #attr:flags#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsFlagsPropertyInfo ,
#endif
    constructDiffFormatEmailOptionsFlags    ,
#if ENABLE_OVERLOADING
    diffFormatEmailOptionsFlags             ,
#endif
    getDiffFormatEmailOptionsFlags          ,
    setDiffFormatEmailOptionsFlags          ,


-- ** id #attr:id#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsIdPropertyInfo    ,
#endif
    clearDiffFormatEmailOptionsId           ,
    constructDiffFormatEmailOptionsId       ,
#if ENABLE_OVERLOADING
    diffFormatEmailOptionsId                ,
#endif
    getDiffFormatEmailOptionsId             ,
    setDiffFormatEmailOptionsId             ,


-- ** patchNumber #attr:patchNumber#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsPatchNumberPropertyInfo,
#endif
    constructDiffFormatEmailOptionsPatchNumber,
#if ENABLE_OVERLOADING
    diffFormatEmailOptionsPatchNumber       ,
#endif
    getDiffFormatEmailOptionsPatchNumber    ,
    setDiffFormatEmailOptionsPatchNumber    ,


-- ** summary #attr:summary#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsSummaryPropertyInfo,
#endif
    clearDiffFormatEmailOptionsSummary      ,
    constructDiffFormatEmailOptionsSummary  ,
#if ENABLE_OVERLOADING
    diffFormatEmailOptionsSummary           ,
#endif
    getDiffFormatEmailOptionsSummary        ,
    setDiffFormatEmailOptionsSummary        ,


-- ** totalPatches #attr:totalPatches#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DiffFormatEmailOptionsTotalPatchesPropertyInfo,
#endif
    constructDiffFormatEmailOptionsTotalPatches,
#if ENABLE_OVERLOADING
    diffFormatEmailOptionsTotalPatches      ,
#endif
    getDiffFormatEmailOptionsTotalPatches   ,
    setDiffFormatEmailOptionsTotalPatches   ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

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

-- | Memory-managed wrapper type.
newtype DiffFormatEmailOptions = DiffFormatEmailOptions (ManagedPtr DiffFormatEmailOptions)
foreign import ccall "ggit_diff_format_email_options_get_type"
    c_ggit_diff_format_email_options_get_type :: IO GType

instance GObject DiffFormatEmailOptions where
    gobjectType = c_ggit_diff_format_email_options_get_type
    

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

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

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

-- | A convenience alias for `Nothing` :: `Maybe` `DiffFormatEmailOptions`.
noDiffFormatEmailOptions :: Maybe DiffFormatEmailOptions
noDiffFormatEmailOptions = Nothing

#if ENABLE_OVERLOADING
type family ResolveDiffFormatEmailOptionsMethod (t :: Symbol) (o :: *) :: * where
    ResolveDiffFormatEmailOptionsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDiffFormatEmailOptionsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDiffFormatEmailOptionsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDiffFormatEmailOptionsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDiffFormatEmailOptionsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveDiffFormatEmailOptionsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDiffFormatEmailOptionsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDiffFormatEmailOptionsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDiffFormatEmailOptionsMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDiffFormatEmailOptionsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDiffFormatEmailOptionsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDiffFormatEmailOptionsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDiffFormatEmailOptionsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDiffFormatEmailOptionsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDiffFormatEmailOptionsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDiffFormatEmailOptionsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDiffFormatEmailOptionsMethod "getAuthor" o = DiffFormatEmailOptionsGetAuthorMethodInfo
    ResolveDiffFormatEmailOptionsMethod "getBody" o = DiffFormatEmailOptionsGetBodyMethodInfo
    ResolveDiffFormatEmailOptionsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDiffFormatEmailOptionsMethod "getFlags" o = DiffFormatEmailOptionsGetFlagsMethodInfo
    ResolveDiffFormatEmailOptionsMethod "getId" o = DiffFormatEmailOptionsGetIdMethodInfo
    ResolveDiffFormatEmailOptionsMethod "getPatchNumber" o = DiffFormatEmailOptionsGetPatchNumberMethodInfo
    ResolveDiffFormatEmailOptionsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDiffFormatEmailOptionsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDiffFormatEmailOptionsMethod "getSummary" o = DiffFormatEmailOptionsGetSummaryMethodInfo
    ResolveDiffFormatEmailOptionsMethod "getTotalPatches" o = DiffFormatEmailOptionsGetTotalPatchesMethodInfo
    ResolveDiffFormatEmailOptionsMethod "setAuthor" o = DiffFormatEmailOptionsSetAuthorMethodInfo
    ResolveDiffFormatEmailOptionsMethod "setBody" o = DiffFormatEmailOptionsSetBodyMethodInfo
    ResolveDiffFormatEmailOptionsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDiffFormatEmailOptionsMethod "setFlags" o = DiffFormatEmailOptionsSetFlagsMethodInfo
    ResolveDiffFormatEmailOptionsMethod "setId" o = DiffFormatEmailOptionsSetIdMethodInfo
    ResolveDiffFormatEmailOptionsMethod "setPatchNumber" o = DiffFormatEmailOptionsSetPatchNumberMethodInfo
    ResolveDiffFormatEmailOptionsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDiffFormatEmailOptionsMethod "setSummary" o = DiffFormatEmailOptionsSetSummaryMethodInfo
    ResolveDiffFormatEmailOptionsMethod "setTotalPatches" o = DiffFormatEmailOptionsSetTotalPatchesMethodInfo
    ResolveDiffFormatEmailOptionsMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveDiffFormatEmailOptionsMethod t DiffFormatEmailOptions, O.MethodInfo info DiffFormatEmailOptions p) => OL.IsLabel t (DiffFormatEmailOptions -> 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 "author"
   -- Type: TInterface (Name {namespace = "Ggit", name = "Signature"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

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

@
'Data.GI.Base.Attributes.get' diffFormatEmailOptions #author
@
-}
getDiffFormatEmailOptionsAuthor :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m (Maybe Ggit.Signature.Signature)
getDiffFormatEmailOptionsAuthor obj = liftIO $ B.Properties.getObjectPropertyObject obj "author" Ggit.Signature.Signature

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

@
'Data.GI.Base.Attributes.set' diffFormatEmailOptions [ #author 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDiffFormatEmailOptionsAuthor :: (MonadIO m, IsDiffFormatEmailOptions o, Ggit.Signature.IsSignature a) => o -> a -> m ()
setDiffFormatEmailOptionsAuthor obj val = liftIO $ B.Properties.setObjectPropertyObject obj "author" (Just val)

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

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

@
'Data.GI.Base.Attributes.clear' #author
@
-}
clearDiffFormatEmailOptionsAuthor :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m ()
clearDiffFormatEmailOptionsAuthor obj = liftIO $ B.Properties.setObjectPropertyObject obj "author" (Nothing :: Maybe Ggit.Signature.Signature)

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsAuthorPropertyInfo
instance AttrInfo DiffFormatEmailOptionsAuthorPropertyInfo where
    type AttrAllowedOps DiffFormatEmailOptionsAuthorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DiffFormatEmailOptionsAuthorPropertyInfo = Ggit.Signature.IsSignature
    type AttrBaseTypeConstraint DiffFormatEmailOptionsAuthorPropertyInfo = IsDiffFormatEmailOptions
    type AttrGetType DiffFormatEmailOptionsAuthorPropertyInfo = (Maybe Ggit.Signature.Signature)
    type AttrLabel DiffFormatEmailOptionsAuthorPropertyInfo = "author"
    type AttrOrigin DiffFormatEmailOptionsAuthorPropertyInfo = DiffFormatEmailOptions
    attrGet _ = getDiffFormatEmailOptionsAuthor
    attrSet _ = setDiffFormatEmailOptionsAuthor
    attrConstruct _ = constructDiffFormatEmailOptionsAuthor
    attrClear _ = clearDiffFormatEmailOptionsAuthor
#endif

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

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

@
'Data.GI.Base.Attributes.get' diffFormatEmailOptions #body
@
-}
getDiffFormatEmailOptionsBody :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m (Maybe T.Text)
getDiffFormatEmailOptionsBody obj = liftIO $ B.Properties.getObjectPropertyString obj "body"

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

@
'Data.GI.Base.Attributes.set' diffFormatEmailOptions [ #body 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDiffFormatEmailOptionsBody :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> T.Text -> m ()
setDiffFormatEmailOptionsBody obj val = liftIO $ B.Properties.setObjectPropertyString obj "body" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@body@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDiffFormatEmailOptionsBody :: (IsDiffFormatEmailOptions o) => T.Text -> IO (GValueConstruct o)
constructDiffFormatEmailOptionsBody val = B.Properties.constructObjectPropertyString "body" (Just val)

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

@
'Data.GI.Base.Attributes.clear' #body
@
-}
clearDiffFormatEmailOptionsBody :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m ()
clearDiffFormatEmailOptionsBody obj = liftIO $ B.Properties.setObjectPropertyString obj "body" (Nothing :: Maybe T.Text)

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsBodyPropertyInfo
instance AttrInfo DiffFormatEmailOptionsBodyPropertyInfo where
    type AttrAllowedOps DiffFormatEmailOptionsBodyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DiffFormatEmailOptionsBodyPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DiffFormatEmailOptionsBodyPropertyInfo = IsDiffFormatEmailOptions
    type AttrGetType DiffFormatEmailOptionsBodyPropertyInfo = (Maybe T.Text)
    type AttrLabel DiffFormatEmailOptionsBodyPropertyInfo = "body"
    type AttrOrigin DiffFormatEmailOptionsBodyPropertyInfo = DiffFormatEmailOptions
    attrGet _ = getDiffFormatEmailOptionsBody
    attrSet _ = setDiffFormatEmailOptionsBody
    attrConstruct _ = constructDiffFormatEmailOptionsBody
    attrClear _ = clearDiffFormatEmailOptionsBody
#endif

-- VVV Prop "flags"
   -- Type: TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailFlags"})
   -- 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' diffFormatEmailOptions #flags
@
-}
getDiffFormatEmailOptionsFlags :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m [Ggit.Flags.DiffFormatEmailFlags]
getDiffFormatEmailOptionsFlags 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' diffFormatEmailOptions [ #flags 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDiffFormatEmailOptionsFlags :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> [Ggit.Flags.DiffFormatEmailFlags] -> m ()
setDiffFormatEmailOptionsFlags 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`.
-}
constructDiffFormatEmailOptionsFlags :: (IsDiffFormatEmailOptions o) => [Ggit.Flags.DiffFormatEmailFlags] -> IO (GValueConstruct o)
constructDiffFormatEmailOptionsFlags val = B.Properties.constructObjectPropertyFlags "flags" val

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsFlagsPropertyInfo
instance AttrInfo DiffFormatEmailOptionsFlagsPropertyInfo where
    type AttrAllowedOps DiffFormatEmailOptionsFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DiffFormatEmailOptionsFlagsPropertyInfo = (~) [Ggit.Flags.DiffFormatEmailFlags]
    type AttrBaseTypeConstraint DiffFormatEmailOptionsFlagsPropertyInfo = IsDiffFormatEmailOptions
    type AttrGetType DiffFormatEmailOptionsFlagsPropertyInfo = [Ggit.Flags.DiffFormatEmailFlags]
    type AttrLabel DiffFormatEmailOptionsFlagsPropertyInfo = "flags"
    type AttrOrigin DiffFormatEmailOptionsFlagsPropertyInfo = DiffFormatEmailOptions
    attrGet _ = getDiffFormatEmailOptionsFlags
    attrSet _ = setDiffFormatEmailOptionsFlags
    attrConstruct _ = constructDiffFormatEmailOptionsFlags
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' diffFormatEmailOptions #id
@
-}
getDiffFormatEmailOptionsId :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m (Maybe Ggit.OId.OId)
getDiffFormatEmailOptionsId obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "id" Ggit.OId.OId

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

@
'Data.GI.Base.Attributes.set' diffFormatEmailOptions [ #id 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDiffFormatEmailOptionsId :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> Ggit.OId.OId -> m ()
setDiffFormatEmailOptionsId obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "id" (Just val)

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

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

@
'Data.GI.Base.Attributes.clear' #id
@
-}
clearDiffFormatEmailOptionsId :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m ()
clearDiffFormatEmailOptionsId obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "id" (Nothing :: Maybe Ggit.OId.OId)

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsIdPropertyInfo
instance AttrInfo DiffFormatEmailOptionsIdPropertyInfo where
    type AttrAllowedOps DiffFormatEmailOptionsIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DiffFormatEmailOptionsIdPropertyInfo = (~) Ggit.OId.OId
    type AttrBaseTypeConstraint DiffFormatEmailOptionsIdPropertyInfo = IsDiffFormatEmailOptions
    type AttrGetType DiffFormatEmailOptionsIdPropertyInfo = (Maybe Ggit.OId.OId)
    type AttrLabel DiffFormatEmailOptionsIdPropertyInfo = "id"
    type AttrOrigin DiffFormatEmailOptionsIdPropertyInfo = DiffFormatEmailOptions
    attrGet _ = getDiffFormatEmailOptionsId
    attrSet _ = setDiffFormatEmailOptionsId
    attrConstruct _ = constructDiffFormatEmailOptionsId
    attrClear _ = clearDiffFormatEmailOptionsId
#endif

-- VVV Prop "patch-number"
   -- Type: TBasicType TUInt64
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

@
'Data.GI.Base.Attributes.get' diffFormatEmailOptions #patchNumber
@
-}
getDiffFormatEmailOptionsPatchNumber :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m Word64
getDiffFormatEmailOptionsPatchNumber obj = liftIO $ B.Properties.getObjectPropertyUInt64 obj "patch-number"

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

@
'Data.GI.Base.Attributes.set' diffFormatEmailOptions [ #patchNumber 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDiffFormatEmailOptionsPatchNumber :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> Word64 -> m ()
setDiffFormatEmailOptionsPatchNumber obj val = liftIO $ B.Properties.setObjectPropertyUInt64 obj "patch-number" val

{- |
Construct a `GValueConstruct` with valid value for the “@patch-number@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDiffFormatEmailOptionsPatchNumber :: (IsDiffFormatEmailOptions o) => Word64 -> IO (GValueConstruct o)
constructDiffFormatEmailOptionsPatchNumber val = B.Properties.constructObjectPropertyUInt64 "patch-number" val

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsPatchNumberPropertyInfo
instance AttrInfo DiffFormatEmailOptionsPatchNumberPropertyInfo where
    type AttrAllowedOps DiffFormatEmailOptionsPatchNumberPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DiffFormatEmailOptionsPatchNumberPropertyInfo = (~) Word64
    type AttrBaseTypeConstraint DiffFormatEmailOptionsPatchNumberPropertyInfo = IsDiffFormatEmailOptions
    type AttrGetType DiffFormatEmailOptionsPatchNumberPropertyInfo = Word64
    type AttrLabel DiffFormatEmailOptionsPatchNumberPropertyInfo = "patch-number"
    type AttrOrigin DiffFormatEmailOptionsPatchNumberPropertyInfo = DiffFormatEmailOptions
    attrGet _ = getDiffFormatEmailOptionsPatchNumber
    attrSet _ = setDiffFormatEmailOptionsPatchNumber
    attrConstruct _ = constructDiffFormatEmailOptionsPatchNumber
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' diffFormatEmailOptions #summary
@
-}
getDiffFormatEmailOptionsSummary :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m (Maybe T.Text)
getDiffFormatEmailOptionsSummary obj = liftIO $ B.Properties.getObjectPropertyString obj "summary"

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

@
'Data.GI.Base.Attributes.set' diffFormatEmailOptions [ #summary 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDiffFormatEmailOptionsSummary :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> T.Text -> m ()
setDiffFormatEmailOptionsSummary obj val = liftIO $ B.Properties.setObjectPropertyString obj "summary" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@summary@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDiffFormatEmailOptionsSummary :: (IsDiffFormatEmailOptions o) => T.Text -> IO (GValueConstruct o)
constructDiffFormatEmailOptionsSummary val = B.Properties.constructObjectPropertyString "summary" (Just val)

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

@
'Data.GI.Base.Attributes.clear' #summary
@
-}
clearDiffFormatEmailOptionsSummary :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m ()
clearDiffFormatEmailOptionsSummary obj = liftIO $ B.Properties.setObjectPropertyString obj "summary" (Nothing :: Maybe T.Text)

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsSummaryPropertyInfo
instance AttrInfo DiffFormatEmailOptionsSummaryPropertyInfo where
    type AttrAllowedOps DiffFormatEmailOptionsSummaryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DiffFormatEmailOptionsSummaryPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DiffFormatEmailOptionsSummaryPropertyInfo = IsDiffFormatEmailOptions
    type AttrGetType DiffFormatEmailOptionsSummaryPropertyInfo = (Maybe T.Text)
    type AttrLabel DiffFormatEmailOptionsSummaryPropertyInfo = "summary"
    type AttrOrigin DiffFormatEmailOptionsSummaryPropertyInfo = DiffFormatEmailOptions
    attrGet _ = getDiffFormatEmailOptionsSummary
    attrSet _ = setDiffFormatEmailOptionsSummary
    attrConstruct _ = constructDiffFormatEmailOptionsSummary
    attrClear _ = clearDiffFormatEmailOptionsSummary
#endif

-- VVV Prop "total-patches"
   -- Type: TBasicType TUInt64
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

@
'Data.GI.Base.Attributes.get' diffFormatEmailOptions #totalPatches
@
-}
getDiffFormatEmailOptionsTotalPatches :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m Word64
getDiffFormatEmailOptionsTotalPatches obj = liftIO $ B.Properties.getObjectPropertyUInt64 obj "total-patches"

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

@
'Data.GI.Base.Attributes.set' diffFormatEmailOptions [ #totalPatches 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDiffFormatEmailOptionsTotalPatches :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> Word64 -> m ()
setDiffFormatEmailOptionsTotalPatches obj val = liftIO $ B.Properties.setObjectPropertyUInt64 obj "total-patches" val

{- |
Construct a `GValueConstruct` with valid value for the “@total-patches@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDiffFormatEmailOptionsTotalPatches :: (IsDiffFormatEmailOptions o) => Word64 -> IO (GValueConstruct o)
constructDiffFormatEmailOptionsTotalPatches val = B.Properties.constructObjectPropertyUInt64 "total-patches" val

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsTotalPatchesPropertyInfo
instance AttrInfo DiffFormatEmailOptionsTotalPatchesPropertyInfo where
    type AttrAllowedOps DiffFormatEmailOptionsTotalPatchesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DiffFormatEmailOptionsTotalPatchesPropertyInfo = (~) Word64
    type AttrBaseTypeConstraint DiffFormatEmailOptionsTotalPatchesPropertyInfo = IsDiffFormatEmailOptions
    type AttrGetType DiffFormatEmailOptionsTotalPatchesPropertyInfo = Word64
    type AttrLabel DiffFormatEmailOptionsTotalPatchesPropertyInfo = "total-patches"
    type AttrOrigin DiffFormatEmailOptionsTotalPatchesPropertyInfo = DiffFormatEmailOptions
    attrGet _ = getDiffFormatEmailOptionsTotalPatches
    attrSet _ = setDiffFormatEmailOptionsTotalPatches
    attrConstruct _ = constructDiffFormatEmailOptionsTotalPatches
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList DiffFormatEmailOptions
type instance O.AttributeList DiffFormatEmailOptions = DiffFormatEmailOptionsAttributeList
type DiffFormatEmailOptionsAttributeList = ('[ '("author", DiffFormatEmailOptionsAuthorPropertyInfo), '("body", DiffFormatEmailOptionsBodyPropertyInfo), '("flags", DiffFormatEmailOptionsFlagsPropertyInfo), '("id", DiffFormatEmailOptionsIdPropertyInfo), '("patchNumber", DiffFormatEmailOptionsPatchNumberPropertyInfo), '("summary", DiffFormatEmailOptionsSummaryPropertyInfo), '("totalPatches", DiffFormatEmailOptionsTotalPatchesPropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
diffFormatEmailOptionsAuthor :: AttrLabelProxy "author"
diffFormatEmailOptionsAuthor = AttrLabelProxy

diffFormatEmailOptionsBody :: AttrLabelProxy "body"
diffFormatEmailOptionsBody = AttrLabelProxy

diffFormatEmailOptionsFlags :: AttrLabelProxy "flags"
diffFormatEmailOptionsFlags = AttrLabelProxy

diffFormatEmailOptionsId :: AttrLabelProxy "id"
diffFormatEmailOptionsId = AttrLabelProxy

diffFormatEmailOptionsPatchNumber :: AttrLabelProxy "patchNumber"
diffFormatEmailOptionsPatchNumber = AttrLabelProxy

diffFormatEmailOptionsSummary :: AttrLabelProxy "summary"
diffFormatEmailOptionsSummary = AttrLabelProxy

diffFormatEmailOptionsTotalPatches :: AttrLabelProxy "totalPatches"
diffFormatEmailOptionsTotalPatches = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
type instance O.SignalList DiffFormatEmailOptions = DiffFormatEmailOptionsSignalList
type DiffFormatEmailOptionsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "ggit_diff_format_email_options_new" ggit_diff_format_email_options_new :: 
    IO (Ptr DiffFormatEmailOptions)

{- |
Create a new checkout options object.
-}
diffFormatEmailOptionsNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m (Maybe DiffFormatEmailOptions)
    {- ^ __Returns:__ a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions' or 'Nothing'. -}
diffFormatEmailOptionsNew  = liftIO $ do
    result <- ggit_diff_format_email_options_new
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject DiffFormatEmailOptions) result'
        return result''
    return maybeResult

#if ENABLE_OVERLOADING
#endif

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

foreign import ccall "ggit_diff_format_email_options_get_author" ggit_diff_format_email_options_get_author :: 
    Ptr DiffFormatEmailOptions ->           -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"})
    IO (Ptr Ggit.Signature.Signature)

{- |
Get the author.
-}
diffFormatEmailOptionsGetAuthor ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -}
    -> m (Maybe Ggit.Signature.Signature)
    {- ^ __Returns:__ a 'GI.Ggit.Objects.Signature.Signature' or 'Nothing'. -}
diffFormatEmailOptionsGetAuthor options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_format_email_options_get_author options'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Ggit.Signature.Signature) result'
        return result''
    touchManagedPtr options
    return maybeResult

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsGetAuthorMethodInfo
instance (signature ~ (m (Maybe Ggit.Signature.Signature)), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsGetAuthorMethodInfo a signature where
    overloadedMethod _ = diffFormatEmailOptionsGetAuthor

#endif

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

foreign import ccall "ggit_diff_format_email_options_get_body" ggit_diff_format_email_options_get_body :: 
    Ptr DiffFormatEmailOptions ->           -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"})
    IO CString

{- |
Get the body.
-}
diffFormatEmailOptionsGetBody ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the body. -}
diffFormatEmailOptionsGetBody options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_format_email_options_get_body options'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr options
    return maybeResult

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsGetBodyMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsGetBodyMethodInfo a signature where
    overloadedMethod _ = diffFormatEmailOptionsGetBody

#endif

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

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

{- |
Get the flags.
-}
diffFormatEmailOptionsGetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -}
    -> m [Ggit.Flags.DiffFormatEmailFlags]
    {- ^ __Returns:__ a 'GI.Ggit.Flags.DiffFormatEmailFlags'. -}
diffFormatEmailOptionsGetFlags options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_format_email_options_get_flags options'
    let result' = wordToGFlags result
    touchManagedPtr options
    return result'

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsGetFlagsMethodInfo
instance (signature ~ (m [Ggit.Flags.DiffFormatEmailFlags]), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsGetFlagsMethodInfo a signature where
    overloadedMethod _ = diffFormatEmailOptionsGetFlags

#endif

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

foreign import ccall "ggit_diff_format_email_options_get_id" ggit_diff_format_email_options_get_id :: 
    Ptr DiffFormatEmailOptions ->           -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"})
    IO (Ptr Ggit.OId.OId)

{- |
Get the object id.
-}
diffFormatEmailOptionsGetId ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -}
    -> m (Maybe Ggit.OId.OId)
    {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId' or 'Nothing'. -}
diffFormatEmailOptionsGetId options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_format_email_options_get_id options'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newBoxed Ggit.OId.OId) result'
        return result''
    touchManagedPtr options
    return maybeResult

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsGetIdMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsGetIdMethodInfo a signature where
    overloadedMethod _ = diffFormatEmailOptionsGetId

#endif

-- method DiffFormatEmailOptions::get_patch_number
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", 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_format_email_options_get_patch_number" ggit_diff_format_email_options_get_patch_number :: 
    Ptr DiffFormatEmailOptions ->           -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"})
    IO Word64

{- |
Get the patch number.
-}
diffFormatEmailOptionsGetPatchNumber ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -}
    -> m Word64
    {- ^ __Returns:__ the patch number. -}
diffFormatEmailOptionsGetPatchNumber options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_format_email_options_get_patch_number options'
    touchManagedPtr options
    return result

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsGetPatchNumberMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsGetPatchNumberMethodInfo a signature where
    overloadedMethod _ = diffFormatEmailOptionsGetPatchNumber

#endif

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

foreign import ccall "ggit_diff_format_email_options_get_summary" ggit_diff_format_email_options_get_summary :: 
    Ptr DiffFormatEmailOptions ->           -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"})
    IO CString

{- |
Get the summary.
-}
diffFormatEmailOptionsGetSummary ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the summary. -}
diffFormatEmailOptionsGetSummary options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_format_email_options_get_summary options'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr options
    return maybeResult

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsGetSummaryMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsGetSummaryMethodInfo a signature where
    overloadedMethod _ = diffFormatEmailOptionsGetSummary

#endif

-- method DiffFormatEmailOptions::get_total_patches
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", 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_format_email_options_get_total_patches" ggit_diff_format_email_options_get_total_patches :: 
    Ptr DiffFormatEmailOptions ->           -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"})
    IO Word64

{- |
Get the total number of patches.
-}
diffFormatEmailOptionsGetTotalPatches ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -}
    -> m Word64
    {- ^ __Returns:__ the total number of patches. -}
diffFormatEmailOptionsGetTotalPatches options = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    result <- ggit_diff_format_email_options_get_total_patches options'
    touchManagedPtr options
    return result

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsGetTotalPatchesMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsGetTotalPatchesMethodInfo a signature where
    overloadedMethod _ = diffFormatEmailOptionsGetTotalPatches

#endif

-- method DiffFormatEmailOptions::set_author
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "author", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitSignature.", 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_format_email_options_set_author" ggit_diff_format_email_options_set_author :: 
    Ptr DiffFormatEmailOptions ->           -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"})
    Ptr Ggit.Signature.Signature ->         -- author : TInterface (Name {namespace = "Ggit", name = "Signature"})
    IO ()

{- |
Set the author.
-}
diffFormatEmailOptionsSetAuthor ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a, Ggit.Signature.IsSignature b) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -}
    -> Maybe (b)
    {- ^ /@author@/: a 'GI.Ggit.Objects.Signature.Signature'. -}
    -> m ()
diffFormatEmailOptionsSetAuthor options author = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    maybeAuthor <- case author of
        Nothing -> return nullPtr
        Just jAuthor -> do
            jAuthor' <- unsafeManagedPtrCastPtr jAuthor
            return jAuthor'
    ggit_diff_format_email_options_set_author options' maybeAuthor
    touchManagedPtr options
    whenJust author touchManagedPtr
    return ()

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsSetAuthorMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsDiffFormatEmailOptions a, Ggit.Signature.IsSignature b) => O.MethodInfo DiffFormatEmailOptionsSetAuthorMethodInfo a signature where
    overloadedMethod _ = diffFormatEmailOptionsSetAuthor

#endif

-- method DiffFormatEmailOptions::set_body
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "body", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the body.", 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_format_email_options_set_body" ggit_diff_format_email_options_set_body :: 
    Ptr DiffFormatEmailOptions ->           -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"})
    CString ->                              -- body : TBasicType TUTF8
    IO ()

{- |
Set the body.
-}
diffFormatEmailOptionsSetBody ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -}
    -> Maybe (T.Text)
    {- ^ /@body@/: the body. -}
    -> m ()
diffFormatEmailOptionsSetBody options body = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    maybeBody <- case body of
        Nothing -> return nullPtr
        Just jBody -> do
            jBody' <- textToCString jBody
            return jBody'
    ggit_diff_format_email_options_set_body options' maybeBody
    touchManagedPtr options
    freeMem maybeBody
    return ()

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsSetBodyMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsSetBodyMethodInfo a signature where
    overloadedMethod _ = diffFormatEmailOptionsSetBody

#endif

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

{- |
Set the flags.
-}
diffFormatEmailOptionsSetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -}
    -> [Ggit.Flags.DiffFormatEmailFlags]
    {- ^ /@flags@/: a 'GI.Ggit.Flags.DiffFormatEmailFlags'. -}
    -> m ()
diffFormatEmailOptionsSetFlags options flags = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    let flags' = gflagsToWord flags
    ggit_diff_format_email_options_set_flags options' flags'
    touchManagedPtr options
    return ()

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsSetFlagsMethodInfo
instance (signature ~ ([Ggit.Flags.DiffFormatEmailFlags] -> m ()), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsSetFlagsMethodInfo a signature where
    overloadedMethod _ = diffFormatEmailOptionsSetFlags

#endif

-- method DiffFormatEmailOptions::set_id
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitOId.", 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_format_email_options_set_id" ggit_diff_format_email_options_set_id :: 
    Ptr DiffFormatEmailOptions ->           -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"})
    Ptr Ggit.OId.OId ->                     -- id : TInterface (Name {namespace = "Ggit", name = "OId"})
    IO ()

{- |
Set the object id.
-}
diffFormatEmailOptionsSetId ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -}
    -> Maybe (Ggit.OId.OId)
    {- ^ /@id@/: a 'GI.Ggit.Structs.OId.OId'. -}
    -> m ()
diffFormatEmailOptionsSetId options id = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    maybeId <- case id of
        Nothing -> return nullPtr
        Just jId -> do
            jId' <- unsafeManagedPtrGetPtr jId
            return jId'
    ggit_diff_format_email_options_set_id options' maybeId
    touchManagedPtr options
    whenJust id touchManagedPtr
    return ()

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsSetIdMethodInfo
instance (signature ~ (Maybe (Ggit.OId.OId) -> m ()), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsSetIdMethodInfo a signature where
    overloadedMethod _ = diffFormatEmailOptionsSetId

#endif

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

{- |
Set the patch number.
-}
diffFormatEmailOptionsSetPatchNumber ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -}
    -> Word64
    {- ^ /@number@/: the patch number. -}
    -> m ()
diffFormatEmailOptionsSetPatchNumber options number = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    ggit_diff_format_email_options_set_patch_number options' number
    touchManagedPtr options
    return ()

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsSetPatchNumberMethodInfo
instance (signature ~ (Word64 -> m ()), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsSetPatchNumberMethodInfo a signature where
    overloadedMethod _ = diffFormatEmailOptionsSetPatchNumber

#endif

-- method DiffFormatEmailOptions::set_summary
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "summary", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the summary.", 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_format_email_options_set_summary" ggit_diff_format_email_options_set_summary :: 
    Ptr DiffFormatEmailOptions ->           -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"})
    CString ->                              -- summary : TBasicType TUTF8
    IO ()

{- |
Set the summary.
-}
diffFormatEmailOptionsSetSummary ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -}
    -> Maybe (T.Text)
    {- ^ /@summary@/: the summary. -}
    -> m ()
diffFormatEmailOptionsSetSummary options summary = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    maybeSummary <- case summary of
        Nothing -> return nullPtr
        Just jSummary -> do
            jSummary' <- textToCString jSummary
            return jSummary'
    ggit_diff_format_email_options_set_summary options' maybeSummary
    touchManagedPtr options
    freeMem maybeSummary
    return ()

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsSetSummaryMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsSetSummaryMethodInfo a signature where
    overloadedMethod _ = diffFormatEmailOptionsSetSummary

#endif

-- method DiffFormatEmailOptions::set_total_patches
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "patches", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the total number of patches.", 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_format_email_options_set_total_patches" ggit_diff_format_email_options_set_total_patches :: 
    Ptr DiffFormatEmailOptions ->           -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"})
    Word64 ->                               -- patches : TBasicType TUInt64
    IO ()

{- |
Set the total number of patches.
-}
diffFormatEmailOptionsSetTotalPatches ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) =>
    a
    {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -}
    -> Word64
    {- ^ /@patches@/: the total number of patches. -}
    -> m ()
diffFormatEmailOptionsSetTotalPatches options patches = liftIO $ do
    options' <- unsafeManagedPtrCastPtr options
    ggit_diff_format_email_options_set_total_patches options' patches
    touchManagedPtr options
    return ()

#if ENABLE_OVERLOADING
data DiffFormatEmailOptionsSetTotalPatchesMethodInfo
instance (signature ~ (Word64 -> m ()), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsSetTotalPatchesMethodInfo a signature where
    overloadedMethod _ = diffFormatEmailOptionsSetTotalPatches

#endif