{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Represents the options used when rebasing.

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

module GI.Ggit.Structs.RebaseOptions
    (

-- * Exported types
    RebaseOptions(..)                       ,
    noRebaseOptions                         ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveRebaseOptionsMethod              ,
#endif


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    RebaseOptionsCopyMethodInfo             ,
#endif
    rebaseOptionsCopy                       ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    RebaseOptionsFreeMethodInfo             ,
#endif
    rebaseOptionsFree                       ,


-- ** getCheckoutOptions #method:getCheckoutOptions#

#if defined(ENABLE_OVERLOADING)
    RebaseOptionsGetCheckoutOptionsMethodInfo,
#endif
    rebaseOptionsGetCheckoutOptions         ,


-- ** getQuiet #method:getQuiet#

#if defined(ENABLE_OVERLOADING)
    RebaseOptionsGetQuietMethodInfo         ,
#endif
    rebaseOptionsGetQuiet                   ,


-- ** getRewriteNotesRef #method:getRewriteNotesRef#

#if defined(ENABLE_OVERLOADING)
    RebaseOptionsGetRewriteNotesRefMethodInfo,
#endif
    rebaseOptionsGetRewriteNotesRef         ,


-- ** new #method:new#

    rebaseOptionsNew                        ,


-- ** setCheckoutOptions #method:setCheckoutOptions#

#if defined(ENABLE_OVERLOADING)
    RebaseOptionsSetCheckoutOptionsMethodInfo,
#endif
    rebaseOptionsSetCheckoutOptions         ,


-- ** setQuiet #method:setQuiet#

#if defined(ENABLE_OVERLOADING)
    RebaseOptionsSetQuietMethodInfo         ,
#endif
    rebaseOptionsSetQuiet                   ,


-- ** setRewriteNotesRef #method:setRewriteNotesRef#

#if defined(ENABLE_OVERLOADING)
    RebaseOptionsSetRewriteNotesRefMethodInfo,
#endif
    rebaseOptionsSetRewriteNotesRef         ,




    ) 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 {-# SOURCE #-} qualified GI.Ggit.Objects.CheckoutOptions as Ggit.CheckoutOptions

-- | Memory-managed wrapper type.
newtype RebaseOptions = RebaseOptions (ManagedPtr RebaseOptions)
    deriving (Eq)
foreign import ccall "ggit_rebase_options_get_type" c_ggit_rebase_options_get_type ::
    IO GType

instance BoxedObject RebaseOptions where
    boxedType _ = c_ggit_rebase_options_get_type

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

    fromGValue gv = do
        ptr <- B.GValue.get_boxed gv :: IO (Ptr RebaseOptions)
        B.ManagedPtr.newBoxed RebaseOptions ptr



-- | A convenience alias for `Nothing` :: `Maybe` `RebaseOptions`.
noRebaseOptions :: Maybe RebaseOptions
noRebaseOptions = Nothing


#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList RebaseOptions
type instance O.AttributeList RebaseOptions = RebaseOptionsAttributeList
type RebaseOptionsAttributeList = ('[ ] :: [(Symbol, *)])
#endif

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

foreign import ccall "ggit_rebase_options_new" ggit_rebase_options_new ::
    IO (Ptr RebaseOptions)

-- | Creates a new t'GI.Ggit.Structs.RebaseOptions.RebaseOptions'.
rebaseOptionsNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m RebaseOptions
    -- ^ __Returns:__ a newly allocated t'GI.Ggit.Structs.RebaseOptions.RebaseOptions'.
rebaseOptionsNew  = liftIO $ do
    result <- ggit_rebase_options_new
    checkUnexpectedReturnNULL "rebaseOptionsNew" result
    result' <- (wrapBoxed RebaseOptions) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "ggit_rebase_options_copy" ggit_rebase_options_copy ::
    Ptr RebaseOptions ->                    -- rebase_options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"})
    IO (Ptr RebaseOptions)

-- | Copies /@rebaseOptions@/ into a newly allocated t'GI.Ggit.Structs.RebaseOptions.RebaseOptions'.
rebaseOptionsCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RebaseOptions
    -- ^ /@rebaseOptions@/: a t'GI.Ggit.Structs.RebaseOptions.RebaseOptions'.
    -> m (Maybe RebaseOptions)
    -- ^ __Returns:__ a newly allocated t'GI.Ggit.Structs.RebaseOptions.RebaseOptions' or 'P.Nothing'.
rebaseOptionsCopy rebaseOptions = liftIO $ do
    rebaseOptions' <- unsafeManagedPtrGetPtr rebaseOptions
    result <- ggit_rebase_options_copy rebaseOptions'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed RebaseOptions) result'
        return result''
    touchManagedPtr rebaseOptions
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data RebaseOptionsCopyMethodInfo
instance (signature ~ (m (Maybe RebaseOptions)), MonadIO m) => O.MethodInfo RebaseOptionsCopyMethodInfo RebaseOptions signature where
    overloadedMethod = rebaseOptionsCopy

#endif

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

foreign import ccall "ggit_rebase_options_free" ggit_rebase_options_free ::
    Ptr RebaseOptions ->                    -- rebase_options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"})
    IO ()

-- | Frees /@rebaseOptions@/.
rebaseOptionsFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RebaseOptions
    -- ^ /@rebaseOptions@/: a t'GI.Ggit.Structs.RebaseOptions.RebaseOptions'.
    -> m ()
rebaseOptionsFree rebaseOptions = liftIO $ do
    rebaseOptions' <- unsafeManagedPtrGetPtr rebaseOptions
    ggit_rebase_options_free rebaseOptions'
    touchManagedPtr rebaseOptions
    return ()

#if defined(ENABLE_OVERLOADING)
data RebaseOptionsFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo RebaseOptionsFreeMethodInfo RebaseOptions signature where
    overloadedMethod = rebaseOptionsFree

#endif

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

foreign import ccall "ggit_rebase_options_get_checkout_options" ggit_rebase_options_get_checkout_options ::
    Ptr RebaseOptions ->                    -- rebase_options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"})
    IO (Ptr Ggit.CheckoutOptions.CheckoutOptions)

-- | Get the checkout options object or 'P.Nothing' if not set.
rebaseOptionsGetCheckoutOptions ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RebaseOptions
    -- ^ /@rebaseOptions@/: a t'GI.Ggit.Structs.RebaseOptions.RebaseOptions'.
    -> m (Maybe Ggit.CheckoutOptions.CheckoutOptions)
    -- ^ __Returns:__ the checkout options or 'P.Nothing'.
rebaseOptionsGetCheckoutOptions rebaseOptions = liftIO $ do
    rebaseOptions' <- unsafeManagedPtrGetPtr rebaseOptions
    result <- ggit_rebase_options_get_checkout_options rebaseOptions'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Ggit.CheckoutOptions.CheckoutOptions) result'
        return result''
    touchManagedPtr rebaseOptions
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data RebaseOptionsGetCheckoutOptionsMethodInfo
instance (signature ~ (m (Maybe Ggit.CheckoutOptions.CheckoutOptions)), MonadIO m) => O.MethodInfo RebaseOptionsGetCheckoutOptionsMethodInfo RebaseOptions signature where
    overloadedMethod = rebaseOptionsGetCheckoutOptions

#endif

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

foreign import ccall "ggit_rebase_options_get_quiet" ggit_rebase_options_get_quiet ::
    Ptr RebaseOptions ->                    -- rebase_options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"})
    IO CInt

-- | Gets whether you want a quiet rebase experience.
rebaseOptionsGetQuiet ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RebaseOptions
    -- ^ /@rebaseOptions@/: a t'GI.Ggit.Structs.RebaseOptions.RebaseOptions'.
    -> m Bool
    -- ^ __Returns:__ returns whether you want a quiet rebase experience.
rebaseOptionsGetQuiet rebaseOptions = liftIO $ do
    rebaseOptions' <- unsafeManagedPtrGetPtr rebaseOptions
    result <- ggit_rebase_options_get_quiet rebaseOptions'
    let result' = (/= 0) result
    touchManagedPtr rebaseOptions
    return result'

#if defined(ENABLE_OVERLOADING)
data RebaseOptionsGetQuietMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo RebaseOptionsGetQuietMethodInfo RebaseOptions signature where
    overloadedMethod = rebaseOptionsGetQuiet

#endif

-- method RebaseOptions::get_rewrite_notes_ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rebase_options"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "RebaseOptions" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitRebaseOptions."
--                 , 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_rebase_options_get_rewrite_notes_ref" ggit_rebase_options_get_rewrite_notes_ref ::
    Ptr RebaseOptions ->                    -- rebase_options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"})
    IO CString

-- | Gets the the name of the notes reference used to rewrite notes for rebased
-- commits when finishing the rebase or 'P.Nothing' if not set.
rebaseOptionsGetRewriteNotesRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RebaseOptions
    -- ^ /@rebaseOptions@/: a t'GI.Ggit.Structs.RebaseOptions.RebaseOptions'.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the name of the notes reference or 'P.Nothing'.
rebaseOptionsGetRewriteNotesRef rebaseOptions = liftIO $ do
    rebaseOptions' <- unsafeManagedPtrGetPtr rebaseOptions
    result <- ggit_rebase_options_get_rewrite_notes_ref rebaseOptions'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr rebaseOptions
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data RebaseOptionsGetRewriteNotesRefMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo RebaseOptionsGetRewriteNotesRefMethodInfo RebaseOptions signature where
    overloadedMethod = rebaseOptionsGetRewriteNotesRef

#endif

-- method RebaseOptions::set_checkout_options
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rebase_options"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "RebaseOptions" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "checkout_options"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "CheckoutOptions" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_rebase_options_set_checkout_options" ggit_rebase_options_set_checkout_options ::
    Ptr RebaseOptions ->                    -- rebase_options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"})
    Ptr Ggit.CheckoutOptions.CheckoutOptions -> -- checkout_options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})
    IO ()

-- | /No description available in the introspection data./
rebaseOptionsSetCheckoutOptions ::
    (B.CallStack.HasCallStack, MonadIO m, Ggit.CheckoutOptions.IsCheckoutOptions a) =>
    RebaseOptions
    -> a
    -> m ()
rebaseOptionsSetCheckoutOptions rebaseOptions checkoutOptions = liftIO $ do
    rebaseOptions' <- unsafeManagedPtrGetPtr rebaseOptions
    checkoutOptions' <- unsafeManagedPtrCastPtr checkoutOptions
    ggit_rebase_options_set_checkout_options rebaseOptions' checkoutOptions'
    touchManagedPtr rebaseOptions
    touchManagedPtr checkoutOptions
    return ()

#if defined(ENABLE_OVERLOADING)
data RebaseOptionsSetCheckoutOptionsMethodInfo
instance (signature ~ (a -> m ()), MonadIO m, Ggit.CheckoutOptions.IsCheckoutOptions a) => O.MethodInfo RebaseOptionsSetCheckoutOptionsMethodInfo RebaseOptions signature where
    overloadedMethod = rebaseOptionsSetCheckoutOptions

#endif

-- method RebaseOptions::set_quiet
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rebase_options"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "RebaseOptions" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitRebaseOptions."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "quiet"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether you want a quiet rebase experience."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_rebase_options_set_quiet" ggit_rebase_options_set_quiet ::
    Ptr RebaseOptions ->                    -- rebase_options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"})
    CInt ->                                 -- quiet : TBasicType TBoolean
    IO ()

-- | Used by @/ggit_rebase_init()/@, this will instruct other clients working
-- on this rebase that you want a quiet rebase experience, which they
-- may choose to provide in an application-specific manner.  This has no
-- effect upon libgit2-glib directly, but is provided for interoperability
-- between Git tools.
rebaseOptionsSetQuiet ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RebaseOptions
    -- ^ /@rebaseOptions@/: a t'GI.Ggit.Structs.RebaseOptions.RebaseOptions'.
    -> Bool
    -- ^ /@quiet@/: whether you want a quiet rebase experience.
    -> m ()
rebaseOptionsSetQuiet rebaseOptions quiet = liftIO $ do
    rebaseOptions' <- unsafeManagedPtrGetPtr rebaseOptions
    let quiet' = (fromIntegral . fromEnum) quiet
    ggit_rebase_options_set_quiet rebaseOptions' quiet'
    touchManagedPtr rebaseOptions
    return ()

#if defined(ENABLE_OVERLOADING)
data RebaseOptionsSetQuietMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo RebaseOptionsSetQuietMethodInfo RebaseOptions signature where
    overloadedMethod = rebaseOptionsSetQuiet

#endif

-- method RebaseOptions::set_rewrite_notes_ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rebase_options"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "RebaseOptions" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitRebaseOptions."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rewrite_notes_ref"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the notes reference."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_rebase_options_set_rewrite_notes_ref" ggit_rebase_options_set_rewrite_notes_ref ::
    Ptr RebaseOptions ->                    -- rebase_options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"})
    CString ->                              -- rewrite_notes_ref : TBasicType TUTF8
    IO ()

-- | Used by 'GI.Ggit.Objects.Rebase.rebaseFinish', this is the name of the notes reference
-- used to rewrite notes for rebased commits when finishing the rebase;
-- if 'P.Nothing', the contents of the configuration option @notes.rewriteRef@
-- is examined, unless the configuration option @notes.rewrite.rebase@
-- is set to false.  If @notes.rewriteRef@ is also 'P.Nothing', notes will
-- not be rewritten.
rebaseOptionsSetRewriteNotesRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RebaseOptions
    -- ^ /@rebaseOptions@/: a t'GI.Ggit.Structs.RebaseOptions.RebaseOptions'.
    -> T.Text
    -- ^ /@rewriteNotesRef@/: the name of the notes reference.
    -> m ()
rebaseOptionsSetRewriteNotesRef rebaseOptions rewriteNotesRef = liftIO $ do
    rebaseOptions' <- unsafeManagedPtrGetPtr rebaseOptions
    rewriteNotesRef' <- textToCString rewriteNotesRef
    ggit_rebase_options_set_rewrite_notes_ref rebaseOptions' rewriteNotesRef'
    touchManagedPtr rebaseOptions
    freeMem rewriteNotesRef'
    return ()

#if defined(ENABLE_OVERLOADING)
data RebaseOptionsSetRewriteNotesRefMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo RebaseOptionsSetRewriteNotesRefMethodInfo RebaseOptions signature where
    overloadedMethod = rebaseOptionsSetRewriteNotesRef

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveRebaseOptionsMethod (t :: Symbol) (o :: *) :: * where
    ResolveRebaseOptionsMethod "copy" o = RebaseOptionsCopyMethodInfo
    ResolveRebaseOptionsMethod "free" o = RebaseOptionsFreeMethodInfo
    ResolveRebaseOptionsMethod "getCheckoutOptions" o = RebaseOptionsGetCheckoutOptionsMethodInfo
    ResolveRebaseOptionsMethod "getQuiet" o = RebaseOptionsGetQuietMethodInfo
    ResolveRebaseOptionsMethod "getRewriteNotesRef" o = RebaseOptionsGetRewriteNotesRefMethodInfo
    ResolveRebaseOptionsMethod "setCheckoutOptions" o = RebaseOptionsSetCheckoutOptionsMethodInfo
    ResolveRebaseOptionsMethod "setQuiet" o = RebaseOptionsSetQuietMethodInfo
    ResolveRebaseOptionsMethod "setRewriteNotesRef" o = RebaseOptionsSetRewriteNotesRefMethodInfo
    ResolveRebaseOptionsMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveRebaseOptionsMethod t RebaseOptions, O.MethodInfo info RebaseOptions p) => OL.IsLabel t (RebaseOptions -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif