-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

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

module GI.Secret.Flags
    ( 

 -- * Flags


-- ** CollectionCreateFlags #flag:CollectionCreateFlags#

    CollectionCreateFlags(..)               ,


-- ** CollectionFlags #flag:CollectionFlags#

    CollectionFlags(..)                     ,


-- ** ItemCreateFlags #flag:ItemCreateFlags#

    ItemCreateFlags(..)                     ,


-- ** ItemFlags #flag:ItemFlags#

    ItemFlags(..)                           ,


-- ** SchemaFlags #flag:SchemaFlags#

    SchemaFlags(..)                         ,


-- ** SearchFlags #flag:SearchFlags#

    SearchFlags(..)                         ,


-- ** ServiceFlags #flag:ServiceFlags#

    ServiceFlags(..)                        ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R


-- Flags ServiceFlags
-- | Flags which determine which parts of the t'GI.Secret.Objects.Service.Service' proxy are initialized
-- during a @/Service.get/@ or @/Service.open/@ operation.
data ServiceFlags = 
      ServiceFlagsNone
    -- ^ no flags for initializing the t'GI.Secret.Objects.Service.Service'
    | ServiceFlagsOpenSession
    -- ^ establish a session for transfer of secrets
    --   while initializing the t'GI.Secret.Objects.Service.Service'
    | ServiceFlagsLoadCollections
    -- ^ load collections while initializing the
    --   t'GI.Secret.Objects.Service.Service'
    | AnotherServiceFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ServiceFlags -> ShowS
[ServiceFlags] -> ShowS
ServiceFlags -> String
(Int -> ServiceFlags -> ShowS)
-> (ServiceFlags -> String)
-> ([ServiceFlags] -> ShowS)
-> Show ServiceFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ServiceFlags -> ShowS
showsPrec :: Int -> ServiceFlags -> ShowS
$cshow :: ServiceFlags -> String
show :: ServiceFlags -> String
$cshowList :: [ServiceFlags] -> ShowS
showList :: [ServiceFlags] -> ShowS
Show, ServiceFlags -> ServiceFlags -> Bool
(ServiceFlags -> ServiceFlags -> Bool)
-> (ServiceFlags -> ServiceFlags -> Bool) -> Eq ServiceFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ServiceFlags -> ServiceFlags -> Bool
== :: ServiceFlags -> ServiceFlags -> Bool
$c/= :: ServiceFlags -> ServiceFlags -> Bool
/= :: ServiceFlags -> ServiceFlags -> Bool
Eq)

instance P.Enum ServiceFlags where
    fromEnum :: ServiceFlags -> Int
fromEnum ServiceFlags
ServiceFlagsNone = Int
0
    fromEnum ServiceFlags
ServiceFlagsOpenSession = Int
2
    fromEnum ServiceFlags
ServiceFlagsLoadCollections = Int
4
    fromEnum (AnotherServiceFlags Int
k) = Int
k

    toEnum :: Int -> ServiceFlags
toEnum Int
0 = ServiceFlags
ServiceFlagsNone
    toEnum Int
2 = ServiceFlags
ServiceFlagsOpenSession
    toEnum Int
4 = ServiceFlags
ServiceFlagsLoadCollections
    toEnum Int
k = Int -> ServiceFlags
AnotherServiceFlags Int
k

instance P.Ord ServiceFlags where
    compare :: ServiceFlags -> ServiceFlags -> Ordering
compare ServiceFlags
a ServiceFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ServiceFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ServiceFlags
a) (ServiceFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ServiceFlags
b)

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

foreign import ccall "secret_service_flags_get_type" c_secret_service_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ServiceFlags where
    glibType :: IO GType
glibType = IO GType
c_secret_service_flags_get_type

instance B.Types.BoxedFlags ServiceFlags

instance IsGFlag ServiceFlags

