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

    The 'GI.GLib.Structs.Sequence.Sequence' struct is an opaque data type representing a
    [sequence][glib-Sequences] data type.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.GLib.Structs.Sequence
        (

    -- * Exported types
        Sequence(..)                            ,
        noSequence                              ,

     -- * Methods
    -- ** append #method:append#

    #if ENABLE_OVERLOADING
        SequenceAppendMethodInfo                ,
    #endif
        sequenceAppend                          ,

    -- ** free #method:free#

    #if ENABLE_OVERLOADING
        SequenceFreeMethodInfo                  ,
    #endif
        sequenceFree                            ,

    -- ** get #method:get#

        sequenceGet                             ,

    -- ** getBeginIter #method:getBeginIter#

    #if ENABLE_OVERLOADING
        SequenceGetBeginIterMethodInfo          ,
    #endif
        sequenceGetBeginIter                    ,

    -- ** getEndIter #method:getEndIter#

    #if ENABLE_OVERLOADING
        SequenceGetEndIterMethodInfo            ,
    #endif
        sequenceGetEndIter                      ,

    -- ** getIterAtPos #method:getIterAtPos#

    #if ENABLE_OVERLOADING
        SequenceGetIterAtPosMethodInfo          ,
    #endif
        sequenceGetIterAtPos                    ,

    -- ** getLength #method:getLength#

    #if ENABLE_OVERLOADING
        SequenceGetLengthMethodInfo             ,
    #endif
        sequenceGetLength                       ,

    -- ** insertBefore #method:insertBefore#

        sequenceInsertBefore                    ,

    -- ** isEmpty #method:isEmpty#

    #if ENABLE_OVERLOADING
        SequenceIsEmptyMethodInfo               ,
    #endif
        sequenceIsEmpty                         ,

    -- ** move #method:move#

        sequenceMove                            ,

    -- ** moveRange #method:moveRange#

        sequenceMoveRange                       ,

    -- ** prepend #method:prepend#

    #if ENABLE_OVERLOADING
        SequencePrependMethodInfo               ,
    #endif
        sequencePrepend                         ,

    -- ** rangeGetMidpoint #method:rangeGetMidpoint#

        sequenceRangeGetMidpoint                ,

    -- ** remove #method:remove#

        sequenceRemove                          ,

    -- ** removeRange #method:removeRange#

        sequenceRemoveRange                     ,

    -- ** set #method:set#

        sequenceSet                             ,

    -- ** swap #method:swap#

        sequenceSwap                            ,

        ) where

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

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    import {-# SOURCE #-} qualified GI.GLib.Structs.SequenceIter as GLib.SequenceIter

    -- | Memory-managed wrapper type.
    newtype Sequence = Sequence (ManagedPtr Sequence)
    -- XXX Wrapping a foreign struct/union with no known destructor or size, leak?
    instance WrappedPtr Sequence where
        wrappedPtrCalloc = return nullPtr
        wrappedPtrCopy = return
        wrappedPtrFree = Nothing

    -- | A convenience alias for `Nothing` :: `Maybe` `Sequence`.
    noSequence :: Maybe Sequence
    noSequence = Nothing

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

    -- method Sequence::append
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "seq", argType = TInterface (Name {namespace = "GLib", name = "Sequence"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequence", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data for the new item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "SequenceIter"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_sequence_append" g_sequence_append ::
        Ptr Sequence ->                         -- seq : TInterface (Name {namespace = "GLib", name = "Sequence"})
        Ptr () ->                               -- data : TBasicType TPtr
        IO (Ptr GLib.SequenceIter.SequenceIter)

    {- |
    Adds a new item to the end of /@seq@/.

    /Since: 2.14/
    -}
    sequenceAppend ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Sequence
        {- ^ /@seq@/: a 'GI.GLib.Structs.Sequence.Sequence' -}
        -> Ptr ()
        {- ^ /@data@/: the data for the new item -}
        -> m GLib.SequenceIter.SequenceIter
        {- ^ __Returns:__ an iterator pointing to the new item -}
    sequenceAppend seq data_ = liftIO $ do
        seq' <- unsafeManagedPtrGetPtr seq
        result <- g_sequence_append seq' data_
        checkUnexpectedReturnNULL "sequenceAppend" result
        result' <- (newPtr GLib.SequenceIter.SequenceIter) result
        touchManagedPtr seq
        return result'

    #if ENABLE_OVERLOADING
    data SequenceAppendMethodInfo
    instance (signature ~ (Ptr () -> m GLib.SequenceIter.SequenceIter), MonadIO m) => O.MethodInfo SequenceAppendMethodInfo Sequence signature where
        overloadedMethod _ = sequenceAppend

    #endif

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

    foreign import ccall "g_sequence_free" g_sequence_free ::
        Ptr Sequence ->                         -- seq : TInterface (Name {namespace = "GLib", name = "Sequence"})
        IO ()

    {- |
    Frees the memory allocated for /@seq@/. If /@seq@/ has a data destroy
    function associated with it, that function is called on all items
    in /@seq@/.

    /Since: 2.14/
    -}
    sequenceFree ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Sequence
        {- ^ /@seq@/: a 'GI.GLib.Structs.Sequence.Sequence' -}
        -> m ()
    sequenceFree seq = liftIO $ do
        seq' <- unsafeManagedPtrGetPtr seq
        g_sequence_free seq'
        touchManagedPtr seq
        return ()

    #if ENABLE_OVERLOADING
    data SequenceFreeMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.MethodInfo SequenceFreeMethodInfo Sequence signature where
        overloadedMethod _ = sequenceFree

    #endif

    -- method Sequence::get_begin_iter
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "seq", argType = TInterface (Name {namespace = "GLib", name = "Sequence"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequence", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "SequenceIter"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_sequence_get_begin_iter" g_sequence_get_begin_iter ::
        Ptr Sequence ->                         -- seq : TInterface (Name {namespace = "GLib", name = "Sequence"})
        IO (Ptr GLib.SequenceIter.SequenceIter)

    {- |
    Returns the begin iterator for /@seq@/.

    /Since: 2.14/
    -}
    sequenceGetBeginIter ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Sequence
        {- ^ /@seq@/: a 'GI.GLib.Structs.Sequence.Sequence' -}
        -> m GLib.SequenceIter.SequenceIter
        {- ^ __Returns:__ the begin iterator for /@seq@/. -}
    sequenceGetBeginIter seq = liftIO $ do
        seq' <- unsafeManagedPtrGetPtr seq
        result <- g_sequence_get_begin_iter seq'
        checkUnexpectedReturnNULL "sequenceGetBeginIter" result
        result' <- (newPtr GLib.SequenceIter.SequenceIter) result
        touchManagedPtr seq
        return result'

    #if ENABLE_OVERLOADING
    data SequenceGetBeginIterMethodInfo
    instance (signature ~ (m GLib.SequenceIter.SequenceIter), MonadIO m) => O.MethodInfo SequenceGetBeginIterMethodInfo Sequence signature where
        overloadedMethod _ = sequenceGetBeginIter

    #endif

    -- method Sequence::get_end_iter
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "seq", argType = TInterface (Name {namespace = "GLib", name = "Sequence"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequence", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "SequenceIter"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_sequence_get_end_iter" g_sequence_get_end_iter ::
        Ptr Sequence ->                         -- seq : TInterface (Name {namespace = "GLib", name = "Sequence"})
        IO (Ptr GLib.SequenceIter.SequenceIter)

    {- |
    Returns the end iterator for /@seg@/

    /Since: 2.14/
    -}
    sequenceGetEndIter ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Sequence
        {- ^ /@seq@/: a 'GI.GLib.Structs.Sequence.Sequence' -}
        -> m GLib.SequenceIter.SequenceIter
        {- ^ __Returns:__ the end iterator for /@seq@/ -}
    sequenceGetEndIter seq = liftIO $ do
        seq' <- unsafeManagedPtrGetPtr seq
        result <- g_sequence_get_end_iter seq'
        checkUnexpectedReturnNULL "sequenceGetEndIter" result
        result' <- (newPtr GLib.SequenceIter.SequenceIter) result
        touchManagedPtr seq
        return result'

    #if ENABLE_OVERLOADING
    data SequenceGetEndIterMethodInfo
    instance (signature ~ (m GLib.SequenceIter.SequenceIter), MonadIO m) => O.MethodInfo SequenceGetEndIterMethodInfo Sequence signature where
        overloadedMethod _ = sequenceGetEndIter

    #endif

    -- method Sequence::get_iter_at_pos
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "seq", argType = TInterface (Name {namespace = "GLib", name = "Sequence"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequence", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a position in @seq, or -1 for the end", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "SequenceIter"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_sequence_get_iter_at_pos" g_sequence_get_iter_at_pos ::
        Ptr Sequence ->                         -- seq : TInterface (Name {namespace = "GLib", name = "Sequence"})
        Int32 ->                                -- pos : TBasicType TInt
        IO (Ptr GLib.SequenceIter.SequenceIter)

    {- |
    Returns the iterator at position /@pos@/. If /@pos@/ is negative or larger
    than the number of items in /@seq@/, the end iterator is returned.

    /Since: 2.14/
    -}
    sequenceGetIterAtPos ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Sequence
        {- ^ /@seq@/: a 'GI.GLib.Structs.Sequence.Sequence' -}
        -> Int32
        {- ^ /@pos@/: a position in /@seq@/, or -1 for the end -}
        -> m GLib.SequenceIter.SequenceIter
        {- ^ __Returns:__ The 'GI.GLib.Structs.SequenceIter.SequenceIter' at position /@pos@/ -}
    sequenceGetIterAtPos seq pos = liftIO $ do
        seq' <- unsafeManagedPtrGetPtr seq
        result <- g_sequence_get_iter_at_pos seq' pos
        checkUnexpectedReturnNULL "sequenceGetIterAtPos" result
        result' <- (newPtr GLib.SequenceIter.SequenceIter) result
        touchManagedPtr seq
        return result'

    #if ENABLE_OVERLOADING
    data SequenceGetIterAtPosMethodInfo
    instance (signature ~ (Int32 -> m GLib.SequenceIter.SequenceIter), MonadIO m) => O.MethodInfo SequenceGetIterAtPosMethodInfo Sequence signature where
        overloadedMethod _ = sequenceGetIterAtPos

    #endif

    -- method Sequence::get_length
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "seq", argType = TInterface (Name {namespace = "GLib", name = "Sequence"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequence", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_sequence_get_length" g_sequence_get_length ::
        Ptr Sequence ->                         -- seq : TInterface (Name {namespace = "GLib", name = "Sequence"})
        IO Int32

    {- |
    Returns the length of /@seq@/. Note that this method is O(h) where \`h\' is the
    height of the tree. It is thus more efficient to use 'GI.GLib.Structs.Sequence.sequenceIsEmpty'
    when comparing the length to zero.

    /Since: 2.14/
    -}
    sequenceGetLength ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Sequence
        {- ^ /@seq@/: a 'GI.GLib.Structs.Sequence.Sequence' -}
        -> m Int32
        {- ^ __Returns:__ the length of /@seq@/ -}
    sequenceGetLength seq = liftIO $ do
        seq' <- unsafeManagedPtrGetPtr seq
        result <- g_sequence_get_length seq'
        touchManagedPtr seq
        return result

    #if ENABLE_OVERLOADING
    data SequenceGetLengthMethodInfo
    instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo SequenceGetLengthMethodInfo Sequence signature where
        overloadedMethod _ = sequenceGetLength

    #endif

    -- method Sequence::is_empty
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "seq", argType = TInterface (Name {namespace = "GLib", name = "Sequence"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequence", 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 "g_sequence_is_empty" g_sequence_is_empty ::
        Ptr Sequence ->                         -- seq : TInterface (Name {namespace = "GLib", name = "Sequence"})
        IO CInt

    {- |
    Returns 'True' if the sequence contains zero items.

    This function is functionally identical to checking the result of
    'GI.GLib.Structs.Sequence.sequenceGetLength' being equal to zero. However this function is
    implemented in O(1) running time.

    /Since: 2.48/
    -}
    sequenceIsEmpty ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Sequence
        {- ^ /@seq@/: a 'GI.GLib.Structs.Sequence.Sequence' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the sequence is empty, otherwise 'False'. -}
    sequenceIsEmpty seq = liftIO $ do
        seq' <- unsafeManagedPtrGetPtr seq
        result <- g_sequence_is_empty seq'
        let result' = (/= 0) result
        touchManagedPtr seq
        return result'

    #if ENABLE_OVERLOADING
    data SequenceIsEmptyMethodInfo
    instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo SequenceIsEmptyMethodInfo Sequence signature where
        overloadedMethod _ = sequenceIsEmpty

    #endif

    -- method Sequence::prepend
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "seq", argType = TInterface (Name {namespace = "GLib", name = "Sequence"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequence", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data for the new item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "SequenceIter"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_sequence_prepend" g_sequence_prepend ::
        Ptr Sequence ->                         -- seq : TInterface (Name {namespace = "GLib", name = "Sequence"})
        Ptr () ->                               -- data : TBasicType TPtr
        IO (Ptr GLib.SequenceIter.SequenceIter)

    {- |
    Adds a new item to the front of /@seq@/

    /Since: 2.14/
    -}
    sequencePrepend ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Sequence
        {- ^ /@seq@/: a 'GI.GLib.Structs.Sequence.Sequence' -}
        -> Ptr ()
        {- ^ /@data@/: the data for the new item -}
        -> m GLib.SequenceIter.SequenceIter
        {- ^ __Returns:__ an iterator pointing to the new item -}
    sequencePrepend seq data_ = liftIO $ do
        seq' <- unsafeManagedPtrGetPtr seq
        result <- g_sequence_prepend seq' data_
        checkUnexpectedReturnNULL "sequencePrepend" result
        result' <- (newPtr GLib.SequenceIter.SequenceIter) result
        touchManagedPtr seq
        return result'

    #if ENABLE_OVERLOADING
    data SequencePrependMethodInfo
    instance (signature ~ (Ptr () -> m GLib.SequenceIter.SequenceIter), MonadIO m) => O.MethodInfo SequencePrependMethodInfo Sequence signature where
        overloadedMethod _ = sequencePrepend

    #endif

    -- method Sequence::get
    -- method type : MemberFunction
    -- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TPtr)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_sequence_get" g_sequence_get ::
        Ptr GLib.SequenceIter.SequenceIter ->   -- iter : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
        IO (Ptr ())

    {- |
    Returns the data that /@iter@/ points to.

    /Since: 2.14/
    -}
    sequenceGet ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GLib.SequenceIter.SequenceIter
        {- ^ /@iter@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
        -> m (Ptr ())
        {- ^ __Returns:__ the data that /@iter@/ points to -}
    sequenceGet iter = liftIO $ do
        iter' <- unsafeManagedPtrGetPtr iter
        result <- g_sequence_get iter'
        touchManagedPtr iter
        return result

    #if ENABLE_OVERLOADING
    #endif

    -- method Sequence::insert_before
    -- method type : MemberFunction
    -- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data for the new item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "SequenceIter"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_sequence_insert_before" g_sequence_insert_before ::
        Ptr GLib.SequenceIter.SequenceIter ->   -- iter : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
        Ptr () ->                               -- data : TBasicType TPtr
        IO (Ptr GLib.SequenceIter.SequenceIter)

    {- |
    Inserts a new item just before the item pointed to by /@iter@/.

    /Since: 2.14/
    -}
    sequenceInsertBefore ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GLib.SequenceIter.SequenceIter
        {- ^ /@iter@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
        -> Ptr ()
        {- ^ /@data@/: the data for the new item -}
        -> m GLib.SequenceIter.SequenceIter
        {- ^ __Returns:__ an iterator pointing to the new item -}
    sequenceInsertBefore iter data_ = liftIO $ do
        iter' <- unsafeManagedPtrGetPtr iter
        result <- g_sequence_insert_before iter' data_
        checkUnexpectedReturnNULL "sequenceInsertBefore" result
        result' <- (newPtr GLib.SequenceIter.SequenceIter) result
        touchManagedPtr iter
        return result'

    #if ENABLE_OVERLOADING
    #endif

    -- method Sequence::move
    -- method type : MemberFunction
    -- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter pointing to the item to move", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter pointing to the position to which\n    the item is moved", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_sequence_move" g_sequence_move ::
        Ptr GLib.SequenceIter.SequenceIter ->   -- src : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
        Ptr GLib.SequenceIter.SequenceIter ->   -- dest : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
        IO ()

    {- |
    Moves the item pointed to by /@src@/ to the position indicated by /@dest@/.
    After calling this function /@dest@/ will point to the position immediately
    after /@src@/. It is allowed for /@src@/ and /@dest@/ to point into different
    sequences.

    /Since: 2.14/
    -}
    sequenceMove ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GLib.SequenceIter.SequenceIter
        {- ^ /@src@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' pointing to the item to move -}
        -> GLib.SequenceIter.SequenceIter
        {- ^ /@dest@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' pointing to the position to which
        the item is moved -}
        -> m ()
    sequenceMove src dest = liftIO $ do
        src' <- unsafeManagedPtrGetPtr src
        dest' <- unsafeManagedPtrGetPtr dest
        g_sequence_move src' dest'
        touchManagedPtr src
        touchManagedPtr dest
        return ()

    #if ENABLE_OVERLOADING
    #endif

    -- method Sequence::move_range
    -- method type : MemberFunction
    -- Args : [Arg {argCName = "dest", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "begin", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_sequence_move_range" g_sequence_move_range ::
        Ptr GLib.SequenceIter.SequenceIter ->   -- dest : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
        Ptr GLib.SequenceIter.SequenceIter ->   -- begin : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
        Ptr GLib.SequenceIter.SequenceIter ->   -- end : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
        IO ()

    {- |
    Inserts the (/@begin@/, /@end@/) range at the destination pointed to by /@dest@/.
    The /@begin@/ and /@end@/ iters must point into the same sequence. It is
    allowed for /@dest@/ to point to a different sequence than the one pointed
    into by /@begin@/ and /@end@/.

    If /@dest@/ is 'Nothing', the range indicated by /@begin@/ and /@end@/ is
    removed from the sequence. If /@dest@/ points to a place within
    the (/@begin@/, /@end@/) range, the range does not move.

    /Since: 2.14/
    -}
    sequenceMoveRange ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GLib.SequenceIter.SequenceIter
        {- ^ /@dest@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
        -> GLib.SequenceIter.SequenceIter
        {- ^ /@begin@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
        -> GLib.SequenceIter.SequenceIter
        {- ^ /@end@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
        -> m ()
    sequenceMoveRange dest begin end = liftIO $ do
        dest' <- unsafeManagedPtrGetPtr dest
        begin' <- unsafeManagedPtrGetPtr begin
        end' <- unsafeManagedPtrGetPtr end
        g_sequence_move_range dest' begin' end'
        touchManagedPtr dest
        touchManagedPtr begin
        touchManagedPtr end
        return ()

    #if ENABLE_OVERLOADING
    #endif

    -- method Sequence::range_get_midpoint
    -- method type : MemberFunction
    -- Args : [Arg {argCName = "begin", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "SequenceIter"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_sequence_range_get_midpoint" g_sequence_range_get_midpoint ::
        Ptr GLib.SequenceIter.SequenceIter ->   -- begin : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
        Ptr GLib.SequenceIter.SequenceIter ->   -- end : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
        IO (Ptr GLib.SequenceIter.SequenceIter)

    {- |
    Finds an iterator somewhere in the range (/@begin@/, /@end@/). This
    iterator will be close to the middle of the range, but is not
    guaranteed to be exactly in the middle.

    The /@begin@/ and /@end@/ iterators must both point to the same sequence
    and /@begin@/ must come before or be equal to /@end@/ in the sequence.

    /Since: 2.14/
    -}
    sequenceRangeGetMidpoint ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GLib.SequenceIter.SequenceIter
        {- ^ /@begin@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
        -> GLib.SequenceIter.SequenceIter
        {- ^ /@end@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
        -> m GLib.SequenceIter.SequenceIter
        {- ^ __Returns:__ a 'GI.GLib.Structs.SequenceIter.SequenceIter' pointing somewhere in the
       (/@begin@/, /@end@/) range -}
    sequenceRangeGetMidpoint begin end = liftIO $ do
        begin' <- unsafeManagedPtrGetPtr begin
        end' <- unsafeManagedPtrGetPtr end
        result <- g_sequence_range_get_midpoint begin' end'
        checkUnexpectedReturnNULL "sequenceRangeGetMidpoint" result
        result' <- (newPtr GLib.SequenceIter.SequenceIter) result
        touchManagedPtr begin
        touchManagedPtr end
        return result'

    #if ENABLE_OVERLOADING
    #endif

    -- method Sequence::remove
    -- method type : MemberFunction
    -- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_sequence_remove" g_sequence_remove ::
        Ptr GLib.SequenceIter.SequenceIter ->   -- iter : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
        IO ()

    {- |
    Removes the item pointed to by /@iter@/. It is an error to pass the
    end iterator to this function.

    If the sequence has a data destroy function associated with it, this
    function is called on the data for the removed item.

    /Since: 2.14/
    -}
    sequenceRemove ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GLib.SequenceIter.SequenceIter
        {- ^ /@iter@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
        -> m ()
    sequenceRemove iter = liftIO $ do
        iter' <- unsafeManagedPtrGetPtr iter
        g_sequence_remove iter'
        touchManagedPtr iter
        return ()

    #if ENABLE_OVERLOADING
    #endif

    -- method Sequence::remove_range
    -- method type : MemberFunction
    -- Args : [Arg {argCName = "begin", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_sequence_remove_range" g_sequence_remove_range ::
        Ptr GLib.SequenceIter.SequenceIter ->   -- begin : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
        Ptr GLib.SequenceIter.SequenceIter ->   -- end : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
        IO ()

    {- |
    Removes all items in the (/@begin@/, /@end@/) range.

    If the sequence has a data destroy function associated with it, this
    function is called on the data for the removed items.

    /Since: 2.14/
    -}
    sequenceRemoveRange ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GLib.SequenceIter.SequenceIter
        {- ^ /@begin@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
        -> GLib.SequenceIter.SequenceIter
        {- ^ /@end@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
        -> m ()
    sequenceRemoveRange begin end = liftIO $ do
        begin' <- unsafeManagedPtrGetPtr begin
        end' <- unsafeManagedPtrGetPtr end
        g_sequence_remove_range begin' end'
        touchManagedPtr begin
        touchManagedPtr end
        return ()

    #if ENABLE_OVERLOADING
    #endif

    -- method Sequence::set
    -- method type : MemberFunction
    -- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "new data for the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_sequence_set" g_sequence_set ::
        Ptr GLib.SequenceIter.SequenceIter ->   -- iter : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
        Ptr () ->                               -- data : TBasicType TPtr
        IO ()

    {- |
    Changes the data for the item pointed to by /@iter@/ to be /@data@/. If
    the sequence has a data destroy function associated with it, that
    function is called on the existing data that /@iter@/ pointed to.

    /Since: 2.14/
    -}
    sequenceSet ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GLib.SequenceIter.SequenceIter
        {- ^ /@iter@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
        -> Ptr ()
        {- ^ /@data@/: new data for the item -}
        -> m ()
    sequenceSet iter data_ = liftIO $ do
        iter' <- unsafeManagedPtrGetPtr iter
        g_sequence_set iter' data_
        touchManagedPtr iter
        return ()

    #if ENABLE_OVERLOADING
    #endif

    -- method Sequence::swap
    -- method type : MemberFunction
    -- Args : [Arg {argCName = "a", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_sequence_swap" g_sequence_swap ::
        Ptr GLib.SequenceIter.SequenceIter ->   -- a : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
        Ptr GLib.SequenceIter.SequenceIter ->   -- b : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
        IO ()

    {- |
    Swaps the items pointed to by /@a@/ and /@b@/. It is allowed for /@a@/ and /@b@/
    to point into difference sequences.

    /Since: 2.14/
    -}
    sequenceSwap ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GLib.SequenceIter.SequenceIter
        {- ^ /@a@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
        -> GLib.SequenceIter.SequenceIter
        {- ^ /@b@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
        -> m ()
    sequenceSwap a b = liftIO $ do
        a' <- unsafeManagedPtrGetPtr a
        b' <- unsafeManagedPtrGetPtr b
        g_sequence_swap a' b'
        touchManagedPtr a
        touchManagedPtr b
        return ()

    #if ENABLE_OVERLOADING
    #endif

    #if ENABLE_OVERLOADING
    type family ResolveSequenceMethod (t :: Symbol) (o :: *) :: * where
        ResolveSequenceMethod "append" o = SequenceAppendMethodInfo
        ResolveSequenceMethod "free" o = SequenceFreeMethodInfo
        ResolveSequenceMethod "isEmpty" o = SequenceIsEmptyMethodInfo
        ResolveSequenceMethod "prepend" o = SequencePrependMethodInfo
        ResolveSequenceMethod "getBeginIter" o = SequenceGetBeginIterMethodInfo
        ResolveSequenceMethod "getEndIter" o = SequenceGetEndIterMethodInfo
        ResolveSequenceMethod "getIterAtPos" o = SequenceGetIterAtPosMethodInfo
        ResolveSequenceMethod "getLength" o = SequenceGetLengthMethodInfo
        ResolveSequenceMethod l o = O.MethodResolutionFailed l o

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

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveSequenceMethod t Sequence, O.MethodInfo info Sequence p) => O.IsLabel t (Sequence -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #else
        fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #endif
    #endif

    #endif