    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A list model that wraps @GBookmarkFile@.
    --
    -- It presents a @GListModel@ and fills it asynchronously with the
    -- @GFileInfo@s returned from that function.
    --
    -- The @GFileInfo@s in the list have some attributes in the recent namespace
    -- added: @recent::private@ (boolean) and @recent:applications@ (stringv). They
    -- also have the @GFile@ referred by the URI in @standard::file@ attribute.

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

    module GI.Gtk.Objects.BookmarkList
        (

    -- * Exported types
        BookmarkList(..)                        ,
        IsBookmarkList                          ,
        toBookmarkList                          ,

     -- * 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"), [isLoading]("GI.Gtk.Objects.BookmarkList#g:method:isLoading"), [itemsChanged]("GI.Gio.Interfaces.ListModel#g:method:itemsChanged"), [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
    -- [getAttributes]("GI.Gtk.Objects.BookmarkList#g:method:getAttributes"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getFilename]("GI.Gtk.Objects.BookmarkList#g:method:getFilename"), [getIoPriority]("GI.Gtk.Objects.BookmarkList#g:method:getIoPriority"), [getItem]("GI.Gio.Interfaces.ListModel#g:method:getItem"), [getItemType]("GI.Gio.Interfaces.ListModel#g:method:getItemType"), [getNItems]("GI.Gio.Interfaces.ListModel#g:method:getNItems"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
    --
    -- ==== Setters
    -- [setAttributes]("GI.Gtk.Objects.BookmarkList#g:method:setAttributes"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setIoPriority]("GI.Gtk.Objects.BookmarkList#g:method:setIoPriority"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

    #if defined(ENABLE_OVERLOADING)
        ResolveBookmarkListMethod               ,
    #endif

    -- ** getAttributes #method:getAttributes#

    #if defined(ENABLE_OVERLOADING)
        BookmarkListGetAttributesMethodInfo     ,
    #endif
        bookmarkListGetAttributes               ,

    -- ** getFilename #method:getFilename#

    #if defined(ENABLE_OVERLOADING)
        BookmarkListGetFilenameMethodInfo       ,
    #endif
        bookmarkListGetFilename                 ,

    -- ** getIoPriority #method:getIoPriority#

    #if defined(ENABLE_OVERLOADING)
        BookmarkListGetIoPriorityMethodInfo     ,
    #endif
        bookmarkListGetIoPriority               ,

    -- ** isLoading #method:isLoading#

    #if defined(ENABLE_OVERLOADING)
        BookmarkListIsLoadingMethodInfo         ,
    #endif
        bookmarkListIsLoading                   ,

    -- ** new #method:new#

        bookmarkListNew                         ,

    -- ** setAttributes #method:setAttributes#

    #if defined(ENABLE_OVERLOADING)
        BookmarkListSetAttributesMethodInfo     ,
    #endif
        bookmarkListSetAttributes               ,

    -- ** setIoPriority #method:setIoPriority#

    #if defined(ENABLE_OVERLOADING)
        BookmarkListSetIoPriorityMethodInfo     ,
    #endif
        bookmarkListSetIoPriority               ,

     -- * Properties

    -- ** attributes #attr:attributes#
    -- | The attributes to query.

    #if defined(ENABLE_OVERLOADING)
        BookmarkListAttributesPropertyInfo      ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        bookmarkListAttributes                  ,
    #endif
        clearBookmarkListAttributes             ,
        constructBookmarkListAttributes         ,
        getBookmarkListAttributes               ,
        setBookmarkListAttributes               ,

    -- ** filename #attr:filename#
    -- | The bookmark file to load.

    #if defined(ENABLE_OVERLOADING)
        BookmarkListFilenamePropertyInfo        ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        bookmarkListFilename                    ,
    #endif
        constructBookmarkListFilename           ,
        getBookmarkListFilename                 ,

    -- ** ioPriority #attr:ioPriority#
    -- | Priority used when loading.

    #if defined(ENABLE_OVERLOADING)
        BookmarkListIoPriorityPropertyInfo      ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        bookmarkListIoPriority                  ,
    #endif
        constructBookmarkListIoPriority         ,
        getBookmarkListIoPriority               ,
        setBookmarkListIoPriority               ,

    -- ** itemType #attr:itemType#
    -- | The type of items. See 'GI.Gio.Interfaces.ListModel.listModelGetItemType'.
    --
    -- /Since: 4.8/

    #if defined(ENABLE_OVERLOADING)
        BookmarkListItemTypePropertyInfo        ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        bookmarkListItemType                    ,
    #endif
        getBookmarkListItemType                 ,

    -- ** loading #attr:loading#
    -- | 'P.True' if files are being loaded.

    #if defined(ENABLE_OVERLOADING)
        BookmarkListLoadingPropertyInfo         ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        bookmarkListLoading                     ,
    #endif
        getBookmarkListLoading                  ,

    -- ** nItems #attr:nItems#
    -- | The number of items. See 'GI.Gio.Interfaces.ListModel.listModelGetNItems'.
    --
    -- /Since: 4.8/

    #if defined(ENABLE_OVERLOADING)
        BookmarkListNItemsPropertyInfo          ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        bookmarkListNItems                      ,
    #endif
        getBookmarkListNItems                   ,

        ) 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
    import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel

    #else
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel

    #endif

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

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

    foreign import ccall "gtk_bookmark_list_get_type"
        c_gtk_bookmark_list_get_type :: IO B.Types.GType

    instance B.Types.TypedObject BookmarkList where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_bookmark_list_get_type

    instance B.Types.GObject BookmarkList

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

    instance O.HasParentTypes BookmarkList
    type instance O.ParentTypes BookmarkList = '[GObject.Object.Object, Gio.ListModel.ListModel]

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

    -- | Convert t'BookmarkList' 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 BookmarkList) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_gtk_bookmark_list_get_type
        gvalueSet_ :: Ptr GValue -> Maybe BookmarkList -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe BookmarkList
    P.Nothing = Ptr GValue -> Ptr BookmarkList -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv (Ptr BookmarkList
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr BookmarkList)
        gvalueSet_ Ptr GValue
    gv (P.Just BookmarkList
    obj) = BookmarkList -> (Ptr BookmarkList -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr BookmarkList
    obj (Ptr GValue -> Ptr BookmarkList -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe BookmarkList)
    gvalueGet_ Ptr GValue
    gv = do
            ptr <- Ptr GValue -> IO (Ptr BookmarkList)
    forall a. GObject a => Ptr GValue -> IO (Ptr a)
    B.GValue.get_object Ptr GValue
    gv :: IO (FP.Ptr BookmarkList)
            if ptr /= FP.nullPtr
            then P.Just <$> B.ManagedPtr.newObject BookmarkList ptr
            else return P.Nothing

    #if defined(ENABLE_OVERLOADING)
    type family ResolveBookmarkListMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveBookmarkListMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveBookmarkListMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveBookmarkListMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveBookmarkListMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveBookmarkListMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveBookmarkListMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveBookmarkListMethod "isLoading" o = BookmarkListIsLoadingMethodInfo
        ResolveBookmarkListMethod "itemsChanged" o = Gio.ListModel.ListModelItemsChangedMethodInfo
        ResolveBookmarkListMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveBookmarkListMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveBookmarkListMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveBookmarkListMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveBookmarkListMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveBookmarkListMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveBookmarkListMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveBookmarkListMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveBookmarkListMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveBookmarkListMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveBookmarkListMethod "getAttributes" o = BookmarkListGetAttributesMethodInfo
        ResolveBookmarkListMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveBookmarkListMethod "getFilename" o = BookmarkListGetFilenameMethodInfo
        ResolveBookmarkListMethod "getIoPriority" o = BookmarkListGetIoPriorityMethodInfo
        ResolveBookmarkListMethod "getItem" o = Gio.ListModel.ListModelGetItemMethodInfo
        ResolveBookmarkListMethod "getItemType" o = Gio.ListModel.ListModelGetItemTypeMethodInfo
        ResolveBookmarkListMethod "getNItems" o = Gio.ListModel.ListModelGetNItemsMethodInfo
        ResolveBookmarkListMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveBookmarkListMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveBookmarkListMethod "setAttributes" o = BookmarkListSetAttributesMethodInfo
        ResolveBookmarkListMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveBookmarkListMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveBookmarkListMethod "setIoPriority" o = BookmarkListSetIoPriorityMethodInfo
        ResolveBookmarkListMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveBookmarkListMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif

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

    -- | Get the value of the “@attributes@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' bookmarkList #attributes
    -- @
    getBookmarkListAttributes :: (MonadIO m, IsBookmarkList o) => o -> m (Maybe T.Text)
    getBookmarkListAttributes :: forall (m :: * -> *) o.
    (MonadIO m, IsBookmarkList o) =>
    o -> m (Maybe Text)
    getBookmarkListAttributes o
    obj = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe 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
    "attributes"

    -- | Set the value of the “@attributes@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' bookmarkList [ #attributes 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setBookmarkListAttributes :: (MonadIO m, IsBookmarkList o) => o -> T.Text -> m ()
    setBookmarkListAttributes :: forall (m :: * -> *) o.
    (MonadIO m, IsBookmarkList o) =>
    o -> Text -> m ()
    setBookmarkListAttributes o
    obj Text
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "attributes" (Text -> Maybe Text
    forall a. a -> Maybe a
    Just Text
    val)

    -- | Construct a t'GValueConstruct' with valid value for the “@attributes@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructBookmarkListAttributes :: (IsBookmarkList o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
    constructBookmarkListAttributes :: forall o (m :: * -> *).
    (IsBookmarkList o, MonadIO m) =>
    Text -> m (GValueConstruct o)
    constructBookmarkListAttributes Text
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe Text -> IO (GValueConstruct o)
    forall o. String -> Maybe Text -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyString String
    "attributes" (Text -> Maybe Text
    forall a. a -> Maybe a
    P.Just Text
    val)

    -- | Set the value of the “@attributes@” property to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #attributes
    -- @
    clearBookmarkListAttributes :: (MonadIO m, IsBookmarkList o) => o -> m ()
    clearBookmarkListAttributes :: forall (m :: * -> *) o. (MonadIO m, IsBookmarkList o) => o -> m ()
    clearBookmarkListAttributes o
    obj = 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
    $ o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "attributes" (Maybe Text
    forall a. Maybe a
    Nothing :: Maybe T.Text)

    #if defined(ENABLE_OVERLOADING)
    data BookmarkListAttributesPropertyInfo
    instance AttrInfo BookmarkListAttributesPropertyInfo where
        type AttrAllowedOps BookmarkListAttributesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint BookmarkListAttributesPropertyInfo = IsBookmarkList
        type AttrSetTypeConstraint BookmarkListAttributesPropertyInfo = (~) T.Text
        type AttrTransferTypeConstraint BookmarkListAttributesPropertyInfo = (~) T.Text
        type AttrTransferType BookmarkListAttributesPropertyInfo = T.Text
        type AttrGetType BookmarkListAttributesPropertyInfo = (Maybe T.Text)
        type AttrLabel BookmarkListAttributesPropertyInfo = "attributes"
        type AttrOrigin BookmarkListAttributesPropertyInfo = BookmarkList
        attrGet = getBookmarkListAttributes
        attrSet = setBookmarkListAttributes
        attrPut = undefined
        attrTransfer _ v = do
            return v
        attrConstruct = constructBookmarkListAttributes
        attrClear = clearBookmarkListAttributes
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.BookmarkList.attributes"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-BookmarkList.html#g:attr:attributes"
            })
    #endif

    -- VVV Prop "filename"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    -- | Get the value of the “@filename@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' bookmarkList #filename
    -- @
    getBookmarkListFilename :: (MonadIO m, IsBookmarkList o) => o -> m (Maybe T.Text)
    getBookmarkListFilename :: forall (m :: * -> *) o.
    (MonadIO m, IsBookmarkList o) =>
    o -> m (Maybe Text)
    getBookmarkListFilename o
    obj = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe 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
    "filename"

    -- | Construct a t'GValueConstruct' with valid value for the “@filename@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructBookmarkListFilename :: (IsBookmarkList o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
    constructBookmarkListFilename :: forall o (m :: * -> *).
    (IsBookmarkList o, MonadIO m) =>
    Text -> m (GValueConstruct o)
    constructBookmarkListFilename Text
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe Text -> IO (GValueConstruct o)
    forall o. String -> Maybe Text -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyString String
    "filename" (Text -> Maybe Text
    forall a. a -> Maybe a
    P.Just Text
    val)

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

    -- VVV Prop "io-priority"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@io-priority@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' bookmarkList #ioPriority
    -- @
    getBookmarkListIoPriority :: (MonadIO m, IsBookmarkList o) => o -> m Int32
    getBookmarkListIoPriority :: forall (m :: * -> *) o.
    (MonadIO m, IsBookmarkList o) =>
    o -> m Int32
    getBookmarkListIoPriority 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
    "io-priority"

    -- | Set the value of the “@io-priority@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' bookmarkList [ #ioPriority 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setBookmarkListIoPriority :: (MonadIO m, IsBookmarkList o) => o -> Int32 -> m ()
    setBookmarkListIoPriority :: forall (m :: * -> *) o.
    (MonadIO m, IsBookmarkList o) =>
    o -> Int32 -> m ()
    setBookmarkListIoPriority o
    obj Int32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Int32 -> IO ()
    forall a. GObject a => a -> String -> Int32 -> IO ()
    B.Properties.setObjectPropertyInt32 o
    obj String
    "io-priority" Int32
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@io-priority@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructBookmarkListIoPriority :: (IsBookmarkList o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
    constructBookmarkListIoPriority :: forall o (m :: * -> *).
    (IsBookmarkList o, MonadIO m) =>
    Int32 -> m (GValueConstruct o)
    constructBookmarkListIoPriority Int32
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Int32 -> IO (GValueConstruct o)
    forall o. String -> Int32 -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyInt32 String
    "io-priority" Int32
    val

    #if defined(ENABLE_OVERLOADING)
    data BookmarkListIoPriorityPropertyInfo
    instance AttrInfo BookmarkListIoPriorityPropertyInfo where
        type AttrAllowedOps BookmarkListIoPriorityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint BookmarkListIoPriorityPropertyInfo = IsBookmarkList
        type AttrSetTypeConstraint BookmarkListIoPriorityPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint BookmarkListIoPriorityPropertyInfo = (~) Int32
        type AttrTransferType BookmarkListIoPriorityPropertyInfo = Int32
        type AttrGetType BookmarkListIoPriorityPropertyInfo = Int32
        type AttrLabel BookmarkListIoPriorityPropertyInfo = "io-priority"
        type AttrOrigin BookmarkListIoPriorityPropertyInfo = BookmarkList
        attrGet = getBookmarkListIoPriority
        attrSet = setBookmarkListIoPriority
        attrPut = setBookmarkListIoPriority
        attrTransfer _ v = do
            return v
        attrConstruct = constructBookmarkListIoPriority
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.BookmarkList.ioPriority"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-BookmarkList.html#g:attr:ioPriority"
            })
    #endif

    -- VVV Prop "item-type"
       -- Type: TBasicType TGType
       -- Flags: [PropertyReadable]
       -- Nullable: (Nothing,Nothing)

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

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

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

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

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

    -- VVV Prop "n-items"
       -- Type: TBasicType TUInt
       -- Flags: [PropertyReadable]
       -- Nullable: (Nothing,Nothing)

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

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

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList BookmarkList
    type instance O.AttributeList BookmarkList = BookmarkListAttributeList
    type BookmarkListAttributeList = ('[ '("attributes", BookmarkListAttributesPropertyInfo), '("filename", BookmarkListFilenamePropertyInfo), '("ioPriority", BookmarkListIoPriorityPropertyInfo), '("itemType", BookmarkListItemTypePropertyInfo), '("loading", BookmarkListLoadingPropertyInfo), '("nItems", BookmarkListNItemsPropertyInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    bookmarkListAttributes :: AttrLabelProxy "attributes"
    bookmarkListAttributes = AttrLabelProxy

    bookmarkListFilename :: AttrLabelProxy "filename"
    bookmarkListFilename = AttrLabelProxy

    bookmarkListIoPriority :: AttrLabelProxy "ioPriority"
    bookmarkListIoPriority = AttrLabelProxy

    bookmarkListItemType :: AttrLabelProxy "itemType"
    bookmarkListItemType = AttrLabelProxy

    bookmarkListLoading :: AttrLabelProxy "loading"
    bookmarkListLoading = AttrLabelProxy

    bookmarkListNItems :: AttrLabelProxy "nItems"
    bookmarkListNItems = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList BookmarkList = BookmarkListSignalList
    type BookmarkListSignalList = ('[ '("itemsChanged", Gio.ListModel.ListModelItemsChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

    #endif

    -- method BookmarkList::new
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "filename"
    --           , argType = TBasicType TFileName
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The bookmark file to load"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "attributes"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The attributes to query"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Gtk" , name = "BookmarkList" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_bookmark_list_new" gtk_bookmark_list_new ::
        CString ->                              -- filename : TBasicType TFileName
        CString ->                              -- attributes : TBasicType TUTF8
        IO (Ptr BookmarkList)

    -- | Creates a new @GtkBookmarkList@ with the given /@attributes@/.
    bookmarkListNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe ([Char])
        -- ^ /@filename@/: The bookmark file to load
        -> Maybe (T.Text)
        -- ^ /@attributes@/: The attributes to query
        -> m BookmarkList
        -- ^ __Returns:__ a new @GtkBookmarkList@
    bookmarkListNew :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe String -> Maybe Text -> m BookmarkList
    bookmarkListNew Maybe String
    filename Maybe Text
    attributes = IO BookmarkList -> m BookmarkList
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO BookmarkList -> m BookmarkList)
    -> IO BookmarkList -> m BookmarkList
    forall a b. (a -> b) -> a -> b
    $ do
        maybeFilename <- case Maybe String
    filename of
            Maybe String
    Nothing -> Ptr CChar -> IO (Ptr CChar)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr CChar
    forall a. Ptr a
    FP.nullPtr
            Just String
    jFilename -> do
                jFilename' <- String -> IO (Ptr CChar)
    stringToCString String
    jFilename
                return jFilename'
        maybeAttributes <- case attributes of
            Maybe Text
    Nothing -> Ptr CChar -> IO (Ptr CChar)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr CChar
    forall a. Ptr a
    FP.nullPtr
            Just Text
    jAttributes -> do
                jAttributes' <- Text -> IO (Ptr CChar)
    textToCString Text
    jAttributes
                return jAttributes'
        result <- gtk_bookmark_list_new maybeFilename maybeAttributes
        checkUnexpectedReturnNULL "bookmarkListNew" result
        result' <- (wrapObject BookmarkList) result
        freeMem maybeFilename
        freeMem maybeAttributes
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method BookmarkList::get_attributes
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "BookmarkList" }
    --           , argCType = Just "GtkBookmarkList*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkBookmarkList`"
    --                 , 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_bookmark_list_get_attributes" gtk_bookmark_list_get_attributes ::
        Ptr BookmarkList ->                     -- self : TInterface (Name {namespace = "Gtk", name = "BookmarkList"})
        IO CString

    -- | Gets the attributes queried on the children.
    bookmarkListGetAttributes ::
        (B.CallStack.HasCallStack, MonadIO m, IsBookmarkList a) =>
        a
        -- ^ /@self@/: a @GtkBookmarkList@
        -> m (Maybe T.Text)
        -- ^ __Returns:__ The queried attributes
    bookmarkListGetAttributes :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsBookmarkList a) =>
    a -> m (Maybe Text)
    bookmarkListGetAttributes a
    self = 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
    $ do
        self' <- a -> IO (Ptr BookmarkList)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_bookmark_list_get_attributes self'
        maybeResult <- convertIfNonNull result $ \Ptr CChar
    result' -> do
            result'' <- HasCallStack => Ptr CChar -> IO Text
    Ptr CChar -> IO Text
    cstringToText Ptr CChar
    result'
            return result''
        touchManagedPtr self
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data BookmarkListGetAttributesMethodInfo
    instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsBookmarkList a) => O.OverloadedMethod BookmarkListGetAttributesMethodInfo a signature where
        overloadedMethod = bookmarkListGetAttributes

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

    #endif

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

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

    -- | Returns the filename of the bookmark file that
    -- this list is loading.
    bookmarkListGetFilename ::
        (B.CallStack.HasCallStack, MonadIO m, IsBookmarkList a) =>
        a
        -- ^ /@self@/: a @GtkBookmarkList@
        -> m [Char]
        -- ^ __Returns:__ the filename of the .xbel file
    bookmarkListGetFilename :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsBookmarkList a) =>
    a -> m String
    bookmarkListGetFilename a
    self = IO String -> m String
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO String -> m String) -> IO String -> m String
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr BookmarkList)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_bookmark_list_get_filename self'
        checkUnexpectedReturnNULL "bookmarkListGetFilename" result
        result' <- cstringToString result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data BookmarkListGetFilenameMethodInfo
    instance (signature ~ (m [Char]), MonadIO m, IsBookmarkList a) => O.OverloadedMethod BookmarkListGetFilenameMethodInfo a signature where
        overloadedMethod = bookmarkListGetFilename

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

    #endif

    -- method BookmarkList::get_io_priority
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "BookmarkList" }
    --           , argCType = Just "GtkBookmarkList*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkBookmarkList`"
    --                 , 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_bookmark_list_get_io_priority" gtk_bookmark_list_get_io_priority ::
        Ptr BookmarkList ->                     -- self : TInterface (Name {namespace = "Gtk", name = "BookmarkList"})
        IO Int32

    -- | Gets the IO priority to use while loading file.
    bookmarkListGetIoPriority ::
        (B.CallStack.HasCallStack, MonadIO m, IsBookmarkList a) =>
        a
        -- ^ /@self@/: a @GtkBookmarkList@
        -> m Int32
        -- ^ __Returns:__ The IO priority.
    bookmarkListGetIoPriority :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsBookmarkList a) =>
    a -> m Int32
    bookmarkListGetIoPriority 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 BookmarkList)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_bookmark_list_get_io_priority self'
        touchManagedPtr self
        return result

    #if defined(ENABLE_OVERLOADING)
    data BookmarkListGetIoPriorityMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsBookmarkList a) => O.OverloadedMethod BookmarkListGetIoPriorityMethodInfo a signature where
        overloadedMethod = bookmarkListGetIoPriority

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

    #endif

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

    foreign import ccall "gtk_bookmark_list_is_loading" gtk_bookmark_list_is_loading ::
        Ptr BookmarkList ->                     -- self : TInterface (Name {namespace = "Gtk", name = "BookmarkList"})
        IO CInt

    -- | Returns 'P.True' if the files are currently being loaded.
    --
    -- Files will be added to /@self@/ from time to time while loading is
    -- going on. The order in which are added is undefined and may change
    -- in between runs.
    bookmarkListIsLoading ::
        (B.CallStack.HasCallStack, MonadIO m, IsBookmarkList a) =>
        a
        -- ^ /@self@/: a @GtkBookmarkList@
        -> m Bool
        -- ^ __Returns:__ 'P.True' if /@self@/ is loading
    bookmarkListIsLoading :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsBookmarkList a) =>
    a -> m Bool
    bookmarkListIsLoading a
    self = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr BookmarkList)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_bookmark_list_is_loading self'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data BookmarkListIsLoadingMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsBookmarkList a) => O.OverloadedMethod BookmarkListIsLoadingMethodInfo a signature where
        overloadedMethod = bookmarkListIsLoading

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

    #endif

    -- method BookmarkList::set_attributes
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "BookmarkList" }
    --           , argCType = Just "GtkBookmarkList*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkBookmarkList`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "attributes"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the attributes to enumerate"
    --                 , 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 "gtk_bookmark_list_set_attributes" gtk_bookmark_list_set_attributes ::
        Ptr BookmarkList ->                     -- self : TInterface (Name {namespace = "Gtk", name = "BookmarkList"})
        CString ->                              -- attributes : TBasicType TUTF8
        IO ()

    -- | Sets the /@attributes@/ to be enumerated and starts the enumeration.
    --
    -- If /@attributes@/ is 'P.Nothing', no attributes will be queried, but a list
    -- of @GFileInfo@s will still be created.
    bookmarkListSetAttributes ::
        (B.CallStack.HasCallStack, MonadIO m, IsBookmarkList a) =>
        a
        -- ^ /@self@/: a @GtkBookmarkList@
        -> Maybe (T.Text)
        -- ^ /@attributes@/: the attributes to enumerate
        -> m ()
    bookmarkListSetAttributes :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsBookmarkList a) =>
    a -> Maybe Text -> m ()
    bookmarkListSetAttributes a
    self Maybe Text
    attributes = 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
        self' <- a -> IO (Ptr BookmarkList)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeAttributes <- case attributes of
            Maybe Text
    Nothing -> Ptr CChar -> IO (Ptr CChar)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr CChar
    forall a. Ptr a
    FP.nullPtr
            Just Text
    jAttributes -> do
                jAttributes' <- Text -> IO (Ptr CChar)
    textToCString Text
    jAttributes
                return jAttributes'
        gtk_bookmark_list_set_attributes self' maybeAttributes
        touchManagedPtr self
        freeMem maybeAttributes
        return ()

    #if defined(ENABLE_OVERLOADING)
    data BookmarkListSetAttributesMethodInfo
    instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsBookmarkList a) => O.OverloadedMethod BookmarkListSetAttributesMethodInfo a signature where
        overloadedMethod = bookmarkListSetAttributes

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

    #endif

    -- method BookmarkList::set_io_priority
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "BookmarkList" }
    --           , argCType = Just "GtkBookmarkList*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkBookmarkList`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "io_priority"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "IO priority to use" , 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 "gtk_bookmark_list_set_io_priority" gtk_bookmark_list_set_io_priority ::
        Ptr BookmarkList ->                     -- self : TInterface (Name {namespace = "Gtk", name = "BookmarkList"})
        Int32 ->                                -- io_priority : TBasicType TInt
        IO ()

    -- | Sets the IO priority to use while loading files.
    --
    -- The default IO priority is 'GI.GLib.Constants.PRIORITY_DEFAULT'.
    bookmarkListSetIoPriority ::
        (B.CallStack.HasCallStack, MonadIO m, IsBookmarkList a) =>
        a
        -- ^ /@self@/: a @GtkBookmarkList@
        -> Int32
        -- ^ /@ioPriority@/: IO priority to use
        -> m ()
    bookmarkListSetIoPriority :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsBookmarkList a) =>
    a -> Int32 -> m ()
    bookmarkListSetIoPriority a
    self Int32
    ioPriority = 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
        self' <- a -> IO (Ptr BookmarkList)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        gtk_bookmark_list_set_io_priority self' ioPriority
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data BookmarkListSetIoPriorityMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsBookmarkList a) => O.OverloadedMethod BookmarkListSetIoPriorityMethodInfo a signature where
        overloadedMethod = bookmarkListSetIoPriority

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

    #endif