{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- @GBookmarkFile@ lets you parse, edit or create files containing bookmarks.
-- 
-- Bookmarks refer to a URI, along with some meta-data about the resource
-- pointed by the URI like its MIME type, the application that is registering
-- the bookmark and the icon that should be used to represent the bookmark.
-- The data is stored using the
-- <https://www.freedesktop.org/wiki/Specifications/desktop-bookmark-spec/ Desktop Bookmark Specification>.
-- 
-- The syntax of the bookmark files is described in detail inside the
-- Desktop Bookmark Specification, here is a quick summary: bookmark
-- files use a sub-class of the XML Bookmark Exchange Language
-- specification, consisting of valid UTF-8 encoded XML, under the
-- @\<xbel>@ root element; each bookmark is stored inside a
-- @\<bookmark>@ element, using its URI: no relative paths can
-- be used inside a bookmark file. The bookmark may have a user defined
-- title and description, to be used instead of the URI. Under the
-- @\<metadata>@ element, with its owner attribute set to
-- @http:\/\/freedesktop.org@, is stored the meta-data about a resource
-- pointed by its URI. The meta-data consists of the resource\'s MIME
-- type; the applications that have registered a bookmark; the groups
-- to which a bookmark belongs to; a visibility flag, used to set the
-- bookmark as \"private\" to the applications and groups that has it
-- registered; the URI and MIME type of an icon, to be used when
-- displaying the bookmark inside a GUI.
-- 
-- Here is an example of a bookmark file:
-- <https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/glib/tests/bookmarks.xbel bookmarks.xbel>
-- 
-- A bookmark file might contain more than one bookmark; each bookmark
-- is accessed through its URI.
-- 
-- The important caveat of bookmark files is that when you add a new
-- bookmark you must also add the application that is registering it, using
-- 'GI.GLib.Structs.BookmarkFile.bookmarkFileAddApplication' or 'GI.GLib.Structs.BookmarkFile.bookmarkFileSetApplicationInfo'.
-- If a bookmark has no applications then it won\'t be dumped when creating
-- the on disk representation, using 'GI.GLib.Structs.BookmarkFile.bookmarkFileToData' or
-- 'GI.GLib.Structs.BookmarkFile.bookmarkFileToFile'.
-- 
-- /Since: 2.12/

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

module GI.GLib.Structs.BookmarkFile
    ( 

-- * Exported types
    BookmarkFile(..)                        ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addApplication]("GI.GLib.Structs.BookmarkFile#g:method:addApplication"), [addGroup]("GI.GLib.Structs.BookmarkFile#g:method:addGroup"), [copy]("GI.GLib.Structs.BookmarkFile#g:method:copy"), [free]("GI.GLib.Structs.BookmarkFile#g:method:free"), [hasApplication]("GI.GLib.Structs.BookmarkFile#g:method:hasApplication"), [hasGroup]("GI.GLib.Structs.BookmarkFile#g:method:hasGroup"), [hasItem]("GI.GLib.Structs.BookmarkFile#g:method:hasItem"), [loadFromData]("GI.GLib.Structs.BookmarkFile#g:method:loadFromData"), [loadFromDataDirs]("GI.GLib.Structs.BookmarkFile#g:method:loadFromDataDirs"), [loadFromFile]("GI.GLib.Structs.BookmarkFile#g:method:loadFromFile"), [moveItem]("GI.GLib.Structs.BookmarkFile#g:method:moveItem"), [removeApplication]("GI.GLib.Structs.BookmarkFile#g:method:removeApplication"), [removeGroup]("GI.GLib.Structs.BookmarkFile#g:method:removeGroup"), [removeItem]("GI.GLib.Structs.BookmarkFile#g:method:removeItem"), [toData]("GI.GLib.Structs.BookmarkFile#g:method:toData"), [toFile]("GI.GLib.Structs.BookmarkFile#g:method:toFile").
-- 
-- ==== Getters
-- [getAdded]("GI.GLib.Structs.BookmarkFile#g:method:getAdded"), [getAddedDateTime]("GI.GLib.Structs.BookmarkFile#g:method:getAddedDateTime"), [getAppInfo]("GI.GLib.Structs.BookmarkFile#g:method:getAppInfo"), [getApplicationInfo]("GI.GLib.Structs.BookmarkFile#g:method:getApplicationInfo"), [getApplications]("GI.GLib.Structs.BookmarkFile#g:method:getApplications"), [getDescription]("GI.GLib.Structs.BookmarkFile#g:method:getDescription"), [getGroups]("GI.GLib.Structs.BookmarkFile#g:method:getGroups"), [getIcon]("GI.GLib.Structs.BookmarkFile#g:method:getIcon"), [getIsPrivate]("GI.GLib.Structs.BookmarkFile#g:method:getIsPrivate"), [getMimeType]("GI.GLib.Structs.BookmarkFile#g:method:getMimeType"), [getModified]("GI.GLib.Structs.BookmarkFile#g:method:getModified"), [getModifiedDateTime]("GI.GLib.Structs.BookmarkFile#g:method:getModifiedDateTime"), [getSize]("GI.GLib.Structs.BookmarkFile#g:method:getSize"), [getTitle]("GI.GLib.Structs.BookmarkFile#g:method:getTitle"), [getUris]("GI.GLib.Structs.BookmarkFile#g:method:getUris"), [getVisited]("GI.GLib.Structs.BookmarkFile#g:method:getVisited"), [getVisitedDateTime]("GI.GLib.Structs.BookmarkFile#g:method:getVisitedDateTime").
-- 
-- ==== Setters
-- [setAdded]("GI.GLib.Structs.BookmarkFile#g:method:setAdded"), [setAddedDateTime]("GI.GLib.Structs.BookmarkFile#g:method:setAddedDateTime"), [setAppInfo]("GI.GLib.Structs.BookmarkFile#g:method:setAppInfo"), [setApplicationInfo]("GI.GLib.Structs.BookmarkFile#g:method:setApplicationInfo"), [setDescription]("GI.GLib.Structs.BookmarkFile#g:method:setDescription"), [setGroups]("GI.GLib.Structs.BookmarkFile#g:method:setGroups"), [setIcon]("GI.GLib.Structs.BookmarkFile#g:method:setIcon"), [setIsPrivate]("GI.GLib.Structs.BookmarkFile#g:method:setIsPrivate"), [setMimeType]("GI.GLib.Structs.BookmarkFile#g:method:setMimeType"), [setModified]("GI.GLib.Structs.BookmarkFile#g:method:setModified"), [setModifiedDateTime]("GI.GLib.Structs.BookmarkFile#g:method:setModifiedDateTime"), [setTitle]("GI.GLib.Structs.BookmarkFile#g:method:setTitle"), [setVisited]("GI.GLib.Structs.BookmarkFile#g:method:setVisited"), [setVisitedDateTime]("GI.GLib.Structs.BookmarkFile#g:method:setVisitedDateTime").

#if defined(ENABLE_OVERLOADING)
    ResolveBookmarkFileMethod               ,
#endif

-- ** addApplication #method:addApplication#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileAddApplicationMethodInfo    ,
#endif
    bookmarkFileAddApplication              ,


-- ** addGroup #method:addGroup#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileAddGroupMethodInfo          ,
#endif
    bookmarkFileAddGroup                    ,


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileCopyMethodInfo              ,
#endif
    bookmarkFileCopy                        ,


-- ** errorQuark #method:errorQuark#

    bookmarkFileErrorQuark                  ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileFreeMethodInfo              ,
#endif
    bookmarkFileFree                        ,


-- ** getAdded #method:getAdded#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetAddedMethodInfo          ,
#endif
    bookmarkFileGetAdded                    ,


-- ** getAddedDateTime #method:getAddedDateTime#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetAddedDateTimeMethodInfo  ,
#endif
    bookmarkFileGetAddedDateTime            ,


-- ** getAppInfo #method:getAppInfo#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetAppInfoMethodInfo        ,
#endif
    bookmarkFileGetAppInfo                  ,


-- ** getApplicationInfo #method:getApplicationInfo#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetApplicationInfoMethodInfo,
#endif
    bookmarkFileGetApplicationInfo          ,


-- ** getApplications #method:getApplications#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetApplicationsMethodInfo   ,
#endif
    bookmarkFileGetApplications             ,


-- ** getDescription #method:getDescription#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetDescriptionMethodInfo    ,
#endif
    bookmarkFileGetDescription              ,


-- ** getGroups #method:getGroups#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetGroupsMethodInfo         ,
#endif
    bookmarkFileGetGroups                   ,


-- ** getIcon #method:getIcon#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetIconMethodInfo           ,
#endif
    bookmarkFileGetIcon                     ,


-- ** getIsPrivate #method:getIsPrivate#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetIsPrivateMethodInfo      ,
#endif
    bookmarkFileGetIsPrivate                ,


-- ** getMimeType #method:getMimeType#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetMimeTypeMethodInfo       ,
#endif
    bookmarkFileGetMimeType                 ,


-- ** getModified #method:getModified#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetModifiedMethodInfo       ,
#endif
    bookmarkFileGetModified                 ,


-- ** getModifiedDateTime #method:getModifiedDateTime#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetModifiedDateTimeMethodInfo,
#endif
    bookmarkFileGetModifiedDateTime         ,


-- ** getSize #method:getSize#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetSizeMethodInfo           ,
#endif
    bookmarkFileGetSize                     ,


-- ** getTitle #method:getTitle#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetTitleMethodInfo          ,
#endif
    bookmarkFileGetTitle                    ,


-- ** getUris #method:getUris#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetUrisMethodInfo           ,
#endif
    bookmarkFileGetUris                     ,


-- ** getVisited #method:getVisited#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetVisitedMethodInfo        ,
#endif
    bookmarkFileGetVisited                  ,


-- ** getVisitedDateTime #method:getVisitedDateTime#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileGetVisitedDateTimeMethodInfo,
#endif
    bookmarkFileGetVisitedDateTime          ,


-- ** hasApplication #method:hasApplication#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileHasApplicationMethodInfo    ,
#endif
    bookmarkFileHasApplication              ,


-- ** hasGroup #method:hasGroup#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileHasGroupMethodInfo          ,
#endif
    bookmarkFileHasGroup                    ,


-- ** hasItem #method:hasItem#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileHasItemMethodInfo           ,
#endif
    bookmarkFileHasItem                     ,


-- ** loadFromData #method:loadFromData#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileLoadFromDataMethodInfo      ,
#endif
    bookmarkFileLoadFromData                ,


-- ** loadFromDataDirs #method:loadFromDataDirs#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileLoadFromDataDirsMethodInfo  ,
#endif
    bookmarkFileLoadFromDataDirs            ,


-- ** loadFromFile #method:loadFromFile#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileLoadFromFileMethodInfo      ,
#endif
    bookmarkFileLoadFromFile                ,


-- ** moveItem #method:moveItem#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileMoveItemMethodInfo          ,
#endif
    bookmarkFileMoveItem                    ,


-- ** new #method:new#

    bookmarkFileNew                         ,


-- ** removeApplication #method:removeApplication#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileRemoveApplicationMethodInfo ,
#endif
    bookmarkFileRemoveApplication           ,


-- ** removeGroup #method:removeGroup#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileRemoveGroupMethodInfo       ,
#endif
    bookmarkFileRemoveGroup                 ,


-- ** removeItem #method:removeItem#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileRemoveItemMethodInfo        ,
#endif
    bookmarkFileRemoveItem                  ,


-- ** setAdded #method:setAdded#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileSetAddedMethodInfo          ,
#endif
    bookmarkFileSetAdded                    ,


-- ** setAddedDateTime #method:setAddedDateTime#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileSetAddedDateTimeMethodInfo  ,
#endif
    bookmarkFileSetAddedDateTime            ,


-- ** setAppInfo #method:setAppInfo#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileSetAppInfoMethodInfo        ,
#endif
    bookmarkFileSetAppInfo                  ,


-- ** setApplicationInfo #method:setApplicationInfo#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileSetApplicationInfoMethodInfo,
#endif
    bookmarkFileSetApplicationInfo          ,


-- ** setDescription #method:setDescription#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileSetDescriptionMethodInfo    ,
#endif
    bookmarkFileSetDescription              ,


-- ** setGroups #method:setGroups#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileSetGroupsMethodInfo         ,
#endif
    bookmarkFileSetGroups                   ,


-- ** setIcon #method:setIcon#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileSetIconMethodInfo           ,
#endif
    bookmarkFileSetIcon                     ,


-- ** setIsPrivate #method:setIsPrivate#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileSetIsPrivateMethodInfo      ,
#endif
    bookmarkFileSetIsPrivate                ,


-- ** setMimeType #method:setMimeType#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileSetMimeTypeMethodInfo       ,
#endif
    bookmarkFileSetMimeType                 ,


-- ** setModified #method:setModified#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileSetModifiedMethodInfo       ,
#endif
    bookmarkFileSetModified                 ,


-- ** setModifiedDateTime #method:setModifiedDateTime#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileSetModifiedDateTimeMethodInfo,
#endif
    bookmarkFileSetModifiedDateTime         ,


-- ** setTitle #method:setTitle#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileSetTitleMethodInfo          ,
#endif
    bookmarkFileSetTitle                    ,


-- ** setVisited #method:setVisited#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileSetVisitedMethodInfo        ,
#endif
    bookmarkFileSetVisited                  ,


-- ** setVisitedDateTime #method:setVisitedDateTime#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileSetVisitedDateTimeMethodInfo,
#endif
    bookmarkFileSetVisitedDateTime          ,


-- ** toData #method:toData#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileToDataMethodInfo            ,
#endif
    bookmarkFileToData                      ,


-- ** toFile #method:toFile#

#if defined(ENABLE_OVERLOADING)
    BookmarkFileToFileMethodInfo            ,
#endif
    bookmarkFileToFile                      ,




    ) 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 {-# SOURCE #-} qualified GI.GLib.Enums as GLib.Enums
import {-# SOURCE #-} qualified GI.GLib.Structs.DateTime as GLib.DateTime
import {-# SOURCE #-} qualified GI.GLib.Structs.TimeVal as GLib.TimeVal
import {-# SOURCE #-} qualified GI.GLib.Structs.TimeZone as GLib.TimeZone

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

#endif

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

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

foreign import ccall "g_bookmark_file_get_type" c_g_bookmark_file_get_type :: 
    IO GType

type instance O.ParentTypes BookmarkFile = '[]
instance O.HasParentTypes BookmarkFile

instance B.Types.TypedObject BookmarkFile where
    glibType :: IO GType
glibType = IO GType
c_g_bookmark_file_get_type

instance B.Types.GBoxed BookmarkFile

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


#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList BookmarkFile
type instance O.AttributeList BookmarkFile = BookmarkFileAttributeList
type BookmarkFileAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif

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

foreign import ccall "g_bookmark_file_new" g_bookmark_file_new :: 
    IO (Ptr BookmarkFile)

-- | Creates a new empty t'GI.GLib.Structs.BookmarkFile.BookmarkFile' object.
-- 
-- Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileLoadFromFile', 'GI.GLib.Structs.BookmarkFile.bookmarkFileLoadFromData'
-- or 'GI.GLib.Structs.BookmarkFile.bookmarkFileLoadFromDataDirs' to read an existing bookmark
-- file.
-- 
-- /Since: 2.12/
bookmarkFileNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m BookmarkFile
    -- ^ __Returns:__ an empty t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
bookmarkFileNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m BookmarkFile
bookmarkFileNew  = IO BookmarkFile -> m BookmarkFile
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BookmarkFile -> m BookmarkFile)
-> IO BookmarkFile -> m BookmarkFile
forall a b. (a -> b) -> a -> b
$ do
    result <- IO (Ptr BookmarkFile)
g_bookmark_file_new
    checkUnexpectedReturnNULL "bookmarkFileNew" result
    result' <- (wrapBoxed BookmarkFile) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method BookmarkFile::add_application
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the name of the application registering the bookmark\n  or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "exec"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "command line to be used to launch the bookmark or %NULL"
--                 , 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_bookmark_file_add_application" g_bookmark_file_add_application :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- exec : TBasicType TUTF8
    IO ()

-- | Adds the application with /@name@/ and /@exec@/ to the list of
-- applications that have registered a bookmark for /@uri@/ into
-- /@bookmark@/.
-- 
-- Every bookmark inside a t'GI.GLib.Structs.BookmarkFile.BookmarkFile' must have at least an
-- application registered.  Each application must provide a name, a
-- command line useful for launching the bookmark, the number of times
-- the bookmark has been registered by the application and the last
-- time the application registered this bookmark.
-- 
-- If /@name@/ is 'P.Nothing', the name of the application will be the
-- same returned by 'GI.GLib.Functions.getApplicationName'; if /@exec@/ is 'P.Nothing', the
-- command line will be a composition of the program name as
-- returned by 'GI.GLib.Functions.getPrgname' and the \"%u\" modifier, which will be
-- expanded to the bookmark\'s URI.
-- 
-- This function will automatically take care of updating the
-- registrations count and timestamping in case an application
-- with the same /@name@/ had already registered a bookmark for
-- /@uri@/ inside /@bookmark@/.
-- 
-- If no bookmark for /@uri@/ is found, one is created.
-- 
-- /Since: 2.12/
bookmarkFileAddApplication ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> Maybe (T.Text)
    -- ^ /@name@/: the name of the application registering the bookmark
    --   or 'P.Nothing'
    -> Maybe (T.Text)
    -- ^ /@exec@/: command line to be used to launch the bookmark or 'P.Nothing'
    -> m ()
bookmarkFileAddApplication :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Maybe Text -> Maybe Text -> m ()
bookmarkFileAddApplication BookmarkFile
bookmark Text
uri Maybe Text
name Maybe Text
exec = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    maybeName <- case name of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jName -> do
            jName' <- Text -> IO CString
textToCString Text
jName
            return jName'
    maybeExec <- case exec of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jExec -> do
            jExec' <- Text -> IO CString
textToCString Text
jExec
            return jExec'
    g_bookmark_file_add_application bookmark' uri' maybeName maybeExec
    touchManagedPtr bookmark
    freeMem uri'
    freeMem maybeName
    freeMem maybeExec
    return ()

#if defined(ENABLE_OVERLOADING)
data BookmarkFileAddApplicationMethodInfo
instance (signature ~ (T.Text -> Maybe (T.Text) -> Maybe (T.Text) -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileAddApplicationMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileAddApplication

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


#endif

-- method BookmarkFile::add_group
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "group"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the group name to be added"
--                 , 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_bookmark_file_add_group" g_bookmark_file_add_group :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    CString ->                              -- group : TBasicType TUTF8
    IO ()

-- | Adds /@group@/ to the list of groups to which the bookmark for /@uri@/
-- belongs to.
-- 
-- If no bookmark for /@uri@/ is found then it is created.
-- 
-- /Since: 2.12/
bookmarkFileAddGroup ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> T.Text
    -- ^ /@group@/: the group name to be added
    -> m ()
bookmarkFileAddGroup :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileAddGroup BookmarkFile
bookmark Text
uri Text
group = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    group' <- textToCString group
    g_bookmark_file_add_group bookmark' uri' group'
    touchManagedPtr bookmark
    freeMem uri'
    freeMem group'
    return ()

#if defined(ENABLE_OVERLOADING)
data BookmarkFileAddGroupMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileAddGroupMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileAddGroup

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


#endif

-- method BookmarkFile::copy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GLib" , name = "BookmarkFile" })
-- throws : False
-- Skip return : False

foreign import ccall "g_bookmark_file_copy" g_bookmark_file_copy :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    IO (Ptr BookmarkFile)

-- | Deeply copies a /@bookmark@/ t'GI.GLib.Structs.BookmarkFile.BookmarkFile' object to a new one.
-- 
-- /Since: 2.76/
bookmarkFileCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: A t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> m BookmarkFile
    -- ^ __Returns:__ the copy of /@bookmark@/. Use
    --   @/g_bookmark_free()/@ when finished using it.
bookmarkFileCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> m BookmarkFile
bookmarkFileCopy BookmarkFile
bookmark = IO BookmarkFile -> m BookmarkFile
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BookmarkFile -> m BookmarkFile)
-> IO BookmarkFile -> m BookmarkFile
forall a b. (a -> b) -> a -> b
$ do
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    result <- g_bookmark_file_copy bookmark'
    checkUnexpectedReturnNULL "bookmarkFileCopy" result
    result' <- (wrapBoxed BookmarkFile) result
    touchManagedPtr bookmark
    return result'

#if defined(ENABLE_OVERLOADING)
data BookmarkFileCopyMethodInfo
instance (signature ~ (m BookmarkFile), MonadIO m) => O.OverloadedMethod BookmarkFileCopyMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileCopy

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


#endif

-- method BookmarkFile::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , 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_bookmark_file_free" g_bookmark_file_free :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    IO ()

-- | Frees a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'.
-- 
-- /Since: 2.12/
bookmarkFileFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> m ()
bookmarkFileFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> m ()
bookmarkFileFree BookmarkFile
bookmark = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    g_bookmark_file_free bookmark'
    touchManagedPtr bookmark
    return ()

#if defined(ENABLE_OVERLOADING)
data BookmarkFileFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod BookmarkFileFreeMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileFree

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


#endif

-- method BookmarkFile::get_added
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType Ttime_t)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_get_added" g_bookmark_file_get_added :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO FCT.CTime

{-# DEPRECATED bookmarkFileGetAdded ["(Since version 2.66)","Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileGetAddedDateTime' instead, as","   @time_t@ is deprecated due to the year 2038 problem."] #-}
-- | Gets the time the bookmark for /@uri@/ was added to /@bookmark@/
-- 
-- In the event the URI cannot be found, -1 is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.
-- 
-- /Since: 2.12/
bookmarkFileGetAdded ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> m FCT.CTime
    -- ^ __Returns:__ a timestamp /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileGetAdded :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m CTime
bookmarkFileGetAdded BookmarkFile
bookmark Text
uri = IO CTime -> m CTime
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CTime -> m CTime) -> IO CTime -> m CTime
forall a b. (a -> b) -> a -> b
$ do
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    onException (do
        result <- propagateGError $ g_bookmark_file_get_added bookmark' uri'
        touchManagedPtr bookmark
        freeMem uri'
        return result
     ) (do
        freeMem uri'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetAddedMethodInfo
instance (signature ~ (T.Text -> m FCT.CTime), MonadIO m) => O.OverloadedMethod BookmarkFileGetAddedMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileGetAdded

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


#endif

-- method BookmarkFile::get_added_date_time
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "DateTime" })
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_get_added_date_time" g_bookmark_file_get_added_date_time :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr GLib.DateTime.DateTime)

-- | Gets the time the bookmark for /@uri@/ was added to /@bookmark@/
-- 
-- In the event the URI cannot be found, 'P.Nothing' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.
-- 
-- /Since: 2.66/
bookmarkFileGetAddedDateTime ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> m GLib.DateTime.DateTime
    -- ^ __Returns:__ a t'GI.GLib.Structs.DateTime.DateTime' /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileGetAddedDateTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m DateTime
bookmarkFileGetAddedDateTime BookmarkFile
bookmark Text
uri = IO DateTime -> m DateTime
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DateTime -> m DateTime) -> IO DateTime -> m DateTime
forall a b. (a -> b) -> a -> b
$ do
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    onException (do
        result <- propagateGError $ g_bookmark_file_get_added_date_time bookmark' uri'
        checkUnexpectedReturnNULL "bookmarkFileGetAddedDateTime" result
        result' <- (newBoxed GLib.DateTime.DateTime) result
        touchManagedPtr bookmark
        freeMem uri'
        return result'
     ) (do
        freeMem uri'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetAddedDateTimeMethodInfo
instance (signature ~ (T.Text -> m GLib.DateTime.DateTime), MonadIO m) => O.OverloadedMethod BookmarkFileGetAddedDateTimeMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileGetAddedDateTime

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


#endif

-- method BookmarkFile::get_app_info
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an application's name"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "exec"
--           , argType = TBasicType TUTF8
--           , argCType = Just "gchar**"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the command line of the application, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "count"
--           , argType = TBasicType TUInt
--           , argCType = Just "guint*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the registration count, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "stamp"
--           , argType = TBasicType Ttime_t
--           , argCType = Just "time_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the last registration time, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_get_app_info" g_bookmark_file_get_app_info :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    CString ->                              -- name : TBasicType TUTF8
    Ptr CString ->                          -- exec : TBasicType TUTF8
    Ptr Word32 ->                           -- count : TBasicType TUInt
    Ptr FCT.CTime ->                        -- stamp : TBasicType Ttime_t
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{-# DEPRECATED bookmarkFileGetAppInfo ["(Since version 2.66)","Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileGetApplicationInfo' instead, as","   @time_t@ is deprecated due to the year 2038 problem."] #-}
-- | Gets the registration information of /@appName@/ for the bookmark for
-- /@uri@/.  See 'GI.GLib.Structs.BookmarkFile.bookmarkFileSetApplicationInfo' for more information about
-- the returned data.
-- 
-- The string returned in /@appExec@/ must be freed.
-- 
-- In the event the URI cannot be found, 'P.False' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.  In the
-- event that no application with name /@appName@/ has registered a bookmark
-- for /@uri@/,  'P.False' is returned and error is set to
-- 'GI.GLib.Enums.BookmarkFileErrorAppNotRegistered'. In the event that unquoting
-- the command line fails, an error of the @/G_SHELL_ERROR/@ domain is
-- set and 'P.False' is returned.
-- 
-- /Since: 2.12/
bookmarkFileGetAppInfo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> T.Text
    -- ^ /@name@/: an application\'s name
    -> m ((T.Text, Word32, FCT.CTime))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileGetAppInfo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m (Text, Word32, CTime)
bookmarkFileGetAppInfo BookmarkFile
bookmark Text
uri Text
name = IO (Text, Word32, CTime) -> m (Text, Word32, CTime)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Word32, CTime) -> m (Text, Word32, CTime))
-> IO (Text, Word32, CTime) -> m (Text, Word32, CTime)
forall a b. (a -> b) -> a -> b
$ do
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    name' <- textToCString name
    exec <- callocMem :: IO (Ptr CString)
    count <- allocMem :: IO (Ptr Word32)
    stamp <- allocMem :: IO (Ptr FCT.CTime)
    onException (do
        _ <- propagateGError $ g_bookmark_file_get_app_info bookmark' uri' name' exec count stamp
        exec' <- peek exec
        exec'' <- cstringToText exec'
        freeMem exec'
        count' <- peek count
        stamp' <- peek stamp
        touchManagedPtr bookmark
        freeMem uri'
        freeMem name'
        freeMem exec
        freeMem count
        freeMem stamp
        return (exec'', count', stamp')
     ) (do
        freeMem uri'
        freeMem name'
        freeMem exec
        freeMem count
        freeMem stamp
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetAppInfoMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ((T.Text, Word32, FCT.CTime))), MonadIO m) => O.OverloadedMethod BookmarkFileGetAppInfoMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileGetAppInfo

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


