1 files changed, 591 insertions, 0 deletions
diff --git a/libsecret/src/auto/flags.rs b/libsecret/src/auto/flags.rs
new file mode 100644
index 0000000..81c0f71
--- /dev/null
+++ b/libsecret/src/auto/flags.rs
@@ -0,0 +1,591 @@
+// This file was generated by gir (https://github.com/gtk-rs/gir)
+// from
+// from gir-files (https://github.com/gtk-rs/gir-files.git)
+// DO NOT EDIT
+
+use glib::{bitflags::bitflags, prelude::*, translate::*};
+
+bitflags! {
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+    #[doc(alias = "SecretCollectionCreateFlags")]
+    pub struct CollectionCreateFlags: u32 {
+        #[doc(alias = "SECRET_COLLECTION_CREATE_NONE")]
+        const NONE = ffi::SECRET_COLLECTION_CREATE_NONE as _;
+    }
+}
+
+#[doc(hidden)]
+impl IntoGlib for CollectionCreateFlags {
+    type GlibType = ffi::SecretCollectionCreateFlags;
+
+    #[inline]
+    fn into_glib(self) -> ffi::SecretCollectionCreateFlags {
+        self.bits()
+    }
+}
+
+#[doc(hidden)]
+impl FromGlib<ffi::SecretCollectionCreateFlags> for CollectionCreateFlags {
+    #[inline]
+    unsafe fn from_glib(value: ffi::SecretCollectionCreateFlags) -> Self {
+        Self::from_bits_truncate(value)
+    }
+}
+
+impl StaticType for CollectionCreateFlags {
+    #[inline]
+    #[doc(alias = "secret_collection_create_flags_get_type")]
+    fn static_type() -> glib::Type {
+        unsafe { from_glib(ffi::secret_collection_create_flags_get_type()) }
+    }
+}
+
+impl glib::HasParamSpec for CollectionCreateFlags {
+    type ParamSpec = glib::ParamSpecFlags;
+    type SetValue = Self;
+    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
+
+    fn param_spec_builder() -> Self::BuilderFn {
+        Self::ParamSpec::builder
+    }
+}
+
+impl glib::value::ValueType for CollectionCreateFlags {
+    type Type = Self;
+}
+
+unsafe impl<'a> glib::value::FromValue<'a> for CollectionCreateFlags {
+    type Checker = glib::value::GenericValueTypeChecker<Self>;
+
+    #[inline]
+    unsafe fn from_value(value: &'a glib::Value) -> Self {
+        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
+    }
+}
+
+impl ToValue for CollectionCreateFlags {
+    #[inline]
+    fn to_value(&self) -> glib::Value {
+        let mut value = glib::Value::for_value_type::<Self>();
+        unsafe {
+            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
+        }
+        value
+    }
+
+    #[inline]
+    fn value_type(&self) -> glib::Type {
+        Self::static_type()
+    }
+}
+
+impl From<CollectionCreateFlags> for glib::Value {
+    #[inline]
+    fn from(v: CollectionCreateFlags) -> Self {
+        ToValue::to_value(&v)
+    }
+}
+
+bitflags! {
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+    #[doc(alias = "SecretCollectionFlags")]
+    pub struct CollectionFlags: u32 {
+        #[doc(alias = "SECRET_COLLECTION_NONE")]
+        const NONE = ffi::SECRET_COLLECTION_NONE as _;
+        #[doc(alias = "SECRET_COLLECTION_LOAD_ITEMS")]
+        const LOAD_ITEMS = ffi::SECRET_COLLECTION_LOAD_ITEMS as _;
+    }
+}
+
+#[doc(hidden)]
+impl IntoGlib for CollectionFlags {
+    type GlibType = ffi::SecretCollectionFlags;
+
+    #[inline]
+    fn into_glib(self) -> ffi::SecretCollectionFlags {
+        self.bits()
+    }
+}
+
+#[doc(hidden)]
+impl FromGlib<ffi::SecretCollectionFlags> for CollectionFlags {
+    #[inline]
+    unsafe fn from_glib(value: ffi::SecretCollectionFlags) -> Self {
+        Self::from_bits_truncate(value)
+    }
+}
+
+impl StaticType for CollectionFlags {
+    #[inline]
+    #[doc(alias = "secret_collection_flags_get_type")]
+    fn static_type() -> glib::Type {
+        unsafe { from_glib(ffi::secret_collection_flags_get_type()) }
+    }
+}
+
+impl glib::HasParamSpec for CollectionFlags {
+    type ParamSpec = glib::ParamSpecFlags;
+    type SetValue = Self;
+    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
+
+    fn param_spec_builder() -> Self::BuilderFn {
+        Self::ParamSpec::builder
+    }
+}
+
+impl glib::value::ValueType for CollectionFlags {
+    type Type = Self;
+}
+
+unsafe impl<'a> glib::value::FromValue<'a> for CollectionFlags {
+    type Checker = glib::value::GenericValueTypeChecker<Self>;
+
+    #[inline]
+    unsafe fn from_value(value: &'a glib::Value) -> Self {
+        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
+    }
+}
+
+impl ToValue for CollectionFlags {
+    #[inline]
+    fn to_value(&self) -> glib::Value {
+        let mut value = glib::Value::for_value_type::<Self>();
+        unsafe {
+            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
+        }
+        value
+    }
+
+    #[inline]
+    fn value_type(&self) -> glib::Type {
+        Self::static_type()
+    }
+}
+
+impl From<CollectionFlags> for glib::Value {
+    #[inline]
+    fn from(v: CollectionFlags) -> Self {
+        ToValue::to_value(&v)
+    }
+}
+
+bitflags! {
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+    #[doc(alias = "SecretItemCreateFlags")]
+    pub struct ItemCreateFlags: u32 {
+        #[doc(alias = "SECRET_ITEM_CREATE_NONE")]
+        const NONE = ffi::SECRET_ITEM_CREATE_NONE as _;
+        #[doc(alias = "SECRET_ITEM_CREATE_REPLACE")]
+        const REPLACE = ffi::SECRET_ITEM_CREATE_REPLACE as _;
+    }
+}
+
+#[doc(hidden)]
+impl IntoGlib for ItemCreateFlags {
+    type GlibType = ffi::SecretItemCreateFlags;
+
+    #[inline]
+    fn into_glib(self) -> ffi::SecretItemCreateFlags {
+        self.bits()
+    }
+}
+
+#[doc(hidden)]
+impl FromGlib<ffi::SecretItemCreateFlags> for ItemCreateFlags {
+    #[inline]
+    unsafe fn from_glib(value: ffi::SecretItemCreateFlags) -> Self {
+        Self::from_bits_truncate(value)
+    }
+}
+
+impl StaticType for ItemCreateFlags {
+    #[inline]
+    #[doc(alias = "secret_item_create_flags_get_type")]
+    fn static_type() -> glib::Type {
+        unsafe { from_glib(ffi::secret_item_create_flags_get_type()) }
+    }
+}
+
+impl glib::HasParamSpec for ItemCreateFlags {
+    type ParamSpec = glib::ParamSpecFlags;
+    type SetValue = Self;
+    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
+
+    fn param_spec_builder() -> Self::BuilderFn {
+        Self::ParamSpec::builder
+    }
+}
+
+impl glib::value::ValueType for ItemCreateFlags {
+    type Type = Self;
+}
+
+unsafe impl<'a> glib::value::FromValue<'a> for ItemCreateFlags {
+    type Checker = glib::value::GenericValueTypeChecker<Self>;
+
+    #[inline]
+    unsafe fn from_value(value: &'a glib::Value) -> Self {
+        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
+    }
+}
+
+impl ToValue for ItemCreateFlags {
+    #[inline]
+    fn to_value(&self) -> glib::Value {
+        let mut value = glib::Value::for_value_type::<Self>();
+        unsafe {
+            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
+        }
+        value
+    }
+
+    #[inline]
+    fn value_type(&self) -> glib::Type {
+        Self::static_type()
+    }
+}
+
+impl From<ItemCreateFlags> for glib::Value {
+    #[inline]
+    fn from(v: ItemCreateFlags) -> Self {
+        ToValue::to_value(&v)
+    }
+}
+
+bitflags! {
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+    #[doc(alias = "SecretItemFlags")]
+    pub struct ItemFlags: u32 {
+        #[doc(alias = "SECRET_ITEM_NONE")]
+        const NONE = ffi::SECRET_ITEM_NONE as _;
+        #[doc(alias = "SECRET_ITEM_LOAD_SECRET")]
+        const LOAD_SECRET = ffi::SECRET_ITEM_LOAD_SECRET as _;
+    }
+}
+
+#[doc(hidden)]
+impl IntoGlib for ItemFlags {
+    type GlibType = ffi::SecretItemFlags;
+
+    #[inline]
+    fn into_glib(self) -> ffi::SecretItemFlags {
+        self.bits()
+    }
+}
+
+#[doc(hidden)]
+impl FromGlib<ffi::SecretItemFlags> for ItemFlags {
+    #[inline]
+    unsafe fn from_glib(value: ffi::SecretItemFlags) -> Self {
+        Self::from_bits_truncate(value)
+    }
+}
+
+impl StaticType for ItemFlags {
+    #[inline]
+    #[doc(alias = "secret_item_flags_get_type")]
+    fn static_type() -> glib::Type {
+        unsafe { from_glib(ffi::secret_item_flags_get_type()) }
+    }
+}
+
+impl glib::HasParamSpec for ItemFlags {
+    type ParamSpec = glib::ParamSpecFlags;
+    type SetValue = Self;
+    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
+
+    fn param_spec_builder() -> Self::BuilderFn {
+        Self::ParamSpec::builder
+    }
+}
+
+impl glib::value::ValueType for ItemFlags {
+    type Type = Self;
+}
+
+unsafe impl<'a> glib::value::FromValue<'a> for ItemFlags {
+    type Checker = glib::value::GenericValueTypeChecker<Self>;
+
+    #[inline]
+    unsafe fn from_value(value: &'a glib::Value) -> Self {
+        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
+    }
+}
+
+impl ToValue for ItemFlags {
+    #[inline]
+    fn to_value(&self) -> glib::Value {
+        let mut value = glib::Value::for_value_type::<Self>();
+        unsafe {
+            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
+        }
+        value
+    }
+
+    #[inline]
+    fn value_type(&self) -> glib::Type {
+        Self::static_type()
+    }
+}
+
+impl From<ItemFlags> for glib::Value {
+    #[inline]
+    fn from(v: ItemFlags) -> Self {
+        ToValue::to_value(&v)
+    }
+}
+
+bitflags! {
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+    #[doc(alias = "SecretSchemaFlags")]
+    pub struct SchemaFlags: u32 {
+        #[doc(alias = "SECRET_SCHEMA_NONE")]
+        const NONE = ffi::SECRET_SCHEMA_NONE as _;
+        #[doc(alias = "SECRET_SCHEMA_DONT_MATCH_NAME")]
+        const DONT_MATCH_NAME = ffi::SECRET_SCHEMA_DONT_MATCH_NAME as _;
+    }
+}
+
+#[doc(hidden)]
+impl IntoGlib for SchemaFlags {
+    type GlibType = ffi::SecretSchemaFlags;
+
+    #[inline]
+    fn into_glib(self) -> ffi::SecretSchemaFlags {
+        self.bits()
+    }
+}
+
+#[doc(hidden)]
+impl FromGlib<ffi::SecretSchemaFlags> for SchemaFlags {
+    #[inline]
+    unsafe fn from_glib(value: ffi::SecretSchemaFlags) -> Self {
+        Self::from_bits_truncate(value)
+    }
+}
+
+impl StaticType for SchemaFlags {
+    #[inline]
+    #[doc(alias = "secret_schema_flags_get_type")]
+    fn static_type() -> glib::Type {
+        unsafe { from_glib(ffi::secret_schema_flags_get_type()) }
+    }
+}
+
+impl glib::HasParamSpec for SchemaFlags {
+    type ParamSpec = glib::ParamSpecFlags;
+    type SetValue = Self;
+    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
+
+    fn param_spec_builder() -> Self::BuilderFn {
+        Self::ParamSpec::builder
+    }
+}
+
+impl glib::value::ValueType for SchemaFlags {
+    type Type = Self;
+}
+
+unsafe impl<'a> glib::value::FromValue<'a> for SchemaFlags {
+    type Checker = glib::value::GenericValueTypeChecker<Self>;
+
+    #[inline]
+    unsafe fn from_value(value: &'a glib::Value) -> Self {
+        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
+    }
+}
+
+impl ToValue for SchemaFlags {
+    #[inline]
+    fn to_value(&self) -> glib::Value {
+        let mut value = glib::Value::for_value_type::<Self>();
+        unsafe {
+            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
+        }
+        value
+    }
+
+    #[inline]
+    fn value_type(&self) -> glib::Type {
+        Self::static_type()
+    }
+}
+
+impl From<SchemaFlags> for glib::Value {
+    #[inline]
+    fn from(v: SchemaFlags) -> Self {
+        ToValue::to_value(&v)
+    }
+}
+
+bitflags! {
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+    #[doc(alias = "SecretSearchFlags")]
+    pub struct SearchFlags: u32 {
+        #[doc(alias = "SECRET_SEARCH_NONE")]
+        const NONE = ffi::SECRET_SEARCH_NONE as _;
+        #[doc(alias = "SECRET_SEARCH_ALL")]
+        const ALL = ffi::SECRET_SEARCH_ALL as _;
+        #[doc(alias = "SECRET_SEARCH_UNLOCK")]
+        const UNLOCK = ffi::SECRET_SEARCH_UNLOCK as _;
+        #[doc(alias = "SECRET_SEARCH_LOAD_SECRETS")]
+        const LOAD_SECRETS = ffi::SECRET_SEARCH_LOAD_SECRETS as _;
+    }
+}
+
+#[doc(hidden)]
+impl IntoGlib for SearchFlags {
+    type GlibType = ffi::SecretSearchFlags;
+
+    #[inline]
+    fn into_glib(self) -> ffi::SecretSearchFlags {
+        self.bits()
+    }
+}
+
+#[doc(hidden)]
+impl FromGlib<ffi::SecretSearchFlags> for SearchFlags {
+    #[inline]
+    unsafe fn from_glib(value: ffi::SecretSearchFlags) -> Self {
+        Self::from_bits_truncate(value)
+    }
+}
+
+impl StaticType for SearchFlags {
+    #[inline]
+    #[doc(alias = "secret_search_flags_get_type")]
+    fn static_type() -> glib::Type {
+        unsafe { from_glib(ffi::secret_search_flags_get_type()) }
+    }
+}
+
+impl glib::HasParamSpec for SearchFlags {
+    type ParamSpec = glib::ParamSpecFlags;
+    type SetValue = Self;
+    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
+
+    fn param_spec_builder() -> Self::BuilderFn {
+        Self::ParamSpec::builder
+    }
+}
+
+impl glib::value::ValueType for SearchFlags {
+    type Type = Self;
+}
+
+unsafe impl<'a> glib::value::FromValue<'a> for SearchFlags {
+    type Checker = glib::value::GenericValueTypeChecker<Self>;
+
+    #[inline]
+    unsafe fn from_value(value: &'a glib::Value) -> Self {
+        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
+    }
+}
+
+impl ToValue for SearchFlags {
+    #[inline]
+    fn to_value(&self) -> glib::Value {
+        let mut value = glib::Value::for_value_type::<Self>();
+        unsafe {
+            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
+        }
+        value
+    }
+
+    #[inline]
+    fn value_type(&self) -> glib::Type {
+        Self::static_type()
+    }
+}
+
+impl From<SearchFlags> for glib::Value {
+    #[inline]
+    fn from(v: SearchFlags) -> Self {
+        ToValue::to_value(&v)
+    }
+}
+
+bitflags! {
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+    #[doc(alias = "SecretServiceFlags")]
+    pub struct ServiceFlags: u32 {
+        #[doc(alias = "SECRET_SERVICE_NONE")]
+        const NONE = ffi::SECRET_SERVICE_NONE as _;
+        #[doc(alias = "SECRET_SERVICE_OPEN_SESSION")]
+        const OPEN_SESSION = ffi::SECRET_SERVICE_OPEN_SESSION as _;
+        #[doc(alias = "SECRET_SERVICE_LOAD_COLLECTIONS")]
+        const LOAD_COLLECTIONS = ffi::SECRET_SERVICE_LOAD_COLLECTIONS as _;
+    }
+}
+
+#[doc(hidden)]
+impl IntoGlib for ServiceFlags {
+    type GlibType = ffi::SecretServiceFlags;
+
+    #[inline]
+    fn into_glib(self) -> ffi::SecretServiceFlags {
+        self.bits()
+    }
+}
+
+#[doc(hidden)]
+impl FromGlib<ffi::SecretServiceFlags> for ServiceFlags {
+    #[inline]
+    unsafe fn from_glib(value: ffi::SecretServiceFlags) -> Self {
+        Self::from_bits_truncate(value)
+    }
+}
+
+impl StaticType for ServiceFlags {
+    #[inline]
+    #[doc(alias = "secret_service_flags_get_type")]
+    fn static_type() -> glib::Type {
+        unsafe { from_glib(ffi::secret_service_flags_get_type()) }
+    }
+}
+
+impl glib::HasParamSpec for ServiceFlags {
+    type ParamSpec = glib::ParamSpecFlags;
+    type SetValue = Self;
+    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
+
+    fn param_spec_builder() -> Self::BuilderFn {
+        Self::ParamSpec::builder
+    }
+}
+
+impl glib::value::ValueType for ServiceFlags {
+    type Type = Self;
+}
+
+unsafe impl<'a> glib::value::FromValue<'a> for ServiceFlags {
+    type Checker = glib::value::GenericValueTypeChecker<Self>;
+
+    #[inline]
+    unsafe fn from_value(value: &'a glib::Value) -> Self {
+        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
+    }
+}
+
+impl ToValue for ServiceFlags {
+    #[inline]
+    fn to_value(&self) -> glib::Value {
+        let mut value = glib::Value::for_value_type::<Self>();
+        unsafe {
+            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
+        }
+        value
+    }
+
+    #[inline]
+    fn value_type(&self) -> glib::Type {
+        Self::static_type()
+    }
+}
+
+impl From<ServiceFlags> for glib::Value {
+    #[inline]
+    fn from(v: ServiceFlags) -> Self {
+        ToValue::to_value(&v)
+    }
+}