    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- @GtkEnumListItem@ is the type of items in a t'GI.Gtk.Objects.EnumList.EnumList'.
    --
    -- /Since: 4.24/

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

    module GI.Gtk.Objects.EnumListItem
        (

    -- * Exported types
        EnumListItem(..)                        ,
        IsEnumListItem                          ,
        toEnumListItem                          ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
    --
    -- ==== Getters
    -- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getName]("GI.Gtk.Objects.EnumListItem#g:method:getName"), [getNick]("GI.Gtk.Objects.EnumListItem#g:method:getNick"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getValue]("GI.Gtk.Objects.EnumListItem#g:method:getValue").
    --
    -- ==== Setters
    -- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

    #if defined(ENABLE_OVERLOADING)
        ResolveEnumListItemMethod               ,
    #endif

    -- ** getName #method:getName#

    #if defined(ENABLE_OVERLOADING)
        EnumListItemGetNameMethodInfo           ,
    #endif
        enumListItemGetName                     ,

    -- ** getNick #method:getNick#

    #if defined(ENABLE_OVERLOADING)
        EnumListItemGetNickMethodInfo           ,
    #endif
        enumListItemGetNick                     ,

    -- ** getValue #method:getValue#

    #if defined(ENABLE_OVERLOADING)
        EnumListItemGetValueMethodInfo          ,
    #endif
        enumListItemGetValue                    ,

     -- * Properties

    -- ** name #attr:name#
    -- | The enum value name.
    --
    -- /Since: 4.24/

    #if defined(ENABLE_OVERLOADING)
        EnumListItemNamePropertyInfo            ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        enumListItemName                        ,
    #endif
        getEnumListItemName                     ,

    -- ** nick #attr:nick#
    -- | The enum value nick.
    --
    -- /Since: 4.24/

    #if defined(ENABLE_OVERLOADING)
        EnumListItemNickPropertyInfo            ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        enumListItemNick                        ,
    #endif
        getEnumListItemNick                     ,

    -- ** value #attr:value#
    -- | The enum value.
    --
    -- /Since: 4.24/

    #if defined(ENABLE_OVERLOADING)
        EnumListItemValuePropertyInfo           ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        enumListItemValue                       ,
    #endif
        getEnumListItemValue                    ,

        ) 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.GObject.Objects.Object as GObject.Object

    #else
    import qualified GI.GObject.Objects.Object as GObject.Object

    #endif

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

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

    foreign import ccall "gtk_enum_list_item_get_type"
        c_gtk_enum_list_item_get_type :: IO B.Types.GType

    instance B.Types.TypedObject EnumListItem where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_enum_list_item_get_type

    instance B.Types.GObject EnumListItem

    -- | Type class for types which can be safely cast to t'EnumListItem', for instance with `toEnumListItem`.
    class (SP.GObject o, O.IsDescendantOf EnumListItem o) => IsEnumListItem o
    instance (SP.GObject o, O.IsDescendantOf EnumListItem o) => IsEnumListItem o

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

    -- | Cast to t'EnumListItem', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'.
    toEnumListItem :: (MIO.MonadIO m, IsEnumListItem o) => o -> m EnumListItem
    toEnumListItem :: forall (m :: * -> *) o.
    (MonadIO m, IsEnumListItem o) =>
    o -> m EnumListItem
    toEnumListItem = IO EnumListItem -> m EnumListItem
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO EnumListItem -> m EnumListItem)
    -> (o -> IO EnumListItem) -> o -> m EnumListItem
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ManagedPtr EnumListItem -> EnumListItem) -> o -> IO EnumListItem
    forall o o'.
    (HasCallStack, ManagedPtrNewtype o, TypedObject o,
     ManagedPtrNewtype o', TypedObject o') =>
    (ManagedPtr o' -> o') -> o -> IO o'
    B.ManagedPtr.unsafeCastTo ManagedPtr EnumListItem -> EnumListItem
    EnumListItem

    -- | Convert t'EnumListItem' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue (Maybe EnumListItem) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_gtk_enum_list_item_get_type
        gvalueSet_ :: Ptr GValue -> Maybe EnumListItem -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe EnumListItem
    P.Nothing = Ptr GValue -> Ptr EnumListItem -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv (Ptr EnumListItem
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr EnumListItem)
        gvalueSet_ Ptr GValue
    gv (P.Just EnumListItem
    obj) = EnumListItem -> (Ptr EnumListItem -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr EnumListItem
    obj (Ptr GValue -> Ptr EnumListItem -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe EnumListItem)
    gvalueGet_ Ptr GValue
    gv = do
            ptr <- Ptr GValue -> IO (Ptr EnumListItem)
    forall a. GObject a => Ptr GValue -> IO (Ptr a)
    B.GValue.get_object Ptr GValue
    gv :: IO (FP.Ptr EnumListItem)
            if ptr /= FP.nullPtr
            then P.Just <$> B.ManagedPtr.newObject EnumListItem ptr
            else return P.Nothing

    #if defined(ENABLE_OVERLOADING)
    type family ResolveEnumListItemMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveEnumListItemMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveEnumListItemMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveEnumListItemMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveEnumListItemMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveEnumListItemMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveEnumListItemMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveEnumListItemMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveEnumListItemMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveEnumListItemMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveEnumListItemMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveEnumListItemMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveEnumListItemMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveEnumListItemMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveEnumListItemMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveEnumListItemMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveEnumListItemMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveEnumListItemMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveEnumListItemMethod "getName" o = EnumListItemGetNameMethodInfo
        ResolveEnumListItemMethod "getNick" o = EnumListItemGetNickMethodInfo
        ResolveEnumListItemMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveEnumListItemMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveEnumListItemMethod "getValue" o = EnumListItemGetValueMethodInfo
        ResolveEnumListItemMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveEnumListItemMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveEnumListItemMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveEnumListItemMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveEnumListItemMethod t EnumListItem, O.OverloadedMethod info EnumListItem p) => OL.IsLabel t (EnumListItem -> 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 ~ ResolveEnumListItemMethod t EnumListItem, O.OverloadedMethod info EnumListItem p, R.HasField t EnumListItem p) => R.HasField t EnumListItem p where
        getField = O.overloadedMethod @info

    #endif

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

    #endif

    -- VVV Prop "name"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable]
       -- Nullable: (Just False,Nothing)

    -- | Get the value of the “@name@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' enumListItem #name
    -- @
    getEnumListItemName :: (MonadIO m, IsEnumListItem o) => o -> m T.Text
    getEnumListItemName :: forall (m :: * -> *) o.
    (MonadIO m, IsEnumListItem o) =>
    o -> m Text
    getEnumListItemName o
    obj = IO Text -> m Text
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ Text -> IO (Maybe Text) -> IO Text
    forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
    checkUnexpectedNothing Text
    "getEnumListItemName" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO (Maybe Text)
    forall a. GObject a => a -> String -> IO (Maybe Text)
    B.Properties.getObjectPropertyString o
    obj String
    "name"

    #if defined(ENABLE_OVERLOADING)
    data EnumListItemNamePropertyInfo
    instance AttrInfo EnumListItemNamePropertyInfo where
        type AttrAllowedOps EnumListItemNamePropertyInfo = '[ 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint EnumListItemNamePropertyInfo = IsEnumListItem
        type AttrSetTypeConstraint EnumListItemNamePropertyInfo = (~) ()
        type AttrTransferTypeConstraint EnumListItemNamePropertyInfo = (~) ()
        type AttrTransferType EnumListItemNamePropertyInfo = ()
        type AttrGetType EnumListItemNamePropertyInfo = T.Text
        type AttrLabel EnumListItemNamePropertyInfo = "name"
        type AttrOrigin EnumListItemNamePropertyInfo = EnumListItem
        attrGet = getEnumListItemName
        attrSet = undefined
        attrPut = undefined
        attrTransfer _ = undefined
        attrConstruct = undefined
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.EnumListItem.name"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-EnumListItem.html#g:attr:name"
            })
    #endif

    -- VVV Prop "nick"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable]
       -- Nullable: (Just False,Nothing)

    -- | Get the value of the “@nick@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' enumListItem #nick
    -- @
    getEnumListItemNick :: (MonadIO m, IsEnumListItem o) => o -> m T.Text
    getEnumListItemNick :: forall (m :: * -> *) o.
    (MonadIO m, IsEnumListItem o) =>
    o -> m Text
    getEnumListItemNick o
    obj = IO Text -> m Text
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ Text -> IO (Maybe Text) -> IO Text
    forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
    checkUnexpectedNothing Text
    "getEnumListItemNick" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO (Maybe Text)
    forall a. GObject a => a -> String -> IO (Maybe Text)
    B.Properties.getObjectPropertyString o
    obj String
    "nick"

    #if defined(ENABLE_OVERLOADING)
    data EnumListItemNickPropertyInfo
    instance AttrInfo EnumListItemNickPropertyInfo where
        type AttrAllowedOps EnumListItemNickPropertyInfo = '[ 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint EnumListItemNickPropertyInfo = IsEnumListItem
        type AttrSetTypeConstraint EnumListItemNickPropertyInfo = (~) ()
        type AttrTransferTypeConstraint EnumListItemNickPropertyInfo = (~) ()
        type AttrTransferType EnumListItemNickPropertyInfo = ()
        type AttrGetType EnumListItemNickPropertyInfo = T.Text
        type AttrLabel EnumListItemNickPropertyInfo = "nick"
        type AttrOrigin EnumListItemNickPropertyInfo = EnumListItem
        attrGet = getEnumListItemNick
        attrSet = undefined
        attrPut = undefined
        attrTransfer _ = undefined
        attrConstruct = undefined
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.EnumListItem.nick"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-EnumListItem.html#g:attr:nick"
            })
    #endif

    -- VVV Prop "value"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable]
       -- Nullable: (Just False,Nothing)

    -- | Get the value of the “@value@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' enumListItem #value
    -- @
    getEnumListItemValue :: (MonadIO m, IsEnumListItem o) => o -> m Int32
    getEnumListItemValue :: forall (m :: * -> *) o.
    (MonadIO m, IsEnumListItem o) =>
    o -> m Int32
    getEnumListItemValue o
    obj = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Int32
    forall a. GObject a => a -> String -> IO Int32
    B.Properties.getObjectPropertyInt32 o
    obj String
    "value"

    #if defined(ENABLE_OVERLOADING)
    data EnumListItemValuePropertyInfo
    instance AttrInfo EnumListItemValuePropertyInfo where
        type AttrAllowedOps EnumListItemValuePropertyInfo = '[ 'AttrGet]
        type AttrBaseTypeConstraint EnumListItemValuePropertyInfo = IsEnumListItem
        type AttrSetTypeConstraint EnumListItemValuePropertyInfo = (~) ()
        type AttrTransferTypeConstraint EnumListItemValuePropertyInfo = (~) ()
        type AttrTransferType EnumListItemValuePropertyInfo = ()
        type AttrGetType EnumListItemValuePropertyInfo = Int32
        type AttrLabel EnumListItemValuePropertyInfo = "value"
        type AttrOrigin EnumListItemValuePropertyInfo = EnumListItem
        attrGet = getEnumListItemValue
        attrSet = undefined
        attrPut = undefined
        attrTransfer _ = undefined
        attrConstruct = undefined
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.EnumListItem.value"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-EnumListItem.html#g:attr:value"
            })
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList EnumListItem
    type instance O.AttributeList EnumListItem = EnumListItemAttributeList
    type EnumListItemAttributeList = ('[ '("name", EnumListItemNamePropertyInfo), '("nick", EnumListItemNickPropertyInfo), '("value", EnumListItemValuePropertyInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    enumListItemName :: AttrLabelProxy "name"
    enumListItemName = AttrLabelProxy

    enumListItemNick :: AttrLabelProxy "nick"
    enumListItemNick = AttrLabelProxy

    enumListItemValue :: AttrLabelProxy "value"
    enumListItemValue = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList EnumListItem = EnumListItemSignalList
    type EnumListItemSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

    #endif

    -- method EnumListItem::get_name
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "EnumListItem" }
    --           , argCType = Just "GtkEnumListItem*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_enum_list_item_get_name" gtk_enum_list_item_get_name ::
        Ptr EnumListItem ->                     -- self : TInterface (Name {namespace = "Gtk", name = "EnumListItem"})
        IO CString

    -- | Gets the enum value name.
    enumListItemGetName ::
        (B.CallStack.HasCallStack, MonadIO m, IsEnumListItem a) =>
        a
        -> m T.Text
        -- ^ __Returns:__ the enum value name
    enumListItemGetName :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsEnumListItem a) =>
    a -> m Text
    enumListItemGetName a
    self = 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
        self' <- a -> IO (Ptr EnumListItem)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_enum_list_item_get_name self'
        checkUnexpectedReturnNULL "enumListItemGetName" result
        result' <- cstringToText result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EnumListItemGetNameMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsEnumListItem a) => O.OverloadedMethod EnumListItemGetNameMethodInfo a signature where
        overloadedMethod = enumListItemGetName

    instance O.OverloadedMethodInfo EnumListItemGetNameMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.EnumListItem.enumListItemGetName",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-EnumListItem.html#v:enumListItemGetName"
            })

    #endif

    -- method EnumListItem::get_nick
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "EnumListItem" }
    --           , argCType = Just "GtkEnumListItem*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_enum_list_item_get_nick" gtk_enum_list_item_get_nick ::
        Ptr EnumListItem ->                     -- self : TInterface (Name {namespace = "Gtk", name = "EnumListItem"})
        IO CString

    -- | Gets the enum value nick.
    enumListItemGetNick ::
        (B.CallStack.HasCallStack, MonadIO m, IsEnumListItem a) =>
        a
        -> m T.Text
        -- ^ __Returns:__ the enum value nick
    enumListItemGetNick :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsEnumListItem a) =>
    a -> m Text
    enumListItemGetNick a
    self = 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
        self' <- a -> IO (Ptr EnumListItem)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_enum_list_item_get_nick self'
        checkUnexpectedReturnNULL "enumListItemGetNick" result
        result' <- cstringToText result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EnumListItemGetNickMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsEnumListItem a) => O.OverloadedMethod EnumListItemGetNickMethodInfo a signature where
        overloadedMethod = enumListItemGetNick

    instance O.OverloadedMethodInfo EnumListItemGetNickMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.EnumListItem.enumListItemGetNick",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-EnumListItem.html#v:enumListItemGetNick"
            })

    #endif

    -- method EnumListItem::get_value
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "EnumListItem" }
    --           , argCType = Just "GtkEnumListItem*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_enum_list_item_get_value" gtk_enum_list_item_get_value ::
        Ptr EnumListItem ->                     -- self : TInterface (Name {namespace = "Gtk", name = "EnumListItem"})
        IO Int32

    -- | Gets the enum value.
    enumListItemGetValue ::
        (B.CallStack.HasCallStack, MonadIO m, IsEnumListItem a) =>
        a
        -> m Int32
        -- ^ __Returns:__ the enum value
    enumListItemGetValue :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsEnumListItem a) =>
    a -> m Int32
    enumListItemGetValue a
    self = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr EnumListItem)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_enum_list_item_get_value self'
        touchManagedPtr self
        return result

    #if defined(ENABLE_OVERLOADING)
    data EnumListItemGetValueMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsEnumListItem a) => O.OverloadedMethod EnumListItemGetValueMethodInfo a signature where
        overloadedMethod = enumListItemGetValue

    instance O.OverloadedMethodInfo EnumListItemGetValueMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.EnumListItem.enumListItemGetValue",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-EnumListItem.html#v:enumListItemGetValue"
            })

    #endif