#endif

-- method BookmarkFile::get_application_info
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an application's name"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "exec"
--           , argType = TBasicType TUTF8
--           , argCType = Just "char**"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the command line of the application, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "count"
--           , argType = TBasicType TUInt
--           , argCType = Just "unsigned int*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the registration count, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "stamp"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DateTime" }
--           , argCType = Just "GDateTime**"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the last registration time, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_get_application_info" g_bookmark_file_get_application_info :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    CString ->                              -- name : TBasicType TUTF8
    Ptr CString ->                          -- exec : TBasicType TUTF8
    Ptr Word32 ->                           -- count : TBasicType TUInt
    Ptr (Ptr GLib.DateTime.DateTime) ->     -- stamp : TInterface (Name {namespace = "GLib", name = "DateTime"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Gets the registration information of /@appName@/ for the bookmark for
-- /@uri@/.  See 'GI.GLib.Structs.BookmarkFile.bookmarkFileSetApplicationInfo' for more information about
-- the returned data.
-- 
-- The string returned in /@appExec@/ must be freed.
-- 
-- In the event the URI cannot be found, 'P.False' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.  In the
-- event that no application with name /@appName@/ has registered a bookmark
-- for /@uri@/,  'P.False' is returned and error is set to
-- 'GI.GLib.Enums.BookmarkFileErrorAppNotRegistered'. In the event that unquoting
-- the command line fails, an error of the @/G_SHELL_ERROR/@ domain is
-- set and 'P.False' is returned.
-- 
-- /Since: 2.66/
bookmarkFileGetApplicationInfo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> T.Text
    -- ^ /@name@/: an application\'s name
    -> m ((T.Text, Word32, GLib.DateTime.DateTime))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileGetApplicationInfo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m (Text, Word32, DateTime)
bookmarkFileGetApplicationInfo BookmarkFile
bookmark Text
uri Text
name = IO (Text, Word32, DateTime) -> m (Text, Word32, DateTime)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Word32, DateTime) -> m (Text, Word32, DateTime))
-> IO (Text, Word32, DateTime) -> m (Text, Word32, DateTime)
forall a b. (a -> b) -> a -> b
$ do
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    name' <- textToCString name
    exec <- callocMem :: IO (Ptr CString)
    count <- allocMem :: IO (Ptr Word32)
    stamp <- callocMem :: IO (Ptr (Ptr GLib.DateTime.DateTime))
    onException (do
        _ <- propagateGError $ g_bookmark_file_get_application_info bookmark' uri' name' exec count stamp
        exec' <- peek exec
        exec'' <- cstringToText exec'
        freeMem exec'
        count' <- peek count
        stamp' <- peek stamp
        stamp'' <- (newBoxed GLib.DateTime.DateTime) stamp'
        touchManagedPtr bookmark
        freeMem uri'
        freeMem name'
        freeMem exec
        freeMem count
        freeMem stamp
        return (exec'', count', stamp'')
     ) (do
        freeMem uri'
        freeMem name'
        freeMem exec
        freeMem count
        freeMem stamp
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetApplicationInfoMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ((T.Text, Word32, GLib.DateTime.DateTime))), MonadIO m) => O.OverloadedMethod BookmarkFileGetApplicationInfoMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileGetApplicationInfo

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


