{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.WebKit2.Objects.WebsiteDataManager
    ( 

-- * Exported types
    WebsiteDataManager(..)                  ,
    IsWebsiteDataManager                    ,
    toWebsiteDataManager                    ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [clear]("GI.WebKit2.Objects.WebsiteDataManager#g:method:clear"), [clearFinish]("GI.WebKit2.Objects.WebsiteDataManager#g:method:clearFinish"), [fetch]("GI.WebKit2.Objects.WebsiteDataManager#g:method:fetch"), [fetchFinish]("GI.WebKit2.Objects.WebsiteDataManager#g:method:fetchFinish"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isEphemeral]("GI.WebKit2.Objects.WebsiteDataManager#g:method:isEphemeral"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [remove]("GI.WebKit2.Objects.WebsiteDataManager#g:method:remove"), [removeFinish]("GI.WebKit2.Objects.WebsiteDataManager#g:method:removeFinish"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getBaseCacheDirectory]("GI.WebKit2.Objects.WebsiteDataManager#g:method:getBaseCacheDirectory"), [getBaseDataDirectory]("GI.WebKit2.Objects.WebsiteDataManager#g:method:getBaseDataDirectory"), [getCookieManager]("GI.WebKit2.Objects.WebsiteDataManager#g:method:getCookieManager"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDiskCacheDirectory]("GI.WebKit2.Objects.WebsiteDataManager#g:method:getDiskCacheDirectory"), [getDomCacheDirectory]("GI.WebKit2.Objects.WebsiteDataManager#g:method:getDomCacheDirectory"), [getHstsCacheDirectory]("GI.WebKit2.Objects.WebsiteDataManager#g:method:getHstsCacheDirectory"), [getIndexeddbDirectory]("GI.WebKit2.Objects.WebsiteDataManager#g:method:getIndexeddbDirectory"), [getItpDirectory]("GI.WebKit2.Objects.WebsiteDataManager#g:method:getItpDirectory"), [getItpEnabled]("GI.WebKit2.Objects.WebsiteDataManager#g:method:getItpEnabled"), [getItpSummary]("GI.WebKit2.Objects.WebsiteDataManager#g:method:getItpSummary"), [getItpSummaryFinish]("GI.WebKit2.Objects.WebsiteDataManager#g:method:getItpSummaryFinish"), [getLocalStorageDirectory]("GI.WebKit2.Objects.WebsiteDataManager#g:method:getLocalStorageDirectory"), [getOfflineApplicationCacheDirectory]("GI.WebKit2.Objects.WebsiteDataManager#g:method:getOfflineApplicationCacheDirectory"), [getPersistentCredentialStorageEnabled]("GI.WebKit2.Objects.WebsiteDataManager#g:method:getPersistentCredentialStorageEnabled"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getServiceWorkerRegistrationsDirectory]("GI.WebKit2.Objects.WebsiteDataManager#g:method:getServiceWorkerRegistrationsDirectory"), [getWebsqlDirectory]("GI.WebKit2.Objects.WebsiteDataManager#g:method:getWebsqlDirectory").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setItpEnabled]("GI.WebKit2.Objects.WebsiteDataManager#g:method:setItpEnabled"), [setPersistentCredentialStorageEnabled]("GI.WebKit2.Objects.WebsiteDataManager#g:method:setPersistentCredentialStorageEnabled"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveWebsiteDataManagerMethod         ,
#endif

-- ** clear #method:clear#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerClearMethodInfo       ,
#endif
    websiteDataManagerClear                 ,


-- ** clearFinish #method:clearFinish#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerClearFinishMethodInfo ,
#endif
    websiteDataManagerClearFinish           ,


-- ** fetch #method:fetch#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerFetchMethodInfo       ,
#endif
    websiteDataManagerFetch                 ,


-- ** fetchFinish #method:fetchFinish#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerFetchFinishMethodInfo ,
#endif
    websiteDataManagerFetchFinish           ,


-- ** getBaseCacheDirectory #method:getBaseCacheDirectory#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerGetBaseCacheDirectoryMethodInfo,
#endif
    websiteDataManagerGetBaseCacheDirectory ,


-- ** getBaseDataDirectory #method:getBaseDataDirectory#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerGetBaseDataDirectoryMethodInfo,
#endif
    websiteDataManagerGetBaseDataDirectory  ,


-- ** getCookieManager #method:getCookieManager#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerGetCookieManagerMethodInfo,
#endif
    websiteDataManagerGetCookieManager      ,


-- ** getDiskCacheDirectory #method:getDiskCacheDirectory#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerGetDiskCacheDirectoryMethodInfo,
#endif
    websiteDataManagerGetDiskCacheDirectory ,


-- ** getDomCacheDirectory #method:getDomCacheDirectory#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerGetDomCacheDirectoryMethodInfo,
#endif
    websiteDataManagerGetDomCacheDirectory  ,


-- ** getHstsCacheDirectory #method:getHstsCacheDirectory#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerGetHstsCacheDirectoryMethodInfo,
#endif
    websiteDataManagerGetHstsCacheDirectory ,


-- ** getIndexeddbDirectory #method:getIndexeddbDirectory#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerGetIndexeddbDirectoryMethodInfo,
#endif
    websiteDataManagerGetIndexeddbDirectory ,


-- ** getItpDirectory #method:getItpDirectory#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerGetItpDirectoryMethodInfo,
#endif
    websiteDataManagerGetItpDirectory       ,


-- ** getItpEnabled #method:getItpEnabled#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerGetItpEnabledMethodInfo,
#endif
    websiteDataManagerGetItpEnabled         ,


-- ** getItpSummary #method:getItpSummary#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerGetItpSummaryMethodInfo,
#endif
    websiteDataManagerGetItpSummary         ,


-- ** getItpSummaryFinish #method:getItpSummaryFinish#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerGetItpSummaryFinishMethodInfo,
#endif
    websiteDataManagerGetItpSummaryFinish   ,


-- ** getLocalStorageDirectory #method:getLocalStorageDirectory#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerGetLocalStorageDirectoryMethodInfo,
#endif
    websiteDataManagerGetLocalStorageDirectory,


-- ** getOfflineApplicationCacheDirectory #method:getOfflineApplicationCacheDirectory#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerGetOfflineApplicationCacheDirectoryMethodInfo,
#endif
    websiteDataManagerGetOfflineApplicationCacheDirectory,


-- ** getPersistentCredentialStorageEnabled #method:getPersistentCredentialStorageEnabled#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerGetPersistentCredentialStorageEnabledMethodInfo,
#endif
    websiteDataManagerGetPersistentCredentialStorageEnabled,


-- ** getServiceWorkerRegistrationsDirectory #method:getServiceWorkerRegistrationsDirectory#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerGetServiceWorkerRegistrationsDirectoryMethodInfo,
#endif
    websiteDataManagerGetServiceWorkerRegistrationsDirectory,


-- ** getWebsqlDirectory #method:getWebsqlDirectory#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerGetWebsqlDirectoryMethodInfo,
#endif
    websiteDataManagerGetWebsqlDirectory    ,


-- ** isEphemeral #method:isEphemeral#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerIsEphemeralMethodInfo ,
#endif
    websiteDataManagerIsEphemeral           ,


-- ** newEphemeral #method:newEphemeral#

    websiteDataManagerNewEphemeral          ,


-- ** remove #method:remove#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerRemoveMethodInfo      ,
#endif
    websiteDataManagerRemove                ,


-- ** removeFinish #method:removeFinish#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerRemoveFinishMethodInfo,
#endif
    websiteDataManagerRemoveFinish          ,


-- ** setItpEnabled #method:setItpEnabled#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerSetItpEnabledMethodInfo,
#endif
    websiteDataManagerSetItpEnabled         ,


-- ** setPersistentCredentialStorageEnabled #method:setPersistentCredentialStorageEnabled#

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerSetPersistentCredentialStorageEnabledMethodInfo,
#endif
    websiteDataManagerSetPersistentCredentialStorageEnabled,




 -- * Properties


-- ** baseCacheDirectory #attr:baseCacheDirectory#
-- | The base directory for Website cache. This is used as a base directory
-- for any Website cache when no specific cache directory has been provided.
-- 
-- /Since: 2.10/

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerBaseCacheDirectoryPropertyInfo,
#endif
    constructWebsiteDataManagerBaseCacheDirectory,
    getWebsiteDataManagerBaseCacheDirectory ,
#if defined(ENABLE_OVERLOADING)
    websiteDataManagerBaseCacheDirectory    ,
#endif


-- ** baseDataDirectory #attr:baseDataDirectory#
-- | The base directory for Website data. This is used as a base directory
-- for any Website data when no specific data directory has been provided.
-- 
-- /Since: 2.10/

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerBaseDataDirectoryPropertyInfo,
#endif
    constructWebsiteDataManagerBaseDataDirectory,
    getWebsiteDataManagerBaseDataDirectory  ,
#if defined(ENABLE_OVERLOADING)
    websiteDataManagerBaseDataDirectory     ,
#endif


-- ** diskCacheDirectory #attr:diskCacheDirectory#
-- | The directory where HTTP disk cache will be stored.
-- 
-- /Since: 2.10/

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerDiskCacheDirectoryPropertyInfo,
#endif
    constructWebsiteDataManagerDiskCacheDirectory,
    getWebsiteDataManagerDiskCacheDirectory ,
#if defined(ENABLE_OVERLOADING)
    websiteDataManagerDiskCacheDirectory    ,
#endif


-- ** domCacheDirectory #attr:domCacheDirectory#
-- | The directory where DOM cache will be stored.
-- 
-- /Since: 2.30/

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerDomCacheDirectoryPropertyInfo,
#endif
    constructWebsiteDataManagerDomCacheDirectory,
    getWebsiteDataManagerDomCacheDirectory  ,
#if defined(ENABLE_OVERLOADING)
    websiteDataManagerDomCacheDirectory     ,
#endif


-- ** hstsCacheDirectory #attr:hstsCacheDirectory#
-- | The directory where the HTTP Strict-Transport-Security (HSTS) cache will be stored.
-- 
-- /Since: 2.26/

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerHstsCacheDirectoryPropertyInfo,
#endif
    constructWebsiteDataManagerHstsCacheDirectory,
    getWebsiteDataManagerHstsCacheDirectory ,
#if defined(ENABLE_OVERLOADING)
    websiteDataManagerHstsCacheDirectory    ,
#endif


-- ** indexeddbDirectory #attr:indexeddbDirectory#
-- | The directory where IndexedDB databases will be stored.
-- 
-- /Since: 2.10/

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerIndexeddbDirectoryPropertyInfo,
#endif
    constructWebsiteDataManagerIndexeddbDirectory,
    getWebsiteDataManagerIndexeddbDirectory ,
#if defined(ENABLE_OVERLOADING)
    websiteDataManagerIndexeddbDirectory    ,
#endif


-- ** isEphemeral #attr:isEphemeral#
-- | Whether the t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' is ephemeral. An ephemeral t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
-- handles all websites data as non-persistent, and nothing will be written to the client
-- storage. Note that if you create an ephemeral t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' all other construction
-- parameters to configure data directories will be ignored.
-- 
-- /Since: 2.16/

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerIsEphemeralPropertyInfo,
#endif
    constructWebsiteDataManagerIsEphemeral  ,
    getWebsiteDataManagerIsEphemeral        ,


-- ** itpDirectory #attr:itpDirectory#
-- | The directory where Intelligent Tracking Prevention (ITP) data will be stored.
-- 
-- /Since: 2.30/

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerItpDirectoryPropertyInfo,
#endif
    constructWebsiteDataManagerItpDirectory ,
    getWebsiteDataManagerItpDirectory       ,
#if defined(ENABLE_OVERLOADING)
    websiteDataManagerItpDirectory          ,
#endif


-- ** localStorageDirectory #attr:localStorageDirectory#
-- | The directory where local storage data will be stored.
-- 
-- /Since: 2.10/

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerLocalStorageDirectoryPropertyInfo,
#endif
    constructWebsiteDataManagerLocalStorageDirectory,
    getWebsiteDataManagerLocalStorageDirectory,
#if defined(ENABLE_OVERLOADING)
    websiteDataManagerLocalStorageDirectory ,
#endif


-- ** offlineApplicationCacheDirectory #attr:offlineApplicationCacheDirectory#
-- | The directory where offline web application cache will be stored.
-- 
-- /Since: 2.10/

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo,
#endif
    constructWebsiteDataManagerOfflineApplicationCacheDirectory,
    getWebsiteDataManagerOfflineApplicationCacheDirectory,
#if defined(ENABLE_OVERLOADING)
    websiteDataManagerOfflineApplicationCacheDirectory,
#endif


-- ** serviceWorkerRegistrationsDirectory #attr:serviceWorkerRegistrationsDirectory#
-- | The directory where service workers registrations will be stored.
-- 
-- /Since: 2.30/

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerServiceWorkerRegistrationsDirectoryPropertyInfo,
#endif
    constructWebsiteDataManagerServiceWorkerRegistrationsDirectory,
    getWebsiteDataManagerServiceWorkerRegistrationsDirectory,
#if defined(ENABLE_OVERLOADING)
    websiteDataManagerServiceWorkerRegistrationsDirectory,
#endif


-- ** websqlDirectory #attr:websqlDirectory#
-- | The directory where WebSQL databases will be stored.
-- 
-- /Since: 2.10/

#if defined(ENABLE_OVERLOADING)
    WebsiteDataManagerWebsqlDirectoryPropertyInfo,
#endif
    constructWebsiteDataManagerWebsqlDirectory,
    getWebsiteDataManagerWebsqlDirectory    ,
#if defined(ENABLE_OVERLOADING)
    websiteDataManagerWebsqlDirectory       ,
#endif




    ) 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.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.Text as T
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 GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.WebKit2.Flags as WebKit2.Flags
import {-# SOURCE #-} qualified GI.WebKit2.Objects.CookieManager as WebKit2.CookieManager
import {-# SOURCE #-} qualified GI.WebKit2.Structs.ITPThirdParty as WebKit2.ITPThirdParty
import {-# SOURCE #-} qualified GI.WebKit2.Structs.WebsiteData as WebKit2.WebsiteData

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

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

foreign import ccall "webkit_website_data_manager_get_type"
    c_webkit_website_data_manager_get_type :: IO B.Types.GType

instance B.Types.TypedObject WebsiteDataManager where
    glibType :: IO GType
glibType = IO GType
c_webkit_website_data_manager_get_type

instance B.Types.GObject WebsiteDataManager

-- | Type class for types which can be safely cast to `WebsiteDataManager`, for instance with `toWebsiteDataManager`.
class (SP.GObject o, O.IsDescendantOf WebsiteDataManager o) => IsWebsiteDataManager o
instance (SP.GObject o, O.IsDescendantOf WebsiteDataManager o) => IsWebsiteDataManager o

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

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveWebsiteDataManagerMethod (t :: Symbol) (o :: *) :: * where
    ResolveWebsiteDataManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveWebsiteDataManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveWebsiteDataManagerMethod "clear" o = WebsiteDataManagerClearMethodInfo
    ResolveWebsiteDataManagerMethod "clearFinish" o = WebsiteDataManagerClearFinishMethodInfo
    ResolveWebsiteDataManagerMethod "fetch" o = WebsiteDataManagerFetchMethodInfo
    ResolveWebsiteDataManagerMethod "fetchFinish" o = WebsiteDataManagerFetchFinishMethodInfo
    ResolveWebsiteDataManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveWebsiteDataManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveWebsiteDataManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveWebsiteDataManagerMethod "isEphemeral" o = WebsiteDataManagerIsEphemeralMethodInfo
    ResolveWebsiteDataManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveWebsiteDataManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveWebsiteDataManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveWebsiteDataManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveWebsiteDataManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveWebsiteDataManagerMethod "remove" o = WebsiteDataManagerRemoveMethodInfo
    ResolveWebsiteDataManagerMethod "removeFinish" o = WebsiteDataManagerRemoveFinishMethodInfo
    ResolveWebsiteDataManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveWebsiteDataManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveWebsiteDataManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveWebsiteDataManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveWebsiteDataManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveWebsiteDataManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveWebsiteDataManagerMethod "getBaseCacheDirectory" o = WebsiteDataManagerGetBaseCacheDirectoryMethodInfo
    ResolveWebsiteDataManagerMethod "getBaseDataDirectory" o = WebsiteDataManagerGetBaseDataDirectoryMethodInfo
    ResolveWebsiteDataManagerMethod "getCookieManager" o = WebsiteDataManagerGetCookieManagerMethodInfo
    ResolveWebsiteDataManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveWebsiteDataManagerMethod "getDiskCacheDirectory" o = WebsiteDataManagerGetDiskCacheDirectoryMethodInfo
    ResolveWebsiteDataManagerMethod "getDomCacheDirectory" o = WebsiteDataManagerGetDomCacheDirectoryMethodInfo
    ResolveWebsiteDataManagerMethod "getHstsCacheDirectory" o = WebsiteDataManagerGetHstsCacheDirectoryMethodInfo
    ResolveWebsiteDataManagerMethod "getIndexeddbDirectory" o = WebsiteDataManagerGetIndexeddbDirectoryMethodInfo
    ResolveWebsiteDataManagerMethod "getItpDirectory" o = WebsiteDataManagerGetItpDirectoryMethodInfo
    ResolveWebsiteDataManagerMethod "getItpEnabled" o = WebsiteDataManagerGetItpEnabledMethodInfo
    ResolveWebsiteDataManagerMethod "getItpSummary" o = WebsiteDataManagerGetItpSummaryMethodInfo
    ResolveWebsiteDataManagerMethod "getItpSummaryFinish" o = WebsiteDataManagerGetItpSummaryFinishMethodInfo
    ResolveWebsiteDataManagerMethod "getLocalStorageDirectory" o = WebsiteDataManagerGetLocalStorageDirectoryMethodInfo
    ResolveWebsiteDataManagerMethod "getOfflineApplicationCacheDirectory" o = WebsiteDataManagerGetOfflineApplicationCacheDirectoryMethodInfo
    ResolveWebsiteDataManagerMethod "getPersistentCredentialStorageEnabled" o = WebsiteDataManagerGetPersistentCredentialStorageEnabledMethodInfo
    ResolveWebsiteDataManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveWebsiteDataManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveWebsiteDataManagerMethod "getServiceWorkerRegistrationsDirectory" o = WebsiteDataManagerGetServiceWorkerRegistrationsDirectoryMethodInfo
    ResolveWebsiteDataManagerMethod "getWebsqlDirectory" o = WebsiteDataManagerGetWebsqlDirectoryMethodInfo
    ResolveWebsiteDataManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveWebsiteDataManagerMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveWebsiteDataManagerMethod "setItpEnabled" o = WebsiteDataManagerSetItpEnabledMethodInfo
    ResolveWebsiteDataManagerMethod "setPersistentCredentialStorageEnabled" o = WebsiteDataManagerSetPersistentCredentialStorageEnabledMethodInfo
    ResolveWebsiteDataManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveWebsiteDataManagerMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- VVV Prop "base-cache-directory"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

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

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

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerBaseCacheDirectoryPropertyInfo
instance AttrInfo WebsiteDataManagerBaseCacheDirectoryPropertyInfo where
    type AttrAllowedOps WebsiteDataManagerBaseCacheDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WebsiteDataManagerBaseCacheDirectoryPropertyInfo = IsWebsiteDataManager
    type AttrSetTypeConstraint WebsiteDataManagerBaseCacheDirectoryPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint WebsiteDataManagerBaseCacheDirectoryPropertyInfo = (~) T.Text
    type AttrTransferType WebsiteDataManagerBaseCacheDirectoryPropertyInfo = T.Text
    type AttrGetType WebsiteDataManagerBaseCacheDirectoryPropertyInfo = (Maybe T.Text)
    type AttrLabel WebsiteDataManagerBaseCacheDirectoryPropertyInfo = "base-cache-directory"
    type AttrOrigin WebsiteDataManagerBaseCacheDirectoryPropertyInfo = WebsiteDataManager
    attrGet = getWebsiteDataManagerBaseCacheDirectory
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructWebsiteDataManagerBaseCacheDirectory
    attrClear = undefined
#endif

-- VVV Prop "base-data-directory"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

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

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

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerBaseDataDirectoryPropertyInfo
instance AttrInfo WebsiteDataManagerBaseDataDirectoryPropertyInfo where
    type AttrAllowedOps WebsiteDataManagerBaseDataDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WebsiteDataManagerBaseDataDirectoryPropertyInfo = IsWebsiteDataManager
    type AttrSetTypeConstraint WebsiteDataManagerBaseDataDirectoryPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint WebsiteDataManagerBaseDataDirectoryPropertyInfo = (~) T.Text
    type AttrTransferType WebsiteDataManagerBaseDataDirectoryPropertyInfo = T.Text
    type AttrGetType WebsiteDataManagerBaseDataDirectoryPropertyInfo = (Maybe T.Text)
    type AttrLabel WebsiteDataManagerBaseDataDirectoryPropertyInfo = "base-data-directory"
    type AttrOrigin WebsiteDataManagerBaseDataDirectoryPropertyInfo = WebsiteDataManager
    attrGet = getWebsiteDataManagerBaseDataDirectory
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructWebsiteDataManagerBaseDataDirectory
    attrClear = undefined
#endif

-- VVV Prop "disk-cache-directory"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

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

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

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerDiskCacheDirectoryPropertyInfo
instance AttrInfo WebsiteDataManagerDiskCacheDirectoryPropertyInfo where
    type AttrAllowedOps WebsiteDataManagerDiskCacheDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WebsiteDataManagerDiskCacheDirectoryPropertyInfo = IsWebsiteDataManager
    type AttrSetTypeConstraint WebsiteDataManagerDiskCacheDirectoryPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint WebsiteDataManagerDiskCacheDirectoryPropertyInfo = (~) T.Text
    type AttrTransferType WebsiteDataManagerDiskCacheDirectoryPropertyInfo = T.Text
    type AttrGetType WebsiteDataManagerDiskCacheDirectoryPropertyInfo = (Maybe T.Text)
    type AttrLabel WebsiteDataManagerDiskCacheDirectoryPropertyInfo = "disk-cache-directory"
    type AttrOrigin WebsiteDataManagerDiskCacheDirectoryPropertyInfo = WebsiteDataManager
    attrGet = getWebsiteDataManagerDiskCacheDirectory
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructWebsiteDataManagerDiskCacheDirectory
    attrClear = undefined
#endif

-- VVV Prop "dom-cache-directory"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

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

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

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerDomCacheDirectoryPropertyInfo
instance AttrInfo WebsiteDataManagerDomCacheDirectoryPropertyInfo where
    type AttrAllowedOps WebsiteDataManagerDomCacheDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WebsiteDataManagerDomCacheDirectoryPropertyInfo = IsWebsiteDataManager
    type AttrSetTypeConstraint WebsiteDataManagerDomCacheDirectoryPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint WebsiteDataManagerDomCacheDirectoryPropertyInfo = (~) T.Text
    type AttrTransferType WebsiteDataManagerDomCacheDirectoryPropertyInfo = T.Text
    type AttrGetType WebsiteDataManagerDomCacheDirectoryPropertyInfo = (Maybe T.Text)
    type AttrLabel WebsiteDataManagerDomCacheDirectoryPropertyInfo = "dom-cache-directory"
    type AttrOrigin WebsiteDataManagerDomCacheDirectoryPropertyInfo = WebsiteDataManager
    attrGet = getWebsiteDataManagerDomCacheDirectory
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructWebsiteDataManagerDomCacheDirectory
    attrClear = undefined
#endif

-- VVV Prop "hsts-cache-directory"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

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

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

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerHstsCacheDirectoryPropertyInfo
instance AttrInfo WebsiteDataManagerHstsCacheDirectoryPropertyInfo where
    type AttrAllowedOps WebsiteDataManagerHstsCacheDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WebsiteDataManagerHstsCacheDirectoryPropertyInfo = IsWebsiteDataManager
    type AttrSetTypeConstraint WebsiteDataManagerHstsCacheDirectoryPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint WebsiteDataManagerHstsCacheDirectoryPropertyInfo = (~) T.Text
    type AttrTransferType WebsiteDataManagerHstsCacheDirectoryPropertyInfo = T.Text
    type AttrGetType WebsiteDataManagerHstsCacheDirectoryPropertyInfo = (Maybe T.Text)
    type AttrLabel WebsiteDataManagerHstsCacheDirectoryPropertyInfo = "hsts-cache-directory"
    type AttrOrigin WebsiteDataManagerHstsCacheDirectoryPropertyInfo = WebsiteDataManager
    attrGet = getWebsiteDataManagerHstsCacheDirectory
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructWebsiteDataManagerHstsCacheDirectory
    attrClear = undefined
#endif

-- VVV Prop "indexeddb-directory"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

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

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

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerIndexeddbDirectoryPropertyInfo
instance AttrInfo WebsiteDataManagerIndexeddbDirectoryPropertyInfo where
    type AttrAllowedOps WebsiteDataManagerIndexeddbDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WebsiteDataManagerIndexeddbDirectoryPropertyInfo = IsWebsiteDataManager
    type AttrSetTypeConstraint WebsiteDataManagerIndexeddbDirectoryPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint WebsiteDataManagerIndexeddbDirectoryPropertyInfo = (~) T.Text
    type AttrTransferType WebsiteDataManagerIndexeddbDirectoryPropertyInfo = T.Text
    type AttrGetType WebsiteDataManagerIndexeddbDirectoryPropertyInfo = (Maybe T.Text)
    type AttrLabel WebsiteDataManagerIndexeddbDirectoryPropertyInfo = "indexeddb-directory"
    type AttrOrigin WebsiteDataManagerIndexeddbDirectoryPropertyInfo = WebsiteDataManager
    attrGet = getWebsiteDataManagerIndexeddbDirectory
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructWebsiteDataManagerIndexeddbDirectory
    attrClear = undefined
#endif

-- VVV Prop "is-ephemeral"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

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

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

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerIsEphemeralPropertyInfo
instance AttrInfo WebsiteDataManagerIsEphemeralPropertyInfo where
    type AttrAllowedOps WebsiteDataManagerIsEphemeralPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint WebsiteDataManagerIsEphemeralPropertyInfo = IsWebsiteDataManager
    type AttrSetTypeConstraint WebsiteDataManagerIsEphemeralPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint WebsiteDataManagerIsEphemeralPropertyInfo = (~) Bool
    type AttrTransferType WebsiteDataManagerIsEphemeralPropertyInfo = Bool
    type AttrGetType WebsiteDataManagerIsEphemeralPropertyInfo = Bool
    type AttrLabel WebsiteDataManagerIsEphemeralPropertyInfo = "is-ephemeral"
    type AttrOrigin WebsiteDataManagerIsEphemeralPropertyInfo = WebsiteDataManager
    attrGet = getWebsiteDataManagerIsEphemeral
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructWebsiteDataManagerIsEphemeral
    attrClear = undefined
#endif

-- VVV Prop "itp-directory"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

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

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

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerItpDirectoryPropertyInfo
instance AttrInfo WebsiteDataManagerItpDirectoryPropertyInfo where
    type AttrAllowedOps WebsiteDataManagerItpDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WebsiteDataManagerItpDirectoryPropertyInfo = IsWebsiteDataManager
    type AttrSetTypeConstraint WebsiteDataManagerItpDirectoryPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint WebsiteDataManagerItpDirectoryPropertyInfo = (~) T.Text
    type AttrTransferType WebsiteDataManagerItpDirectoryPropertyInfo = T.Text
    type AttrGetType WebsiteDataManagerItpDirectoryPropertyInfo = (Maybe T.Text)
    type AttrLabel WebsiteDataManagerItpDirectoryPropertyInfo = "itp-directory"
    type AttrOrigin WebsiteDataManagerItpDirectoryPropertyInfo = WebsiteDataManager
    attrGet = getWebsiteDataManagerItpDirectory
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructWebsiteDataManagerItpDirectory
    attrClear = undefined
#endif

-- VVV Prop "local-storage-directory"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

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

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

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerLocalStorageDirectoryPropertyInfo
instance AttrInfo WebsiteDataManagerLocalStorageDirectoryPropertyInfo where
    type AttrAllowedOps WebsiteDataManagerLocalStorageDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WebsiteDataManagerLocalStorageDirectoryPropertyInfo = IsWebsiteDataManager
    type AttrSetTypeConstraint WebsiteDataManagerLocalStorageDirectoryPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint WebsiteDataManagerLocalStorageDirectoryPropertyInfo = (~) T.Text
    type AttrTransferType WebsiteDataManagerLocalStorageDirectoryPropertyInfo = T.Text
    type AttrGetType WebsiteDataManagerLocalStorageDirectoryPropertyInfo = (Maybe T.Text)
    type AttrLabel WebsiteDataManagerLocalStorageDirectoryPropertyInfo = "local-storage-directory"
    type AttrOrigin WebsiteDataManagerLocalStorageDirectoryPropertyInfo = WebsiteDataManager
    attrGet = getWebsiteDataManagerLocalStorageDirectory
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructWebsiteDataManagerLocalStorageDirectory
    attrClear = undefined
#endif

-- VVV Prop "offline-application-cache-directory"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

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

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

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo
instance AttrInfo WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo where
    type AttrAllowedOps WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo = IsWebsiteDataManager
    type AttrSetTypeConstraint WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo = (~) T.Text
    type AttrTransferType WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo = T.Text
    type AttrGetType WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo = (Maybe T.Text)
    type AttrLabel WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo = "offline-application-cache-directory"
    type AttrOrigin WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo = WebsiteDataManager
    attrGet = getWebsiteDataManagerOfflineApplicationCacheDirectory
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructWebsiteDataManagerOfflineApplicationCacheDirectory
    attrClear = undefined
#endif

-- VVV Prop "service-worker-registrations-directory"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

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

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

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerServiceWorkerRegistrationsDirectoryPropertyInfo
instance AttrInfo WebsiteDataManagerServiceWorkerRegistrationsDirectoryPropertyInfo where
    type AttrAllowedOps WebsiteDataManagerServiceWorkerRegistrationsDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WebsiteDataManagerServiceWorkerRegistrationsDirectoryPropertyInfo = IsWebsiteDataManager
    type AttrSetTypeConstraint WebsiteDataManagerServiceWorkerRegistrationsDirectoryPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint WebsiteDataManagerServiceWorkerRegistrationsDirectoryPropertyInfo = (~) T.Text
    type AttrTransferType WebsiteDataManagerServiceWorkerRegistrationsDirectoryPropertyInfo = T.Text
    type AttrGetType WebsiteDataManagerServiceWorkerRegistrationsDirectoryPropertyInfo = (Maybe T.Text)
    type AttrLabel WebsiteDataManagerServiceWorkerRegistrationsDirectoryPropertyInfo = "service-worker-registrations-directory"
    type AttrOrigin WebsiteDataManagerServiceWorkerRegistrationsDirectoryPropertyInfo = WebsiteDataManager
    attrGet = getWebsiteDataManagerServiceWorkerRegistrationsDirectory
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructWebsiteDataManagerServiceWorkerRegistrationsDirectory
    attrClear = undefined
#endif

-- VVV Prop "websql-directory"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

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

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

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerWebsqlDirectoryPropertyInfo
instance AttrInfo WebsiteDataManagerWebsqlDirectoryPropertyInfo where
    type AttrAllowedOps WebsiteDataManagerWebsqlDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WebsiteDataManagerWebsqlDirectoryPropertyInfo = IsWebsiteDataManager
    type AttrSetTypeConstraint WebsiteDataManagerWebsqlDirectoryPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint WebsiteDataManagerWebsqlDirectoryPropertyInfo = (~) T.Text
    type AttrTransferType WebsiteDataManagerWebsqlDirectoryPropertyInfo = T.Text
    type AttrGetType WebsiteDataManagerWebsqlDirectoryPropertyInfo = (Maybe T.Text)
    type AttrLabel WebsiteDataManagerWebsqlDirectoryPropertyInfo = "websql-directory"
    type AttrOrigin WebsiteDataManagerWebsqlDirectoryPropertyInfo = WebsiteDataManager
    attrGet = getWebsiteDataManagerWebsqlDirectory
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructWebsiteDataManagerWebsqlDirectory
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList WebsiteDataManager
type instance O.AttributeList WebsiteDataManager = WebsiteDataManagerAttributeList
type WebsiteDataManagerAttributeList = ('[ '("baseCacheDirectory", WebsiteDataManagerBaseCacheDirectoryPropertyInfo), '("baseDataDirectory", WebsiteDataManagerBaseDataDirectoryPropertyInfo), '("diskCacheDirectory", WebsiteDataManagerDiskCacheDirectoryPropertyInfo), '("domCacheDirectory", WebsiteDataManagerDomCacheDirectoryPropertyInfo), '("hstsCacheDirectory", WebsiteDataManagerHstsCacheDirectoryPropertyInfo), '("indexeddbDirectory", WebsiteDataManagerIndexeddbDirectoryPropertyInfo), '("isEphemeral", WebsiteDataManagerIsEphemeralPropertyInfo), '("itpDirectory", WebsiteDataManagerItpDirectoryPropertyInfo), '("localStorageDirectory", WebsiteDataManagerLocalStorageDirectoryPropertyInfo), '("offlineApplicationCacheDirectory", WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo), '("serviceWorkerRegistrationsDirectory", WebsiteDataManagerServiceWorkerRegistrationsDirectoryPropertyInfo), '("websqlDirectory", WebsiteDataManagerWebsqlDirectoryPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
websiteDataManagerBaseCacheDirectory :: AttrLabelProxy "baseCacheDirectory"
websiteDataManagerBaseCacheDirectory = AttrLabelProxy

websiteDataManagerBaseDataDirectory :: AttrLabelProxy "baseDataDirectory"
websiteDataManagerBaseDataDirectory = AttrLabelProxy

websiteDataManagerDiskCacheDirectory :: AttrLabelProxy "diskCacheDirectory"
websiteDataManagerDiskCacheDirectory = AttrLabelProxy

websiteDataManagerDomCacheDirectory :: AttrLabelProxy "domCacheDirectory"
websiteDataManagerDomCacheDirectory = AttrLabelProxy

websiteDataManagerHstsCacheDirectory :: AttrLabelProxy "hstsCacheDirectory"
websiteDataManagerHstsCacheDirectory = AttrLabelProxy

websiteDataManagerIndexeddbDirectory :: AttrLabelProxy "indexeddbDirectory"
websiteDataManagerIndexeddbDirectory = AttrLabelProxy

websiteDataManagerItpDirectory :: AttrLabelProxy "itpDirectory"
websiteDataManagerItpDirectory = AttrLabelProxy

websiteDataManagerLocalStorageDirectory :: AttrLabelProxy "localStorageDirectory"
websiteDataManagerLocalStorageDirectory = AttrLabelProxy

websiteDataManagerOfflineApplicationCacheDirectory :: AttrLabelProxy "offlineApplicationCacheDirectory"
websiteDataManagerOfflineApplicationCacheDirectory = AttrLabelProxy

websiteDataManagerServiceWorkerRegistrationsDirectory :: AttrLabelProxy "serviceWorkerRegistrationsDirectory"
websiteDataManagerServiceWorkerRegistrationsDirectory = AttrLabelProxy

websiteDataManagerWebsqlDirectory :: AttrLabelProxy "websqlDirectory"
websiteDataManagerWebsqlDirectory = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList WebsiteDataManager = WebsiteDataManagerSignalList
type WebsiteDataManagerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "webkit_website_data_manager_new_ephemeral" webkit_website_data_manager_new_ephemeral :: 
    IO (Ptr WebsiteDataManager)

-- | Creates an ephemeral t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'. See t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/is-ephemeral/@ for more details.
-- 
-- /Since: 2.16/
websiteDataManagerNewEphemeral ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m WebsiteDataManager
    -- ^ __Returns:__ a new ephemeral t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'.
websiteDataManagerNewEphemeral :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m WebsiteDataManager
websiteDataManagerNewEphemeral  = IO WebsiteDataManager -> m WebsiteDataManager
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO WebsiteDataManager -> m WebsiteDataManager)
-> IO WebsiteDataManager -> m WebsiteDataManager
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
result <- IO (Ptr WebsiteDataManager)
webkit_website_data_manager_new_ephemeral
    Text -> Ptr WebsiteDataManager -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"websiteDataManagerNewEphemeral" Ptr WebsiteDataManager
result
    WebsiteDataManager
result' <- ((ManagedPtr WebsiteDataManager -> WebsiteDataManager)
-> Ptr WebsiteDataManager -> IO WebsiteDataManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr WebsiteDataManager -> WebsiteDataManager
WebsiteDataManager) Ptr WebsiteDataManager
result
    WebsiteDataManager -> IO WebsiteDataManager
forall (m :: * -> *) a. Monad m => a -> m a
return WebsiteDataManager
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method WebsiteDataManager::clear
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "WebsiteDataManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitWebsiteDataManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "types"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "WebsiteDataTypes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#WebKitWebsiteDataTypes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "timespan"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GTimeSpan" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable or %NULL to ignore"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GAsyncReadyCallback to call when the request is satisfied"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 5
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the data to pass to callback function"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_website_data_manager_clear" webkit_website_data_manager_clear :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    CUInt ->                                -- types : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataTypes"})
    Int64 ->                                -- timespan : TBasicType TInt64
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Asynchronously clear the website data of the given /@types@/ modified in the past /@timespan@/.
-- If /@timespan@/ is 0, all website data will be removed.
-- 
-- When the operation is finished, /@callback@/ will be called. You can then call
-- 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerClearFinish' to get the result of the operation.
-- 
-- Due to implementation limitations, this function does not currently delete
-- any stored cookies if /@timespan@/ is nonzero. This behavior may change in the
-- future.
-- 
-- /Since: 2.16/
websiteDataManagerClear ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> [WebKit2.Flags.WebsiteDataTypes]
    -- ^ /@types@/: t'GI.WebKit2.Flags.WebsiteDataTypes'
    -> Int64
    -- ^ /@timespan@/: a @/GTimeSpan/@
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable' or 'P.Nothing' to ignore
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied
    -> m ()
websiteDataManagerClear :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWebsiteDataManager a,
 IsCancellable b) =>
a
-> [WebsiteDataTypes]
-> Int64
-> Maybe b
-> Maybe AsyncReadyCallback
-> m ()
websiteDataManagerClear a
manager [WebsiteDataTypes]
types Int64
timespan Maybe b
cancellable Maybe AsyncReadyCallback
callback = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    let types' :: CUInt
types' = [WebsiteDataTypes] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [WebsiteDataTypes]
types
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr WebsiteDataManager
-> CUInt
-> Int64
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
webkit_website_data_manager_clear Ptr WebsiteDataManager
manager' CUInt
types' Int64
timespan Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerClearMethodInfo
instance (signature ~ ([WebKit2.Flags.WebsiteDataTypes] -> Int64 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebsiteDataManager a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod WebsiteDataManagerClearMethodInfo a signature where
    overloadedMethod = websiteDataManagerClear

instance O.OverloadedMethodInfo WebsiteDataManagerClearMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerClear",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerClear"
        }


#endif

-- method WebsiteDataManager::clear_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "WebsiteDataManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitWebsiteDataManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "result"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GAsyncResult" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "webkit_website_data_manager_clear_finish" webkit_website_data_manager_clear_finish :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerClear'
-- 
-- /Since: 2.16/
websiteDataManagerClearFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> b
    -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
websiteDataManagerClearFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWebsiteDataManager a,
 IsAsyncResult b) =>
a -> b -> m ()
websiteDataManagerClearFinish a
manager b
result_ = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr WebsiteDataManager
-> Ptr AsyncResult -> Ptr (Ptr GError) -> IO CInt
webkit_website_data_manager_clear_finish Ptr WebsiteDataManager
manager' Ptr AsyncResult
result_'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerClearFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWebsiteDataManager a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod WebsiteDataManagerClearFinishMethodInfo a signature where
    overloadedMethod = websiteDataManagerClearFinish

instance O.OverloadedMethodInfo WebsiteDataManagerClearFinishMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerClearFinish",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerClearFinish"
        }


#endif

-- method WebsiteDataManager::fetch
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "WebsiteDataManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitWebsiteDataManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "types"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "WebsiteDataTypes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#WebKitWebsiteDataTypes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable or %NULL to ignore"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GAsyncReadyCallback to call when the request is satisfied"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 4
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the data to pass to callback function"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_website_data_manager_fetch" webkit_website_data_manager_fetch :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    CUInt ->                                -- types : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataTypes"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Asynchronously get the list of t'GI.WebKit2.Structs.WebsiteData.WebsiteData' for the given /@types@/.
-- 
-- When the operation is finished, /@callback@/ will be called. You can then call
-- 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerFetchFinish' to get the result of the operation.
-- 
-- /Since: 2.16/
websiteDataManagerFetch ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> [WebKit2.Flags.WebsiteDataTypes]
    -- ^ /@types@/: t'GI.WebKit2.Flags.WebsiteDataTypes'
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable' or 'P.Nothing' to ignore
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied
    -> m ()
websiteDataManagerFetch :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWebsiteDataManager a,
 IsCancellable b) =>
a
-> [WebsiteDataTypes]
-> Maybe b
-> Maybe AsyncReadyCallback
-> m ()
websiteDataManagerFetch a
manager [WebsiteDataTypes]
types Maybe b
cancellable Maybe AsyncReadyCallback
callback = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    let types' :: CUInt
types' = [WebsiteDataTypes] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [WebsiteDataTypes]
types
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr WebsiteDataManager
-> CUInt
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
webkit_website_data_manager_fetch Ptr WebsiteDataManager
manager' CUInt
types' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerFetchMethodInfo
instance (signature ~ ([WebKit2.Flags.WebsiteDataTypes] -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebsiteDataManager a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod WebsiteDataManagerFetchMethodInfo a signature where
    overloadedMethod = websiteDataManagerFetch

instance O.OverloadedMethodInfo WebsiteDataManagerFetchMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerFetch",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerFetch"
        }


#endif

-- method WebsiteDataManager::fetch_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "WebsiteDataManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitWebsiteDataManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "result"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GAsyncResult" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGList
--                  (TInterface Name { namespace = "WebKit2" , name = "WebsiteData" }))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_website_data_manager_fetch_finish" webkit_website_data_manager_fetch_finish :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr (GList (Ptr WebKit2.WebsiteData.WebsiteData)))

-- | Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerFetch'.
-- 
-- /Since: 2.16/
websiteDataManagerFetchFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> b
    -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'
    -> m [WebKit2.WebsiteData.WebsiteData]
    -- ^ __Returns:__ a t'GI.GLib.Structs.List.List' of t'GI.WebKit2.Structs.WebsiteData.WebsiteData'. You must free the t'GI.GLib.Structs.List.List' with
    --    @/g_list_free()/@ and unref the t'GI.WebKit2.Structs.WebsiteData.WebsiteData's with 'GI.WebKit2.Structs.WebsiteData.websiteDataUnref' when you\'re done with them. /(Can throw 'Data.GI.Base.GError.GError')/
websiteDataManagerFetchFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWebsiteDataManager a,
 IsAsyncResult b) =>
