    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- @GCompletion@ provides support for automatic completion of a string
    -- using any group of target strings. It is typically used for file
    -- name completion as is common in many UNIX shells.
    --
    -- A @GCompletion@ is created using t'GI.GLib.Structs.Completion.Completion'.@/new/@(). Target items are
    -- added and removed with t'GI.GLib.Structs.Completion.Completion'.@/add_items/@(),
    -- t'GI.GLib.Structs.Completion.Completion'.@/remove_items/@() and
    -- 'GI.GLib.Structs.Completion.completionClearItems'. A completion attempt is requested with
    -- t'GI.GLib.Structs.Completion.Completion'.@/complete/@() or 'GI.GLib.Structs.Completion.completionCompleteUtf8'.
    -- When no longer needed, the @GCompletion@ is freed with
    -- 'GI.GLib.Structs.Completion.completionFree'.
    --
    -- Items in the completion can be simple strings (e.g. filenames), or
    -- pointers to arbitrary data structures. If data structures are used
    -- you must provide a [type/@gLib@/.CompletionFunc] in t'GI.GLib.Structs.Completion.Completion'.@/new/@(),
    -- which retrieves the item’s string from the data structure. You can change
    -- the way in which strings are compared by setting a different
    -- [type/@gLib@/.CompletionStrncmpFunc] in t'GI.GLib.Structs.Completion.Completion'.@/set_compare/@().
    --
    -- @GCompletion@ has been marked as deprecated, since this API is rarely
    -- used and not very actively maintained.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.GLib.Structs.Completion
        (

    -- * Exported types
        Completion(..)                          ,
        newZeroCompletion                       ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [clearItems]("GI.GLib.Structs.Completion#g:method:clearItems"), [completeUtf8]("GI.GLib.Structs.Completion#g:method:completeUtf8"), [free]("GI.GLib.Structs.Completion#g:method:free").
    --
    -- ==== Getters
    -- /None/.
    --
    -- ==== Setters
    -- /None/.

    #if defined(ENABLE_OVERLOADING)
        ResolveCompletionMethod                 ,
    #endif

    -- ** clearItems #method:clearItems#

    #if defined(ENABLE_OVERLOADING)
        CompletionClearItemsMethodInfo          ,
    #endif
        completionClearItems                    ,

    -- ** completeUtf8 #method:completeUtf8#

    #if defined(ENABLE_OVERLOADING)
        CompletionCompleteUtf8MethodInfo        ,
    #endif
        completionCompleteUtf8                  ,

    -- ** free #method:free#

    #if defined(ENABLE_OVERLOADING)
        CompletionFreeMethodInfo                ,
    #endif
        completionFree                          ,

     -- * Properties

    -- ** cache #attr:cache#
    -- | the list of items which begin with /@prefix@/.

        clearCompletionCache                    ,
    #if defined(ENABLE_OVERLOADING)
        completion_cache                        ,
    #endif
        getCompletionCache                      ,
        setCompletionCache                      ,

    -- ** func #attr:func#
    -- | function which is called to get the string associated with a
    --        target item. It is 'P.Nothing' if the target items are strings.

        clearCompletionFunc                     ,
    #if defined(ENABLE_OVERLOADING)
        completion_func                         ,
    #endif
        getCompletionFunc                       ,
        setCompletionFunc                       ,

    -- ** items #attr:items#
    -- | list of target items (strings or data structures).

        clearCompletionItems                    ,
    #if defined(ENABLE_OVERLOADING)
        completion_items                        ,
    #endif
        getCompletionItems                      ,
        setCompletionItems                      ,

    -- ** prefix #attr:prefix#
    -- | the last prefix passed to @/g_completion_complete()/@ or
    --          'GI.GLib.Structs.Completion.completionCompleteUtf8'.

        clearCompletionPrefix                   ,
    #if defined(ENABLE_OVERLOADING)
        completion_prefix                       ,
    #endif
        getCompletionPrefix                     ,
        setCompletionPrefix                     ,

    -- ** strncmpFunc #attr:strncmpFunc#
    -- | The function to use when comparing strings.  Use
    --                @/g_completion_set_compare()/@ to modify this function.

        clearCompletionStrncmpFunc              ,
    #if defined(ENABLE_OVERLOADING)
        completion_strncmpFunc                  ,
    #endif
        getCompletionStrncmpFunc                ,
        setCompletionStrncmpFunc                ,

        ) 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.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    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 Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    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 GHC.Records as R
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import qualified GI.GLib.Callbacks as GLib.Callbacks

    #else
    import qualified GI.GLib.Callbacks as GLib.Callbacks

    #endif

    -- | Memory-managed wrapper type.
    newtype Completion = Completion (SP.ManagedPtr Completion)
        deriving (Completion -> Completion -> Bool
    (Completion -> Completion -> Bool)
    -> (Completion -> Completion -> Bool) -> Eq Completion
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Completion -> Completion -> Bool
    == :: Completion -> Completion -> Bool
    $c/= :: Completion -> Completion -> Bool
    /= :: Completion -> Completion -> Bool
    Eq)

    instance SP.ManagedPtrNewtype Completion where
        toManagedPtr :: Completion -> ManagedPtr Completion
    toManagedPtr (Completion ManagedPtr Completion
    p) = ManagedPtr Completion
    p

    instance BoxedPtr Completion where
        boxedPtrCopy :: Completion -> IO Completion
    boxedPtrCopy = \Completion
    p -> Completion -> (Ptr Completion -> IO Completion) -> IO Completion
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr Completion
    p (Int -> Ptr Completion -> IO (Ptr Completion)
    forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
    copyBytes Int
    40 (Ptr Completion -> IO (Ptr Completion))
    -> (Ptr Completion -> IO Completion)
    -> Ptr Completion
    -> IO Completion
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> (ManagedPtr Completion -> Completion)
    -> Ptr Completion -> IO Completion
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    B.ManagedPtr.wrapPtr ManagedPtr Completion -> Completion
    Completion)
        boxedPtrFree :: Completion -> IO ()
    boxedPtrFree = \Completion
    x -> Completion -> (Ptr Completion -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    SP.withManagedPtr Completion
    x Ptr Completion -> IO ()
    forall a. Ptr a -> IO ()
    SP.freeMem
    instance CallocPtr Completion where
        boxedPtrCalloc :: IO (Ptr Completion)
    boxedPtrCalloc = Int -> IO (Ptr Completion)
    forall a. Int -> IO (Ptr a)
    callocBytes Int
    40

    -- | Construct a t'Completion' struct initialized to zero.
    newZeroCompletion :: MonadIO m => m Completion
    newZeroCompletion :: forall (m :: * -> *). MonadIO m => m Completion
    newZeroCompletion = IO Completion -> m Completion
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Completion -> m Completion) -> IO Completion -> m Completion
    forall a b. (a -> b) -> a -> b
    $ IO (Ptr Completion)
    forall a. CallocPtr a => IO (Ptr a)
    boxedPtrCalloc IO (Ptr Completion)
    -> (Ptr Completion -> IO Completion) -> IO Completion
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (ManagedPtr Completion -> Completion)
    -> Ptr Completion -> IO Completion
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr Completion -> Completion
    Completion

    instance tag ~ 'AttrSet => Constructible Completion tag where
        new :: forall (m :: * -> *).
    MonadIO m =>
    (ManagedPtr Completion -> Completion)
    -> [AttrOp Completion tag] -> m Completion
    new ManagedPtr Completion -> Completion
    _ [AttrOp Completion tag]
    attrs = do
            o <- m Completion
    forall (m :: * -> *). MonadIO m => m Completion
    newZeroCompletion
            GI.Attributes.set o attrs
            return o

    -- | Get the value of the “@items@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' completion #items
    -- @
    getCompletionItems :: MonadIO m => Completion -> m ([Ptr ()])
    getCompletionItems :: forall (m :: * -> *). MonadIO m => Completion -> m [Ptr ()]
    getCompletionItems Completion
    s = IO [Ptr ()] -> m [Ptr ()]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [Ptr ()] -> m [Ptr ()]) -> IO [Ptr ()] -> m [Ptr ()]
    forall a b. (a -> b) -> a -> b
    $ Completion -> (Ptr Completion -> IO [Ptr ()]) -> IO [Ptr ()]
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Completion
    s ((Ptr Completion -> IO [Ptr ()]) -> IO [Ptr ()])
    -> (Ptr Completion -> IO [Ptr ()]) -> IO [Ptr ()]
    forall a b. (a -> b) -> a -> b
    $ \Ptr Completion
    ptr -> do
        val <- Ptr (Ptr (GList (Ptr ()))) -> IO (Ptr (GList (Ptr ())))
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Completion
    ptr Ptr Completion -> Int -> Ptr (Ptr (GList (Ptr ())))
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) :: IO (Ptr (GList (Ptr ())))
        val' <- unpackGList val
        return val'

    -- | Set the value of the “@items@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' completion [ #items 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setCompletionItems :: MonadIO m => Completion -> Ptr (GList (Ptr ())) -> m ()
    setCompletionItems :: forall (m :: * -> *).
    MonadIO m =>
    Completion -> Ptr (GList (Ptr ())) -> m ()
    setCompletionItems Completion
    s Ptr (GList (Ptr ()))
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Completion -> (Ptr Completion -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Completion
    s ((Ptr Completion -> IO ()) -> IO ())
    -> (Ptr Completion -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Completion
    ptr -> do
        Ptr (Ptr (GList (Ptr ()))) -> Ptr (GList (Ptr ())) -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Completion
    ptr Ptr Completion -> Int -> Ptr (Ptr (GList (Ptr ())))
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (Ptr (GList (Ptr ()))
    val :: Ptr (GList (Ptr ())))

    -- | Set the value of the “@items@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #items
    -- @
    clearCompletionItems :: MonadIO m => Completion -> m ()
    clearCompletionItems :: forall (m :: * -> *). MonadIO m => Completion -> m ()
    clearCompletionItems Completion
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Completion -> (Ptr Completion -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Completion
    s ((Ptr Completion -> IO ()) -> IO ())
    -> (Ptr Completion -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Completion
    ptr -> do
        Ptr (Ptr (GList (Ptr ()))) -> Ptr (GList (Ptr ())) -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Completion
    ptr Ptr Completion -> Int -> Ptr (Ptr (GList (Ptr ())))
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (Ptr (GList (Ptr ()))
    forall a. Ptr a
    FP.nullPtr :: Ptr (GList (Ptr ())))

    #if defined(ENABLE_OVERLOADING)
    data CompletionItemsFieldInfo
    instance AttrInfo CompletionItemsFieldInfo where
        type AttrBaseTypeConstraint CompletionItemsFieldInfo = (~) Completion
        type AttrAllowedOps CompletionItemsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint CompletionItemsFieldInfo = (~) (Ptr (GList (Ptr ())))
        type AttrTransferTypeConstraint CompletionItemsFieldInfo = (~)(Ptr (GList (Ptr ())))
        type AttrTransferType CompletionItemsFieldInfo = (Ptr (GList (Ptr ())))
        type AttrGetType CompletionItemsFieldInfo = [Ptr ()]
        type AttrLabel CompletionItemsFieldInfo = "items"
        type AttrOrigin CompletionItemsFieldInfo = Completion
        attrGet = getCompletionItems
        attrSet = setCompletionItems
        attrConstruct = undefined
        attrClear = clearCompletionItems
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GLib.Structs.Completion.items"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Completion.html#g:attr:items"
            })

    completion_items :: AttrLabelProxy "items"
    completion_items = AttrLabelProxy

    #endif

    -- | Get the value of the “@func@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' completion #func
    -- @
    getCompletionFunc :: MonadIO m => Completion -> m (Maybe GLib.Callbacks.CompletionFunc)
    getCompletionFunc :: forall (m :: * -> *).
    MonadIO m =>
    Completion -> m (Maybe CompletionFunc)
    getCompletionFunc Completion
    s = IO (Maybe CompletionFunc) -> m (Maybe CompletionFunc)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe CompletionFunc) -> m (Maybe CompletionFunc))
    -> IO (Maybe CompletionFunc) -> m (Maybe CompletionFunc)
    forall a b. (a -> b) -> a -> b
    $ Completion
    -> (Ptr Completion -> IO (Maybe CompletionFunc))
    -> IO (Maybe CompletionFunc)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Completion
    s ((Ptr Completion -> IO (Maybe CompletionFunc))
     -> IO (Maybe CompletionFunc))
    -> (Ptr Completion -> IO (Maybe CompletionFunc))
    -> IO (Maybe CompletionFunc)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Completion
    ptr -> do
        val <- Ptr (FunPtr C_CompletionFunc) -> IO (FunPtr C_CompletionFunc)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Completion
    ptr Ptr Completion -> Int -> Ptr (FunPtr C_CompletionFunc)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) :: IO (FunPtr GLib.Callbacks.C_CompletionFunc)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_CompletionFunc
    val' -> do
            let val'' :: CompletionFunc
    val'' = FunPtr C_CompletionFunc -> CompletionFunc
    forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    FunPtr C_CompletionFunc -> Ptr () -> m Text
    GLib.Callbacks.dynamic_CompletionFunc FunPtr C_CompletionFunc
    val'
            CompletionFunc -> IO CompletionFunc
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return CompletionFunc
    val''
        return result

    -- | Set the value of the “@func@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' completion [ #func 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setCompletionFunc :: MonadIO m => Completion -> FunPtr GLib.Callbacks.C_CompletionFunc -> m ()
    setCompletionFunc :: forall (m :: * -> *).
    MonadIO m =>
    Completion -> FunPtr C_CompletionFunc -> m ()
    setCompletionFunc Completion
    s FunPtr C_CompletionFunc
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Completion -> (Ptr Completion -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Completion
    s ((Ptr Completion -> IO ()) -> IO ())
    -> (Ptr Completion -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Completion
    ptr -> do
        Ptr (FunPtr C_CompletionFunc) -> FunPtr C_CompletionFunc -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Completion
    ptr Ptr Completion -> Int -> Ptr (FunPtr C_CompletionFunc)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) (FunPtr C_CompletionFunc
    val :: FunPtr GLib.Callbacks.C_CompletionFunc)

    -- | Set the value of the “@func@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #func
    -- @
    clearCompletionFunc :: MonadIO m => Completion -> m ()
    clearCompletionFunc :: forall (m :: * -> *). MonadIO m => Completion -> m ()
    clearCompletionFunc Completion
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Completion -> (Ptr Completion -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Completion
    s ((Ptr Completion -> IO ()) -> IO ())
    -> (Ptr Completion -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Completion
    ptr -> do
        Ptr (FunPtr C_CompletionFunc) -> FunPtr C_CompletionFunc -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Completion
    ptr Ptr Completion -> Int -> Ptr (FunPtr C_CompletionFunc)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) (FunPtr C_CompletionFunc
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr GLib.Callbacks.C_CompletionFunc)

    #if defined(ENABLE_OVERLOADING)
    data CompletionFuncFieldInfo
    instance AttrInfo CompletionFuncFieldInfo where
        type AttrBaseTypeConstraint CompletionFuncFieldInfo = (~) Completion
        type AttrAllowedOps CompletionFuncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint CompletionFuncFieldInfo = (~) (FunPtr GLib.Callbacks.C_CompletionFunc)
        type AttrTransferTypeConstraint CompletionFuncFieldInfo = (~)GLib.Callbacks.CompletionFunc
        type AttrTransferType CompletionFuncFieldInfo = (FunPtr GLib.Callbacks.C_CompletionFunc)
        type AttrGetType CompletionFuncFieldInfo = Maybe GLib.Callbacks.CompletionFunc
        type AttrLabel CompletionFuncFieldInfo = "func"
        type AttrOrigin CompletionFuncFieldInfo = Completion
        attrGet = getCompletionFunc
        attrSet = setCompletionFunc
        attrConstruct = undefined
        attrClear = clearCompletionFunc
        attrTransfer _ v = do
            GLib.Callbacks.mk_CompletionFunc (GLib.Callbacks.wrap_CompletionFunc Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GLib.Structs.Completion.func"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Completion.html#g:attr:func"
            })

    completion_func :: AttrLabelProxy "func"
    completion_func = AttrLabelProxy

    #endif

    -- | Get the value of the “@prefix@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' completion #prefix
    -- @
    getCompletionPrefix :: MonadIO m => Completion -> m (Maybe T.Text)
    getCompletionPrefix :: forall (m :: * -> *). MonadIO m => Completion -> m (Maybe Text)
    getCompletionPrefix Completion
    s = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ Completion
    -> (Ptr Completion -> IO (Maybe Text)) -> IO (Maybe Text)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Completion
    s ((Ptr Completion -> IO (Maybe Text)) -> IO (Maybe Text))
    -> (Ptr Completion -> IO (Maybe Text)) -> IO (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Completion
    ptr -> do
        val <- Ptr CString -> IO CString
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Completion
    ptr Ptr Completion -> Int -> Ptr CString
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    16) :: IO CString
        result <- SP.convertIfNonNull val $ \CString
    val' -> do
            val'' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    val'
            return val''
        return result

    -- | Set the value of the “@prefix@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' completion [ #prefix 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setCompletionPrefix :: MonadIO m => Completion -> CString -> m ()
    setCompletionPrefix :: forall (m :: * -> *). MonadIO m => Completion -> CString -> m ()
    setCompletionPrefix Completion
    s CString
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Completion -> (Ptr Completion -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Completion
    s ((Ptr Completion -> IO ()) -> IO ())
    -> (Ptr Completion -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Completion
    ptr -> do
        Ptr CString -> CString -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Completion
    ptr Ptr Completion -> Int -> Ptr CString
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    16) (CString
    val :: CString)

    -- | Set the value of the “@prefix@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #prefix
    -- @
    clearCompletionPrefix :: MonadIO m => Completion -> m ()
    clearCompletionPrefix :: forall (m :: * -> *). MonadIO m => Completion -> m ()
    clearCompletionPrefix Completion
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Completion -> (Ptr Completion -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Completion
    s ((Ptr Completion -> IO ()) -> IO ())
    -> (Ptr Completion -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Completion
    ptr -> do
        Ptr CString -> CString -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Completion
    ptr Ptr Completion -> Int -> Ptr CString
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    16) (CString
    forall a. Ptr a
    FP.nullPtr :: CString)

    #if defined(ENABLE_OVERLOADING)
    data CompletionPrefixFieldInfo
    instance AttrInfo CompletionPrefixFieldInfo where
        type AttrBaseTypeConstraint CompletionPrefixFieldInfo = (~) Completion
        type AttrAllowedOps CompletionPrefixFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint CompletionPrefixFieldInfo = (~) CString
        type AttrTransferTypeConstraint CompletionPrefixFieldInfo = (~)CString
        type AttrTransferType CompletionPrefixFieldInfo = CString
        type AttrGetType CompletionPrefixFieldInfo = Maybe T.Text
        type AttrLabel CompletionPrefixFieldInfo = "prefix"
        type AttrOrigin CompletionPrefixFieldInfo = Completion
        attrGet = getCompletionPrefix
        attrSet = setCompletionPrefix
        attrConstruct = undefined
        attrClear = clearCompletionPrefix
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GLib.Structs.Completion.prefix"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Completion.html#g:attr:prefix"
            })

    completion_prefix :: AttrLabelProxy "prefix"
    completion_prefix = AttrLabelProxy

    #endif

    -- | Get the value of the “@cache@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' completion #cache
    -- @
    getCompletionCache :: MonadIO m => Completion -> m ([Ptr ()])
    getCompletionCache :: forall (m :: * -> *). MonadIO m => Completion -> m [Ptr ()]
    getCompletionCache Completion
    s = IO [Ptr ()] -> m [Ptr ()]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [Ptr ()] -> m [Ptr ()]) -> IO [Ptr ()] -> m [Ptr ()]
    forall a b. (a -> b) -> a -> b
    $ Completion -> (Ptr Completion -> IO [Ptr ()]) -> IO [Ptr ()]
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Completion
    s ((Ptr Completion -> IO [Ptr ()]) -> IO [Ptr ()])
    -> (Ptr Completion -> IO [Ptr ()]) -> IO [Ptr ()]
    forall a b. (a -> b) -> a -> b
    $ \Ptr Completion
    ptr -> do
        val <- Ptr (Ptr (GList (Ptr ()))) -> IO (Ptr (GList (Ptr ())))
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Completion
    ptr Ptr Completion -> Int -> Ptr (Ptr (GList (Ptr ())))
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    24) :: IO (Ptr (GList (Ptr ())))
        val' <- unpackGList val
        return val'

    -- | Set the value of the “@cache@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' completion [ #cache 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setCompletionCache :: MonadIO m => Completion -> Ptr (GList (Ptr ())) -> m ()
    setCompletionCache :: forall (m :: * -> *).
    MonadIO m =>
    Completion -> Ptr (GList (Ptr ())) -> m ()
    setCompletionCache Completion
    s Ptr (GList (Ptr ()))
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Completion -> (Ptr Completion -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Completion
    s ((Ptr Completion -> IO ()) -> IO ())
    -> (Ptr Completion -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Completion
    ptr -> do
        Ptr (Ptr (GList (Ptr ()))) -> Ptr (GList (Ptr ())) -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Completion
    ptr Ptr Completion -> Int -> Ptr (Ptr (GList (Ptr ())))
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    24) (Ptr (GList (Ptr ()))
    val :: Ptr (GList (Ptr ())))

    -- | Set the value of the “@cache@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #cache
    -- @
    clearCompletionCache :: MonadIO m => Completion -> m ()
    clearCompletionCache :: forall (m :: * -> *). MonadIO m => Completion -> m ()
    clearCompletionCache Completion
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Completion -> (Ptr Completion -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Completion
    s ((Ptr Completion -> IO ()) -> IO ())
    -> (Ptr Completion -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Completion
    ptr -> do
        Ptr (Ptr (GList (Ptr ()))) -> Ptr (GList (Ptr ())) -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Completion
    ptr Ptr Completion -> Int -> Ptr (Ptr (GList (Ptr ())))
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    24) (Ptr (GList (Ptr ()))
    forall a. Ptr a
    FP.nullPtr :: Ptr (GList (Ptr ())))

    #if defined(ENABLE_OVERLOADING)
    data CompletionCacheFieldInfo
    instance AttrInfo CompletionCacheFieldInfo where
        type AttrBaseTypeConstraint CompletionCacheFieldInfo = (~) Completion
        type AttrAllowedOps CompletionCacheFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint CompletionCacheFieldInfo = (~) (Ptr (GList (Ptr ())))
        type AttrTransferTypeConstraint CompletionCacheFieldInfo = (~)(Ptr (GList (Ptr ())))
        type AttrTransferType CompletionCacheFieldInfo = (Ptr (GList (Ptr ())))
        type AttrGetType CompletionCacheFieldInfo = [Ptr ()]
        type AttrLabel CompletionCacheFieldInfo = "cache"
        type AttrOrigin CompletionCacheFieldInfo = Completion
        attrGet = getCompletionCache
        attrSet = setCompletionCache
        attrConstruct = undefined
        attrClear = clearCompletionCache
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GLib.Structs.Completion.cache"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Completion.html#g:attr:cache"
            })

    completion_cache :: AttrLabelProxy "cache"
    completion_cache = AttrLabelProxy

    #endif

    -- | Get the value of the “@strncmp_func@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' completion #strncmpFunc
    -- @
    getCompletionStrncmpFunc :: MonadIO m => Completion -> m (Maybe GLib.Callbacks.CompletionStrncmpFunc)
    getCompletionStrncmpFunc :: forall (m :: * -> *).
    MonadIO m =>
    Completion -> m (Maybe CompletionStrncmpFunc)
    getCompletionStrncmpFunc Completion
    s = IO (Maybe CompletionStrncmpFunc) -> m (Maybe CompletionStrncmpFunc)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe CompletionStrncmpFunc)
     -> m (Maybe CompletionStrncmpFunc))
    -> IO (Maybe CompletionStrncmpFunc)
    -> m (Maybe CompletionStrncmpFunc)
    forall a b. (a -> b) -> a -> b
    $ Completion
    -> (Ptr Completion -> IO (Maybe CompletionStrncmpFunc))
    -> IO (Maybe CompletionStrncmpFunc)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Completion
    s ((Ptr Completion -> IO (Maybe CompletionStrncmpFunc))
     -> IO (Maybe CompletionStrncmpFunc))
    -> (Ptr Completion -> IO (Maybe CompletionStrncmpFunc))
    -> IO (Maybe CompletionStrncmpFunc)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Completion
    ptr -> do
        val <- Ptr (FunPtr C_CompletionStrncmpFunc)
    -> IO (FunPtr C_CompletionStrncmpFunc)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Completion
    ptr Ptr Completion -> Int -> Ptr (FunPtr C_CompletionStrncmpFunc)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    32) :: IO (FunPtr GLib.Callbacks.C_CompletionStrncmpFunc)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_CompletionStrncmpFunc
    val' -> do
            let val'' :: CompletionStrncmpFunc
    val'' = FunPtr C_CompletionStrncmpFunc -> CompletionStrncmpFunc
    forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    FunPtr C_CompletionStrncmpFunc -> Text -> Text -> CSize -> m Int32
    GLib.Callbacks.dynamic_CompletionStrncmpFunc FunPtr C_CompletionStrncmpFunc
    val'
            CompletionStrncmpFunc -> IO CompletionStrncmpFunc
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return CompletionStrncmpFunc
    val''
        return result

    -- | Set the value of the “@strncmp_func@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' completion [ #strncmpFunc 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setCompletionStrncmpFunc :: MonadIO m => Completion -> FunPtr GLib.Callbacks.C_CompletionStrncmpFunc -> m ()
    setCompletionStrncmpFunc :: forall (m :: * -> *).
    MonadIO m =>
    Completion -> FunPtr C_CompletionStrncmpFunc -> m ()
    setCompletionStrncmpFunc Completion
    s FunPtr C_CompletionStrncmpFunc
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Completion -> (Ptr Completion -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Completion
    s ((Ptr Completion -> IO ()) -> IO ())
    -> (Ptr Completion -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Completion
    ptr -> do
        Ptr (FunPtr C_CompletionStrncmpFunc)
    -> FunPtr C_CompletionStrncmpFunc -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Completion
    ptr Ptr Completion -> Int -> Ptr (FunPtr C_CompletionStrncmpFunc)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    32) (FunPtr C_CompletionStrncmpFunc
    val :: FunPtr GLib.Callbacks.C_CompletionStrncmpFunc)

    -- | Set the value of the “@strncmp_func@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #strncmpFunc
    -- @
    clearCompletionStrncmpFunc :: MonadIO m => Completion -> m ()
    clearCompletionStrncmpFunc :: forall (m :: * -> *). MonadIO m => Completion -> m ()
    clearCompletionStrncmpFunc Completion
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Completion -> (Ptr Completion -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Completion
    s ((Ptr Completion -> IO ()) -> IO ())
    -> (Ptr Completion -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Completion
    ptr -> do
        Ptr (FunPtr C_CompletionStrncmpFunc)
    -> FunPtr C_CompletionStrncmpFunc -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Completion
    ptr Ptr Completion -> Int -> Ptr (FunPtr C_CompletionStrncmpFunc)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    32) (FunPtr C_CompletionStrncmpFunc
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr GLib.Callbacks.C_CompletionStrncmpFunc)

    #if defined(ENABLE_OVERLOADING)
    data CompletionStrncmpFuncFieldInfo
    instance AttrInfo CompletionStrncmpFuncFieldInfo where
        type AttrBaseTypeConstraint CompletionStrncmpFuncFieldInfo = (~) Completion
        type AttrAllowedOps CompletionStrncmpFuncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint CompletionStrncmpFuncFieldInfo = (~) (FunPtr GLib.Callbacks.C_CompletionStrncmpFunc)
        type AttrTransferTypeConstraint CompletionStrncmpFuncFieldInfo = (~)GLib.Callbacks.CompletionStrncmpFunc
        type AttrTransferType CompletionStrncmpFuncFieldInfo = (FunPtr GLib.Callbacks.C_CompletionStrncmpFunc)
        type AttrGetType CompletionStrncmpFuncFieldInfo = Maybe GLib.Callbacks.CompletionStrncmpFunc
        type AttrLabel CompletionStrncmpFuncFieldInfo = "strncmp_func"
        type AttrOrigin CompletionStrncmpFuncFieldInfo = Completion
        attrGet = getCompletionStrncmpFunc
        attrSet = setCompletionStrncmpFunc
        attrConstruct = undefined
        attrClear = clearCompletionStrncmpFunc
        attrTransfer _ v = do
            GLib.Callbacks.mk_CompletionStrncmpFunc (GLib.Callbacks.wrap_CompletionStrncmpFunc Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GLib.Structs.Completion.strncmpFunc"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Completion.html#g:attr:strncmpFunc"
            })

    completion_strncmpFunc :: AttrLabelProxy "strncmpFunc"
    completion_strncmpFunc = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Completion
    type instance O.AttributeList Completion = CompletionAttributeList
    type CompletionAttributeList = ('[ '("items", CompletionItemsFieldInfo), '("func", CompletionFuncFieldInfo), '("prefix", CompletionPrefixFieldInfo), '("cache", CompletionCacheFieldInfo), '("strncmpFunc", CompletionStrncmpFuncFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

    -- method Completion::clear_items
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "cmp"
    --           , argType =
    --               TInterface Name { namespace = "GLib" , name = "Completion" }
    --           , argCType = Just "GCompletion*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #GCompletion." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_completion_clear_items" g_completion_clear_items ::
        Ptr Completion ->                       -- cmp : TInterface (Name {namespace = "GLib", name = "Completion"})
        IO ()

    {-# DEPRECATED completionClearItems ["(Since version 2.26)","Rarely used API"] #-}
    -- | Removes all items from the t'GI.GLib.Structs.Completion.Completion'. The items are not freed, so if the
    -- memory was dynamically allocated, it should be freed after calling this
    -- function.
    completionClearItems ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Completion
        -- ^ /@cmp@/: the t'GI.GLib.Structs.Completion.Completion'.
        -> m ()
    completionClearItems :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Completion -> m ()
    completionClearItems Completion
    cmp = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        cmp' <- Completion -> IO (Ptr Completion)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Completion
    cmp
        g_completion_clear_items cmp'
        touchManagedPtr cmp
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CompletionClearItemsMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod CompletionClearItemsMethodInfo Completion signature where
        overloadedMethod = completionClearItems

    instance O.OverloadedMethodInfo CompletionClearItemsMethodInfo Completion where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GLib.Structs.Completion.completionClearItems",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Completion.html#v:completionClearItems"
            })

    #endif

    -- method Completion::complete_utf8
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "cmp"
    --           , argType =
    --               TInterface Name { namespace = "GLib" , name = "Completion" }
    --           , argCType = Just "GCompletion*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #GCompletion" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "prefix"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const gchar*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the prefix string, typically used by the user, which is compared\n   with each of the items"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "new_prefix"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "gchar**"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "if non-%NULL, returns the longest prefix which is common to all\n   items that matched @prefix, or %NULL if no items matched @prefix.\n   This string should be freed when no longer needed."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TGList (TBasicType TUTF8))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_completion_complete_utf8" g_completion_complete_utf8 ::
        Ptr Completion ->                       -- cmp : TInterface (Name {namespace = "GLib", name = "Completion"})
        CString ->                              -- prefix : TBasicType TUTF8
        CString ->                              -- new_prefix : TBasicType TUTF8
        IO (Ptr (GList CString))

    {-# DEPRECATED completionCompleteUtf8 ["(Since version 2.26)","Rarely used API"] #-}
    -- | Attempts to complete the string /@prefix@/ using the t'GI.GLib.Structs.Completion.Completion' target items.
    -- In contrast to @/g_completion_complete()/@, this function returns the largest common
    -- prefix that is a valid UTF-8 string, omitting a possible common partial
    -- character.
    --
    -- You should use this function instead of @/g_completion_complete()/@ if your
    -- items are UTF-8 strings.
    --
    -- /Since: 2.4/
    completionCompleteUtf8 ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Completion
        -- ^ /@cmp@/: the t'GI.GLib.Structs.Completion.Completion'
        -> T.Text
        -- ^ /@prefix@/: the prefix string, typically used by the user, which is compared
        --    with each of the items
        -> T.Text
        -- ^ /@newPrefix@/: if non-'P.Nothing', returns the longest prefix which is common to all
        --    items that matched /@prefix@/, or 'P.Nothing' if no items matched /@prefix@/.
        --    This string should be freed when no longer needed.
        -> m [T.Text]
        -- ^ __Returns:__ the list of items whose strings begin with /@prefix@/. This should
        -- not be changed.
    completionCompleteUtf8 :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Completion -> Text -> Text -> m [Text]
    completionCompleteUtf8 Completion
    cmp Text
    prefix Text
    newPrefix = IO [Text] -> m [Text]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
    forall a b. (a -> b) -> a -> b
    $ do
        cmp' <- Completion -> IO (Ptr Completion)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Completion
    cmp
        prefix' <- textToCString prefix
        newPrefix' <- textToCString newPrefix
        result <- g_completion_complete_utf8 cmp' prefix' newPrefix'
        result' <- unpackGList result
        result'' <- mapM cstringToText result'
        touchManagedPtr cmp
        freeMem prefix'
        freeMem newPrefix'
        return result''

    #if defined(ENABLE_OVERLOADING)
    data CompletionCompleteUtf8MethodInfo
    instance (signature ~ (T.Text -> T.Text -> m [T.Text]), MonadIO m) => O.OverloadedMethod CompletionCompleteUtf8MethodInfo Completion signature where
        overloadedMethod = completionCompleteUtf8

    instance O.OverloadedMethodInfo CompletionCompleteUtf8MethodInfo Completion where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GLib.Structs.Completion.completionCompleteUtf8",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Completion.html#v:completionCompleteUtf8"
            })

    #endif

    -- method Completion::free
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "cmp"
    --           , argType =
    --               TInterface Name { namespace = "GLib" , name = "Completion" }
    --           , argCType = Just "GCompletion*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #GCompletion." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_completion_free" g_completion_free ::
        Ptr Completion ->                       -- cmp : TInterface (Name {namespace = "GLib", name = "Completion"})
        IO ()

    {-# DEPRECATED completionFree ["(Since version 2.26)","Rarely used API"] #-}
    -- | Frees all memory used by the t'GI.GLib.Structs.Completion.Completion'. The items are not freed, so if
    -- the memory was dynamically allocated, it should be freed after calling this
    -- function.
    completionFree ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Completion
        -- ^ /@cmp@/: the t'GI.GLib.Structs.Completion.Completion'.
        -> m ()
    completionFree :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Completion -> m ()
    completionFree Completion
    cmp = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        cmp' <- Completion -> IO (Ptr Completion)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Completion
    cmp
        g_completion_free cmp'
        touchManagedPtr cmp
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CompletionFreeMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod CompletionFreeMethodInfo Completion signature where
        overloadedMethod = completionFree

    instance O.OverloadedMethodInfo CompletionFreeMethodInfo Completion where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GLib.Structs.Completion.completionFree",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Completion.html#v:completionFree"
            })

    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveCompletionMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveCompletionMethod "clearItems" o = CompletionClearItemsMethodInfo
        ResolveCompletionMethod "completeUtf8" o = CompletionCompleteUtf8MethodInfo
        ResolveCompletionMethod "free" o = CompletionFreeMethodInfo
        ResolveCompletionMethod l o = O.MethodResolutionFailed l o

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

    #if MIN_VERSION_base(4,13,0)
    instance (info ~ ResolveCompletionMethod t Completion, O.OverloadedMethod info Completion p, R.HasField t Completion p) => R.HasField t Completion p where
        getField = O.overloadedMethod @info

    #endif

    instance (info ~ ResolveCompletionMethod t Completion, O.OverloadedMethodInfo info Completion) => OL.IsLabel t (O.MethodProxy info Completion) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.MethodProxy
    #else
        fromLabel _ = O.MethodProxy
    #endif

    #endif