#endif

-- method BookmarkFile::get_applications
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TSize
--           , argCType = Just "gsize*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location of the length of the returned list, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "length"
--              , argType = TBasicType TSize
--              , argCType = Just "gsize*"
--              , direction = DirectionOut
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText =
--                        Just "return location of the length of the returned list, or %NULL"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferEverything
--              }
--          ]
-- returnType: Just (TCArray False (-1) 2 (TBasicType TUTF8))
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_get_applications" g_bookmark_file_get_applications :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr FCT.CSize ->                        -- length : TBasicType TSize
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr CString)

-- | Retrieves the names of the applications that have registered the
-- bookmark for /@uri@/.
-- 
-- In the event the URI cannot be found, 'P.Nothing' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.
-- 
-- /Since: 2.12/
bookmarkFileGetApplications ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> m [T.Text]
    -- ^ __Returns:__ a newly allocated 'P.Nothing'-terminated array of strings.
    --   Use 'GI.GLib.Functions.strfreev' to free it. /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileGetApplications :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m [Text]
bookmarkFileGetApplications BookmarkFile
bookmark Text
uri = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    length_ <- allocMem :: IO (Ptr FCT.CSize)
    onException (do
        result <- propagateGError $ g_bookmark_file_get_applications bookmark' uri' length_
        length_' <- peek length_
        checkUnexpectedReturnNULL "bookmarkFileGetApplications" result
        result' <- (unpackUTF8CArrayWithLength length_') result
        (mapCArrayWithLength length_') freeMem result
        freeMem result
        touchManagedPtr bookmark
        freeMem uri'
        freeMem length_
        return result'
     ) (do
        freeMem uri'
        freeMem length_
     )

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

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


#endif

-- method BookmarkFile::get_description
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_get_description" g_bookmark_file_get_description :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CString

-- | Retrieves the description of the bookmark for /@uri@/.
-- 
-- In the event the URI cannot be found, 'P.Nothing' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.
-- 
-- /Since: 2.12/
bookmarkFileGetDescription ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> m T.Text
    -- ^ __Returns:__ a newly allocated string or 'P.Nothing' if the specified
    --   URI cannot be found. /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileGetDescription :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m Text
bookmarkFileGetDescription BookmarkFile
bookmark Text
uri = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    onException (do
        result <- propagateGError $ g_bookmark_file_get_description bookmark' uri'
        checkUnexpectedReturnNULL "bookmarkFileGetDescription" result
        result' <- cstringToText result
        freeMem result
        touchManagedPtr bookmark
        freeMem uri'
        return result'
     ) (do
        freeMem uri'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetDescriptionMethodInfo
instance (signature ~ (T.Text -> m T.Text), MonadIO m) => O.OverloadedMethod BookmarkFileGetDescriptionMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileGetDescription

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


#endif

-- method BookmarkFile::get_groups
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TSize
--           , argCType = Just "gsize*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the length of the returned string, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "length"
--              , argType = TBasicType TSize
--              , argCType = Just "gsize*"
--              , direction = DirectionOut
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText =
--                        Just
--                          "return location for the length of the returned string, or %NULL"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferEverything
--              }
--          ]
-- returnType: Just (TCArray False (-1) 2 (TBasicType TUTF8))
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_get_groups" g_bookmark_file_get_groups :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr FCT.CSize ->                        -- length : TBasicType TSize
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr CString)

-- | Retrieves the list of group names of the bookmark for /@uri@/.
-- 
-- In the event the URI cannot be found, 'P.Nothing' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.
-- 
-- The returned array is 'P.Nothing' terminated, so /@length@/ may optionally
-- be 'P.Nothing'.
-- 
-- /Since: 2.12/
bookmarkFileGetGroups ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> m [T.Text]
    -- ^ __Returns:__ a newly allocated 'P.Nothing'-terminated array of group names.
    --   Use 'GI.GLib.Functions.strfreev' to free it. /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileGetGroups :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m [Text]
bookmarkFileGetGroups BookmarkFile
bookmark Text
uri = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    length_ <- allocMem :: IO (Ptr FCT.CSize)
    onException (do
        result <- propagateGError $ g_bookmark_file_get_groups bookmark' uri' length_
        length_' <- peek length_
        checkUnexpectedReturnNULL "bookmarkFileGetGroups" result
        result' <- (unpackUTF8CArrayWithLength length_') result
        (mapCArrayWithLength length_') freeMem result
        freeMem result
        touchManagedPtr bookmark
        freeMem uri'
        freeMem length_
        return result'
     ) (do
        freeMem uri'
        freeMem length_
     )

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

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


#endif

-- method BookmarkFile::get_icon
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "href"
--           , argType = TBasicType TUTF8
--           , argCType = Just "gchar**"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the icon's location or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "mime_type"
--           , argType = TBasicType TUTF8
--           , argCType = Just "gchar**"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the icon's MIME type or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_get_icon" g_bookmark_file_get_icon :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr CString ->                          -- href : TBasicType TUTF8
    Ptr CString ->                          -- mime_type : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Gets the icon of the bookmark for /@uri@/.