a -> b -> m [WebsiteData]
websiteDataManagerFetchFinish a
manager b
result_ = IO [WebsiteData] -> m [WebsiteData]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [WebsiteData] -> m [WebsiteData])
-> IO [WebsiteData] -> m [WebsiteData]
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    IO [WebsiteData] -> IO () -> IO [WebsiteData]
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr (GList (Ptr WebsiteData))
result <- (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr WebsiteData))))
-> IO (Ptr (GList (Ptr WebsiteData)))
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr (GList (Ptr WebsiteData))))
 -> IO (Ptr (GList (Ptr WebsiteData))))
-> (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr WebsiteData))))
-> IO (Ptr (GList (Ptr WebsiteData)))
forall a b. (a -> b) -> a -> b
$ Ptr WebsiteDataManager
-> Ptr AsyncResult
-> Ptr (Ptr GError)
-> IO (Ptr (GList (Ptr WebsiteData)))
webkit_website_data_manager_fetch_finish Ptr WebsiteDataManager
manager' Ptr AsyncResult
result_'
        [Ptr WebsiteData]
result' <- Ptr (GList (Ptr WebsiteData)) -> IO [Ptr WebsiteData]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr WebsiteData))
result
        [WebsiteData]
result'' <- (Ptr WebsiteData -> IO WebsiteData)
-> [Ptr WebsiteData] -> IO [WebsiteData]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr WebsiteData -> WebsiteData)
-> Ptr WebsiteData -> IO WebsiteData
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr WebsiteData -> WebsiteData
WebKit2.WebsiteData.WebsiteData) [Ptr WebsiteData]
result'
        Ptr (GList (Ptr WebsiteData)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr WebsiteData))
