gi-secret-0.0.7: GI/Secret/Objects/Collection.hs

{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

A proxy object representing a collection of secrets in the Secret Service.
-}

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

module GI.Secret.Objects.Collection
    ( 

-- * Exported types
    Collection(..)                          ,
    IsCollection                            ,
    toCollection                            ,
    noCollection                            ,


 -- * Methods
-- ** create #method:create#

    collectionCreate                        ,


-- ** createFinish #method:createFinish#

    collectionCreateFinish                  ,


-- ** createSync #method:createSync#

    collectionCreateSync                    ,


-- ** delete #method:delete#

#if ENABLE_OVERLOADING
    CollectionDeleteMethodInfo              ,
#endif
    collectionDelete                        ,


-- ** deleteFinish #method:deleteFinish#

#if ENABLE_OVERLOADING
    CollectionDeleteFinishMethodInfo        ,
#endif
    collectionDeleteFinish                  ,


-- ** deleteSync #method:deleteSync#

#if ENABLE_OVERLOADING
    CollectionDeleteSyncMethodInfo          ,
#endif
    collectionDeleteSync                    ,


-- ** forAlias #method:forAlias#

    collectionForAlias                      ,


-- ** forAliasFinish #method:forAliasFinish#

    collectionForAliasFinish                ,


-- ** forAliasSync #method:forAliasSync#

    collectionForAliasSync                  ,


-- ** getCreated #method:getCreated#

#if ENABLE_OVERLOADING
    CollectionGetCreatedMethodInfo          ,
#endif
    collectionGetCreated                    ,


-- ** getFlags #method:getFlags#

#if ENABLE_OVERLOADING
    CollectionGetFlagsMethodInfo            ,
#endif
    collectionGetFlags                      ,


-- ** getItems #method:getItems#

#if ENABLE_OVERLOADING
    CollectionGetItemsMethodInfo            ,
#endif
    collectionGetItems                      ,


-- ** getLabel #method:getLabel#

#if ENABLE_OVERLOADING
    CollectionGetLabelMethodInfo            ,
#endif
    collectionGetLabel                      ,


-- ** getLocked #method:getLocked#

#if ENABLE_OVERLOADING
    CollectionGetLockedMethodInfo           ,
#endif
    collectionGetLocked                     ,


-- ** getModified #method:getModified#

#if ENABLE_OVERLOADING
    CollectionGetModifiedMethodInfo         ,
#endif
    collectionGetModified                   ,


-- ** getService #method:getService#

#if ENABLE_OVERLOADING
    CollectionGetServiceMethodInfo          ,
#endif
    collectionGetService                    ,


-- ** loadItems #method:loadItems#

#if ENABLE_OVERLOADING
    CollectionLoadItemsMethodInfo           ,
#endif
    collectionLoadItems                     ,


-- ** loadItemsFinish #method:loadItemsFinish#

#if ENABLE_OVERLOADING
    CollectionLoadItemsFinishMethodInfo     ,
#endif
    collectionLoadItemsFinish               ,


-- ** loadItemsSync #method:loadItemsSync#

#if ENABLE_OVERLOADING
    CollectionLoadItemsSyncMethodInfo       ,
#endif
    collectionLoadItemsSync                 ,


-- ** refresh #method:refresh#

#if ENABLE_OVERLOADING
    CollectionRefreshMethodInfo             ,
#endif
    collectionRefresh                       ,


-- ** search #method:search#

#if ENABLE_OVERLOADING
    CollectionSearchMethodInfo              ,
#endif
    collectionSearch                        ,


-- ** searchFinish #method:searchFinish#

#if ENABLE_OVERLOADING
    CollectionSearchFinishMethodInfo        ,
#endif
    collectionSearchFinish                  ,


-- ** searchSync #method:searchSync#

#if ENABLE_OVERLOADING
    CollectionSearchSyncMethodInfo          ,
#endif
    collectionSearchSync                    ,


-- ** setLabel #method:setLabel#

#if ENABLE_OVERLOADING
    CollectionSetLabelMethodInfo            ,
#endif
    collectionSetLabel                      ,


-- ** setLabelFinish #method:setLabelFinish#

#if ENABLE_OVERLOADING
    CollectionSetLabelFinishMethodInfo      ,
#endif
    collectionSetLabelFinish                ,


-- ** setLabelSync #method:setLabelSync#

#if ENABLE_OVERLOADING
    CollectionSetLabelSyncMethodInfo        ,
#endif
    collectionSetLabelSync                  ,




 -- * Properties
-- ** created #attr:created#
{- | The date and time (in seconds since the UNIX epoch) that this
collection was created.
-}
#if ENABLE_OVERLOADING
    CollectionCreatedPropertyInfo           ,
#endif
#if ENABLE_OVERLOADING
    collectionCreated                       ,
#endif
    constructCollectionCreated              ,
    getCollectionCreated                    ,
    setCollectionCreated                    ,


-- ** label #attr:label#
{- | The human readable label for the collection.

Setting this property will result in the label of the collection being
set asynchronously. To properly track the changing of the label use the
'GI.Secret.Objects.Collection.collectionSetLabel' function.
-}
#if ENABLE_OVERLOADING
    CollectionLabelPropertyInfo             ,
#endif
    clearCollectionLabel                    ,
#if ENABLE_OVERLOADING
    collectionLabel                         ,
#endif
    constructCollectionLabel                ,
    getCollectionLabel                      ,
    setCollectionLabel                      ,


-- ** locked #attr:locked#
{- | Whether the collection is locked or not.

To lock or unlock a collection use the 'GI.Secret.Objects.Service.serviceLock' or
'GI.Secret.Objects.Service.serviceUnlock' functions.
-}
#if ENABLE_OVERLOADING
    CollectionLockedPropertyInfo            ,
#endif
#if ENABLE_OVERLOADING
    collectionLocked                        ,
#endif
    getCollectionLocked                     ,


-- ** modified #attr:modified#
{- | The date and time (in seconds since the UNIX epoch) that this
collection was last modified.
-}
#if ENABLE_OVERLOADING
    CollectionModifiedPropertyInfo          ,
#endif
#if ENABLE_OVERLOADING
    collectionModified                      ,
#endif
    constructCollectionModified             ,
    getCollectionModified                   ,
    setCollectionModified                   ,


-- ** service #attr:service#
{- | The 'GI.Secret.Objects.Service.Service' object that this collection is associated with and
uses to interact with the actual D-Bus Secret Service.
-}
#if ENABLE_OVERLOADING
    CollectionServicePropertyInfo           ,
#endif
#if ENABLE_OVERLOADING
    collectionService                       ,
#endif
    constructCollectionService              ,
    getCollectionService                    ,




    ) 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.ManagedPtr as B.ManagedPtr
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.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 GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncInitable as Gio.AsyncInitable
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Interfaces.DBusInterface as Gio.DBusInterface
import qualified GI.Gio.Interfaces.Initable as Gio.Initable
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.DBusProxy as Gio.DBusProxy
import {-# SOURCE #-} qualified GI.Secret.Flags as Secret.Flags
import {-# SOURCE #-} qualified GI.Secret.Objects.Item as Secret.Item
import {-# SOURCE #-} qualified GI.Secret.Objects.Service as Secret.Service
import {-# SOURCE #-} qualified GI.Secret.Structs.Schema as Secret.Schema

-- | Memory-managed wrapper type.
newtype Collection = Collection (ManagedPtr Collection)
foreign import ccall "secret_collection_get_type"
    c_secret_collection_get_type :: IO GType

instance GObject Collection where
    gobjectType = c_secret_collection_get_type
    

-- | Type class for types which can be safely cast to `Collection`, for instance with `toCollection`.
class (GObject o, O.IsDescendantOf Collection o) => IsCollection o
instance (GObject o, O.IsDescendantOf Collection o) => IsCollection o

instance O.HasParentTypes Collection
type instance O.ParentTypes Collection = '[Gio.DBusProxy.DBusProxy, GObject.Object.Object, Gio.AsyncInitable.AsyncInitable, Gio.DBusInterface.DBusInterface, Gio.Initable.Initable]

-- | Cast to `Collection`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toCollection :: (MonadIO m, IsCollection o) => o -> m Collection
toCollection = liftIO . unsafeCastTo Collection

-- | A convenience alias for `Nothing` :: `Maybe` `Collection`.
noCollection :: Maybe Collection
noCollection = Nothing

#if ENABLE_OVERLOADING
type family ResolveCollectionMethod (t :: Symbol) (o :: *) :: * where
    ResolveCollectionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveCollectionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveCollectionMethod "call" o = Gio.DBusProxy.DBusProxyCallMethodInfo
    ResolveCollectionMethod "callFinish" o = Gio.DBusProxy.DBusProxyCallFinishMethodInfo
    ResolveCollectionMethod "callSync" o = Gio.DBusProxy.DBusProxyCallSyncMethodInfo
    ResolveCollectionMethod "callWithUnixFdList" o = Gio.DBusProxy.DBusProxyCallWithUnixFdListMethodInfo
    ResolveCollectionMethod "callWithUnixFdListFinish" o = Gio.DBusProxy.DBusProxyCallWithUnixFdListFinishMethodInfo
    ResolveCollectionMethod "callWithUnixFdListSync" o = Gio.DBusProxy.DBusProxyCallWithUnixFdListSyncMethodInfo
    ResolveCollectionMethod "delete" o = CollectionDeleteMethodInfo
    ResolveCollectionMethod "deleteFinish" o = CollectionDeleteFinishMethodInfo
    ResolveCollectionMethod "deleteSync" o = CollectionDeleteSyncMethodInfo
    ResolveCollectionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveCollectionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveCollectionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveCollectionMethod "init" o = Gio.Initable.InitableInitMethodInfo
    ResolveCollectionMethod "initAsync" o = Gio.AsyncInitable.AsyncInitableInitAsyncMethodInfo
    ResolveCollectionMethod "initFinish" o = Gio.AsyncInitable.AsyncInitableInitFinishMethodInfo
    ResolveCollectionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveCollectionMethod "loadItems" o = CollectionLoadItemsMethodInfo
    ResolveCollectionMethod "loadItemsFinish" o = CollectionLoadItemsFinishMethodInfo
    ResolveCollectionMethod "loadItemsSync" o = CollectionLoadItemsSyncMethodInfo
    ResolveCollectionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveCollectionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveCollectionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveCollectionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveCollectionMethod "refresh" o = CollectionRefreshMethodInfo
    ResolveCollectionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveCollectionMethod "search" o = CollectionSearchMethodInfo
    ResolveCollectionMethod "searchFinish" o = CollectionSearchFinishMethodInfo
    ResolveCollectionMethod "searchSync" o = CollectionSearchSyncMethodInfo
    ResolveCollectionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveCollectionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveCollectionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveCollectionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveCollectionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveCollectionMethod "getCachedProperty" o = Gio.DBusProxy.DBusProxyGetCachedPropertyMethodInfo
    ResolveCollectionMethod "getCachedPropertyNames" o = Gio.DBusProxy.DBusProxyGetCachedPropertyNamesMethodInfo
    ResolveCollectionMethod "getConnection" o = Gio.DBusProxy.DBusProxyGetConnectionMethodInfo
    ResolveCollectionMethod "getCreated" o = CollectionGetCreatedMethodInfo
    ResolveCollectionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveCollectionMethod "getDefaultTimeout" o = Gio.DBusProxy.DBusProxyGetDefaultTimeoutMethodInfo
    ResolveCollectionMethod "getFlags" o = CollectionGetFlagsMethodInfo
    ResolveCollectionMethod "getInfo" o = Gio.DBusInterface.DBusInterfaceGetInfoMethodInfo
    ResolveCollectionMethod "getInterfaceInfo" o = Gio.DBusProxy.DBusProxyGetInterfaceInfoMethodInfo
    ResolveCollectionMethod "getInterfaceName" o = Gio.DBusProxy.DBusProxyGetInterfaceNameMethodInfo
    ResolveCollectionMethod "getItems" o = CollectionGetItemsMethodInfo
    ResolveCollectionMethod "getLabel" o = CollectionGetLabelMethodInfo
    ResolveCollectionMethod "getLocked" o = CollectionGetLockedMethodInfo
    ResolveCollectionMethod "getModified" o = CollectionGetModifiedMethodInfo
    ResolveCollectionMethod "getName" o = Gio.DBusProxy.DBusProxyGetNameMethodInfo
    ResolveCollectionMethod "getNameOwner" o = Gio.DBusProxy.DBusProxyGetNameOwnerMethodInfo
    ResolveCollectionMethod "getObject" o = Gio.DBusInterface.DBusInterfaceGetObjectMethodInfo
    ResolveCollectionMethod "getObjectPath" o = Gio.DBusProxy.DBusProxyGetObjectPathMethodInfo
    ResolveCollectionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveCollectionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveCollectionMethod "getService" o = CollectionGetServiceMethodInfo
    ResolveCollectionMethod "setCachedProperty" o = Gio.DBusProxy.DBusProxySetCachedPropertyMethodInfo
    ResolveCollectionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveCollectionMethod "setDefaultTimeout" o = Gio.DBusProxy.DBusProxySetDefaultTimeoutMethodInfo
    ResolveCollectionMethod "setInterfaceInfo" o = Gio.DBusProxy.DBusProxySetInterfaceInfoMethodInfo
    ResolveCollectionMethod "setLabel" o = CollectionSetLabelMethodInfo
    ResolveCollectionMethod "setLabelFinish" o = CollectionSetLabelFinishMethodInfo
    ResolveCollectionMethod "setLabelSync" o = CollectionSetLabelSyncMethodInfo
    ResolveCollectionMethod "setObject" o = Gio.DBusInterface.DBusInterfaceSetObjectMethodInfo
    ResolveCollectionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveCollectionMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveCollectionMethod t Collection, O.MethodInfo info Collection p) => OL.IsLabel t (Collection -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif

-- VVV Prop "created"
   -- Type: TBasicType TUInt64
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

{- |
Get the value of the “@created@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' collection #created
@
-}
getCollectionCreated :: (MonadIO m, IsCollection o) => o -> m Word64
getCollectionCreated obj = liftIO $ B.Properties.getObjectPropertyUInt64 obj "created"

{- |
Set the value of the “@created@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' collection [ #created 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCollectionCreated :: (MonadIO m, IsCollection o) => o -> Word64 -> m ()
setCollectionCreated obj val = liftIO $ B.Properties.setObjectPropertyUInt64 obj "created" val

{- |
Construct a `GValueConstruct` with valid value for the “@created@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCollectionCreated :: (IsCollection o) => Word64 -> IO (GValueConstruct o)
constructCollectionCreated val = B.Properties.constructObjectPropertyUInt64 "created" val

#if ENABLE_OVERLOADING
data CollectionCreatedPropertyInfo
instance AttrInfo CollectionCreatedPropertyInfo where
    type AttrAllowedOps CollectionCreatedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CollectionCreatedPropertyInfo = (~) Word64
    type AttrBaseTypeConstraint CollectionCreatedPropertyInfo = IsCollection
    type AttrGetType CollectionCreatedPropertyInfo = Word64
    type AttrLabel CollectionCreatedPropertyInfo = "created"
    type AttrOrigin CollectionCreatedPropertyInfo = Collection
    attrGet _ = getCollectionCreated
    attrSet _ = setCollectionCreated
    attrConstruct _ = constructCollectionCreated
    attrClear _ = undefined
#endif

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

{- |
Get the value of the “@label@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' collection #label
@
-}
getCollectionLabel :: (MonadIO m, IsCollection o) => o -> m (Maybe T.Text)
getCollectionLabel obj = liftIO $ B.Properties.getObjectPropertyString obj "label"

{- |
Set the value of the “@label@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' collection [ #label 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCollectionLabel :: (MonadIO m, IsCollection o) => o -> T.Text -> m ()
setCollectionLabel obj val = liftIO $ B.Properties.setObjectPropertyString obj "label" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@label@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCollectionLabel :: (IsCollection o) => T.Text -> IO (GValueConstruct o)
constructCollectionLabel val = B.Properties.constructObjectPropertyString "label" (Just val)

{- |
Set the value of the “@label@” property to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #label
@
-}
clearCollectionLabel :: (MonadIO m, IsCollection o) => o -> m ()
clearCollectionLabel obj = liftIO $ B.Properties.setObjectPropertyString obj "label" (Nothing :: Maybe T.Text)

#if ENABLE_OVERLOADING
data CollectionLabelPropertyInfo
instance AttrInfo CollectionLabelPropertyInfo where
    type AttrAllowedOps CollectionLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CollectionLabelPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CollectionLabelPropertyInfo = IsCollection
    type AttrGetType CollectionLabelPropertyInfo = (Maybe T.Text)
    type AttrLabel CollectionLabelPropertyInfo = "label"
    type AttrOrigin CollectionLabelPropertyInfo = Collection
    attrGet _ = getCollectionLabel
    attrSet _ = setCollectionLabel
    attrConstruct _ = constructCollectionLabel
    attrClear _ = clearCollectionLabel
#endif

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

{- |
Get the value of the “@locked@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' collection #locked
@
-}
getCollectionLocked :: (MonadIO m, IsCollection o) => o -> m Bool
getCollectionLocked obj = liftIO $ B.Properties.getObjectPropertyBool obj "locked"

#if ENABLE_OVERLOADING
data CollectionLockedPropertyInfo
instance AttrInfo CollectionLockedPropertyInfo where
    type AttrAllowedOps CollectionLockedPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint CollectionLockedPropertyInfo = (~) ()
    type AttrBaseTypeConstraint CollectionLockedPropertyInfo = IsCollection
    type AttrGetType CollectionLockedPropertyInfo = Bool
    type AttrLabel CollectionLockedPropertyInfo = "locked"
    type AttrOrigin CollectionLockedPropertyInfo = Collection
    attrGet _ = getCollectionLocked
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "modified"
   -- Type: TBasicType TUInt64
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

{- |
Get the value of the “@modified@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' collection #modified
@
-}
getCollectionModified :: (MonadIO m, IsCollection o) => o -> m Word64
getCollectionModified obj = liftIO $ B.Properties.getObjectPropertyUInt64 obj "modified"

{- |
Set the value of the “@modified@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' collection [ #modified 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCollectionModified :: (MonadIO m, IsCollection o) => o -> Word64 -> m ()
setCollectionModified obj val = liftIO $ B.Properties.setObjectPropertyUInt64 obj "modified" val

{- |
Construct a `GValueConstruct` with valid value for the “@modified@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCollectionModified :: (IsCollection o) => Word64 -> IO (GValueConstruct o)
constructCollectionModified val = B.Properties.constructObjectPropertyUInt64 "modified" val

#if ENABLE_OVERLOADING
data CollectionModifiedPropertyInfo
instance AttrInfo CollectionModifiedPropertyInfo where
    type AttrAllowedOps CollectionModifiedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CollectionModifiedPropertyInfo = (~) Word64
    type AttrBaseTypeConstraint CollectionModifiedPropertyInfo = IsCollection
    type AttrGetType CollectionModifiedPropertyInfo = Word64
    type AttrLabel CollectionModifiedPropertyInfo = "modified"
    type AttrOrigin CollectionModifiedPropertyInfo = Collection
    attrGet _ = getCollectionModified
    attrSet _ = setCollectionModified
    attrConstruct _ = constructCollectionModified
    attrClear _ = undefined
#endif

-- VVV Prop "service"
   -- Type: TInterface (Name {namespace = "Secret", name = "Service"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

{- |
Get the value of the “@service@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' collection #service
@
-}
getCollectionService :: (MonadIO m, IsCollection o) => o -> m Secret.Service.Service
getCollectionService obj = liftIO $ checkUnexpectedNothing "getCollectionService" $ B.Properties.getObjectPropertyObject obj "service" Secret.Service.Service

{- |
Construct a `GValueConstruct` with valid value for the “@service@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCollectionService :: (IsCollection o, Secret.Service.IsService a) => a -> IO (GValueConstruct o)
constructCollectionService val = B.Properties.constructObjectPropertyObject "service" (Just val)

#if ENABLE_OVERLOADING
data CollectionServicePropertyInfo
instance AttrInfo CollectionServicePropertyInfo where
    type AttrAllowedOps CollectionServicePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CollectionServicePropertyInfo = Secret.Service.IsService
    type AttrBaseTypeConstraint CollectionServicePropertyInfo = IsCollection
    type AttrGetType CollectionServicePropertyInfo = Secret.Service.Service
    type AttrLabel CollectionServicePropertyInfo = "service"
    type AttrOrigin CollectionServicePropertyInfo = Collection
    attrGet _ = getCollectionService
    attrSet _ = undefined
    attrConstruct _ = constructCollectionService
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList Collection
type instance O.AttributeList Collection = CollectionAttributeList
type CollectionAttributeList = ('[ '("created", CollectionCreatedPropertyInfo), '("gBusType", Gio.DBusProxy.DBusProxyGBusTypePropertyInfo), '("gConnection", Gio.DBusProxy.DBusProxyGConnectionPropertyInfo), '("gDefaultTimeout", Gio.DBusProxy.DBusProxyGDefaultTimeoutPropertyInfo), '("gFlags", Gio.DBusProxy.DBusProxyGFlagsPropertyInfo), '("gInterfaceInfo", Gio.DBusProxy.DBusProxyGInterfaceInfoPropertyInfo), '("gInterfaceName", Gio.DBusProxy.DBusProxyGInterfaceNamePropertyInfo), '("gName", Gio.DBusProxy.DBusProxyGNamePropertyInfo), '("gNameOwner", Gio.DBusProxy.DBusProxyGNameOwnerPropertyInfo), '("gObjectPath", Gio.DBusProxy.DBusProxyGObjectPathPropertyInfo), '("label", CollectionLabelPropertyInfo), '("locked", CollectionLockedPropertyInfo), '("modified", CollectionModifiedPropertyInfo), '("service", CollectionServicePropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
collectionCreated :: AttrLabelProxy "created"
collectionCreated = AttrLabelProxy

collectionLabel :: AttrLabelProxy "label"
collectionLabel = AttrLabelProxy

collectionLocked :: AttrLabelProxy "locked"
collectionLocked = AttrLabelProxy

collectionModified :: AttrLabelProxy "modified"
collectionModified = AttrLabelProxy

collectionService :: AttrLabelProxy "service"
collectionService = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
type instance O.SignalList Collection = CollectionSignalList
type CollectionSignalList = ('[ '("gPropertiesChanged", Gio.DBusProxy.DBusProxyGPropertiesChangedSignalInfo), '("gSignal", Gio.DBusProxy.DBusProxyGSignalSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method Collection::delete
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a collection", 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 "optional cancellation object", 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 "called when the operation completes", 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 "data to pass to the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "secret_collection_delete" secret_collection_delete :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    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 ()

{- |
Delete this collection.

This method returns immediately and completes asynchronously. The secret
service may prompt the user. 'GI.Secret.Objects.Service.servicePrompt' will be used to handle
any prompts that show up.
-}
collectionDelete ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: a collection -}
    -> Maybe (b)
    {- ^ /@cancellable@/: optional cancellation object -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: called when the operation completes -}
    -> m ()
collectionDelete self cancellable callback = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    secret_collection_delete self' maybeCancellable maybeCallback userData
    touchManagedPtr self
    whenJust cancellable touchManagedPtr
    return ()

#if ENABLE_OVERLOADING
data CollectionDeleteMethodInfo
instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsCollection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo CollectionDeleteMethodInfo a signature where
    overloadedMethod _ = collectionDelete

#endif

-- method Collection::delete_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a collection", 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 "asynchronous result passed to the callback", 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 "secret_collection_delete_finish" secret_collection_delete_finish :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Complete operation to delete this collection.
-}
collectionDeleteFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@self@/: a collection -}
    -> b
    {- ^ /@result@/: asynchronous result passed to the callback -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
collectionDeleteFinish self result_ = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        _ <- propagateGError $ secret_collection_delete_finish self' result_'
        touchManagedPtr self
        touchManagedPtr result_
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data CollectionDeleteFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsCollection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo CollectionDeleteFinishMethodInfo a signature where
    overloadedMethod _ = collectionDeleteFinish

#endif

-- method Collection::delete_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a collection", 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 "optional cancellation object", 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 "secret_collection_delete_sync" secret_collection_delete_sync :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Delete this collection.

This method may block indefinitely and should not be used in user
interface threads. The secret service may prompt the user.
'GI.Secret.Objects.Service.servicePrompt' will be used to handle any prompts that show up.
-}
collectionDeleteSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: a collection -}
    -> Maybe (b)
    {- ^ /@cancellable@/: optional cancellation object -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
collectionDeleteSync self cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ secret_collection_delete_sync self' maybeCancellable
        touchManagedPtr self
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data CollectionDeleteSyncMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsCollection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo CollectionDeleteSyncMethodInfo a signature where
    overloadedMethod _ = collectionDeleteSync

#endif

-- method Collection::get_created
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a collection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "secret_collection_get_created" secret_collection_get_created :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    IO Word64

{- |
Get the created date and time of the collection. The return value is
the number of seconds since the unix epoch, January 1st 1970.
-}
collectionGetCreated ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a) =>
    a
    {- ^ /@self@/: a collection -}
    -> m Word64
    {- ^ __Returns:__ the created date and time -}
collectionGetCreated self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- secret_collection_get_created self'
    touchManagedPtr self
    return result

#if ENABLE_OVERLOADING
data CollectionGetCreatedMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsCollection a) => O.MethodInfo CollectionGetCreatedMethodInfo a signature where
    overloadedMethod _ = collectionGetCreated

#endif

-- method Collection::get_flags
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the secret collection proxy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Secret", name = "CollectionFlags"}))
-- throws : False
-- Skip return : False

foreign import ccall "secret_collection_get_flags" secret_collection_get_flags :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    IO CUInt

{- |
Get the flags representing what features of the 'GI.Secret.Objects.Collection.Collection' proxy
have been initialized.

Use 'GI.Secret.Objects.Collection.collectionLoadItems'  to initialize further features
and change the flags.
-}
collectionGetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a) =>
    a
    {- ^ /@self@/: the secret collection proxy -}
    -> m [Secret.Flags.CollectionFlags]
    {- ^ __Returns:__ the flags for features initialized -}
collectionGetFlags self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- secret_collection_get_flags self'
    let result' = wordToGFlags result
    touchManagedPtr self
    return result'

#if ENABLE_OVERLOADING
data CollectionGetFlagsMethodInfo
instance (signature ~ (m [Secret.Flags.CollectionFlags]), MonadIO m, IsCollection a) => O.MethodInfo CollectionGetFlagsMethodInfo a signature where
    overloadedMethod _ = collectionGetFlags

#endif

-- method Collection::get_items
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a collection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Secret", name = "Item"})))
-- throws : False
-- Skip return : False

foreign import ccall "secret_collection_get_items" secret_collection_get_items :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    IO (Ptr (GList (Ptr Secret.Item.Item)))

{- |
Get the list of items in this collection.
-}
collectionGetItems ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a) =>
    a
    {- ^ /@self@/: a collection -}
    -> m [Secret.Item.Item]
    {- ^ __Returns:__ a list of items,
when done, the list should be freed with g_list_free, and each item should
be released with 'GI.GObject.Objects.Object.objectUnref' -}
collectionGetItems self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- secret_collection_get_items self'
    result' <- unpackGList result
    result'' <- mapM (wrapObject Secret.Item.Item) result'
    g_list_free result
    touchManagedPtr self
    return result''

#if ENABLE_OVERLOADING
data CollectionGetItemsMethodInfo
instance (signature ~ (m [Secret.Item.Item]), MonadIO m, IsCollection a) => O.MethodInfo CollectionGetItemsMethodInfo a signature where
    overloadedMethod _ = collectionGetItems

#endif

-- method Collection::get_label
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a collection", 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 "secret_collection_get_label" secret_collection_get_label :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    IO CString

{- |
Get the label of this collection.
-}
collectionGetLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a) =>
    a
    {- ^ /@self@/: a collection -}
    -> m T.Text
    {- ^ __Returns:__ the label, which should be freed with 'GI.GLib.Functions.free' -}
collectionGetLabel self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- secret_collection_get_label self'
    checkUnexpectedReturnNULL "collectionGetLabel" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

#if ENABLE_OVERLOADING
data CollectionGetLabelMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsCollection a) => O.MethodInfo CollectionGetLabelMethodInfo a signature where
    overloadedMethod _ = collectionGetLabel

#endif

-- method Collection::get_locked
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a collection", 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 "secret_collection_get_locked" secret_collection_get_locked :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    IO CInt

{- |
Get whether the collection is locked or not.

Use 'GI.Secret.Objects.Service.serviceLock' or 'GI.Secret.Objects.Service.serviceUnlock' to lock or unlock the
collection.
-}
collectionGetLocked ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a) =>
    a
    {- ^ /@self@/: a collection -}
    -> m Bool
    {- ^ __Returns:__ whether the collection is locked or not -}
collectionGetLocked self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- secret_collection_get_locked self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if ENABLE_OVERLOADING
data CollectionGetLockedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsCollection a) => O.MethodInfo CollectionGetLockedMethodInfo a signature where
    overloadedMethod _ = collectionGetLocked

#endif

-- method Collection::get_modified
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a collection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "secret_collection_get_modified" secret_collection_get_modified :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    IO Word64

{- |
Get the modified date and time of the collection. The return value is
the number of seconds since the unix epoch, January 1st 1970.
-}
collectionGetModified ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a) =>
    a
    {- ^ /@self@/: a collection -}
    -> m Word64
    {- ^ __Returns:__ the modified date and time -}
collectionGetModified self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- secret_collection_get_modified self'
    touchManagedPtr self
    return result

#if ENABLE_OVERLOADING
data CollectionGetModifiedMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsCollection a) => O.MethodInfo CollectionGetModifiedMethodInfo a signature where
    overloadedMethod _ = collectionGetModified

#endif

-- method Collection::get_service
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a collection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Secret", name = "Service"}))
-- throws : False
-- Skip return : False

foreign import ccall "secret_collection_get_service" secret_collection_get_service :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    IO (Ptr Secret.Service.Service)

{- |
Get the Secret Service object that this collection was created with.
-}
collectionGetService ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a) =>
    a
    {- ^ /@self@/: a collection -}
    -> m Secret.Service.Service
    {- ^ __Returns:__ the Secret Service object -}
collectionGetService self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- secret_collection_get_service self'
    checkUnexpectedReturnNULL "collectionGetService" result
    result' <- (newObject Secret.Service.Service) result
    touchManagedPtr self
    return result'

#if ENABLE_OVERLOADING
data CollectionGetServiceMethodInfo
instance (signature ~ (m Secret.Service.Service), MonadIO m, IsCollection a) => O.MethodInfo CollectionGetServiceMethodInfo a signature where
    overloadedMethod _ = collectionGetService

#endif

-- method Collection::load_items
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the secret collection", 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 "optional cancellation object", 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 "called when the operation completes", 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 "data to be passed to the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "secret_collection_load_items" secret_collection_load_items :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    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 ()

{- |
Ensure that the 'GI.Secret.Objects.Collection.Collection' proxy has loaded all the items present
in the Secret Service. This affects the result of
'GI.Secret.Objects.Collection.collectionGetItems'.

For collections returned from 'GI.Secret.Objects.Service.serviceGetCollections' the items
will have already been loaded.

This method will return immediately and complete asynchronously.
-}
collectionLoadItems ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: the secret collection -}
    -> Maybe (b)
    {- ^ /@cancellable@/: optional cancellation object -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: called when the operation completes -}
    -> m ()
collectionLoadItems self cancellable callback = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    secret_collection_load_items self' maybeCancellable maybeCallback userData
    touchManagedPtr self
    whenJust cancellable touchManagedPtr
    return ()

#if ENABLE_OVERLOADING
data CollectionLoadItemsMethodInfo
instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsCollection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo CollectionLoadItemsMethodInfo a signature where
    overloadedMethod _ = collectionLoadItems

#endif

-- method Collection::load_items_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the secret collection", 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 "the asynchronous result passed to the callback", 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 "secret_collection_load_items_finish" secret_collection_load_items_finish :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Complete an asynchronous operation to ensure that the 'GI.Secret.Objects.Collection.Collection' proxy
has loaded all the items present in the Secret Service.
-}
collectionLoadItemsFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@self@/: the secret collection -}
    -> b
    {- ^ /@result@/: the asynchronous result passed to the callback -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
collectionLoadItemsFinish self result_ = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        _ <- propagateGError $ secret_collection_load_items_finish self' result_'
        touchManagedPtr self
        touchManagedPtr result_
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data CollectionLoadItemsFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsCollection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo CollectionLoadItemsFinishMethodInfo a signature where
    overloadedMethod _ = collectionLoadItemsFinish

#endif

-- method Collection::load_items_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the secret collection", 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 "optional cancellation object", 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 "secret_collection_load_items_sync" secret_collection_load_items_sync :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Ensure that the 'GI.Secret.Objects.Collection.Collection' proxy has loaded all the items present
in the Secret Service. This affects the result of
'GI.Secret.Objects.Collection.collectionGetItems'.

For collections returned from 'GI.Secret.Objects.Service.serviceGetCollections' the items
will have already been loaded.

This method may block indefinitely and should not be used in user interface
threads.
-}
collectionLoadItemsSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: the secret collection -}
    -> Maybe (b)
    {- ^ /@cancellable@/: optional cancellation object -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
collectionLoadItemsSync self cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ secret_collection_load_items_sync self' maybeCancellable
        touchManagedPtr self
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data CollectionLoadItemsSyncMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsCollection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo CollectionLoadItemsSyncMethodInfo a signature where
    overloadedMethod _ = collectionLoadItemsSync

#endif

-- method Collection::refresh
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the collection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "secret_collection_refresh" secret_collection_refresh :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    IO ()

{- |
Refresh the properties on this collection. This fires off a request to
refresh, and the properties will be updated later.

Calling this method is not normally necessary, as the secret service
will notify the client when properties change.
-}
collectionRefresh ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a) =>
    a
    {- ^ /@self@/: the collection -}
    -> m ()
collectionRefresh self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    secret_collection_refresh self'
    touchManagedPtr self
    return ()

#if ENABLE_OVERLOADING
data CollectionRefreshMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCollection a) => O.MethodInfo CollectionRefreshMethodInfo a signature where
    overloadedMethod _ = collectionRefresh

#endif

-- method Collection::search
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a secret collection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "schema", argType = TInterface (Name {namespace = "Secret", name = "Schema"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the schema for the attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attributes", argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "search for items matching these attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Secret", name = "SearchFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "search option flags", 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 "optional cancellation object", 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 "called when the operation completes", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to pass to the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "secret_collection_search" secret_collection_search :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    Ptr Secret.Schema.Schema ->             -- schema : TInterface (Name {namespace = "Secret", name = "Schema"})
    Ptr (GHashTable CString CString) ->     -- attributes : TGHash (TBasicType TUTF8) (TBasicType TUTF8)
    CUInt ->                                -- flags : TInterface (Name {namespace = "Secret", name = "SearchFlags"})
    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 ()

{- |
Search for items matching the /@attributes@/ in the /@collection@/.
The /@attributes@/ should be a table of string keys and string values.

If 'GI.Secret.Flags.SearchFlagsAll' is set in /@flags@/, then all the items matching the
search will be returned. Otherwise only the first item will be returned.
This is almost always the unlocked item that was most recently stored.

If 'GI.Secret.Flags.SearchFlagsUnlock' is set in /@flags@/, then items will be unlocked
if necessary. In either case, locked and unlocked items will match the
search and be returned. If the unlock fails, the search does not fail.

If 'GI.Secret.Flags.SearchFlagsLoadSecrets' is set in /@flags@/, then the items will have
their secret values loaded and available via 'GI.Secret.Objects.Item.itemGetSecret'.

This function returns immediately and completes asynchronously.
-}
collectionSearch ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: a secret collection -}
    -> Maybe (Secret.Schema.Schema)
    {- ^ /@schema@/: the schema for the attributes -}
    -> Map.Map T.Text T.Text
    {- ^ /@attributes@/: search for items matching these attributes -}
    -> [Secret.Flags.SearchFlags]
    {- ^ /@flags@/: search option flags -}
    -> Maybe (b)
    {- ^ /@cancellable@/: optional cancellation object -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: called when the operation completes -}
    -> m ()
collectionSearch self schema attributes flags cancellable callback = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeSchema <- case schema of
        Nothing -> return nullPtr
        Just jSchema -> do
            jSchema' <- unsafeManagedPtrGetPtr jSchema
            return jSchema'
    let attributes' = Map.toList attributes
    attributes'' <- mapFirstA textToCString attributes'
    attributes''' <- mapSecondA textToCString attributes''
    let attributes'''' = mapFirst cstringPackPtr attributes'''
    let attributes''''' = mapSecond cstringPackPtr attributes''''
    attributes'''''' <- packGHashTable gStrHash gStrEqual (Just ptr_to_g_free) (Just ptr_to_g_free) attributes'''''
    let flags' = gflagsToWord flags
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    secret_collection_search self' maybeSchema attributes'''''' flags' maybeCancellable maybeCallback userData
    touchManagedPtr self
    whenJust schema touchManagedPtr
    whenJust cancellable touchManagedPtr
    unrefGHashTable attributes''''''
    return ()

#if ENABLE_OVERLOADING
data CollectionSearchMethodInfo
instance (signature ~ (Maybe (Secret.Schema.Schema) -> Map.Map T.Text T.Text -> [Secret.Flags.SearchFlags] -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsCollection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo CollectionSearchMethodInfo a signature where
    overloadedMethod _ = collectionSearch

#endif

-- method Collection::search_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the secret collection", 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 "asynchronous result passed to callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Secret", name = "Item"})))
-- throws : True
-- Skip return : False

foreign import ccall "secret_collection_search_finish" secret_collection_search_finish :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr (GList (Ptr Secret.Item.Item)))

{- |
Complete asynchronous operation to search for items in a collection.
-}
collectionSearchFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@self@/: the secret collection -}
    -> b
    {- ^ /@result@/: asynchronous result passed to callback -}
    -> m [Secret.Item.Item]
    {- ^ __Returns:__ 
         a list of items that matched the search /(Can throw 'Data.GI.Base.GError.GError')/ -}
collectionSearchFinish self result_ = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        result <- propagateGError $ secret_collection_search_finish self' result_'
        result' <- unpackGList result
        result'' <- mapM (wrapObject Secret.Item.Item) result'
        g_list_free result
        touchManagedPtr self
        touchManagedPtr result_
        return result''
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data CollectionSearchFinishMethodInfo
instance (signature ~ (b -> m [Secret.Item.Item]), MonadIO m, IsCollection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo CollectionSearchFinishMethodInfo a signature where
    overloadedMethod _ = collectionSearchFinish

#endif

-- method Collection::search_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a secret collection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "schema", argType = TInterface (Name {namespace = "Secret", name = "Schema"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the schema for the attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attributes", argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "search for items matching these attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Secret", name = "SearchFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "search option flags", 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 "optional cancellation object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Secret", name = "Item"})))
-- throws : True
-- Skip return : False

foreign import ccall "secret_collection_search_sync" secret_collection_search_sync :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    Ptr Secret.Schema.Schema ->             -- schema : TInterface (Name {namespace = "Secret", name = "Schema"})
    Ptr (GHashTable CString CString) ->     -- attributes : TGHash (TBasicType TUTF8) (TBasicType TUTF8)
    CUInt ->                                -- flags : TInterface (Name {namespace = "Secret", name = "SearchFlags"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr (GList (Ptr Secret.Item.Item)))

{- |
Search for items matching the /@attributes@/ in the /@collection@/.
The /@attributes@/ should be a table of string keys and string values.

If 'GI.Secret.Flags.SearchFlagsAll' is set in /@flags@/, then all the items matching the
search will be returned. Otherwise only the first item will be returned.
This is almost always the unlocked item that was most recently stored.

If 'GI.Secret.Flags.SearchFlagsUnlock' is set in /@flags@/, then items will be unlocked
if necessary. In either case, locked and unlocked items will match the
search and be returned. If the unlock fails, the search does not fail.

If 'GI.Secret.Flags.SearchFlagsLoadSecrets' is set in /@flags@/, then the items will have
their secret values loaded and available via 'GI.Secret.Objects.Item.itemGetSecret'.

This function may block indefinitely. Use the asynchronous version
in user interface threads.
-}
collectionSearchSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: a secret collection -}
    -> Maybe (Secret.Schema.Schema)
    {- ^ /@schema@/: the schema for the attributes -}
    -> Map.Map T.Text T.Text
    {- ^ /@attributes@/: search for items matching these attributes -}
    -> [Secret.Flags.SearchFlags]
    {- ^ /@flags@/: search option flags -}
    -> Maybe (b)
    {- ^ /@cancellable@/: optional cancellation object -}
    -> m [Secret.Item.Item]
    {- ^ __Returns:__ 
         a list of items that matched the search /(Can throw 'Data.GI.Base.GError.GError')/ -}
collectionSearchSync self schema attributes flags cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeSchema <- case schema of
        Nothing -> return nullPtr
        Just jSchema -> do
            jSchema' <- unsafeManagedPtrGetPtr jSchema
            return jSchema'
    let attributes' = Map.toList attributes
    attributes'' <- mapFirstA textToCString attributes'
    attributes''' <- mapSecondA textToCString attributes''
    let attributes'''' = mapFirst cstringPackPtr attributes'''
    let attributes''''' = mapSecond cstringPackPtr attributes''''
    attributes'''''' <- packGHashTable gStrHash gStrEqual (Just ptr_to_g_free) (Just ptr_to_g_free) attributes'''''
    let flags' = gflagsToWord flags
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ secret_collection_search_sync self' maybeSchema attributes'''''' flags' maybeCancellable
        result' <- unpackGList result
        result'' <- mapM (wrapObject Secret.Item.Item) result'
        g_list_free result
        touchManagedPtr self
        whenJust schema touchManagedPtr
        whenJust cancellable touchManagedPtr
        unrefGHashTable attributes''''''
        return result''
     ) (do
        unrefGHashTable attributes''''''
     )

#if ENABLE_OVERLOADING
data CollectionSearchSyncMethodInfo
instance (signature ~ (Maybe (Secret.Schema.Schema) -> Map.Map T.Text T.Text -> [Secret.Flags.SearchFlags] -> Maybe (b) -> m [Secret.Item.Item]), MonadIO m, IsCollection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo CollectionSearchSyncMethodInfo a signature where
    overloadedMethod _ = collectionSearchSync

#endif

-- method Collection::set_label
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a collection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a new label", 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 "optional cancellation object", 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 "called when the operation completes", 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 "data to pass to the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "secret_collection_set_label" secret_collection_set_label :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    CString ->                              -- label : TBasicType TUTF8
    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 ()

{- |
Set the label of this collection.

This function returns immediately and completes asynchronously.
-}
collectionSetLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: a collection -}
    -> T.Text
    {- ^ /@label@/: a new label -}
    -> Maybe (b)
    {- ^ /@cancellable@/: optional cancellation object -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: called when the operation completes -}
    -> m ()
collectionSetLabel self label cancellable callback = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    label' <- textToCString label
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    secret_collection_set_label self' label' maybeCancellable maybeCallback userData
    touchManagedPtr self
    whenJust cancellable touchManagedPtr
    freeMem label'
    return ()

#if ENABLE_OVERLOADING
data CollectionSetLabelMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsCollection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo CollectionSetLabelMethodInfo a signature where
    overloadedMethod _ = collectionSetLabel

#endif

-- method Collection::set_label_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a collection", 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 "asynchronous result passed to callback", 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 "secret_collection_set_label_finish" secret_collection_set_label_finish :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Complete asynchronous operation to set the label of this collection.
-}
collectionSetLabelFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@self@/: a collection -}
    -> b
    {- ^ /@result@/: asynchronous result passed to callback -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
collectionSetLabelFinish self result_ = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        _ <- propagateGError $ secret_collection_set_label_finish self' result_'
        touchManagedPtr self
        touchManagedPtr result_
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data CollectionSetLabelFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsCollection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo CollectionSetLabelFinishMethodInfo a signature where
    overloadedMethod _ = collectionSetLabelFinish

#endif

-- method Collection::set_label_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Secret", name = "Collection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a collection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a new label", 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 "optional cancellation object", 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 "secret_collection_set_label_sync" secret_collection_set_label_sync :: 
    Ptr Collection ->                       -- self : TInterface (Name {namespace = "Secret", name = "Collection"})
    CString ->                              -- label : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Set the label of this collection.

This function may block indefinitely. Use the asynchronous version
in user interface threads.
-}
collectionSetLabelSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsCollection a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: a collection -}
    -> T.Text
    {- ^ /@label@/: a new label -}
    -> Maybe (b)
    {- ^ /@cancellable@/: optional cancellation object -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
collectionSetLabelSync self label cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    label' <- textToCString label
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ secret_collection_set_label_sync self' label' maybeCancellable
        touchManagedPtr self
        whenJust cancellable touchManagedPtr
        freeMem label'
        return ()
     ) (do
        freeMem label'
     )

#if ENABLE_OVERLOADING
data CollectionSetLabelSyncMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> m ()), MonadIO m, IsCollection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo CollectionSetLabelSyncMethodInfo a signature where
    overloadedMethod _ = collectionSetLabelSync

#endif

-- method Collection::create
-- method type : MemberFunction
-- Args : [Arg {argCName = "service", argType = TInterface (Name {namespace = "Secret", name = "Service"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a secret service object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "label for the new collection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "alias", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "alias to assign to the collection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Secret", name = "CollectionCreateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "currently unused", 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 "optional cancellation object", 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 "called when the operation completes", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to pass to the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "secret_collection_create" secret_collection_create :: 
    Ptr Secret.Service.Service ->           -- service : TInterface (Name {namespace = "Secret", name = "Service"})
    CString ->                              -- label : TBasicType TUTF8
    CString ->                              -- alias : TBasicType TUTF8
    CUInt ->                                -- flags : TInterface (Name {namespace = "Secret", name = "CollectionCreateFlags"})
    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 ()

{- |
Create a new collection in the secret service.

This method returns immediately and completes asynchronously. The secret
service may prompt the user. 'GI.Secret.Objects.Service.servicePrompt' will be used to handle
any prompts that are required.

An /@alias@/ is a well-known tag for a collection, such as \'default\' (ie: the
default collection to store items in). This allows other applications to
easily identify and share a collection. If you specify an /@alias@/, and a
collection with that alias already exists, then a new collection will not
be created. The previous one will be returned instead.

If /@service@/ is NULL, then 'GI.Secret.Objects.Service.serviceGet' will be called to get
the default 'GI.Secret.Objects.Service.Service' proxy.
-}
collectionCreate ::
    (B.CallStack.HasCallStack, MonadIO m, Secret.Service.IsService a, Gio.Cancellable.IsCancellable b) =>
    Maybe (a)
    {- ^ /@service@/: a secret service object -}
    -> T.Text
    {- ^ /@label@/: label for the new collection -}
    -> Maybe (T.Text)
    {- ^ /@alias@/: alias to assign to the collection -}
    -> [Secret.Flags.CollectionCreateFlags]
    {- ^ /@flags@/: currently unused -}
    -> Maybe (b)
    {- ^ /@cancellable@/: optional cancellation object -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: called when the operation completes -}
    -> m ()
collectionCreate service label alias flags cancellable callback = liftIO $ do
    maybeService <- case service of
        Nothing -> return nullPtr
        Just jService -> do
            jService' <- unsafeManagedPtrCastPtr jService
            return jService'
    label' <- textToCString label
    maybeAlias <- case alias of
        Nothing -> return nullPtr
        Just jAlias -> do
            jAlias' <- textToCString jAlias
            return jAlias'
    let flags' = gflagsToWord flags
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    secret_collection_create maybeService label' maybeAlias flags' maybeCancellable maybeCallback userData
    whenJust service touchManagedPtr
    whenJust cancellable touchManagedPtr
    freeMem label'
    freeMem maybeAlias
    return ()

#if ENABLE_OVERLOADING
#endif

-- method Collection::create_finish
-- method type : MemberFunction
-- Args : [Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the asynchronous result passed to the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Secret", name = "Collection"}))
-- throws : True
-- Skip return : False

foreign import ccall "secret_collection_create_finish" secret_collection_create_finish :: 
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Collection)

{- |
Finish operation to create a new collection in the secret service.
-}
collectionCreateFinish ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a) =>
    a
    {- ^ /@result@/: the asynchronous result passed to the callback -}
    -> m Collection
    {- ^ __Returns:__ the new collection, which should be unreferenced
         with 'GI.GObject.Objects.Object.objectUnref' /(Can throw 'Data.GI.Base.GError.GError')/ -}
collectionCreateFinish result_ = liftIO $ do
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        result <- propagateGError $ secret_collection_create_finish result_'
        checkUnexpectedReturnNULL "collectionCreateFinish" result
        result' <- (wrapObject Collection) result
        touchManagedPtr result_
        return result'
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
#endif

-- method Collection::create_sync
-- method type : MemberFunction
-- Args : [Arg {argCName = "service", argType = TInterface (Name {namespace = "Secret", name = "Service"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a secret service object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "label for the new collection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "alias", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "alias to assign to the collection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Secret", name = "CollectionCreateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "currently unused", 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 "optional cancellation object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Secret", name = "Collection"}))
-- throws : True
-- Skip return : False

foreign import ccall "secret_collection_create_sync" secret_collection_create_sync :: 
    Ptr Secret.Service.Service ->           -- service : TInterface (Name {namespace = "Secret", name = "Service"})
    CString ->                              -- label : TBasicType TUTF8
    CString ->                              -- alias : TBasicType TUTF8
    CUInt ->                                -- flags : TInterface (Name {namespace = "Secret", name = "CollectionCreateFlags"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Collection)

{- |
Create a new collection in the secret service.

This method may block indefinitely and should not be used in user interface
threads. The secret service may prompt the user. 'GI.Secret.Objects.Service.servicePrompt'
will be used to handle any prompts that are required.

An /@alias@/ is a well-known tag for a collection, such as \'default\' (ie: the
default collection to store items in). This allows other applications to
easily identify and share a collection. If you specify an /@alias@/, and a
collection with that alias already exists, then a new collection will not
be created. The previous one will be returned instead.

If /@service@/ is NULL, then 'GI.Secret.Objects.Service.serviceGetSync' will be called to get
the default 'GI.Secret.Objects.Service.Service' proxy.
-}
collectionCreateSync ::
    (B.CallStack.HasCallStack, MonadIO m, Secret.Service.IsService a, Gio.Cancellable.IsCancellable b) =>
    Maybe (a)
    {- ^ /@service@/: a secret service object -}
    -> T.Text
    {- ^ /@label@/: label for the new collection -}
    -> Maybe (T.Text)
    {- ^ /@alias@/: alias to assign to the collection -}
    -> [Secret.Flags.CollectionCreateFlags]
    {- ^ /@flags@/: currently unused -}
    -> Maybe (b)
    {- ^ /@cancellable@/: optional cancellation object -}
    -> m Collection
    {- ^ __Returns:__ the new collection, which should be unreferenced
         with 'GI.GObject.Objects.Object.objectUnref' /(Can throw 'Data.GI.Base.GError.GError')/ -}
collectionCreateSync service label alias flags cancellable = liftIO $ do
    maybeService <- case service of
        Nothing -> return nullPtr
        Just jService -> do
            jService' <- unsafeManagedPtrCastPtr jService
            return jService'
    label' <- textToCString label
    maybeAlias <- case alias of
        Nothing -> return nullPtr
        Just jAlias -> do
            jAlias' <- textToCString jAlias
            return jAlias'
    let flags' = gflagsToWord flags
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ secret_collection_create_sync maybeService label' maybeAlias flags' maybeCancellable
        checkUnexpectedReturnNULL "collectionCreateSync" result
        result' <- (wrapObject Collection) result
        whenJust service touchManagedPtr
        whenJust cancellable touchManagedPtr
        freeMem label'
        freeMem maybeAlias
        return result'
     ) (do
        freeMem label'
        freeMem maybeAlias
     )

#if ENABLE_OVERLOADING
#endif

-- method Collection::for_alias
-- method type : MemberFunction
-- Args : [Arg {argCName = "service", argType = TInterface (Name {namespace = "Secret", name = "Service"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a secret service object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "alias", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the alias to lookup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Secret", name = "CollectionFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "options for the collection initialization", 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 "optional cancellation object", 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 "called when the operation completes", 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 "data to pass to the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "secret_collection_for_alias" secret_collection_for_alias :: 
    Ptr Secret.Service.Service ->           -- service : TInterface (Name {namespace = "Secret", name = "Service"})
    CString ->                              -- alias : TBasicType TUTF8
    CUInt ->                                -- flags : TInterface (Name {namespace = "Secret", name = "CollectionFlags"})
    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 ()

{- |
Lookup which collection is assigned to this alias. Aliases help determine
well known collections, such as \'default\'.

If /@service@/ is NULL, then 'GI.Secret.Objects.Service.serviceGet' will be called to get
the default 'GI.Secret.Objects.Service.Service' proxy.

This method will return immediately and complete asynchronously.
-}
collectionForAlias ::
    (B.CallStack.HasCallStack, MonadIO m, Secret.Service.IsService a, Gio.Cancellable.IsCancellable b) =>
    Maybe (a)
    {- ^ /@service@/: a secret service object -}
    -> T.Text
    {- ^ /@alias@/: the alias to lookup -}
    -> [Secret.Flags.CollectionFlags]
    {- ^ /@flags@/: options for the collection initialization -}
    -> Maybe (b)
    {- ^ /@cancellable@/: optional cancellation object -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: called when the operation completes -}
    -> m ()
collectionForAlias service alias flags cancellable callback = liftIO $ do
    maybeService <- case service of
        Nothing -> return nullPtr
        Just jService -> do
            jService' <- unsafeManagedPtrCastPtr jService
            return jService'
    alias' <- textToCString alias
    let flags' = gflagsToWord flags
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    secret_collection_for_alias maybeService alias' flags' maybeCancellable maybeCallback userData
    whenJust service touchManagedPtr
    whenJust cancellable touchManagedPtr
    freeMem alias'
    return ()

#if ENABLE_OVERLOADING
#endif

-- method Collection::for_alias_finish
-- method type : MemberFunction
-- Args : [Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "asynchronous result passed to callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Secret", name = "Collection"}))
-- throws : True
-- Skip return : False

foreign import ccall "secret_collection_for_alias_finish" secret_collection_for_alias_finish :: 
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Collection)

{- |
Finish an asynchronous operation to lookup which collection is assigned
to an alias.
-}
collectionForAliasFinish ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a) =>
    a
    {- ^ /@result@/: asynchronous result passed to callback -}
    -> m Collection
    {- ^ __Returns:__ the collection, or 'Nothing' if none assigned to the alias /(Can throw 'Data.GI.Base.GError.GError')/ -}
collectionForAliasFinish result_ = liftIO $ do
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        result <- propagateGError $ secret_collection_for_alias_finish result_'
        checkUnexpectedReturnNULL "collectionForAliasFinish" result
        result' <- (wrapObject Collection) result
        touchManagedPtr result_
        return result'
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
#endif

-- method Collection::for_alias_sync
-- method type : MemberFunction
-- Args : [Arg {argCName = "service", argType = TInterface (Name {namespace = "Secret", name = "Service"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a secret service object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "alias", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the alias to lookup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Secret", name = "CollectionFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "options for the collection initialization", 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 "optional cancellation object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Secret", name = "Collection"}))
-- throws : True
-- Skip return : False

foreign import ccall "secret_collection_for_alias_sync" secret_collection_for_alias_sync :: 
    Ptr Secret.Service.Service ->           -- service : TInterface (Name {namespace = "Secret", name = "Service"})
    CString ->                              -- alias : TBasicType TUTF8
    CUInt ->                                -- flags : TInterface (Name {namespace = "Secret", name = "CollectionFlags"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Collection)

{- |
Lookup which collection is assigned to this alias. Aliases help determine
well known collections, such as \'default\'.

If /@service@/ is NULL, then 'GI.Secret.Objects.Service.serviceGetSync' will be called to get
the default 'GI.Secret.Objects.Service.Service' proxy.

This method may block and should not be used in user interface threads.
-}
collectionForAliasSync ::
    (B.CallStack.HasCallStack, MonadIO m, Secret.Service.IsService a, Gio.Cancellable.IsCancellable b) =>
    Maybe (a)
    {- ^ /@service@/: a secret service object -}
    -> T.Text
    {- ^ /@alias@/: the alias to lookup -}
    -> [Secret.Flags.CollectionFlags]
    {- ^ /@flags@/: options for the collection initialization -}
    -> Maybe (b)
    {- ^ /@cancellable@/: optional cancellation object -}
    -> m Collection
    {- ^ __Returns:__ the collection, or 'Nothing' if none assigned to the alias /(Can throw 'Data.GI.Base.GError.GError')/ -}
collectionForAliasSync service alias flags cancellable = liftIO $ do
    maybeService <- case service of
        Nothing -> return nullPtr
        Just jService -> do
            jService' <- unsafeManagedPtrCastPtr jService
            return jService'
    alias' <- textToCString alias
    let flags' = gflagsToWord flags
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ secret_collection_for_alias_sync maybeService alias' flags' maybeCancellable
        checkUnexpectedReturnNULL "collectionForAliasSync" result
        result' <- (wrapObject Collection) result
        whenJust service touchManagedPtr
        whenJust cancellable touchManagedPtr
        freeMem alias'
        return result'
     ) (do
        freeMem alias'
     )

#if ENABLE_OVERLOADING
#endif