-- 
-- In the event the URI cannot be found, 'P.False' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.
-- 
-- /Since: 2.12/
bookmarkFileGetIcon ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> m ((T.Text, T.Text))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileGetIcon :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m (Text, Text)
bookmarkFileGetIcon BookmarkFile
bookmark Text
uri = IO (Text, Text) -> m (Text, Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Text) -> m (Text, Text))
-> IO (Text, Text) -> m (Text, Text)
forall a b. (a -> b) -> a -> b
$ do
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    href <- callocMem :: IO (Ptr CString)
    mimeType <- callocMem :: IO (Ptr CString)
    onException (do
        _ <- propagateGError $ g_bookmark_file_get_icon bookmark' uri' href mimeType
        href' <- peek href
        href'' <- cstringToText href'
        freeMem href'
        mimeType' <- peek mimeType
        mimeType'' <- cstringToText mimeType'
        freeMem mimeType'
        touchManagedPtr bookmark
        freeMem uri'
        freeMem href
        freeMem mimeType
        return (href'', mimeType'')
     ) (do
        freeMem uri'
        freeMem href
        freeMem mimeType
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetIconMethodInfo
instance (signature ~ (T.Text -> m ((T.Text, T.Text))), MonadIO m) => O.OverloadedMethod BookmarkFileGetIconMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileGetIcon

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


#endif

-- method BookmarkFile::get_is_private
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_get_is_private" g_bookmark_file_get_is_private :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Gets whether the private flag of the bookmark for /@uri@/ is set.
-- 
-- In the event the URI cannot be found, 'P.False' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.  In the
-- event that the private flag cannot be found, 'P.False' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorInvalidValue'.
-- 
-- /Since: 2.12/
bookmarkFileGetIsPrivate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileGetIsPrivate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m ()
bookmarkFileGetIsPrivate BookmarkFile
bookmark Text
uri = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    onException (do
        _ <- propagateGError $ g_bookmark_file_get_is_private bookmark' uri'
        touchManagedPtr bookmark
        freeMem uri'
        return ()
     ) (do
        freeMem uri'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetIsPrivateMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileGetIsPrivateMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileGetIsPrivate

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


#endif

-- method BookmarkFile::get_mime_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_get_mime_type" g_bookmark_file_get_mime_type :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CString

-- | Retrieves the MIME type of the resource pointed by /@uri@/.
-- 
-- In the event the URI cannot be found, 'P.Nothing' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.  In the
-- event that the MIME type cannot be found, 'P.Nothing' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorInvalidValue'.
-- 
-- /Since: 2.12/
bookmarkFileGetMimeType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> m T.Text
    -- ^ __Returns:__ a newly allocated string or 'P.Nothing' if the specified
    --   URI cannot be found. /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileGetMimeType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m Text
bookmarkFileGetMimeType BookmarkFile
bookmark Text
uri = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    onException (do
        result <- propagateGError $ g_bookmark_file_get_mime_type bookmark' uri'
        checkUnexpectedReturnNULL "bookmarkFileGetMimeType" result
        result' <- cstringToText result
        freeMem result
        touchManagedPtr bookmark
        freeMem uri'
        return result'
     ) (do
        freeMem uri'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetMimeTypeMethodInfo
instance (signature ~ (T.Text -> m T.Text), MonadIO m) => O.OverloadedMethod BookmarkFileGetMimeTypeMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileGetMimeType

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


#endif

-- method BookmarkFile::get_modified
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType Ttime_t)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_get_modified" g_bookmark_file_get_modified :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO FCT.CTime

{-# DEPRECATED bookmarkFileGetModified ["(Since version 2.66)","Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileGetModifiedDateTime' instead, as","   @time_t@ is deprecated due to the year 2038 problem."] #-}
-- | Gets the time when the bookmark for /@uri@/ was last modified.
-- 
-- In the event the URI cannot be found, -1 is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.
-- 
-- /Since: 2.12/
bookmarkFileGetModified ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> m FCT.CTime
    -- ^ __Returns:__ a timestamp /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileGetModified :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m CTime
bookmarkFileGetModified BookmarkFile
bookmark Text
uri = IO CTime -> m CTime
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CTime -> m CTime) -> IO CTime -> m CTime
forall a b. (a -> b) -> a -> b
$ do
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    onException (do
        result <- propagateGError $ g_bookmark_file_get_modified bookmark' uri'
        touchManagedPtr bookmark
        freeMem uri'
        return result
     ) (do
        freeMem uri'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetModifiedMethodInfo
instance (signature ~ (T.Text -> m FCT.CTime), MonadIO m) => O.OverloadedMethod BookmarkFileGetModifiedMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileGetModified

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


#endif

-- method BookmarkFile::get_modified_date_time
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "DateTime" })
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_get_modified_date_time" g_bookmark_file_get_modified_date_time :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr GLib.DateTime.DateTime)

-- | Gets the time when the bookmark for /@uri@/ was last modified.
-- 
-- In the event the URI cannot be found, 'P.Nothing' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.
-- 
-- /Since: 2.66/
bookmarkFileGetModifiedDateTime ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> m GLib.DateTime.DateTime
    -- ^ __Returns:__ a t'GI.GLib.Structs.DateTime.DateTime' /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileGetModifiedDateTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m DateTime
bookmarkFileGetModifiedDateTime BookmarkFile
bookmark Text
uri = IO DateTime -> m DateTime
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DateTime -> m DateTime) -> IO DateTime -> m DateTime
forall a b. (a -> b) -> a -> b
$ do
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    onException (do
        result <- propagateGError $ g_bookmark_file_get_modified_date_time bookmark' uri'
        checkUnexpectedReturnNULL "bookmarkFileGetModifiedDateTime" result
        result' <- (newBoxed GLib.DateTime.DateTime) result
        touchManagedPtr bookmark
        freeMem uri'
        return result'
     ) (do
        freeMem uri'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetModifiedDateTimeMethodInfo
instance (signature ~ (T.Text -> m GLib.DateTime.DateTime), MonadIO m) => O.OverloadedMethod BookmarkFileGetModifiedDateTimeMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileGetModifiedDateTime

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


#endif

-- method BookmarkFile::get_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , 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 "g_bookmark_file_get_size" g_bookmark_file_get_size :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    IO Int32

-- | Gets the number of bookmarks inside /@bookmark@/.
-- 
-- /Since: 2.12/
bookmarkFileGetSize ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> m Int32
    -- ^ __Returns:__ the number of bookmarks
bookmarkFileGetSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> m Int32
bookmarkFileGetSize BookmarkFile
bookmark = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    result <- g_bookmark_file_get_size bookmark'
    touchManagedPtr bookmark
    return result

#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetSizeMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod BookmarkFileGetSizeMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileGetSize

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


#endif

-- method BookmarkFile::get_title
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_get_title" g_bookmark_file_get_title :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CString

-- | Returns the title of the bookmark for /@uri@/.
-- 
-- If /@uri@/ is 'P.Nothing', the title of /@bookmark@/ is returned.
-- 
-- In the event the URI cannot be found, 'P.Nothing' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.
-- 
-- /Since: 2.12/
bookmarkFileGetTitle ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> Maybe (T.Text)
    -- ^ /@uri@/: a valid URI or 'P.Nothing'
    -> m T.Text
    -- ^ __Returns:__ a newly allocated string or 'P.Nothing' if the specified
    --   URI cannot be found. /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileGetTitle :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Maybe Text -> m Text
bookmarkFileGetTitle BookmarkFile
bookmark Maybe Text
uri = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    maybeUri <- case uri of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jUri -> do
            jUri' <- Text -> IO CString
textToCString Text
jUri
            return jUri'
    onException (do
        result <- propagateGError $ g_bookmark_file_get_title bookmark' maybeUri
        checkUnexpectedReturnNULL "bookmarkFileGetTitle" result
        result' <- cstringToText result
        freeMem result
        touchManagedPtr bookmark
        freeMem maybeUri
        return result'
     ) (do
        freeMem maybeUri
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetTitleMethodInfo
instance (signature ~ (Maybe (T.Text) -> m T.Text), MonadIO m) => O.OverloadedMethod BookmarkFileGetTitleMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileGetTitle

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


#endif

-- method BookmarkFile::get_uris
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TSize
--           , argCType = Just "gsize*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the number of returned URIs, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "length"
--              , argType = TBasicType TSize
--              , argCType = Just "gsize*"
--              , direction = DirectionOut
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText =
--                        Just "return location for the number of returned URIs, or %NULL"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferEverything
--              }
--          ]
-- returnType: Just (TCArray False (-1) 1 (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "g_bookmark_file_get_uris" g_bookmark_file_get_uris :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    Ptr FCT.CSize ->                        -- length : TBasicType TSize
    IO (Ptr CString)

-- | Returns all URIs of the bookmarks in the bookmark file /@bookmark@/.
-- The array of returned URIs will be 'P.Nothing'-terminated, so /@length@/ may
-- optionally be 'P.Nothing'.
-- 
-- /Since: 2.12/
bookmarkFileGetUris ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> m [T.Text]
    -- ^ __Returns:__ a newly allocated 'P.Nothing'-terminated array of strings.
    --   Use 'GI.GLib.Functions.strfreev' to free it.
bookmarkFileGetUris :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> m [Text]
bookmarkFileGetUris BookmarkFile
bookmark = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    length_ <- allocMem :: IO (Ptr FCT.CSize)
    result <- g_bookmark_file_get_uris bookmark' length_
    length_' <- peek length_
    checkUnexpectedReturnNULL "bookmarkFileGetUris" result
    result' <- (unpackUTF8CArrayWithLength length_') result
    (mapCArrayWithLength length_') freeMem result
    freeMem result
    touchManagedPtr bookmark
    freeMem length_
    return result'

#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetUrisMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m) => O.OverloadedMethod BookmarkFileGetUrisMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileGetUris

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


#endif

-- method BookmarkFile::get_visited
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType Ttime_t)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_get_visited" g_bookmark_file_get_visited :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO FCT.CTime

{-# DEPRECATED bookmarkFileGetVisited ["(Since version 2.66)","Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileGetVisitedDateTime' instead, as","   @time_t@ is deprecated due to the year 2038 problem."] #-}
-- | Gets the time the bookmark for /@uri@/ was last visited.
-- 
-- In the event the URI cannot be found, -1 is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.
-- 
-- /Since: 2.12/
bookmarkFileGetVisited ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> m FCT.CTime
    -- ^ __Returns:__ a timestamp. /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileGetVisited :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m CTime
bookmarkFileGetVisited BookmarkFile
bookmark Text
uri = IO CTime -> m CTime
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CTime -> m CTime) -> IO CTime -> m CTime
forall a b. (a -> b) -> a -> b
$ do
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    onException (do
        result <- propagateGError $ g_bookmark_file_get_visited bookmark' uri'
        touchManagedPtr bookmark
        freeMem uri'
        return result
     ) (do
        freeMem uri'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetVisitedMethodInfo
instance (signature ~ (T.Text -> m FCT.CTime), MonadIO m) => O.OverloadedMethod BookmarkFileGetVisitedMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileGetVisited

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


#endif

-- method BookmarkFile::get_visited_date_time
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "DateTime" })
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_get_visited_date_time" g_bookmark_file_get_visited_date_time :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr GLib.DateTime.DateTime)

-- | Gets the time the bookmark for /@uri@/ was last visited.
-- 
-- In the event the URI cannot be found, 'P.Nothing' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.
-- 
-- /Since: 2.66/
bookmarkFileGetVisitedDateTime ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> m GLib.DateTime.DateTime
    -- ^ __Returns:__ a t'GI.GLib.Structs.DateTime.DateTime' /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileGetVisitedDateTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m DateTime