result
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
        [WebsiteData] -> IO [WebsiteData]
forall (m :: * -> *) a. Monad m => a -> m a
return [WebsiteData]
result''
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerFetchFinishMethodInfo
instance (signature ~ (b -> m [WebKit2.WebsiteData.WebsiteData]), MonadIO m, IsWebsiteDataManager a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod WebsiteDataManagerFetchFinishMethodInfo a signature where
    overloadedMethod = websiteDataManagerFetchFinish

instance O.OverloadedMethodInfo WebsiteDataManagerFetchFinishMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerFetchFinish",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerFetchFinish"
        }


#endif

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

foreign import ccall "webkit_website_data_manager_get_base_cache_directory" webkit_website_data_manager_get_base_cache_directory :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    IO CString

-- | Get the t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/base-cache-directory/@ property.
-- 
-- /Since: 2.10/
websiteDataManagerGetBaseCacheDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the base directory for Website cache, or 'P.Nothing' if
    --    t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/base-cache-directory/@ was not provided or /@manager@/ is ephemeral.
websiteDataManagerGetBaseCacheDirectory :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> m (Maybe Text)
websiteDataManagerGetBaseCacheDirectory a
manager = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CString
result <- Ptr WebsiteDataManager -> IO CString
webkit_website_data_manager_get_base_cache_directory Ptr WebsiteDataManager
manager'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo WebsiteDataManagerGetBaseCacheDirectoryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetBaseCacheDirectory",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerGetBaseCacheDirectory"
        }


#endif

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

foreign import ccall "webkit_website_data_manager_get_base_data_directory" webkit_website_data_manager_get_base_data_directory :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    IO CString

-- | Get the t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/base-data-directory/@ property.
-- 
-- /Since: 2.10/
websiteDataManagerGetBaseDataDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the base directory for Website data, or 'P.Nothing' if
    --    t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/base-data-directory/@ was not provided or /@manager@/ is ephemeral.
websiteDataManagerGetBaseDataDirectory :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> m (Maybe Text)
websiteDataManagerGetBaseDataDirectory a
manager = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CString
result <- Ptr WebsiteDataManager -> IO CString
webkit_website_data_manager_get_base_data_directory Ptr WebsiteDataManager
manager'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo WebsiteDataManagerGetBaseDataDirectoryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetBaseDataDirectory",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerGetBaseDataDirectory"
        }


#endif

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

foreign import ccall "webkit_website_data_manager_get_cookie_manager" webkit_website_data_manager_get_cookie_manager :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    IO (Ptr WebKit2.CookieManager.CookieManager)

-- | Get the t'GI.WebKit2.Objects.CookieManager.CookieManager' of /@manager@/.
-- 
-- /Since: 2.16/
websiteDataManagerGetCookieManager ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> m WebKit2.CookieManager.CookieManager
    -- ^ __Returns:__ a t'GI.WebKit2.Objects.CookieManager.CookieManager'
websiteDataManagerGetCookieManager :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> m CookieManager
websiteDataManagerGetCookieManager a
manager = IO CookieManager -> m CookieManager
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CookieManager -> m CookieManager)
-> IO CookieManager -> m CookieManager
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    Ptr CookieManager
result <- Ptr WebsiteDataManager -> IO (Ptr CookieManager)
webkit_website_data_manager_get_cookie_manager Ptr WebsiteDataManager
manager'
    Text -> Ptr CookieManager -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"websiteDataManagerGetCookieManager" Ptr CookieManager
result
    CookieManager
result' <- ((ManagedPtr CookieManager -> CookieManager)
-> Ptr CookieManager -> IO CookieManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr CookieManager -> CookieManager
WebKit2.CookieManager.CookieManager) Ptr CookieManager
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    CookieManager -> IO CookieManager
forall (m :: * -> *) a. Monad m => a -> m a
return CookieManager
result'

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerGetCookieManagerMethodInfo
instance (signature ~ (m WebKit2.CookieManager.CookieManager), MonadIO m, IsWebsiteDataManager a) => O.OverloadedMethod WebsiteDataManagerGetCookieManagerMethodInfo a signature where
    overloadedMethod = websiteDataManagerGetCookieManager

instance O.OverloadedMethodInfo WebsiteDataManagerGetCookieManagerMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetCookieManager",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerGetCookieManager"
        }


#endif

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

foreign import ccall "webkit_website_data_manager_get_disk_cache_directory" webkit_website_data_manager_get_disk_cache_directory :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    IO CString

-- | Get the t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/disk-cache-directory/@ property.
-- 
-- /Since: 2.10/
websiteDataManagerGetDiskCacheDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the directory where HTTP disk cache is stored or 'P.Nothing' if /@manager@/ is ephemeral.
websiteDataManagerGetDiskCacheDirectory :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> m (Maybe Text)
websiteDataManagerGetDiskCacheDirectory a
manager = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CString
result <- Ptr WebsiteDataManager -> IO CString
webkit_website_data_manager_get_disk_cache_directory Ptr WebsiteDataManager
manager'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo WebsiteDataManagerGetDiskCacheDirectoryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetDiskCacheDirectory",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerGetDiskCacheDirectory"
        }


#endif

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

foreign import ccall "webkit_website_data_manager_get_dom_cache_directory" webkit_website_data_manager_get_dom_cache_directory :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    IO CString

-- | Get the t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/dom-cache-directory/@ property.
-- 
-- /Since: 2.30/
websiteDataManagerGetDomCacheDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the directory where DOM cache is stored or 'P.Nothing' if /@manager@/ is ephemeral.
websiteDataManagerGetDomCacheDirectory :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> m (Maybe Text)
websiteDataManagerGetDomCacheDirectory a
manager = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CString
result <- Ptr WebsiteDataManager -> IO CString
webkit_website_data_manager_get_dom_cache_directory Ptr WebsiteDataManager
manager'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo WebsiteDataManagerGetDomCacheDirectoryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetDomCacheDirectory",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerGetDomCacheDirectory"
        }


#endif

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

foreign import ccall "webkit_website_data_manager_get_hsts_cache_directory" webkit_website_data_manager_get_hsts_cache_directory :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    IO CString

-- | Get the t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/hsts-cache-directory/@ property.
-- 
-- /Since: 2.26/
websiteDataManagerGetHstsCacheDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the directory where the HSTS cache is stored or 'P.Nothing' if /@manager@/ is ephemeral.
websiteDataManagerGetHstsCacheDirectory :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> m (Maybe Text)
websiteDataManagerGetHstsCacheDirectory a
manager = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CString
result <- Ptr WebsiteDataManager -> IO CString
webkit_website_data_manager_get_hsts_cache_directory Ptr WebsiteDataManager
manager'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo WebsiteDataManagerGetHstsCacheDirectoryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetHstsCacheDirectory",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerGetHstsCacheDirectory"
        }


#endif

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

foreign import ccall "webkit_website_data_manager_get_indexeddb_directory" webkit_website_data_manager_get_indexeddb_directory :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    IO CString

-- | Get the t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/indexeddb-directory/@ property.
-- 
-- /Since: 2.10/
websiteDataManagerGetIndexeddbDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the directory where IndexedDB databases are stored or 'P.Nothing' if /@manager@/ is ephemeral.
websiteDataManagerGetIndexeddbDirectory :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> m (Maybe Text)
websiteDataManagerGetIndexeddbDirectory a
manager = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CString
result <- Ptr WebsiteDataManager -> IO CString
webkit_website_data_manager_get_indexeddb_directory Ptr WebsiteDataManager
manager'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo WebsiteDataManagerGetIndexeddbDirectoryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetIndexeddbDirectory",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerGetIndexeddbDirectory"
        }


#endif

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

foreign import ccall "webkit_website_data_manager_get_itp_directory" webkit_website_data_manager_get_itp_directory :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    IO CString

-- | Get the t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/itp-directory/@ property.
-- 
-- /Since: 2.30/
websiteDataManagerGetItpDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the directory where Intelligent Tracking Prevention data is stored or 'P.Nothing' if /@manager@/ is ephemeral.
websiteDataManagerGetItpDirectory :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> m (Maybe Text)
websiteDataManagerGetItpDirectory a
manager = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CString
result <- Ptr WebsiteDataManager -> IO CString
webkit_website_data_manager_get_itp_directory Ptr WebsiteDataManager
manager'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo WebsiteDataManagerGetItpDirectoryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetItpDirectory",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerGetItpDirectory"
        }


#endif

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

foreign import ccall "webkit_website_data_manager_get_itp_enabled" webkit_website_data_manager_get_itp_enabled :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    IO CInt

-- | Get whether Intelligent Tracking Prevention (ITP) is enabled or not.
-- 
-- /Since: 2.30/
websiteDataManagerGetItpEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if ITP is enabled, or 'P.False' otherwise.
websiteDataManagerGetItpEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> m Bool
websiteDataManagerGetItpEnabled a
manager = IO Bool -> m Bool
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
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CInt
result <- Ptr WebsiteDataManager -> IO CInt
webkit_website_data_manager_get_itp_enabled Ptr WebsiteDataManager
manager'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerGetItpEnabledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWebsiteDataManager a) => O.OverloadedMethod WebsiteDataManagerGetItpEnabledMethodInfo a signature where
    overloadedMethod = websiteDataManagerGetItpEnabled

instance O.OverloadedMethodInfo WebsiteDataManagerGetItpEnabledMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetItpEnabled",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerGetItpEnabled"
        }


#endif

-- method WebsiteDataManager::get_itp_summary
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "WebsiteDataManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitWebsiteDataManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable or %NULL to ignore"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GAsyncReadyCallback to call when the request is satisfied"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 3
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the data to pass to callback function"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_website_data_manager_get_itp_summary" webkit_website_data_manager_get_itp_summary :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Asynchronously get the list of t'GI.WebKit2.Structs.ITPThirdParty.ITPThirdParty' seen for /@manager@/. Every t'GI.WebKit2.Structs.ITPThirdParty.ITPThirdParty'
-- contains the list of t'GI.WebKit2.Structs.ITPFirstParty.ITPFirstParty' under which it has been seen.
-- 
-- When the operation is finished, /@callback@/ will be called. You can then call
-- 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetItpSummaryFinish' to get the result of the operation.
-- 
-- /Since: 2.30/
websiteDataManagerGetItpSummary ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable' or 'P.Nothing' to ignore
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied
    -> m ()
websiteDataManagerGetItpSummary :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWebsiteDataManager a,
 IsCancellable b) =>
a -> Maybe b -> Maybe AsyncReadyCallback -> m ()
websiteDataManagerGetItpSummary a
manager Maybe b
cancellable Maybe AsyncReadyCallback
callback = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr WebsiteDataManager
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
webkit_website_data_manager_get_itp_summary Ptr WebsiteDataManager
manager' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerGetItpSummaryMethodInfo
instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebsiteDataManager a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod WebsiteDataManagerGetItpSummaryMethodInfo a signature where
    overloadedMethod = websiteDataManagerGetItpSummary

instance O.OverloadedMethodInfo WebsiteDataManagerGetItpSummaryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetItpSummary",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerGetItpSummary"
        }


#endif

-- method WebsiteDataManager::get_itp_summary_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "WebsiteDataManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitWebsiteDataManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "result"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GAsyncResult" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGList
--                  (TInterface
--                     Name { namespace = "WebKit2" , name = "ITPThirdParty" }))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_website_data_manager_get_itp_summary_finish" webkit_website_data_manager_get_itp_summary_finish :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr (GList (Ptr WebKit2.ITPThirdParty.ITPThirdParty)))

-- | Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetItpSummary'.
-- 
-- /Since: 2.30/
websiteDataManagerGetItpSummaryFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> b
    -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'
    -> m [WebKit2.ITPThirdParty.ITPThirdParty]
    -- ^ __Returns:__ a t'GI.GLib.Structs.List.List' of t'GI.WebKit2.Structs.ITPThirdParty.ITPThirdParty'.
    --    You must free the t'GI.GLib.Structs.List.List' with @/g_list_free()/@ and unref the t'GI.WebKit2.Structs.ITPThirdParty.ITPThirdParty's with
    --    'GI.WebKit2.Structs.ITPThirdParty.iTPThirdPartyUnref' when you\'re done with them. /(Can throw 'Data.GI.Base.GError.GError')/
websiteDataManagerGetItpSummaryFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWebsiteDataManager a,
 IsAsyncResult b) =>
a -> b -> m [ITPThirdParty]
websiteDataManagerGetItpSummaryFinish a
manager b
result_ = IO [ITPThirdParty] -> m [ITPThirdParty]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [ITPThirdParty] -> m [ITPThirdParty])
-> IO [ITPThirdParty] -> m [ITPThirdParty]
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    IO [ITPThirdParty] -> IO () -> IO [ITPThirdParty]
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr (GList (Ptr ITPThirdParty))
result <- (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr ITPThirdParty))))
-> IO (Ptr (GList (Ptr ITPThirdParty)))
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr (GList (Ptr ITPThirdParty))))
 -> IO (Ptr (GList (Ptr ITPThirdParty))))
-> (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr ITPThirdParty))))
-> IO (Ptr (GList (Ptr ITPThirdParty)))
forall a b. (a -> b) -> a -> b
$ Ptr WebsiteDataManager
-> Ptr AsyncResult
-> Ptr (Ptr GError)
-> IO (Ptr (GList (Ptr ITPThirdParty)))
webkit_website_data_manager_get_itp_summary_finish Ptr WebsiteDataManager
manager' Ptr AsyncResult
result_'
        [Ptr ITPThirdParty]
result' <- Ptr (GList (Ptr ITPThirdParty)) -> IO [Ptr ITPThirdParty]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr ITPThirdParty))
result
        [ITPThirdParty]
result'' <- (Ptr ITPThirdParty -> IO ITPThirdParty)
-> [Ptr ITPThirdParty] -> IO [ITPThirdParty]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr ITPThirdParty -> ITPThirdParty)
-> Ptr ITPThirdParty -> IO ITPThirdParty
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr ITPThirdParty -> ITPThirdParty
WebKit2.ITPThirdParty.ITPThirdParty) [Ptr ITPThirdParty]
result'
        Ptr (GList (Ptr ITPThirdParty)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr ITPThirdParty))
result
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
        [ITPThirdParty] -> IO [ITPThirdParty]
forall (m :: * -> *) a. Monad m => a -> m a
return [ITPThirdParty]
result''
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerGetItpSummaryFinishMethodInfo
instance (signature ~ (b -> m [WebKit2.ITPThirdParty.ITPThirdParty]), MonadIO m, IsWebsiteDataManager a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod WebsiteDataManagerGetItpSummaryFinishMethodInfo a signature where
    overloadedMethod = websiteDataManagerGetItpSummaryFinish

instance O.OverloadedMethodInfo WebsiteDataManagerGetItpSummaryFinishMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetItpSummaryFinish",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerGetItpSummaryFinish"
        }


#endif

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

foreign import ccall "webkit_website_data_manager_get_local_storage_directory" webkit_website_data_manager_get_local_storage_directory :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    IO CString

-- | Get the t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/local-storage-directory/@ property.
-- 
-- /Since: 2.10/
websiteDataManagerGetLocalStorageDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the directory where local storage data is stored or 'P.Nothing' if /@manager@/ is ephemeral.
websiteDataManagerGetLocalStorageDirectory :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> m (Maybe Text)
websiteDataManagerGetLocalStorageDirectory a
manager = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CString
result <- Ptr WebsiteDataManager -> IO CString
webkit_website_data_manager_get_local_storage_directory Ptr WebsiteDataManager
manager'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo WebsiteDataManagerGetLocalStorageDirectoryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetLocalStorageDirectory",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerGetLocalStorageDirectory"
        }


#endif

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

foreign import ccall "webkit_website_data_manager_get_offline_application_cache_directory" webkit_website_data_manager_get_offline_application_cache_directory :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    IO CString

-- | Get the t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/offline-application-cache-directory/@ property.
-- 
-- /Since: 2.10/
websiteDataManagerGetOfflineApplicationCacheDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the directory where offline web application cache is stored or 'P.Nothing' if /@manager@/ is ephemeral.
websiteDataManagerGetOfflineApplicationCacheDirectory :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> m (Maybe Text)
websiteDataManagerGetOfflineApplicationCacheDirectory a
manager = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CString
result <- Ptr WebsiteDataManager -> IO CString
webkit_website_data_manager_get_offline_application_cache_directory Ptr WebsiteDataManager
manager'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo WebsiteDataManagerGetOfflineApplicationCacheDirectoryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetOfflineApplicationCacheDirectory",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerGetOfflineApplicationCacheDirectory"
        }


#endif

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

foreign import ccall "webkit_website_data_manager_get_persistent_credential_storage_enabled" webkit_website_data_manager_get_persistent_credential_storage_enabled :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    IO CInt

-- | Get whether persistent credential storage is enabled or not.
-- See also 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerSetPersistentCredentialStorageEnabled'.
-- 
-- /Since: 2.30/
websiteDataManagerGetPersistentCredentialStorageEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if persistent credential storage is enabled, or 'P.False' otherwise.
websiteDataManagerGetPersistentCredentialStorageEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> m Bool
websiteDataManagerGetPersistentCredentialStorageEnabled a
manager = IO Bool -> m Bool
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
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CInt
result <- Ptr WebsiteDataManager -> IO CInt
webkit_website_data_manager_get_persistent_credential_storage_enabled Ptr WebsiteDataManager
manager'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerGetPersistentCredentialStorageEnabledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWebsiteDataManager a) => O.OverloadedMethod WebsiteDataManagerGetPersistentCredentialStorageEnabledMethodInfo a signature where
    overloadedMethod = websiteDataManagerGetPersistentCredentialStorageEnabled

instance O.OverloadedMethodInfo WebsiteDataManagerGetPersistentCredentialStorageEnabledMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetPersistentCredentialStorageEnabled",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerGetPersistentCredentialStorageEnabled"
        }


#endif

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

foreign import ccall "webkit_website_data_manager_get_service_worker_registrations_directory" webkit_website_data_manager_get_service_worker_registrations_directory :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    IO CString

-- | Get the t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/service-worker-registrations-directory/@ property.
-- 
-- /Since: 2.30/
websiteDataManagerGetServiceWorkerRegistrationsDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the directory where service worker registrations are stored or 'P.Nothing' if /@manager@/ is ephemeral.
websiteDataManagerGetServiceWorkerRegistrationsDirectory :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> m (Maybe Text)
websiteDataManagerGetServiceWorkerRegistrationsDirectory a
manager = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CString
result <- Ptr WebsiteDataManager -> IO CString
webkit_website_data_manager_get_service_worker_registrations_directory Ptr WebsiteDataManager
manager'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo WebsiteDataManagerGetServiceWorkerRegistrationsDirectoryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetServiceWorkerRegistrationsDirectory",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerGetServiceWorkerRegistrationsDirectory"
        }


#endif

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

foreign import ccall "webkit_website_data_manager_get_websql_directory" webkit_website_data_manager_get_websql_directory :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    IO CString

{-# DEPRECATED websiteDataManagerGetWebsqlDirectory ["(Since version 2.24.)","WebSQL is no longer supported. Use IndexedDB instead."] #-}
-- | Get the t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/websql-directory/@ property.
-- 
-- /Since: 2.10/
websiteDataManagerGetWebsqlDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the directory where WebSQL databases are stored or 'P.Nothing' if /@manager@/ is ephemeral.
websiteDataManagerGetWebsqlDirectory :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> m (Maybe Text)
websiteDataManagerGetWebsqlDirectory a
manager = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CString
result <- Ptr WebsiteDataManager -> IO CString
webkit_website_data_manager_get_websql_directory Ptr WebsiteDataManager
manager'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo WebsiteDataManagerGetWebsqlDirectoryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetWebsqlDirectory",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerGetWebsqlDirectory"
        }


#endif

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

foreign import ccall "webkit_website_data_manager_is_ephemeral" webkit_website_data_manager_is_ephemeral :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    IO CInt

-- | Get whether a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' is ephemeral. See t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/is-ephemeral/@ for more details.
-- 
-- /Since: 2.16/
websiteDataManagerIsEphemeral ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@manager@/ is ephemeral or 'P.False' otherwise.
websiteDataManagerIsEphemeral :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> m Bool
websiteDataManagerIsEphemeral a
manager = IO Bool -> m Bool
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
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CInt
result <- Ptr WebsiteDataManager -> IO CInt
webkit_website_data_manager_is_ephemeral Ptr WebsiteDataManager
manager'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerIsEphemeralMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWebsiteDataManager a) => O.OverloadedMethod WebsiteDataManagerIsEphemeralMethodInfo a signature where
    overloadedMethod = websiteDataManagerIsEphemeral

instance O.OverloadedMethodInfo WebsiteDataManagerIsEphemeralMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerIsEphemeral",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerIsEphemeral"
        }


#endif

-- method WebsiteDataManager::remove
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "WebsiteDataManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitWebsiteDataManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "types"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "WebsiteDataTypes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#WebKitWebsiteDataTypes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "website_data"
--           , argType =
--               TGList
--                 (TInterface Name { namespace = "WebKit2" , name = "WebsiteData" })
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GList of #WebKitWebsiteData"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable or %NULL to ignore"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GAsyncReadyCallback to call when the request is satisfied"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 5
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the data to pass to callback function"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_website_data_manager_remove" webkit_website_data_manager_remove :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    CUInt ->                                -- types : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataTypes"})
    Ptr (GList (Ptr WebKit2.WebsiteData.WebsiteData)) -> -- website_data : TGList (TInterface (Name {namespace = "WebKit2", name = "WebsiteData"}))
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Asynchronously removes the website data of the for the given /@types@/ for websites in the given /@websiteData@/ list.
-- Use 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerClear' if you want to remove the website data for all sites.
-- 
-- When the operation is finished, /@callback@/ will be called. You can then call
-- 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerRemoveFinish' to get the result of the operation.
-- 
-- /Since: 2.16/
websiteDataManagerRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> [WebKit2.Flags.WebsiteDataTypes]
    -- ^ /@types@/: t'GI.WebKit2.Flags.WebsiteDataTypes'
    -> [WebKit2.WebsiteData.WebsiteData]
    -- ^ /@websiteData@/: a t'GI.GLib.Structs.List.List' of t'GI.WebKit2.Structs.WebsiteData.WebsiteData'
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable' or 'P.Nothing' to ignore
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied
    -> m ()
websiteDataManagerRemove :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWebsiteDataManager a,
 IsCancellable b) =>
a
-> [WebsiteDataTypes]
-> [WebsiteData]
-> Maybe b
-> Maybe AsyncReadyCallback
-> m ()
websiteDataManagerRemove a
manager [WebsiteDataTypes]
types [WebsiteData]
websiteData Maybe b
cancellable Maybe AsyncReadyCallback
callback = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    let types' :: CUInt
types' = [WebsiteDataTypes] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [WebsiteDataTypes]
types
    [Ptr WebsiteData]
websiteData' <- (WebsiteData -> IO (Ptr WebsiteData))
-> [WebsiteData] -> IO [Ptr WebsiteData]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM WebsiteData -> IO (Ptr WebsiteData)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [WebsiteData]
websiteData
    Ptr (GList (Ptr WebsiteData))
websiteData'' <- [Ptr WebsiteData] -> IO (Ptr (GList (Ptr WebsiteData)))
forall a. [Ptr a] -> IO (Ptr (GList (Ptr a)))
packGList [Ptr WebsiteData]
websiteData'
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr WebsiteDataManager
-> CUInt
-> Ptr (GList (Ptr WebsiteData))
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
webkit_website_data_manager_remove Ptr WebsiteDataManager
manager' CUInt
types' Ptr (GList (Ptr WebsiteData))
websiteData'' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    (WebsiteData -> IO ()) -> [WebsiteData] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ WebsiteData -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [WebsiteData]
websiteData
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    Ptr (GList (Ptr WebsiteData)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr WebsiteData))
websiteData''
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerRemoveMethodInfo
instance (signature ~ ([WebKit2.Flags.WebsiteDataTypes] -> [WebKit2.WebsiteData.WebsiteData] -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebsiteDataManager a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod WebsiteDataManagerRemoveMethodInfo a signature where
    overloadedMethod = websiteDataManagerRemove

instance O.OverloadedMethodInfo WebsiteDataManagerRemoveMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerRemove",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerRemove"
        }


#endif

-- method WebsiteDataManager::remove_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "WebsiteDataManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitWebsiteDataManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "result"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GAsyncResult" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "webkit_website_data_manager_remove_finish" webkit_website_data_manager_remove_finish :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerRemove'.
-- 
-- /Since: 2.16/
websiteDataManagerRemoveFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> b
    -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
websiteDataManagerRemoveFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWebsiteDataManager a,
 IsAsyncResult b) =>
a -> b -> m ()
websiteDataManagerRemoveFinish a
manager b
result_ = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr WebsiteDataManager
-> Ptr AsyncResult -> Ptr (Ptr GError) -> IO CInt
webkit_website_data_manager_remove_finish Ptr WebsiteDataManager
manager' Ptr AsyncResult
result_'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerRemoveFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWebsiteDataManager a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod WebsiteDataManagerRemoveFinishMethodInfo a signature where
    overloadedMethod = websiteDataManagerRemoveFinish

instance O.OverloadedMethodInfo WebsiteDataManagerRemoveFinishMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerRemoveFinish",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerRemoveFinish"
        }


#endif

-- method WebsiteDataManager::set_itp_enabled
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "WebsiteDataManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitWebsiteDataManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enabled"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "value to set" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_website_data_manager_set_itp_enabled" webkit_website_data_manager_set_itp_enabled :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

-- | Enable or disable Intelligent Tracking Prevention (ITP). When ITP is enabled resource load statistics
-- are collected and used to decide whether to allow or block third-party cookies and prevent user tracking.
-- Note that while ITP is enabled the accept policy 'GI.WebKit2.Enums.CookieAcceptPolicyNoThirdParty' is ignored and
-- 'GI.WebKit2.Enums.CookieAcceptPolicyAlways' is used instead. See also 'GI.WebKit2.Objects.CookieManager.cookieManagerSetAcceptPolicy'.
-- 
-- /Since: 2.30/
websiteDataManagerSetItpEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> Bool
    -- ^ /@enabled@/: value to set
    -> m ()
websiteDataManagerSetItpEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> Bool -> m ()
websiteDataManagerSetItpEnabled a
manager Bool
enabled = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    let enabled' :: CInt
enabled' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
fromEnum) Bool
enabled
    Ptr WebsiteDataManager -> CInt -> IO ()
webkit_website_data_manager_set_itp_enabled Ptr WebsiteDataManager
manager' CInt
enabled'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerSetItpEnabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWebsiteDataManager a) => O.OverloadedMethod WebsiteDataManagerSetItpEnabledMethodInfo a signature where
    overloadedMethod = websiteDataManagerSetItpEnabled

instance O.OverloadedMethodInfo WebsiteDataManagerSetItpEnabledMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerSetItpEnabled",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerSetItpEnabled"
        }


#endif

-- method WebsiteDataManager::set_persistent_credential_storage_enabled
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "WebsiteDataManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitWebsiteDataManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enabled"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "value to set" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_website_data_manager_set_persistent_credential_storage_enabled" webkit_website_data_manager_set_persistent_credential_storage_enabled :: 
    Ptr WebsiteDataManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

-- | Enable or disable persistent credential storage. When enabled, which is the default for
-- non-ephemeral sessions, the network process will try to read and write HTTP authentiacation
-- credentials from persistent storage.
-- 
-- /Since: 2.30/
websiteDataManagerSetPersistentCredentialStorageEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
    a
    -- ^ /@manager@/: a t'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
    -> Bool
    -- ^ /@enabled@/: value to set
    -> m ()
websiteDataManagerSetPersistentCredentialStorageEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebsiteDataManager a) =>
a -> Bool -> m ()
websiteDataManagerSetPersistentCredentialStorageEnabled a
manager Bool
enabled = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebsiteDataManager
manager' <- a -> IO (Ptr WebsiteDataManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    let enabled' :: CInt
enabled' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
fromEnum) Bool
enabled
    Ptr WebsiteDataManager -> CInt -> IO ()
webkit_website_data_manager_set_persistent_credential_storage_enabled Ptr WebsiteDataManager
manager' CInt
enabled'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WebsiteDataManagerSetPersistentCredentialStorageEnabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWebsiteDataManager a) => O.OverloadedMethod WebsiteDataManagerSetPersistentCredentialStorageEnabledMethodInfo a signature where
    overloadedMethod = websiteDataManagerSetPersistentCredentialStorageEnabled

instance O.OverloadedMethodInfo WebsiteDataManagerSetPersistentCredentialStorageEnabledMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerSetPersistentCredentialStorageEnabled",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-WebsiteDataManager.html#v:websiteDataManagerSetPersistentCredentialStorageEnabled"
        }


#endif