-- Flags SearchFlags
-- | Various flags to be used with [method/@service@/.search] and [method/@service@/.search_sync].
data SearchFlags = 
      SearchFlagsNone
    -- ^ no flags
    | SearchFlagsAll
    -- ^ all the items matching the search will be returned, instead of just the first one
    | SearchFlagsUnlock
    -- ^ unlock locked items while searching
    | SearchFlagsLoadSecrets
    -- ^ while searching load secrets for items that are not locked
    | AnotherSearchFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SearchFlags -> ShowS
[SearchFlags] -> ShowS
SearchFlags -> String
(Int -> SearchFlags -> ShowS)
-> (SearchFlags -> String)
-> ([SearchFlags] -> ShowS)
-> Show SearchFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SearchFlags -> ShowS
showsPrec :: Int -> SearchFlags -> ShowS
$cshow :: SearchFlags -> String
show :: SearchFlags -> String
$cshowList :: [SearchFlags] -> ShowS
showList :: [SearchFlags] -> ShowS
Show, SearchFlags -> SearchFlags -> Bool
(SearchFlags -> SearchFlags -> Bool)
-> (SearchFlags -> SearchFlags -> Bool) -> Eq SearchFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SearchFlags -> SearchFlags -> Bool
== :: SearchFlags -> SearchFlags -> Bool
$c/= :: SearchFlags -> SearchFlags -> Bool
/= :: SearchFlags -> SearchFlags -> Bool
Eq)

instance P.Enum SearchFlags where
    fromEnum :: SearchFlags -> Int
fromEnum SearchFlags
SearchFlagsNone = Int
0
    fromEnum SearchFlags
SearchFlagsAll = Int
2
    fromEnum SearchFlags
SearchFlagsUnlock = Int
4
    fromEnum SearchFlags
SearchFlagsLoadSecrets = Int
8
    fromEnum (AnotherSearchFlags Int
k) = Int
k

    toEnum :: Int -> SearchFlags
toEnum Int
0 = SearchFlags
SearchFlagsNone
    toEnum Int
2 = SearchFlags
SearchFlagsAll
    toEnum Int
4 = SearchFlags
SearchFlagsUnlock
    toEnum Int
8 = SearchFlags
SearchFlagsLoadSecrets
    toEnum Int
k = Int -> SearchFlags
AnotherSearchFlags Int
k

instance P.Ord SearchFlags where
    compare :: SearchFlags -> SearchFlags -> Ordering
compare SearchFlags
a SearchFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SearchFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SearchFlags
a) (SearchFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SearchFlags
b)

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

foreign import ccall "secret_search_flags_get_type" c_secret_search_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SearchFlags where
    glibType :: IO GType
glibType = IO GType
c_secret_search_flags_get_type

instance B.Types.BoxedFlags SearchFlags

instance IsGFlag SearchFlags

-- Flags SchemaFlags
-- | Flags for a t'GI.Secret.Structs.Schema.Schema' definition.
data SchemaFlags = 
      SchemaFlagsNone
    -- ^ no flags for the schema
    | SchemaFlagsDontMatchName
    -- ^ don\'t match the schema name when looking up or
    --   removing passwords
    | AnotherSchemaFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SchemaFlags -> ShowS
[SchemaFlags] -> ShowS
SchemaFlags -> String
(Int -> SchemaFlags -> ShowS)
-> (SchemaFlags -> String)
-> ([SchemaFlags] -> ShowS)
-> Show SchemaFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SchemaFlags -> ShowS
showsPrec :: Int -> SchemaFlags -> ShowS
$cshow :: SchemaFlags -> String
show :: SchemaFlags -> String
$cshowList :: [SchemaFlags] -> ShowS
showList :: [SchemaFlags] -> ShowS
Show, SchemaFlags -> SchemaFlags -> Bool
(SchemaFlags -> SchemaFlags -> Bool)
-> (SchemaFlags -> SchemaFlags -> Bool) -> Eq SchemaFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SchemaFlags -> SchemaFlags -> Bool
== :: SchemaFlags -> SchemaFlags -> Bool
$c/= :: SchemaFlags -> SchemaFlags -> Bool
/= :: SchemaFlags -> SchemaFlags -> Bool
Eq)

instance P.Enum SchemaFlags where
    fromEnum :: SchemaFlags -> Int
fromEnum SchemaFlags
SchemaFlagsNone = Int
0
    fromEnum SchemaFlags
SchemaFlagsDontMatchName = Int
2
    fromEnum (AnotherSchemaFlags Int
k) = Int
k

    toEnum :: Int -> SchemaFlags
toEnum Int
0 = SchemaFlags
SchemaFlagsNone
    toEnum Int
2 = SchemaFlags
SchemaFlagsDontMatchName
    toEnum Int
k = Int -> SchemaFlags
AnotherSchemaFlags Int
k

instance P.Ord SchemaFlags where
    compare :: SchemaFlags -> SchemaFlags -> Ordering
compare SchemaFlags
a SchemaFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SchemaFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SchemaFlags
a) (SchemaFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SchemaFlags
b)

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

foreign import ccall "secret_schema_flags_get_type" c_secret_schema_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SchemaFlags where
    glibType :: IO GType
glibType = IO GType
c_secret_schema_flags_get_type

instance B.Types.BoxedFlags SchemaFlags

instance IsGFlag SchemaFlags

-- Flags ItemFlags
-- | Flags which determine which parts of the t'GI.Secret.Objects.Item.Item' proxy are initialized.
data ItemFlags = 
      ItemFlagsNone
    -- ^ no flags
    | ItemFlagsLoadSecret
    -- ^ a secret has been (or should be) loaded for t'GI.Secret.Objects.Item.Item'
    | AnotherItemFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ItemFlags -> ShowS
[ItemFlags] -> ShowS
ItemFlags -> String
(Int -> ItemFlags -> ShowS)
-> (ItemFlags -> String)
-> ([ItemFlags] -> ShowS)
-> Show ItemFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ItemFlags -> ShowS
showsPrec :: Int -> ItemFlags -> ShowS
$cshow :: ItemFlags -> String
show :: ItemFlags -> String
$cshowList :: [ItemFlags] -> ShowS
showList :: [ItemFlags] -> ShowS
Show, ItemFlags -> ItemFlags -> Bool
(ItemFlags -> ItemFlags -> Bool)
-> (ItemFlags -> ItemFlags -> Bool) -> Eq ItemFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ItemFlags -> ItemFlags -> Bool
== :: ItemFlags -> ItemFlags -> Bool
$c/= :: ItemFlags -> ItemFlags -> Bool
/= :: ItemFlags -> ItemFlags -> Bool
Eq)

instance P.Enum ItemFlags where
    fromEnum :: ItemFlags -> Int
fromEnum ItemFlags
ItemFlagsNone = Int
0
    fromEnum ItemFlags
ItemFlagsLoadSecret = Int
2
    fromEnum (AnotherItemFlags Int
k) = Int
k

    toEnum :: Int -> ItemFlags
toEnum Int
0 = ItemFlags
ItemFlagsNone
    toEnum Int
2 = ItemFlags
ItemFlagsLoadSecret
    toEnum Int
k = Int -> ItemFlags
AnotherItemFlags Int
k

instance P.Ord ItemFlags where
    compare :: ItemFlags -> ItemFlags -> Ordering
compare ItemFlags
a ItemFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ItemFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ItemFlags
a) (ItemFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ItemFlags
b)

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

foreign import ccall "secret_item_flags_get_type" c_secret_item_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ItemFlags where
    glibType :: IO GType
glibType = IO GType
c_secret_item_flags_get_type

instance B.Types.BoxedFlags ItemFlags

instance IsGFlag ItemFlags

-- Flags ItemCreateFlags
-- | Flags for @/Item.create/@.
data ItemCreateFlags = 
      ItemCreateFlagsNone
    -- ^ no flags
    | ItemCreateFlagsReplace
    -- ^ replace an item with the same attributes.
    | AnotherItemCreateFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ItemCreateFlags -> ShowS
[ItemCreateFlags] -> ShowS
ItemCreateFlags -> String
(Int -> ItemCreateFlags -> ShowS)
-> (ItemCreateFlags -> String)
-> ([ItemCreateFlags] -> ShowS)
-> Show ItemCreateFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ItemCreateFlags -> ShowS
showsPrec :: Int -> ItemCreateFlags -> ShowS
$cshow :: ItemCreateFlags -> String
show :: ItemCreateFlags -> String
$cshowList :: [ItemCreateFlags] -> ShowS
showList :: [ItemCreateFlags] -> ShowS
Show, ItemCreateFlags -> ItemCreateFlags -> Bool
(ItemCreateFlags -> ItemCreateFlags -> Bool)
-> (ItemCreateFlags -> ItemCreateFlags -> Bool)
-> Eq ItemCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ItemCreateFlags -> ItemCreateFlags -> Bool
== :: ItemCreateFlags -> ItemCreateFlags -> Bool
$c/= :: ItemCreateFlags -> ItemCreateFlags -> Bool
/= :: ItemCreateFlags -> ItemCreateFlags -> Bool
Eq)

instance P.Enum ItemCreateFlags where
    fromEnum :: ItemCreateFlags -> Int
fromEnum ItemCreateFlags
ItemCreateFlagsNone = Int
0
    fromEnum ItemCreateFlags
ItemCreateFlagsReplace = Int
2
    fromEnum (AnotherItemCreateFlags Int
k) = Int
k

    toEnum :: Int -> ItemCreateFlags
toEnum Int
0 = ItemCreateFlags
ItemCreateFlagsNone
    toEnum Int
2 = ItemCreateFlags
ItemCreateFlagsReplace
    toEnum Int
k = Int -> ItemCreateFlags
AnotherItemCreateFlags Int
k

instance P.Ord ItemCreateFlags where
    compare :: ItemCreateFlags -> ItemCreateFlags -> Ordering
compare ItemCreateFlags
a ItemCreateFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ItemCreateFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ItemCreateFlags
a) (ItemCreateFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ItemCreateFlags
b)

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

foreign import ccall "secret_item_create_flags_get_type" c_secret_item_create_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ItemCreateFlags where
    glibType :: IO GType
glibType = IO GType
c_secret_item_create_flags_get_type

instance B.Types.BoxedFlags ItemCreateFlags

instance IsGFlag ItemCreateFlags

-- Flags CollectionFlags
-- | Flags which determine which parts of the t'GI.Secret.Objects.Collection.Collection' proxy are initialized.
data CollectionFlags = 
      CollectionFlagsNone
    -- ^ no flags
    | CollectionFlagsLoadItems
    -- ^ items have or should be loaded
    | AnotherCollectionFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CollectionFlags -> ShowS
[CollectionFlags] -> ShowS
CollectionFlags -> String
(Int -> CollectionFlags -> ShowS)
-> (CollectionFlags -> String)
-> ([CollectionFlags] -> ShowS)
-> Show CollectionFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CollectionFlags -> ShowS
showsPrec :: Int -> CollectionFlags -> ShowS
$cshow :: CollectionFlags -> String
show :: CollectionFlags -> String
$cshowList :: [CollectionFlags] -> ShowS
showList :: [CollectionFlags] -> ShowS
Show, CollectionFlags -> CollectionFlags -> Bool
(CollectionFlags -> CollectionFlags -> Bool)
-> (CollectionFlags -> CollectionFlags -> Bool)
-> Eq CollectionFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CollectionFlags -> CollectionFlags -> Bool
== :: CollectionFlags -> CollectionFlags -> Bool
$c/= :: CollectionFlags -> CollectionFlags -> Bool
/= :: CollectionFlags -> CollectionFlags -> Bool
Eq)

instance P.Enum CollectionFlags where
    fromEnum :: CollectionFlags -> Int
fromEnum CollectionFlags
CollectionFlagsNone = Int
0
    fromEnum CollectionFlags
CollectionFlagsLoadItems = Int
2
    fromEnum (AnotherCollectionFlags Int
k) = Int
k

    toEnum :: Int -> CollectionFlags
toEnum Int
0 = CollectionFlags
CollectionFlagsNone
    toEnum Int
2 = CollectionFlags
CollectionFlagsLoadItems
    toEnum Int
k = Int -> CollectionFlags
AnotherCollectionFlags Int
k

instance P.Ord CollectionFlags where
    compare :: CollectionFlags -> CollectionFlags -> Ordering
compare CollectionFlags
a CollectionFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CollectionFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum CollectionFlags
a) (CollectionFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum CollectionFlags
b)

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

foreign import ccall "secret_collection_flags_get_type" c_secret_collection_flags_get_type :: 
    IO GType

instance B.Types.TypedObject CollectionFlags where
    glibType :: IO GType
glibType = IO GType
c_secret_collection_flags_get_type

instance B.Types.BoxedFlags CollectionFlags

instance IsGFlag CollectionFlags

-- Flags CollectionCreateFlags
-- | Flags for @/Collection.create/@.
data CollectionCreateFlags = 
      CollectionCreateFlagsNone
    -- ^ no flags
    | AnotherCollectionCreateFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CollectionCreateFlags -> ShowS
[CollectionCreateFlags] -> ShowS
CollectionCreateFlags -> String
(Int -> CollectionCreateFlags -> ShowS)
-> (CollectionCreateFlags -> String)
-> ([CollectionCreateFlags] -> ShowS)
-> Show CollectionCreateFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CollectionCreateFlags -> ShowS
showsPrec :: Int -> CollectionCreateFlags -> ShowS
$cshow :: CollectionCreateFlags -> String
show :: CollectionCreateFlags -> String
$cshowList :: [CollectionCreateFlags] -> ShowS
showList :: [CollectionCreateFlags] -> ShowS
Show, CollectionCreateFlags -> CollectionCreateFlags -> Bool
(CollectionCreateFlags -> CollectionCreateFlags -> Bool)
-> (CollectionCreateFlags -> CollectionCreateFlags -> Bool)
-> Eq CollectionCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CollectionCreateFlags -> CollectionCreateFlags -> Bool
== :: CollectionCreateFlags -> CollectionCreateFlags -> Bool
$c/= :: CollectionCreateFlags -> CollectionCreateFlags -> Bool
/= :: CollectionCreateFlags -> CollectionCreateFlags -> Bool
Eq)

instance P.Enum CollectionCreateFlags where
    fromEnum :: CollectionCreateFlags -> Int
fromEnum CollectionCreateFlags
CollectionCreateFlagsNone = Int
0
    fromEnum (AnotherCollectionCreateFlags Int
k) = Int
k

    toEnum :: Int -> CollectionCreateFlags
toEnum Int
0 = CollectionCreateFlags
CollectionCreateFlagsNone
    toEnum Int
k = Int -> CollectionCreateFlags
AnotherCollectionCreateFlags Int
k

instance P.Ord CollectionCreateFlags where
    compare :: CollectionCreateFlags -> CollectionCreateFlags -> Ordering
compare CollectionCreateFlags
a CollectionCreateFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CollectionCreateFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum CollectionCreateFlags
a) (CollectionCreateFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum CollectionCreateFlags
b)

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

foreign import ccall "secret_collection_create_flags_get_type" c_secret_collection_create_flags_get_type :: 
    IO GType

instance B.Types.TypedObject CollectionCreateFlags where
    glibType :: IO GType
glibType = IO GType
c_secret_collection_create_flags_get_type

instance B.Types.BoxedFlags CollectionCreateFlags

instance IsGFlag CollectionCreateFlags