bookmarkFileGetVisitedDateTime BookmarkFile
bookmark Text
uri = IO DateTime -> m DateTime
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DateTime -> m DateTime) -> IO DateTime -> m DateTime
forall a b. (a -> b) -> a -> b
$ do
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    onException (do
        result <- propagateGError $ g_bookmark_file_get_visited_date_time bookmark' uri'
        checkUnexpectedReturnNULL "bookmarkFileGetVisitedDateTime" result
        result' <- (newBoxed GLib.DateTime.DateTime) result
        touchManagedPtr bookmark
        freeMem uri'
        return result'
     ) (do
        freeMem uri'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetVisitedDateTimeMethodInfo
instance (signature ~ (T.Text -> m GLib.DateTime.DateTime), MonadIO m) => O.OverloadedMethod BookmarkFileGetVisitedDateTimeMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileGetVisitedDateTime

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


#endif

-- method BookmarkFile::has_application
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the application"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_has_application" g_bookmark_file_has_application :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    CString ->                              -- name : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Checks whether the bookmark for /@uri@/ inside /@bookmark@/ has been
-- registered by application /@name@/.
-- 
-- In the event the URI cannot be found, 'P.False' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.
-- 
-- /Since: 2.12/
bookmarkFileHasApplication ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> T.Text
    -- ^ /@name@/: the name of the application
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileHasApplication :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileHasApplication BookmarkFile
bookmark Text
uri Text
name = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    name' <- textToCString name
    onException (do
        _ <- propagateGError $ g_bookmark_file_has_application bookmark' uri' name'
        touchManagedPtr bookmark
        freeMem uri'
        freeMem name'
        return ()
     ) (do
        freeMem uri'
        freeMem name'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileHasApplicationMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileHasApplicationMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileHasApplication

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


#endif

-- method BookmarkFile::has_group
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "group"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the group name to be searched"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_has_group" g_bookmark_file_has_group :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    CString ->                              -- group : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Checks whether /@group@/ appears in the list of groups to which
-- the bookmark for /@uri@/ belongs to.
-- 
-- In the event the URI cannot be found, 'P.False' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.
-- 
-- /Since: 2.12/
bookmarkFileHasGroup ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> T.Text
    -- ^ /@group@/: the group name to be searched
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileHasGroup :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileHasGroup BookmarkFile
bookmark Text
uri Text
group = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    group' <- textToCString group
    onException (do
        _ <- propagateGError $ g_bookmark_file_has_group bookmark' uri' group'
        touchManagedPtr bookmark
        freeMem uri'
        freeMem group'
        return ()
     ) (do
        freeMem uri'
        freeMem group'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileHasGroupMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileHasGroupMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileHasGroup

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


#endif

-- method BookmarkFile::has_item
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , 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 "g_bookmark_file_has_item" g_bookmark_file_has_item :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    IO CInt

-- | Looks whether the desktop bookmark has an item with its URI set to /@uri@/.
-- 
-- /Since: 2.12/
bookmarkFileHasItem ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@uri@/ is inside /@bookmark@/, 'P.False' otherwise
bookmarkFileHasItem :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m Bool
bookmarkFileHasItem BookmarkFile
bookmark Text
uri = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    result <- g_bookmark_file_has_item bookmark' uri'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr bookmark
    freeMem uri'
    return result'

#if defined(ENABLE_OVERLOADING)
data BookmarkFileHasItemMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.OverloadedMethod BookmarkFileHasItemMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileHasItem

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


#endif

-- method BookmarkFile::load_from_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an empty #GBookmarkFile struct"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TCArray False (-1) 2 (TBasicType TUInt8)
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "desktop bookmarks\n   loaded in memory"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TSize
--           , argCType = Just "gsize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the length of @data in bytes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "length"
--              , argType = TBasicType TSize
--              , argCType = Just "gsize"
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "the length of @data in bytes"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_load_from_data" g_bookmark_file_load_from_data :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    Ptr Word8 ->                            -- data : TCArray False (-1) 2 (TBasicType TUInt8)
    FCT.CSize ->                            -- length : TBasicType TSize
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Loads a bookmark file from memory into an empty t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
-- structure.  If the object cannot be created then /@error@/ is set to a
-- t'GI.GLib.Enums.BookmarkFileError'.
-- 
-- /Since: 2.12/
bookmarkFileLoadFromData ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: an empty t'GI.GLib.Structs.BookmarkFile.BookmarkFile' struct
    -> ByteString
    -- ^ /@data@/: desktop bookmarks
    --    loaded in memory
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileLoadFromData :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> ByteString -> m ()
bookmarkFileLoadFromData BookmarkFile
bookmark ByteString
data_ = 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
    let length_ :: CSize
length_ = Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
data_
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    data_' <- packByteString data_
    onException (do
        _ <- propagateGError $ g_bookmark_file_load_from_data bookmark' data_' length_
        touchManagedPtr bookmark
        freeMem data_'
        return ()
     ) (do
        freeMem data_'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileLoadFromDataMethodInfo
instance (signature ~ (ByteString -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileLoadFromDataMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileLoadFromData

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


#endif

-- method BookmarkFile::load_from_data_dirs
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "file"
--           , argType = TBasicType TFileName
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a relative path to a filename to open and parse"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "full_path"
--           , argType = TBasicType TFileName
--           , argCType = Just "gchar**"
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for a string\n   containing the full path of the file, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_load_from_data_dirs" g_bookmark_file_load_from_data_dirs :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- file : TBasicType TFileName
    Ptr CString ->                          -- full_path : TBasicType TFileName
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | This function looks for a desktop bookmark file named /@file@/ in the
-- paths returned from 'GI.GLib.Functions.getUserDataDir' and 'GI.GLib.Functions.getSystemDataDirs',
-- loads the file into /@bookmark@/ and returns the file\'s full path in
-- /@fullPath@/.  If the file could not be loaded then /@error@/ is
-- set to either a t'GI.GLib.Enums.FileError' or t'GI.GLib.Enums.BookmarkFileError'.
-- 
-- /Since: 2.12/
bookmarkFileLoadFromDataDirs ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> [Char]
    -- ^ /@file@/: a relative path to a filename to open and parse
    -> m ((Maybe [Char]))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileLoadFromDataDirs :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> String -> m (Maybe String)
bookmarkFileLoadFromDataDirs BookmarkFile
bookmark String
file = IO (Maybe String) -> m (Maybe String)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe String) -> m (Maybe String))
-> IO (Maybe String) -> m (Maybe String)
forall a b. (a -> b) -> a -> b
$ do
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    file' <- stringToCString file
    fullPath <- callocMem :: IO (Ptr CString)
    onException (do
        _ <- propagateGError $ g_bookmark_file_load_from_data_dirs bookmark' file' fullPath
        fullPath' <- peek fullPath
        maybeFullPath' <- convertIfNonNull fullPath' $ \CString
fullPath'' -> do
            fullPath''' <- HasCallStack => CString -> IO String
CString -> IO String
cstringToString CString
fullPath''
            return fullPath'''
        freeMem fullPath'
        touchManagedPtr bookmark
        freeMem file'
        freeMem fullPath
        return maybeFullPath'
     ) (do
        freeMem file'
        freeMem fullPath
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileLoadFromDataDirsMethodInfo
instance (signature ~ ([Char] -> m ((Maybe [Char]))), MonadIO m) => O.OverloadedMethod BookmarkFileLoadFromDataDirsMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileLoadFromDataDirs

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


#endif

-- method BookmarkFile::load_from_file
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an empty #GBookmarkFile struct"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "filename"
--           , argType = TBasicType TFileName
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the path of a filename to load, in the\n    GLib file name encoding"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_load_from_file" g_bookmark_file_load_from_file :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- filename : TBasicType TFileName
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Loads a desktop bookmark file into an empty t'GI.GLib.Structs.BookmarkFile.BookmarkFile' structure.
-- If the file could not be loaded then /@error@/ is set to either a t'GI.GLib.Enums.FileError'
-- or t'GI.GLib.Enums.BookmarkFileError'.
-- 
-- /Since: 2.12/
bookmarkFileLoadFromFile ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: an empty t'GI.GLib.Structs.BookmarkFile.BookmarkFile' struct
    -> [Char]
    -- ^ /@filename@/: the path of a filename to load, in the
    --     GLib file name encoding
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileLoadFromFile :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> String -> m ()
bookmarkFileLoadFromFile BookmarkFile
bookmark String
filename = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    filename' <- stringToCString filename
    onException (do
        _ <- propagateGError $ g_bookmark_file_load_from_file bookmark' filename'
        touchManagedPtr bookmark
        freeMem filename'
        return ()
     ) (do
        freeMem filename'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileLoadFromFileMethodInfo
instance (signature ~ ([Char] -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileLoadFromFileMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileLoadFromFile

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


#endif

-- method BookmarkFile::move_item
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "old_uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "new_uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_move_item" g_bookmark_file_move_item :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- old_uri : TBasicType TUTF8
    CString ->                              -- new_uri : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Changes the URI of a bookmark item from /@oldUri@/ to /@newUri@/.  Any
-- existing bookmark for /@newUri@/ will be overwritten.  If /@newUri@/ is
-- 'P.Nothing', then the bookmark is removed.
-- 
-- In the event the URI cannot be found, 'P.False' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.
-- 
-- /Since: 2.12/
bookmarkFileMoveItem ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@oldUri@/: a valid URI
    -> Maybe (T.Text)
    -- ^ /@newUri@/: a valid URI, or 'P.Nothing'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileMoveItem :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Maybe Text -> m ()
bookmarkFileMoveItem BookmarkFile
bookmark Text
oldUri Maybe Text
newUri = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    oldUri' <- textToCString oldUri
    maybeNewUri <- case newUri of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jNewUri -> do
            jNewUri' <- Text -> IO CString
textToCString Text
jNewUri
            return jNewUri'
    onException (do
        _ <- propagateGError $ g_bookmark_file_move_item bookmark' oldUri' maybeNewUri
        touchManagedPtr bookmark
        freeMem oldUri'
        freeMem maybeNewUri
        return ()
     ) (do
        freeMem oldUri'
        freeMem maybeNewUri
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileMoveItemMethodInfo
instance (signature ~ (T.Text -> Maybe (T.Text) -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileMoveItemMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileMoveItem

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


#endif

-- method BookmarkFile::remove_application
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the application"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_remove_application" g_bookmark_file_remove_application :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    CString ->                              -- name : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Removes application registered with /@name@/ from the list of applications
-- that have registered a bookmark for /@uri@/ inside /@bookmark@/.
-- 
-- In the event the URI cannot be found, 'P.False' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.
-- In the event that no application with name /@appName@/ has registered
-- a bookmark for /@uri@/,  'P.False' is returned and error is set to
-- 'GI.GLib.Enums.BookmarkFileErrorAppNotRegistered'.
-- 
-- /Since: 2.12/
bookmarkFileRemoveApplication ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> T.Text
    -- ^ /@name@/: the name of the application
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileRemoveApplication :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileRemoveApplication BookmarkFile
bookmark Text
uri Text
name = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    name' <- textToCString name
    onException (do
        _ <- propagateGError $ g_bookmark_file_remove_application bookmark' uri' name'
        touchManagedPtr bookmark
        freeMem uri'
        freeMem name'
        return ()
     ) (do
        freeMem uri'
        freeMem name'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileRemoveApplicationMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileRemoveApplicationMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileRemoveApplication

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


#endif

-- method BookmarkFile::remove_group
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "group"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the group name to be removed"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_remove_group" g_bookmark_file_remove_group :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    CString ->                              -- group : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Removes /@group@/ from the list of groups to which the bookmark
-- for /@uri@/ belongs to.
-- 
-- In the event the URI cannot be found, 'P.False' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'.
-- In the event no group was defined, 'P.False' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorInvalidValue'.
-- 
-- /Since: 2.12/
bookmarkFileRemoveGroup ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> T.Text
    -- ^ /@group@/: the group name to be removed
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileRemoveGroup :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileRemoveGroup BookmarkFile
bookmark Text
uri Text
group = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    group' <- textToCString group
    onException (do
        _ <- propagateGError $ g_bookmark_file_remove_group bookmark' uri' group'
        touchManagedPtr bookmark
        freeMem uri'
        freeMem group'
        return ()
     ) (do
        freeMem uri'
        freeMem group'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileRemoveGroupMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileRemoveGroupMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileRemoveGroup

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


#endif

-- method BookmarkFile::remove_item
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_remove_item" g_bookmark_file_remove_item :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Removes the bookmark for /@uri@/ from the bookmark file /@bookmark@/.
-- 
-- /Since: 2.12/
bookmarkFileRemoveItem ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileRemoveItem :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m ()
bookmarkFileRemoveItem BookmarkFile
bookmark Text
uri = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    onException (do
        _ <- propagateGError $ g_bookmark_file_remove_item bookmark' uri'
        touchManagedPtr bookmark
        freeMem uri'
        return ()
     ) (do
        freeMem uri'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileRemoveItemMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileRemoveItemMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileRemoveItem

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


#endif

-- method BookmarkFile::set_added
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "added"
--           , argType = TBasicType Ttime_t
--           , argCType = Just "time_t"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a timestamp or -1 to use the current time"
--                 , 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_bookmark_file_set_added" g_bookmark_file_set_added :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    FCT.CTime ->                            -- added : TBasicType Ttime_t
    IO ()

{-# DEPRECATED bookmarkFileSetAdded ["(Since version 2.66)","Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileSetAddedDateTime' instead, as","   @time_t@ is deprecated due to the year 2038 problem."] #-}
-- | Sets the time the bookmark for /@uri@/ was added into /@bookmark@/.
-- 
-- If no bookmark for /@uri@/ is found then it is created.
-- 
-- /Since: 2.12/
bookmarkFileSetAdded ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> FCT.CTime
    -- ^ /@added@/: a timestamp or -1 to use the current time
    -> m ()
bookmarkFileSetAdded :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> CTime -> m ()
bookmarkFileSetAdded BookmarkFile
bookmark Text
uri CTime
added = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    g_bookmark_file_set_added bookmark' uri' added
    touchManagedPtr bookmark
    freeMem uri'
    return ()

#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetAddedMethodInfo
instance (signature ~ (T.Text -> FCT.CTime -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetAddedMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileSetAdded

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


#endif

-- method BookmarkFile::set_added_date_time
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "added"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DateTime" }
--           , argCType = Just "GDateTime*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GDateTime" , 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_bookmark_file_set_added_date_time" g_bookmark_file_set_added_date_time :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr GLib.DateTime.DateTime ->           -- added : TInterface (Name {namespace = "GLib", name = "DateTime"})
    IO ()

-- | Sets the time the bookmark for /@uri@/ was added into /@bookmark@/.
-- 
-- If no bookmark for /@uri@/ is found then it is created.
-- 
-- /Since: 2.66/
bookmarkFileSetAddedDateTime ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> GLib.DateTime.DateTime
    -- ^ /@added@/: a t'GI.GLib.Structs.DateTime.DateTime'
    -> m ()
bookmarkFileSetAddedDateTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> DateTime -> m ()
bookmarkFileSetAddedDateTime BookmarkFile
bookmark Text
uri DateTime
added = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    added' <- unsafeManagedPtrGetPtr added
    g_bookmark_file_set_added_date_time bookmark' uri' added'
    touchManagedPtr bookmark
    touchManagedPtr added
    freeMem uri'
    return ()

#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetAddedDateTimeMethodInfo
instance (signature ~ (T.Text -> GLib.DateTime.DateTime -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetAddedDateTimeMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileSetAddedDateTime

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


#endif

-- method BookmarkFile::set_app_info
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an application's name"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "exec"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an application's command line"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "count"
--           , argType = TBasicType TInt
--           , argCType = Just "gint"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the number of registrations done for this application"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "stamp"
--           , argType = TBasicType Ttime_t
--           , argCType = Just "time_t"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the time of the last registration for this application"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_set_app_info" g_bookmark_file_set_app_info :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- exec : TBasicType TUTF8
    Int32 ->                                -- count : TBasicType TInt
    FCT.CTime ->                            -- stamp : TBasicType Ttime_t
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{-# DEPRECATED bookmarkFileSetAppInfo ["(Since version 2.66)","Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileSetApplicationInfo' instead, as","   @time_t@ is deprecated due to the year 2038 problem."] #-}
-- | Sets the meta-data of application /@name@/ inside the list of
-- applications that have registered a bookmark for /@uri@/ inside
-- /@bookmark@/.
-- 
-- You should rarely use this function; use 'GI.GLib.Structs.BookmarkFile.bookmarkFileAddApplication'
-- and 'GI.GLib.Structs.BookmarkFile.bookmarkFileRemoveApplication' instead.
-- 
-- /@name@/ can be any UTF-8 encoded string used to identify an
-- application.
-- /@exec@/ can have one of these two modifiers: \"%f\", which will
-- be expanded as the local file name retrieved from the bookmark\'s
-- URI; \"%u\", which will be expanded as the bookmark\'s URI.
-- The expansion is done automatically when retrieving the stored
-- command line using the 'GI.GLib.Structs.BookmarkFile.bookmarkFileGetApplicationInfo' function.
-- /@count@/ is the number of times the application has registered the
-- bookmark; if is \< 0, the current registration count will be increased
-- by one, if is 0, the application with /@name@/ will be removed from
-- the list of registered applications.
-- /@stamp@/ is the Unix time of the last registration; if it is -1, the
-- current time will be used.
-- 
-- If you try to remove an application by setting its registration count to
-- zero, and no bookmark for /@uri@/ is found, 'P.False' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'; similarly,
-- in the event that no application /@name@/ has registered a bookmark
-- for /@uri@/,  'P.False' is returned and error is set to
-- 'GI.GLib.Enums.BookmarkFileErrorAppNotRegistered'.  Otherwise, if no bookmark
-- for /@uri@/ is found, one is created.
-- 
-- /Since: 2.12/
bookmarkFileSetAppInfo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> T.Text
    -- ^ /@name@/: an application\'s name
    -> T.Text
    -- ^ /@exec@/: an application\'s command line
    -> Int32
    -- ^ /@count@/: the number of registrations done for this application
    -> FCT.CTime
    -- ^ /@stamp@/: the time of the last registration for this application
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileSetAppInfo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> Text -> Int32 -> CTime -> m ()
bookmarkFileSetAppInfo BookmarkFile
bookmark Text
uri Text
name Text
exec Int32
count CTime
stamp = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    name' <- textToCString name
    exec' <- textToCString exec
    onException (do
        _ <- propagateGError $ g_bookmark_file_set_app_info bookmark' uri' name' exec' count stamp
        touchManagedPtr bookmark
        freeMem uri'
        freeMem name'
        freeMem exec'
        return ()
     ) (do
        freeMem uri'
        freeMem name'
        freeMem exec'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetAppInfoMethodInfo
instance (signature ~ (T.Text -> T.Text -> T.Text -> Int32 -> FCT.CTime -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetAppInfoMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileSetAppInfo

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


#endif

-- method BookmarkFile::set_application_info
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an application's name"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "exec"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an application's command line"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "count"
--           , argType = TBasicType TInt
--           , argCType = Just "int"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the number of registrations done for this application"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "stamp"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DateTime" }
--           , argCType = Just "GDateTime*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the time of the last registration for this application,\n   which may be %NULL if @count is 0"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_set_application_info" g_bookmark_file_set_application_info :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- exec : TBasicType TUTF8
    Int32 ->                                -- count : TBasicType TInt
    Ptr GLib.DateTime.DateTime ->           -- stamp : TInterface (Name {namespace = "GLib", name = "DateTime"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Sets the meta-data of application /@name@/ inside the list of
-- applications that have registered a bookmark for /@uri@/ inside
-- /@bookmark@/.
-- 
-- You should rarely use this function; use 'GI.GLib.Structs.BookmarkFile.bookmarkFileAddApplication'
-- and 'GI.GLib.Structs.BookmarkFile.bookmarkFileRemoveApplication' instead.
-- 
-- /@name@/ can be any UTF-8 encoded string used to identify an
-- application.
-- /@exec@/ can have one of these two modifiers: \"%f\", which will
-- be expanded as the local file name retrieved from the bookmark\'s
-- URI; \"%u\", which will be expanded as the bookmark\'s URI.
-- The expansion is done automatically when retrieving the stored
-- command line using the 'GI.GLib.Structs.BookmarkFile.bookmarkFileGetApplicationInfo' function.
-- /@count@/ is the number of times the application has registered the
-- bookmark; if is \< 0, the current registration count will be increased
-- by one, if is 0, the application with /@name@/ will be removed from
-- the list of registered applications.
-- /@stamp@/ is the Unix time of the last registration.
-- 
-- If you try to remove an application by setting its registration count to
-- zero, and no bookmark for /@uri@/ is found, 'P.False' is returned and
-- /@error@/ is set to 'GI.GLib.Enums.BookmarkFileErrorUriNotFound'; similarly,
-- in the event that no application /@name@/ has registered a bookmark
-- for /@uri@/,  'P.False' is returned and error is set to
-- 'GI.GLib.Enums.BookmarkFileErrorAppNotRegistered'.  Otherwise, if no bookmark
-- for /@uri@/ is found, one is created.
-- 
-- /Since: 2.66/
bookmarkFileSetApplicationInfo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> T.Text
    -- ^ /@name@/: an application\'s name
    -> T.Text
    -- ^ /@exec@/: an application\'s command line
    -> Int32
    -- ^ /@count@/: the number of registrations done for this application
    -> Maybe (GLib.DateTime.DateTime)
    -- ^ /@stamp@/: the time of the last registration for this application,
    --    which may be 'P.Nothing' if /@count@/ is 0
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileSetApplicationInfo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile
-> Text -> Text -> Text -> Int32 -> Maybe DateTime -> m ()
bookmarkFileSetApplicationInfo BookmarkFile
bookmark Text
uri Text
name Text
exec Int32
count Maybe DateTime
stamp = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    name' <- textToCString name
    exec' <- textToCString exec
    maybeStamp <- case stamp of
        Maybe DateTime
Nothing -> Ptr DateTime -> IO (Ptr DateTime)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr DateTime
forall a. Ptr a
FP.nullPtr
        Just DateTime
jStamp -> do
            jStamp' <- DateTime -> IO (Ptr DateTime)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DateTime
jStamp
            return jStamp'
    onException (do
        _ <- propagateGError $ g_bookmark_file_set_application_info bookmark' uri' name' exec' count maybeStamp
        touchManagedPtr bookmark
        whenJust stamp touchManagedPtr
        freeMem uri'
        freeMem name'
        freeMem exec'
        return ()
     ) (do
        freeMem uri'
        freeMem name'
        freeMem exec'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetApplicationInfoMethodInfo
instance (signature ~ (T.Text -> T.Text -> T.Text -> Int32 -> Maybe (GLib.DateTime.DateTime) -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetApplicationInfoMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileSetApplicationInfo

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


#endif

-- method BookmarkFile::set_description
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "description"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string" , 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_bookmark_file_set_description" g_bookmark_file_set_description :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    CString ->                              -- description : TBasicType TUTF8
    IO ()

-- | Sets /@description@/ as the description of the bookmark for /@uri@/.
-- 
-- If /@uri@/ is 'P.Nothing', the description of /@bookmark@/ is set.
-- 
-- If a bookmark for /@uri@/ cannot be found then it is created.
-- 
-- /Since: 2.12/
bookmarkFileSetDescription ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> Maybe (T.Text)
    -- ^ /@uri@/: a valid URI or 'P.Nothing'
    -> T.Text
    -- ^ /@description@/: a string
    -> m ()
bookmarkFileSetDescription :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Maybe Text -> Text -> m ()
bookmarkFileSetDescription BookmarkFile
bookmark Maybe Text
uri Text
description = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    maybeUri <- case uri of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jUri -> do
            jUri' <- Text -> IO CString
textToCString Text
jUri
            return jUri'
    description' <- textToCString description
    g_bookmark_file_set_description bookmark' maybeUri description'
    touchManagedPtr bookmark
    freeMem maybeUri
    freeMem description'
    return ()

#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetDescriptionMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetDescriptionMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileSetDescription

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


#endif

-- method BookmarkFile::set_groups
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an item's URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "groups"
--           , argType = TCArray False (-1) 3 (TBasicType TUTF8)
--           , argCType = Just "const gchar**"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "an array of\n   group names, or %NULL to remove all groups"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TSize
--           , argCType = Just "gsize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "number of group name values in @groups"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "length"
--              , argType = TBasicType TSize
--              , argCType = Just "gsize"
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "number of group name values in @groups"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_bookmark_file_set_groups" g_bookmark_file_set_groups :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr CString ->                          -- groups : TCArray False (-1) 3 (TBasicType TUTF8)
    FCT.CSize ->                            -- length : TBasicType TSize
    IO ()

-- | Sets a list of group names for the item with URI /@uri@/.  Each previously
-- set group name list is removed.
-- 
-- If /@uri@/ cannot be found then an item for it is created.
-- 
-- /Since: 2.12/
bookmarkFileSetGroups ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: an item\'s URI
    -> Maybe ([T.Text])
    -- ^ /@groups@/: an array of
    --    group names, or 'P.Nothing' to remove all groups
    -> m ()
bookmarkFileSetGroups :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Maybe [Text] -> m ()
bookmarkFileSetGroups BookmarkFile
bookmark Text
uri Maybe [Text]
groups = 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
    let length_ :: CSize
length_ = case Maybe [Text]
groups of
            Maybe [Text]
Nothing -> CSize
0
            Just [Text]
jGroups -> Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ [Text] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Text]
jGroups
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    maybeGroups <- case groups of
        Maybe [Text]
Nothing -> Ptr CString -> IO (Ptr CString)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
FP.nullPtr
        Just [Text]
jGroups -> do
            jGroups' <- [Text] -> IO (Ptr CString)
packUTF8CArray [Text]
jGroups
            return jGroups'
    g_bookmark_file_set_groups bookmark' uri' maybeGroups length_
    touchManagedPtr bookmark
    freeMem uri'
    (mapCArrayWithLength length_) freeMem maybeGroups
    freeMem maybeGroups
    return ()

#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetGroupsMethodInfo
instance (signature ~ (T.Text -> Maybe ([T.Text]) -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetGroupsMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileSetGroups

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


#endif

-- method BookmarkFile::set_icon
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "href"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the URI of the icon for the bookmark, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mime_type"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the MIME type of the icon for the bookmark"
--                 , 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_bookmark_file_set_icon" g_bookmark_file_set_icon :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    CString ->                              -- href : TBasicType TUTF8
    CString ->                              -- mime_type : TBasicType TUTF8
    IO ()

-- | Sets the icon for the bookmark for /@uri@/. If /@href@/ is 'P.Nothing', unsets
-- the currently set icon. /@href@/ can either be a full URL for the icon
-- file or the icon name following the Icon Naming specification.
-- 
-- If no bookmark for /@uri@/ is found one is created.
-- 
-- /Since: 2.12/
bookmarkFileSetIcon ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> Maybe (T.Text)
    -- ^ /@href@/: the URI of the icon for the bookmark, or 'P.Nothing'
    -> T.Text
    -- ^ /@mimeType@/: the MIME type of the icon for the bookmark
    -> m ()
bookmarkFileSetIcon :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Maybe Text -> Text -> m ()
bookmarkFileSetIcon BookmarkFile
bookmark Text
uri Maybe Text
href Text
mimeType = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    maybeHref <- case href of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jHref -> do
            jHref' <- Text -> IO CString
textToCString Text
jHref
            return jHref'
    mimeType' <- textToCString mimeType
    g_bookmark_file_set_icon bookmark' uri' maybeHref mimeType'
    touchManagedPtr bookmark
    freeMem uri'
    freeMem maybeHref
    freeMem mimeType'
    return ()

#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetIconMethodInfo
instance (signature ~ (T.Text -> Maybe (T.Text) -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetIconMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileSetIcon

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


#endif

-- method BookmarkFile::set_is_private
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "is_private"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE if the bookmark should be marked as private"
--                 , 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_bookmark_file_set_is_private" g_bookmark_file_set_is_private :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    CInt ->                                 -- is_private : TBasicType TBoolean
    IO ()

-- | Sets the private flag of the bookmark for /@uri@/.
-- 
-- If a bookmark for /@uri@/ cannot be found then it is created.
-- 
-- /Since: 2.12/
bookmarkFileSetIsPrivate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> Bool
    -- ^ /@isPrivate@/: 'P.True' if the bookmark should be marked as private
    -> m ()
bookmarkFileSetIsPrivate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Bool -> m ()
bookmarkFileSetIsPrivate BookmarkFile
bookmark Text
uri Bool
isPrivate = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    let isPrivate' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
isPrivate
    g_bookmark_file_set_is_private bookmark' uri' isPrivate'
    touchManagedPtr bookmark
    freeMem uri'
    return ()

#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetIsPrivateMethodInfo
instance (signature ~ (T.Text -> Bool -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetIsPrivateMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileSetIsPrivate

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


#endif

-- method BookmarkFile::set_mime_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mime_type"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a MIME type" , 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_bookmark_file_set_mime_type" g_bookmark_file_set_mime_type :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    CString ->                              -- mime_type : TBasicType TUTF8
    IO ()

-- | Sets /@mimeType@/ as the MIME type of the bookmark for /@uri@/.
-- 
-- If a bookmark for /@uri@/ cannot be found then it is created.
-- 
-- /Since: 2.12/
bookmarkFileSetMimeType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> T.Text
    -- ^ /@mimeType@/: a MIME type
    -> m ()
bookmarkFileSetMimeType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileSetMimeType BookmarkFile
bookmark Text
uri Text
mimeType = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    mimeType' <- textToCString mimeType
    g_bookmark_file_set_mime_type bookmark' uri' mimeType'
    touchManagedPtr bookmark
    freeMem uri'
    freeMem mimeType'
    return ()

#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetMimeTypeMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetMimeTypeMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileSetMimeType

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


#endif

-- method BookmarkFile::set_modified
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "modified"
--           , argType = TBasicType Ttime_t
--           , argCType = Just "time_t"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a timestamp or -1 to use the current time"
--                 , 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_bookmark_file_set_modified" g_bookmark_file_set_modified :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    FCT.CTime ->                            -- modified : TBasicType Ttime_t
    IO ()

{-# DEPRECATED bookmarkFileSetModified ["(Since version 2.66)","Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileSetModifiedDateTime' instead, as","   @time_t@ is deprecated due to the year 2038 problem."] #-}
-- | Sets the last time the bookmark for /@uri@/ was last modified.
-- 
-- If no bookmark for /@uri@/ is found then it is created.
-- 
-- The \"modified\" time should only be set when the bookmark\'s meta-data
-- was actually changed.  Every function of t'GI.GLib.Structs.BookmarkFile.BookmarkFile' that
-- modifies a bookmark also changes the modification time, except for
-- 'GI.GLib.Structs.BookmarkFile.bookmarkFileSetVisitedDateTime'.
-- 
-- /Since: 2.12/
bookmarkFileSetModified ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> FCT.CTime
    -- ^ /@modified@/: a timestamp or -1 to use the current time
    -> m ()
bookmarkFileSetModified :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> CTime -> m ()
bookmarkFileSetModified BookmarkFile
bookmark Text
uri CTime
modified = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    g_bookmark_file_set_modified bookmark' uri' modified
    touchManagedPtr bookmark
    freeMem uri'
    return ()

#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetModifiedMethodInfo
instance (signature ~ (T.Text -> FCT.CTime -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetModifiedMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileSetModified

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


#endif

-- method BookmarkFile::set_modified_date_time
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "modified"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DateTime" }
--           , argCType = Just "GDateTime*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GDateTime" , 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_bookmark_file_set_modified_date_time" g_bookmark_file_set_modified_date_time :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr GLib.DateTime.DateTime ->           -- modified : TInterface (Name {namespace = "GLib", name = "DateTime"})
    IO ()

-- | Sets the last time the bookmark for /@uri@/ was last modified.
-- 
-- If no bookmark for /@uri@/ is found then it is created.
-- 
-- The \"modified\" time should only be set when the bookmark\'s meta-data
-- was actually changed.  Every function of t'GI.GLib.Structs.BookmarkFile.BookmarkFile' that
-- modifies a bookmark also changes the modification time, except for
-- 'GI.GLib.Structs.BookmarkFile.bookmarkFileSetVisitedDateTime'.
-- 
-- /Since: 2.66/
bookmarkFileSetModifiedDateTime ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> GLib.DateTime.DateTime
    -- ^ /@modified@/: a t'GI.GLib.Structs.DateTime.DateTime'
    -> m ()
bookmarkFileSetModifiedDateTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> DateTime -> m ()
bookmarkFileSetModifiedDateTime BookmarkFile
bookmark Text
uri DateTime
modified = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    modified' <- unsafeManagedPtrGetPtr modified
    g_bookmark_file_set_modified_date_time bookmark' uri' modified'
    touchManagedPtr bookmark
    touchManagedPtr modified
    freeMem uri'
    return ()

#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetModifiedDateTimeMethodInfo
instance (signature ~ (T.Text -> GLib.DateTime.DateTime -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetModifiedDateTimeMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileSetModifiedDateTime

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


#endif

-- method BookmarkFile::set_title
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "title"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a UTF-8 encoded string"
--                 , 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_bookmark_file_set_title" g_bookmark_file_set_title :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    CString ->                              -- title : TBasicType TUTF8
    IO ()

-- | Sets /@title@/ as the title of the bookmark for /@uri@/ inside the
-- bookmark file /@bookmark@/.
-- 
-- If /@uri@/ is 'P.Nothing', the title of /@bookmark@/ is set.
-- 
-- If a bookmark for /@uri@/ cannot be found then it is created.
-- 
-- /Since: 2.12/
bookmarkFileSetTitle ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> Maybe (T.Text)
    -- ^ /@uri@/: a valid URI or 'P.Nothing'
    -> T.Text
    -- ^ /@title@/: a UTF-8 encoded string
    -> m ()
bookmarkFileSetTitle :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Maybe Text -> Text -> m ()
bookmarkFileSetTitle BookmarkFile
bookmark Maybe Text
uri Text
title = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    maybeUri <- case uri of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jUri -> do
            jUri' <- Text -> IO CString
textToCString Text
jUri
            return jUri'
    title' <- textToCString title
    g_bookmark_file_set_title bookmark' maybeUri title'
    touchManagedPtr bookmark
    freeMem maybeUri
    freeMem title'
    return ()

#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetTitleMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetTitleMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileSetTitle

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


#endif

-- method BookmarkFile::set_visited
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "visited"
--           , argType = TBasicType Ttime_t
--           , argCType = Just "time_t"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a timestamp or -1 to use the current time"
--                 , 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_bookmark_file_set_visited" g_bookmark_file_set_visited :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    FCT.CTime ->                            -- visited : TBasicType Ttime_t
    IO ()

{-# DEPRECATED bookmarkFileSetVisited ["(Since version 2.66)","Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileSetVisitedDateTime' instead, as","   @time_t@ is deprecated due to the year 2038 problem."] #-}
-- | Sets the time the bookmark for /@uri@/ was last visited.
-- 
-- If no bookmark for /@uri@/ is found then it is created.
-- 
-- The \"visited\" time should only be set if the bookmark was launched,
-- either using the command line retrieved by 'GI.GLib.Structs.BookmarkFile.bookmarkFileGetApplicationInfo'
-- or by the default application for the bookmark\'s MIME type, retrieved
-- using 'GI.GLib.Structs.BookmarkFile.bookmarkFileGetMimeType'.  Changing the \"visited\" time
-- does not affect the \"modified\" time.
-- 
-- /Since: 2.12/
bookmarkFileSetVisited ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> FCT.CTime
    -- ^ /@visited@/: a timestamp or -1 to use the current time
    -> m ()
bookmarkFileSetVisited :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> CTime -> m ()
bookmarkFileSetVisited BookmarkFile
bookmark Text
uri CTime
visited = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    g_bookmark_file_set_visited bookmark' uri' visited
    touchManagedPtr bookmark
    freeMem uri'
    return ()

#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetVisitedMethodInfo
instance (signature ~ (T.Text -> FCT.CTime -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetVisitedMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileSetVisited

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


#endif

-- method BookmarkFile::set_visited_date_time
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "visited"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DateTime" }
--           , argCType = Just "GDateTime*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GDateTime" , 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_bookmark_file_set_visited_date_time" g_bookmark_file_set_visited_date_time :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- uri : TBasicType TUTF8
    Ptr GLib.DateTime.DateTime ->           -- visited : TInterface (Name {namespace = "GLib", name = "DateTime"})
    IO ()

-- | Sets the time the bookmark for /@uri@/ was last visited.
-- 
-- If no bookmark for /@uri@/ is found then it is created.
-- 
-- The \"visited\" time should only be set if the bookmark was launched,
-- either using the command line retrieved by 'GI.GLib.Structs.BookmarkFile.bookmarkFileGetApplicationInfo'
-- or by the default application for the bookmark\'s MIME type, retrieved
-- using 'GI.GLib.Structs.BookmarkFile.bookmarkFileGetMimeType'.  Changing the \"visited\" time
-- does not affect the \"modified\" time.
-- 
-- /Since: 2.66/
bookmarkFileSetVisitedDateTime ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> T.Text
    -- ^ /@uri@/: a valid URI
    -> GLib.DateTime.DateTime
    -- ^ /@visited@/: a t'GI.GLib.Structs.DateTime.DateTime'
    -> m ()
bookmarkFileSetVisitedDateTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> DateTime -> m ()
bookmarkFileSetVisitedDateTime BookmarkFile
bookmark Text
uri DateTime
visited = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    uri' <- textToCString uri
    visited' <- unsafeManagedPtrGetPtr visited
    g_bookmark_file_set_visited_date_time bookmark' uri' visited'
    touchManagedPtr bookmark
    touchManagedPtr visited
    freeMem uri'
    return ()

#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetVisitedDateTimeMethodInfo
instance (signature ~ (T.Text -> GLib.DateTime.DateTime -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetVisitedDateTimeMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileSetVisitedDateTime

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


#endif

-- method BookmarkFile::to_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TSize
--           , argCType = Just "gsize*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the length of the returned string, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "length"
--              , argType = TBasicType TSize
--              , argCType = Just "gsize*"
--              , direction = DirectionOut
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText =
--                        Just
--                          "return location for the length of the returned string, or %NULL"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferEverything
--              }
--          ]
-- returnType: Just (TCArray False (-1) 1 (TBasicType TUInt8))
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_to_data" g_bookmark_file_to_data :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    Ptr FCT.CSize ->                        -- length : TBasicType TSize
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Word8)

-- | This function outputs /@bookmark@/ as a string.
-- 
-- /Since: 2.12/
bookmarkFileToData ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> m ByteString
    -- ^ __Returns:__ 
    --   a newly allocated string holding the contents of the t'GI.GLib.Structs.BookmarkFile.BookmarkFile' /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileToData :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> m ByteString
bookmarkFileToData BookmarkFile
bookmark = IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ do
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    length_ <- allocMem :: IO (Ptr FCT.CSize)
    onException (do
        result <- propagateGError $ g_bookmark_file_to_data bookmark' length_
        length_' <- peek length_
        checkUnexpectedReturnNULL "bookmarkFileToData" result
        result' <- (unpackByteStringWithLength length_') result
        freeMem result
        touchManagedPtr bookmark
        freeMem length_
        return result'
     ) (do
        freeMem length_
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileToDataMethodInfo
instance (signature ~ (m ByteString), MonadIO m) => O.OverloadedMethod BookmarkFileToDataMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileToData

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


#endif

-- method BookmarkFile::to_file
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bookmark"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "BookmarkFile" }
--           , argCType = Just "GBookmarkFile*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBookmarkFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "filename"
--           , argType = TBasicType TFileName
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "path of the output file"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_bookmark_file_to_file" g_bookmark_file_to_file :: 
    Ptr BookmarkFile ->                     -- bookmark : TInterface (Name {namespace = "GLib", name = "BookmarkFile"})
    CString ->                              -- filename : TBasicType TFileName
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | This function outputs /@bookmark@/ into a file.  The write process is
-- guaranteed to be atomic by using 'GI.GLib.Functions.fileSetContents' internally.
-- 
-- /Since: 2.12/
bookmarkFileToFile ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BookmarkFile
    -- ^ /@bookmark@/: a t'GI.GLib.Structs.BookmarkFile.BookmarkFile'
    -> [Char]
    -- ^ /@filename@/: path of the output file
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
bookmarkFileToFile :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> String -> m ()
bookmarkFileToFile BookmarkFile
bookmark String
filename = 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
    bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
    filename' <- stringToCString filename
    onException (do
        _ <- propagateGError $ g_bookmark_file_to_file bookmark' filename'
        touchManagedPtr bookmark
        freeMem filename'
        return ()
     ) (do
        freeMem filename'
     )

#if defined(ENABLE_OVERLOADING)
data BookmarkFileToFileMethodInfo
instance (signature ~ ([Char] -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileToFileMethodInfo BookmarkFile signature where
    overloadedMethod = bookmarkFileToFile

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


#endif

-- method BookmarkFile::error_quark
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just (TBasicType TUInt32)
-- throws : False
-- Skip return : False

foreign import ccall "g_bookmark_file_error_quark" g_bookmark_file_error_quark :: 
    IO Word32

-- | /No description available in the introspection data./
bookmarkFileErrorQuark ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Word32
bookmarkFileErrorQuark :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
bookmarkFileErrorQuark  = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    result <- IO Word32
g_bookmark_file_error_quark
    return result

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveBookmarkFileMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveBookmarkFileMethod "addApplication" o = BookmarkFileAddApplicationMethodInfo
    ResolveBookmarkFileMethod "addGroup" o = BookmarkFileAddGroupMethodInfo
    ResolveBookmarkFileMethod "copy" o = BookmarkFileCopyMethodInfo
    ResolveBookmarkFileMethod "free" o = BookmarkFileFreeMethodInfo
    ResolveBookmarkFileMethod "hasApplication" o = BookmarkFileHasApplicationMethodInfo
    ResolveBookmarkFileMethod "hasGroup" o = BookmarkFileHasGroupMethodInfo
    ResolveBookmarkFileMethod "hasItem" o = BookmarkFileHasItemMethodInfo
    ResolveBookmarkFileMethod "loadFromData" o = BookmarkFileLoadFromDataMethodInfo
    ResolveBookmarkFileMethod "loadFromDataDirs" o = BookmarkFileLoadFromDataDirsMethodInfo
    ResolveBookmarkFileMethod "loadFromFile" o = BookmarkFileLoadFromFileMethodInfo
    ResolveBookmarkFileMethod "moveItem" o = BookmarkFileMoveItemMethodInfo
    ResolveBookmarkFileMethod "removeApplication" o = BookmarkFileRemoveApplicationMethodInfo
    ResolveBookmarkFileMethod "removeGroup" o = BookmarkFileRemoveGroupMethodInfo
    ResolveBookmarkFileMethod "removeItem" o = BookmarkFileRemoveItemMethodInfo
    ResolveBookmarkFileMethod "toData" o = BookmarkFileToDataMethodInfo
    ResolveBookmarkFileMethod "toFile" o = BookmarkFileToFileMethodInfo
    ResolveBookmarkFileMethod "getAdded" o = BookmarkFileGetAddedMethodInfo
    ResolveBookmarkFileMethod "getAddedDateTime" o = BookmarkFileGetAddedDateTimeMethodInfo
    ResolveBookmarkFileMethod "getAppInfo" o = BookmarkFileGetAppInfoMethodInfo
    ResolveBookmarkFileMethod "getApplicationInfo" o = BookmarkFileGetApplicationInfoMethodInfo
    ResolveBookmarkFileMethod "getApplications" o = BookmarkFileGetApplicationsMethodInfo
    ResolveBookmarkFileMethod "getDescription" o = BookmarkFileGetDescriptionMethodInfo
    ResolveBookmarkFileMethod "getGroups" o = BookmarkFileGetGroupsMethodInfo
    ResolveBookmarkFileMethod "getIcon" o = BookmarkFileGetIconMethodInfo
    ResolveBookmarkFileMethod "getIsPrivate" o = BookmarkFileGetIsPrivateMethodInfo
    ResolveBookmarkFileMethod "getMimeType" o = BookmarkFileGetMimeTypeMethodInfo
    ResolveBookmarkFileMethod "getModified" o = BookmarkFileGetModifiedMethodInfo
    ResolveBookmarkFileMethod "getModifiedDateTime" o = BookmarkFileGetModifiedDateTimeMethodInfo
    ResolveBookmarkFileMethod "getSize" o = BookmarkFileGetSizeMethodInfo
    ResolveBookmarkFileMethod "getTitle" o = BookmarkFileGetTitleMethodInfo
    ResolveBookmarkFileMethod "getUris" o = BookmarkFileGetUrisMethodInfo
    ResolveBookmarkFileMethod "getVisited" o = BookmarkFileGetVisitedMethodInfo
    ResolveBookmarkFileMethod "getVisitedDateTime" o = BookmarkFileGetVisitedDateTimeMethodInfo
    ResolveBookmarkFileMethod "setAdded" o = BookmarkFileSetAddedMethodInfo
    ResolveBookmarkFileMethod "setAddedDateTime" o = BookmarkFileSetAddedDateTimeMethodInfo
    ResolveBookmarkFileMethod "setAppInfo" o = BookmarkFileSetAppInfoMethodInfo
    ResolveBookmarkFileMethod "setApplicationInfo" o = BookmarkFileSetApplicationInfoMethodInfo
    ResolveBookmarkFileMethod "setDescription" o = BookmarkFileSetDescriptionMethodInfo
    ResolveBookmarkFileMethod "setGroups" o = BookmarkFileSetGroupsMethodInfo
    ResolveBookmarkFileMethod "setIcon" o = BookmarkFileSetIconMethodInfo
    ResolveBookmarkFileMethod "setIsPrivate" o = BookmarkFileSetIsPrivateMethodInfo
    ResolveBookmarkFileMethod "setMimeType" o = BookmarkFileSetMimeTypeMethodInfo
    ResolveBookmarkFileMethod "setModified" o = BookmarkFileSetModifiedMethodInfo
    ResolveBookmarkFileMethod "setModifiedDateTime" o = BookmarkFileSetModifiedDateTimeMethodInfo
    ResolveBookmarkFileMethod "setTitle" o = BookmarkFileSetTitleMethodInfo
    ResolveBookmarkFileMethod "setVisited" o = BookmarkFileSetVisitedMethodInfo
    ResolveBookmarkFileMethod "setVisitedDateTime" o = BookmarkFileSetVisitedDateTimeMethodInfo
    ResolveBookmarkFileMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif