// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git)
// DO NOT EDIT

use bitflags::bitflags;
use glib::translate::*;
use glib::value::FromValue;
use glib::value::ToValue;
use glib::StaticType;
use glib::Type;
#[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
use std::ffi::CStr;
#[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
use std::fmt;

bitflags! {
    /// GstBinFlags are a set of flags specific to bins. Most are set/used
    /// internally. They can be checked using the GST_OBJECT_FLAG_IS_SET() macro,
    /// and (un)set using GST_OBJECT_FLAG_SET() and GST_OBJECT_FLAG_UNSET().
    #[doc(alias = "GstBinFlags")]
    pub struct BinFlags: u32 {
        /// Don't resync a state change when elements are added or linked in the bin
        #[doc(alias = "GST_BIN_FLAG_NO_RESYNC")]
        const NO_RESYNC = ffi::GST_BIN_FLAG_NO_RESYNC as u32;
        /// Indicates whether the bin can handle elements that add/remove source pads
        /// at any point in time without first posting a no-more-pads signal.
        #[cfg(any(feature = "v1_10", feature = "dox"))]
        #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
        #[doc(alias = "GST_BIN_FLAG_STREAMS_AWARE")]
        const STREAMS_AWARE = ffi::GST_BIN_FLAG_STREAMS_AWARE as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for BinFlags {
    type GlibType = ffi::GstBinFlags;

    fn into_glib(self) -> ffi::GstBinFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstBinFlags> for BinFlags {
    unsafe fn from_glib(value: ffi::GstBinFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for BinFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_bin_flags_get_type()) }
    }
}

impl glib::value::ValueType for BinFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for BinFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for BinFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// A set of flags that can be provided to the [`Buffer::copy_into()`][crate::Buffer::copy_into()]
    /// function to specify which items should be copied.
    #[doc(alias = "GstBufferCopyFlags")]
    pub struct BufferCopyFlags: u32 {
        /// flag indicating that buffer flags should be copied
        #[doc(alias = "GST_BUFFER_COPY_FLAGS")]
        const FLAGS = ffi::GST_BUFFER_COPY_FLAGS as u32;
        /// flag indicating that buffer pts, dts,
        ///  duration, offset and offset_end should be copied
        #[doc(alias = "GST_BUFFER_COPY_TIMESTAMPS")]
        const TIMESTAMPS = ffi::GST_BUFFER_COPY_TIMESTAMPS as u32;
        /// flag indicating that buffer meta should be
        ///  copied
        #[doc(alias = "GST_BUFFER_COPY_META")]
        const META = ffi::GST_BUFFER_COPY_META as u32;
        /// flag indicating that buffer memory should be reffed
        ///  and appended to already existing memory. Unless the memory is marked as
        ///  NO_SHARE, no actual copy of the memory is made but it is simply reffed.
        ///  Add [`DEEP`][Self::DEEP] to force a real copy.
        #[doc(alias = "GST_BUFFER_COPY_MEMORY")]
        const MEMORY = ffi::GST_BUFFER_COPY_MEMORY as u32;
        /// flag indicating that buffer memory should be
        ///  merged
        #[doc(alias = "GST_BUFFER_COPY_MERGE")]
        const MERGE = ffi::GST_BUFFER_COPY_MERGE as u32;
        /// flag indicating that memory should always be copied instead of reffed
        #[doc(alias = "GST_BUFFER_COPY_DEEP")]
        const DEEP = ffi::GST_BUFFER_COPY_DEEP as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for BufferCopyFlags {
    type GlibType = ffi::GstBufferCopyFlags;

    fn into_glib(self) -> ffi::GstBufferCopyFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstBufferCopyFlags> for BufferCopyFlags {
    unsafe fn from_glib(value: ffi::GstBufferCopyFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for BufferCopyFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_buffer_copy_flags_get_type()) }
    }
}

impl glib::value::ValueType for BufferCopyFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for BufferCopyFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for BufferCopyFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// A set of buffer flags used to describe properties of a [`Buffer`][crate::Buffer].
    #[cfg_attr(feature = "ser_de", derive(serde::Serialize, serde::Deserialize))]
    #[doc(alias = "GstBufferFlags")]
    pub struct BufferFlags: u32 {
        /// the buffer is live data and should be discarded in
        ///  the PAUSED state.
        #[doc(alias = "GST_BUFFER_FLAG_LIVE")]
        const LIVE = ffi::GST_BUFFER_FLAG_LIVE as u32;
        /// the buffer contains data that should be dropped
        ///  because it will be clipped against the segment
        ///  boundaries or because it does not contain data
        ///  that should be shown to the user.
        #[doc(alias = "GST_BUFFER_FLAG_DECODE_ONLY")]
        const DECODE_ONLY = ffi::GST_BUFFER_FLAG_DECODE_ONLY as u32;
        /// the buffer marks a data discontinuity in the stream.
        ///  This typically occurs after a seek or a dropped buffer
        ///  from a live or network source.
        #[doc(alias = "GST_BUFFER_FLAG_DISCONT")]
        const DISCONT = ffi::GST_BUFFER_FLAG_DISCONT as u32;
        /// the buffer timestamps might have a discontinuity
        ///  and this buffer is a good point to resynchronize.
        #[doc(alias = "GST_BUFFER_FLAG_RESYNC")]
        const RESYNC = ffi::GST_BUFFER_FLAG_RESYNC as u32;
        /// the buffer data is corrupted.
        #[doc(alias = "GST_BUFFER_FLAG_CORRUPTED")]
        const CORRUPTED = ffi::GST_BUFFER_FLAG_CORRUPTED as u32;
        /// the buffer contains a media specific marker. for
        ///  video this is the end of a frame boundary, for audio
        ///  this is the start of a talkspurt.
        #[doc(alias = "GST_BUFFER_FLAG_MARKER")]
        const MARKER = ffi::GST_BUFFER_FLAG_MARKER as u32;
        /// the buffer contains header information that is
        ///  needed to decode the following data.
        #[doc(alias = "GST_BUFFER_FLAG_HEADER")]
        const HEADER = ffi::GST_BUFFER_FLAG_HEADER as u32;
        /// the buffer has been created to fill a gap in the
        ///  stream and contains media neutral data (elements can
        ///  switch to optimized code path that ignores the buffer
        ///  content).
        #[doc(alias = "GST_BUFFER_FLAG_GAP")]
        const GAP = ffi::GST_BUFFER_FLAG_GAP as u32;
        /// the buffer can be dropped without breaking the
        ///  stream, for example to reduce bandwidth.
        #[doc(alias = "GST_BUFFER_FLAG_DROPPABLE")]
        const DROPPABLE = ffi::GST_BUFFER_FLAG_DROPPABLE as u32;
        /// this unit cannot be decoded independently.
        #[doc(alias = "GST_BUFFER_FLAG_DELTA_UNIT")]
        const DELTA_UNIT = ffi::GST_BUFFER_FLAG_DELTA_UNIT as u32;
        /// this flag is set when memory of the buffer
        ///  is added/removed
        #[doc(alias = "GST_BUFFER_FLAG_TAG_MEMORY")]
        const TAG_MEMORY = ffi::GST_BUFFER_FLAG_TAG_MEMORY as u32;
        /// Elements which write to disk or permanent storage should ensure the data
        /// is synced after writing the contents of this buffer.
        #[doc(alias = "GST_BUFFER_FLAG_SYNC_AFTER")]
        const SYNC_AFTER = ffi::GST_BUFFER_FLAG_SYNC_AFTER as u32;
        /// This buffer is important and should not be dropped.
        ///
        /// This can be used to mark important buffers, e.g. to flag RTP packets
        /// carrying keyframes or codec setup data for RTP Forward Error Correction
        /// purposes, or to prevent still video frames from being dropped by elements
        /// due to QoS.
        #[cfg(any(feature = "v1_14", feature = "dox"))]
        #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
        #[doc(alias = "GST_BUFFER_FLAG_NON_DROPPABLE")]
        const NON_DROPPABLE = ffi::GST_BUFFER_FLAG_NON_DROPPABLE as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for BufferFlags {
    type GlibType = ffi::GstBufferFlags;

    fn into_glib(self) -> ffi::GstBufferFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstBufferFlags> for BufferFlags {
    unsafe fn from_glib(value: ffi::GstBufferFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for BufferFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_buffer_flags_get_type()) }
    }
}

impl glib::value::ValueType for BufferFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for BufferFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for BufferFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// Additional flags to control the allocation of a buffer
    #[doc(alias = "GstBufferPoolAcquireFlags")]
    pub struct BufferPoolAcquireFlags: u32 {
        /// buffer is keyframe
        #[doc(alias = "GST_BUFFER_POOL_ACQUIRE_FLAG_KEY_UNIT")]
        const KEY_UNIT = ffi::GST_BUFFER_POOL_ACQUIRE_FLAG_KEY_UNIT as u32;
        /// when the bufferpool is empty, acquire_buffer
        /// will by default block until a buffer is released into the pool again. Setting
        /// this flag makes acquire_buffer return [`FlowReturn::Eos`][crate::FlowReturn::Eos] instead of blocking.
        #[doc(alias = "GST_BUFFER_POOL_ACQUIRE_FLAG_DONTWAIT")]
        const DONTWAIT = ffi::GST_BUFFER_POOL_ACQUIRE_FLAG_DONTWAIT as u32;
        /// buffer is discont
        #[doc(alias = "GST_BUFFER_POOL_ACQUIRE_FLAG_DISCONT")]
        const DISCONT = ffi::GST_BUFFER_POOL_ACQUIRE_FLAG_DISCONT as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for BufferPoolAcquireFlags {
    type GlibType = ffi::GstBufferPoolAcquireFlags;

    fn into_glib(self) -> ffi::GstBufferPoolAcquireFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstBufferPoolAcquireFlags> for BufferPoolAcquireFlags {
    unsafe fn from_glib(value: ffi::GstBufferPoolAcquireFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for BufferPoolAcquireFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_buffer_pool_acquire_flags_get_type()) }
    }
}

impl glib::value::ValueType for BufferPoolAcquireFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for BufferPoolAcquireFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for BufferPoolAcquireFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// The capabilities of this clock
    #[doc(alias = "GstClockFlags")]
    pub struct ClockFlags: u32 {
        /// clock can do a single sync timeout request
        #[doc(alias = "GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC")]
        const CAN_DO_SINGLE_SYNC = ffi::GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC as u32;
        /// clock can do a single async timeout request
        #[doc(alias = "GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC")]
        const CAN_DO_SINGLE_ASYNC = ffi::GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC as u32;
        /// clock can do sync periodic timeout requests
        #[doc(alias = "GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC")]
        const CAN_DO_PERIODIC_SYNC = ffi::GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC as u32;
        /// clock can do async periodic timeout callbacks
        #[doc(alias = "GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC")]
        const CAN_DO_PERIODIC_ASYNC = ffi::GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC as u32;
        /// clock's resolution can be changed
        #[doc(alias = "GST_CLOCK_FLAG_CAN_SET_RESOLUTION")]
        const CAN_SET_RESOLUTION = ffi::GST_CLOCK_FLAG_CAN_SET_RESOLUTION as u32;
        /// clock can be slaved to a master clock
        #[doc(alias = "GST_CLOCK_FLAG_CAN_SET_MASTER")]
        const CAN_SET_MASTER = ffi::GST_CLOCK_FLAG_CAN_SET_MASTER as u32;
        /// clock needs to be synced before it can be used
        #[doc(alias = "GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC")]
        const NEEDS_STARTUP_SYNC = ffi::GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for ClockFlags {
    type GlibType = ffi::GstClockFlags;

    fn into_glib(self) -> ffi::GstClockFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstClockFlags> for ClockFlags {
    unsafe fn from_glib(value: ffi::GstClockFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for ClockFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_clock_flags_get_type()) }
    }
}

impl glib::value::ValueType for ClockFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for ClockFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for ClockFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// These are some terminal style flags you can use when creating your
    /// debugging categories to make them stand out in debugging output.
    #[doc(alias = "GstDebugColorFlags")]
    pub struct DebugColorFlags: u32 {
        /// Use black as foreground color.
        #[doc(alias = "GST_DEBUG_FG_BLACK")]
        const FG_BLACK = ffi::GST_DEBUG_FG_BLACK as u32;
        /// Use red as foreground color.
        #[doc(alias = "GST_DEBUG_FG_RED")]
        const FG_RED = ffi::GST_DEBUG_FG_RED as u32;
        /// Use green as foreground color.
        #[doc(alias = "GST_DEBUG_FG_GREEN")]
        const FG_GREEN = ffi::GST_DEBUG_FG_GREEN as u32;
        /// Use yellow as foreground color.
        #[doc(alias = "GST_DEBUG_FG_YELLOW")]
        const FG_YELLOW = ffi::GST_DEBUG_FG_YELLOW as u32;
        /// Use blue as foreground color.
        #[doc(alias = "GST_DEBUG_FG_BLUE")]
        const FG_BLUE = ffi::GST_DEBUG_FG_BLUE as u32;
        /// Use magenta as foreground color.
        #[doc(alias = "GST_DEBUG_FG_MAGENTA")]
        const FG_MAGENTA = ffi::GST_DEBUG_FG_MAGENTA as u32;
        /// Use cyan as foreground color.
        #[doc(alias = "GST_DEBUG_FG_CYAN")]
        const FG_CYAN = ffi::GST_DEBUG_FG_CYAN as u32;
        /// Use white as foreground color.
        #[doc(alias = "GST_DEBUG_FG_WHITE")]
        const FG_WHITE = ffi::GST_DEBUG_FG_WHITE as u32;
        /// Use black as background color.
        #[doc(alias = "GST_DEBUG_BG_BLACK")]
        const BG_BLACK = ffi::GST_DEBUG_BG_BLACK as u32;
        /// Use red as background color.
        #[doc(alias = "GST_DEBUG_BG_RED")]
        const BG_RED = ffi::GST_DEBUG_BG_RED as u32;
        /// Use green as background color.
        #[doc(alias = "GST_DEBUG_BG_GREEN")]
        const BG_GREEN = ffi::GST_DEBUG_BG_GREEN as u32;
        /// Use yellow as background color.
        #[doc(alias = "GST_DEBUG_BG_YELLOW")]
        const BG_YELLOW = ffi::GST_DEBUG_BG_YELLOW as u32;
        /// Use blue as background color.
        #[doc(alias = "GST_DEBUG_BG_BLUE")]
        const BG_BLUE = ffi::GST_DEBUG_BG_BLUE as u32;
        /// Use magenta as background color.
        #[doc(alias = "GST_DEBUG_BG_MAGENTA")]
        const BG_MAGENTA = ffi::GST_DEBUG_BG_MAGENTA as u32;
        /// Use cyan as background color.
        #[doc(alias = "GST_DEBUG_BG_CYAN")]
        const BG_CYAN = ffi::GST_DEBUG_BG_CYAN as u32;
        /// Use white as background color.
        #[doc(alias = "GST_DEBUG_BG_WHITE")]
        const BG_WHITE = ffi::GST_DEBUG_BG_WHITE as u32;
        /// Make the output bold.
        #[doc(alias = "GST_DEBUG_BOLD")]
        const BOLD = ffi::GST_DEBUG_BOLD as u32;
        /// Underline the output.
        #[doc(alias = "GST_DEBUG_UNDERLINE")]
        const UNDERLINE = ffi::GST_DEBUG_UNDERLINE as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for DebugColorFlags {
    type GlibType = ffi::GstDebugColorFlags;

    fn into_glib(self) -> ffi::GstDebugColorFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstDebugColorFlags> for DebugColorFlags {
    unsafe fn from_glib(value: ffi::GstDebugColorFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for DebugColorFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_debug_color_flags_get_type()) }
    }
}

impl glib::value::ValueType for DebugColorFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for DebugColorFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for DebugColorFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// Available details for pipeline graphs produced by GST_DEBUG_BIN_TO_DOT_FILE()
    /// and GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS().
    #[doc(alias = "GstDebugGraphDetails")]
    pub struct DebugGraphDetails: u32 {
        /// show caps-name on edges
        #[doc(alias = "GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE")]
        const MEDIA_TYPE = ffi::GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE as u32;
        /// show caps-details on edges
        #[doc(alias = "GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS")]
        const CAPS_DETAILS = ffi::GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS as u32;
        /// show modified parameters on
        ///  elements
        #[doc(alias = "GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS")]
        const NON_DEFAULT_PARAMS = ffi::GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS as u32;
        /// show element states
        #[doc(alias = "GST_DEBUG_GRAPH_SHOW_STATES")]
        const STATES = ffi::GST_DEBUG_GRAPH_SHOW_STATES as u32;
        /// show full element parameter values even
        ///  if they are very long
        #[doc(alias = "GST_DEBUG_GRAPH_SHOW_FULL_PARAMS")]
        const FULL_PARAMS = ffi::GST_DEBUG_GRAPH_SHOW_FULL_PARAMS as u32;
        /// show all the typical details that one might want
        #[doc(alias = "GST_DEBUG_GRAPH_SHOW_ALL")]
        const ALL = ffi::GST_DEBUG_GRAPH_SHOW_ALL as u32;
        /// show all details regardless of how large or
        ///  verbose they make the resulting output
        #[doc(alias = "GST_DEBUG_GRAPH_SHOW_VERBOSE")]
        const VERBOSE = ffi::GST_DEBUG_GRAPH_SHOW_VERBOSE as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for DebugGraphDetails {
    type GlibType = ffi::GstDebugGraphDetails;

    fn into_glib(self) -> ffi::GstDebugGraphDetails {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstDebugGraphDetails> for DebugGraphDetails {
    unsafe fn from_glib(value: ffi::GstDebugGraphDetails) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for DebugGraphDetails {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_debug_graph_details_get_type()) }
    }
}

impl glib::value::ValueType for DebugGraphDetails {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for DebugGraphDetails {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for DebugGraphDetails {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// The standard flags that an element may have.
    #[doc(alias = "GstElementFlags")]
    pub struct ElementFlags: u32 {
        /// ignore state changes from parent
        #[doc(alias = "GST_ELEMENT_FLAG_LOCKED_STATE")]
        const LOCKED_STATE = ffi::GST_ELEMENT_FLAG_LOCKED_STATE as u32;
        /// the element is a sink
        #[doc(alias = "GST_ELEMENT_FLAG_SINK")]
        const SINK = ffi::GST_ELEMENT_FLAG_SINK as u32;
        /// the element is a source.
        #[doc(alias = "GST_ELEMENT_FLAG_SOURCE")]
        const SOURCE = ffi::GST_ELEMENT_FLAG_SOURCE as u32;
        /// the element can provide a clock
        #[doc(alias = "GST_ELEMENT_FLAG_PROVIDE_CLOCK")]
        const PROVIDE_CLOCK = ffi::GST_ELEMENT_FLAG_PROVIDE_CLOCK as u32;
        /// the element requires a clock
        #[doc(alias = "GST_ELEMENT_FLAG_REQUIRE_CLOCK")]
        const REQUIRE_CLOCK = ffi::GST_ELEMENT_FLAG_REQUIRE_CLOCK as u32;
        /// the element can use an index
        #[doc(alias = "GST_ELEMENT_FLAG_INDEXABLE")]
        const INDEXABLE = ffi::GST_ELEMENT_FLAG_INDEXABLE as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for ElementFlags {
    type GlibType = ffi::GstElementFlags;

    fn into_glib(self) -> ffi::GstElementFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstElementFlags> for ElementFlags {
    unsafe fn from_glib(value: ffi::GstElementFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for ElementFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_element_flags_get_type()) }
    }
}

impl glib::value::ValueType for ElementFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for ElementFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for ElementFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// [`EventTypeFlags`][crate::EventTypeFlags] indicate the aspects of the different [`EventType`][crate::EventType]
    /// values. You can get the type flags of a [`EventType`][crate::EventType] with the
    /// [`EventType::flags()`][crate::EventType::flags()] function.
    #[doc(alias = "GstEventTypeFlags")]
    pub struct EventTypeFlags: u32 {
        /// Set if the event can travel upstream.
        #[doc(alias = "GST_EVENT_TYPE_UPSTREAM")]
        const UPSTREAM = ffi::GST_EVENT_TYPE_UPSTREAM as u32;
        /// Set if the event can travel downstream.
        #[doc(alias = "GST_EVENT_TYPE_DOWNSTREAM")]
        const DOWNSTREAM = ffi::GST_EVENT_TYPE_DOWNSTREAM as u32;
        /// Set if the event should be serialized with data
        ///  flow.
        #[doc(alias = "GST_EVENT_TYPE_SERIALIZED")]
        const SERIALIZED = ffi::GST_EVENT_TYPE_SERIALIZED as u32;
        /// Set if the event is sticky on the pads.
        #[doc(alias = "GST_EVENT_TYPE_STICKY")]
        const STICKY = ffi::GST_EVENT_TYPE_STICKY as u32;
        /// Multiple sticky events can be on a pad, each
        ///  identified by the event name.
        #[doc(alias = "GST_EVENT_TYPE_STICKY_MULTI")]
        const STICKY_MULTI = ffi::GST_EVENT_TYPE_STICKY_MULTI as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for EventTypeFlags {
    type GlibType = ffi::GstEventTypeFlags;

    fn into_glib(self) -> ffi::GstEventTypeFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstEventTypeFlags> for EventTypeFlags {
    unsafe fn from_glib(value: ffi::GstEventTypeFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for EventTypeFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_event_type_flags_get_type()) }
    }
}

impl glib::value::ValueType for EventTypeFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for EventTypeFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for EventTypeFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
bitflags! {
    /// The different flags that can be set on [`EventType::Gap`][crate::EventType::Gap] events. See
    /// [`Event::set_gap_flags()`][crate::Event::set_gap_flags()] for details.
    #[doc(alias = "GstGapFlags")]
    pub struct GapFlags: u32 {
        /// The [`EventType::Gap`][crate::EventType::Gap] signals missing data,
        ///  for example because of packet loss.
        #[doc(alias = "GST_GAP_FLAG_MISSING_DATA")]
        const DATA = ffi::GST_GAP_FLAG_MISSING_DATA as u32;
    }
}

#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
#[doc(hidden)]
impl IntoGlib for GapFlags {
    type GlibType = ffi::GstGapFlags;

    fn into_glib(self) -> ffi::GstGapFlags {
        self.bits()
    }
}

#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
#[doc(hidden)]
impl FromGlib<ffi::GstGapFlags> for GapFlags {
    unsafe fn from_glib(value: ffi::GstGapFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
impl StaticType for GapFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_gap_flags_get_type()) }
    }
}

#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
impl glib::value::ValueType for GapFlags {
    type Type = Self;
}

#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
unsafe impl<'a> FromValue<'a> for GapFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
impl ToValue for GapFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// Flags for wrapped memory.
    #[doc(alias = "GstMemoryFlags")]
    pub struct MemoryFlags: u32 {
        /// memory is readonly. It is not allowed to map the
        /// memory with `GST_MAP_WRITE`.
        #[doc(alias = "GST_MEMORY_FLAG_READONLY")]
        const READONLY = ffi::GST_MEMORY_FLAG_READONLY as u32;
        /// memory must not be shared. Copies will have to be
        /// made when this memory needs to be shared between buffers. (DEPRECATED:
        /// do not use in new code, instead you should create a custom GstAllocator for
        /// memory pooling instead of relying on the GstBuffer they were originally
        /// attached to.)
        #[doc(alias = "GST_MEMORY_FLAG_NO_SHARE")]
        const NO_SHARE = ffi::GST_MEMORY_FLAG_NO_SHARE as u32;
        /// the memory prefix is filled with 0 bytes
        #[doc(alias = "GST_MEMORY_FLAG_ZERO_PREFIXED")]
        const ZERO_PREFIXED = ffi::GST_MEMORY_FLAG_ZERO_PREFIXED as u32;
        /// the memory padding is filled with 0 bytes
        #[doc(alias = "GST_MEMORY_FLAG_ZERO_PADDED")]
        const ZERO_PADDED = ffi::GST_MEMORY_FLAG_ZERO_PADDED as u32;
        /// the memory is physically
        /// contiguous. (Since: 1.2)
        #[doc(alias = "GST_MEMORY_FLAG_PHYSICALLY_CONTIGUOUS")]
        const PHYSICALLY_CONTIGUOUS = ffi::GST_MEMORY_FLAG_PHYSICALLY_CONTIGUOUS as u32;
        /// the memory can't be mapped via
        /// [`Memory::into_mapped_memory_readable()`][crate::Memory::into_mapped_memory_readable()] without any preconditions. (Since: 1.2)
        #[doc(alias = "GST_MEMORY_FLAG_NOT_MAPPABLE")]
        const NOT_MAPPABLE = ffi::GST_MEMORY_FLAG_NOT_MAPPABLE as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for MemoryFlags {
    type GlibType = ffi::GstMemoryFlags;

    fn into_glib(self) -> ffi::GstMemoryFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstMemoryFlags> for MemoryFlags {
    unsafe fn from_glib(value: ffi::GstMemoryFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for MemoryFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_memory_flags_get_type()) }
    }
}

impl glib::value::ValueType for MemoryFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for MemoryFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for MemoryFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// The standard flags that an gstobject may have.
    #[doc(alias = "GstObjectFlags")]
    pub struct ObjectFlags: u32 {
        /// the object is expected to stay alive even
        /// after `gst_deinit()` has been called and so should be ignored by leak
        /// detection tools. (Since: 1.10)
        #[cfg(any(feature = "v1_10", feature = "dox"))]
        #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
        #[doc(alias = "GST_OBJECT_FLAG_MAY_BE_LEAKED")]
        const MAY_BE_LEAKED = ffi::GST_OBJECT_FLAG_MAY_BE_LEAKED as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for ObjectFlags {
    type GlibType = ffi::GstObjectFlags;

    fn into_glib(self) -> ffi::GstObjectFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstObjectFlags> for ObjectFlags {
    unsafe fn from_glib(value: ffi::GstObjectFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for ObjectFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_object_flags_get_type()) }
    }
}

impl glib::value::ValueType for ObjectFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for ObjectFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for ObjectFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// Pad state flags
    #[doc(alias = "GstPadFlags")]
    pub struct PadFlags: u32 {
        /// is dataflow on a pad blocked
        #[doc(alias = "GST_PAD_FLAG_BLOCKED")]
        const BLOCKED = ffi::GST_PAD_FLAG_BLOCKED as u32;
        /// is pad flushing
        #[doc(alias = "GST_PAD_FLAG_FLUSHING")]
        const FLUSHING = ffi::GST_PAD_FLAG_FLUSHING as u32;
        /// is pad in EOS state
        #[doc(alias = "GST_PAD_FLAG_EOS")]
        const EOS = ffi::GST_PAD_FLAG_EOS as u32;
        /// is pad currently blocking on a buffer or event
        #[doc(alias = "GST_PAD_FLAG_BLOCKING")]
        const BLOCKING = ffi::GST_PAD_FLAG_BLOCKING as u32;
        /// ensure that there is a parent object before calling
        ///  into the pad callbacks.
        #[doc(alias = "GST_PAD_FLAG_NEED_PARENT")]
        const NEED_PARENT = ffi::GST_PAD_FLAG_NEED_PARENT as u32;
        /// the pad should be reconfigured/renegotiated.
        ///  The flag has to be unset manually after
        ///  reconfiguration happened.
        #[doc(alias = "GST_PAD_FLAG_NEED_RECONFIGURE")]
        const NEED_RECONFIGURE = ffi::GST_PAD_FLAG_NEED_RECONFIGURE as u32;
        /// the pad has pending events
        #[doc(alias = "GST_PAD_FLAG_PENDING_EVENTS")]
        const PENDING_EVENTS = ffi::GST_PAD_FLAG_PENDING_EVENTS as u32;
        /// the pad is using fixed caps. This means that
        ///  once the caps are set on the pad, the default caps query function
        ///  will only return those caps.
        #[doc(alias = "GST_PAD_FLAG_FIXED_CAPS")]
        const FIXED_CAPS = ffi::GST_PAD_FLAG_FIXED_CAPS as u32;
        /// the default event and query handler will forward
        ///  all events and queries to the internally linked pads
        ///  instead of discarding them.
        #[doc(alias = "GST_PAD_FLAG_PROXY_CAPS")]
        const PROXY_CAPS = ffi::GST_PAD_FLAG_PROXY_CAPS as u32;
        /// the default query handler will forward
        ///  allocation queries to the internally linked pads
        ///  instead of discarding them.
        #[doc(alias = "GST_PAD_FLAG_PROXY_ALLOCATION")]
        const PROXY_ALLOCATION = ffi::GST_PAD_FLAG_PROXY_ALLOCATION as u32;
        /// the default query handler will forward
        ///  scheduling queries to the internally linked pads
        ///  instead of discarding them.
        #[doc(alias = "GST_PAD_FLAG_PROXY_SCHEDULING")]
        const PROXY_SCHEDULING = ffi::GST_PAD_FLAG_PROXY_SCHEDULING as u32;
        /// the default accept-caps handler will check
        ///  it the caps intersect the query-caps result instead
        ///  of checking for a subset. This is interesting for
        ///  parsers that can accept incompletely specified caps.
        #[doc(alias = "GST_PAD_FLAG_ACCEPT_INTERSECT")]
        const ACCEPT_INTERSECT = ffi::GST_PAD_FLAG_ACCEPT_INTERSECT as u32;
        /// the default accept-caps handler will use
        ///  the template pad caps instead of query caps to
        ///  compare with the accept caps. Use this in combination
        ///  with [`ACCEPT_INTERSECT`][Self::ACCEPT_INTERSECT]. (Since: 1.6)
        #[doc(alias = "GST_PAD_FLAG_ACCEPT_TEMPLATE")]
        const ACCEPT_TEMPLATE = ffi::GST_PAD_FLAG_ACCEPT_TEMPLATE as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for PadFlags {
    type GlibType = ffi::GstPadFlags;

    fn into_glib(self) -> ffi::GstPadFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPadFlags> for PadFlags {
    unsafe fn from_glib(value: ffi::GstPadFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for PadFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_pad_flags_get_type()) }
    }
}

impl glib::value::ValueType for PadFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for PadFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for PadFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// The amount of checking to be done when linking pads. [`CAPS`][Self::CAPS]
    /// and [`TEMPLATE_CAPS`][Self::TEMPLATE_CAPS] are mutually exclusive. If both are
    /// specified, expensive but safe [`CAPS`][Self::CAPS] are performed.
    ///
    /// > Only disable some of the checks if you are 100% certain you know the link
    /// > will not fail because of hierarchy/caps compatibility failures. If uncertain,
    /// > use the default checks ([`DEFAULT`][Self::DEFAULT]) or the regular methods
    /// > for linking the pads.
    #[doc(alias = "GstPadLinkCheck")]
    pub struct PadLinkCheck: u32 {
        /// Check the pads have same parents/grandparents.
        ///  Could be omitted if it is already known that the two elements that own the
        ///  pads are in the same bin.
        #[doc(alias = "GST_PAD_LINK_CHECK_HIERARCHY")]
        const HIERARCHY = ffi::GST_PAD_LINK_CHECK_HIERARCHY as u32;
        /// Check if the pads are compatible by using
        ///  their template caps. This is much faster than [`CAPS`][Self::CAPS], but
        ///  would be unsafe e.g. if one pad has `GST_CAPS_ANY`.
        #[doc(alias = "GST_PAD_LINK_CHECK_TEMPLATE_CAPS")]
        const TEMPLATE_CAPS = ffi::GST_PAD_LINK_CHECK_TEMPLATE_CAPS as u32;
        /// Check if the pads are compatible by comparing the
        ///  caps returned by [`PadExt::query_caps()`][crate::prelude::PadExt::query_caps()].
        #[doc(alias = "GST_PAD_LINK_CHECK_CAPS")]
        const CAPS = ffi::GST_PAD_LINK_CHECK_CAPS as u32;
        /// Disables pushing a reconfigure event when pads are
        ///  linked.
        #[doc(alias = "GST_PAD_LINK_CHECK_NO_RECONFIGURE")]
        const NO_RECONFIGURE = ffi::GST_PAD_LINK_CHECK_NO_RECONFIGURE as u32;
        /// The default checks done when linking
        ///  pads (i.e. the ones used by [`PadExt::link()`][crate::prelude::PadExt::link()]).
        #[doc(alias = "GST_PAD_LINK_CHECK_DEFAULT")]
        const DEFAULT = ffi::GST_PAD_LINK_CHECK_DEFAULT as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for PadLinkCheck {
    type GlibType = ffi::GstPadLinkCheck;

    fn into_glib(self) -> ffi::GstPadLinkCheck {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPadLinkCheck> for PadLinkCheck {
    unsafe fn from_glib(value: ffi::GstPadLinkCheck) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for PadLinkCheck {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_pad_link_check_get_type()) }
    }
}

impl glib::value::ValueType for PadLinkCheck {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for PadLinkCheck {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for PadLinkCheck {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// The different probing types that can occur. When either one of
    /// [`IDLE`][Self::IDLE] or [`BLOCK`][Self::BLOCK] is used, the probe will be a
    /// blocking probe.
    #[doc(alias = "GstPadProbeType")]
    pub struct PadProbeType: u32 {
        /// probe idle pads and block while the callback is called
        #[doc(alias = "GST_PAD_PROBE_TYPE_IDLE")]
        const IDLE = ffi::GST_PAD_PROBE_TYPE_IDLE as u32;
        /// probe and block pads
        #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK")]
        const BLOCK = ffi::GST_PAD_PROBE_TYPE_BLOCK as u32;
        /// probe buffers
        #[doc(alias = "GST_PAD_PROBE_TYPE_BUFFER")]
        const BUFFER = ffi::GST_PAD_PROBE_TYPE_BUFFER as u32;
        /// probe buffer lists
        #[doc(alias = "GST_PAD_PROBE_TYPE_BUFFER_LIST")]
        const BUFFER_LIST = ffi::GST_PAD_PROBE_TYPE_BUFFER_LIST as u32;
        /// probe downstream events
        #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM")]
        const EVENT_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM as u32;
        /// probe upstream events
        #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_UPSTREAM")]
        const EVENT_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_EVENT_UPSTREAM as u32;
        /// probe flush events. This probe has to be
        ///  explicitly enabled and is not included in the
        ///  @[`EVENT_DOWNSTREAM`][Self::EVENT_DOWNSTREAM] or
        ///  @[`EVENT_UPSTREAM`][Self::EVENT_UPSTREAM] probe types.
        #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_FLUSH")]
        const EVENT_FLUSH = ffi::GST_PAD_PROBE_TYPE_EVENT_FLUSH as u32;
        /// probe downstream queries
        #[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM")]
        const QUERY_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM as u32;
        /// probe upstream queries
        #[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_UPSTREAM")]
        const QUERY_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_QUERY_UPSTREAM as u32;
        /// probe push
        #[doc(alias = "GST_PAD_PROBE_TYPE_PUSH")]
        const PUSH = ffi::GST_PAD_PROBE_TYPE_PUSH as u32;
        /// probe pull
        #[doc(alias = "GST_PAD_PROBE_TYPE_PULL")]
        const PULL = ffi::GST_PAD_PROBE_TYPE_PULL as u32;
        /// probe and block at the next opportunity, at data flow or when idle
        #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCKING")]
        const BLOCKING = ffi::GST_PAD_PROBE_TYPE_BLOCKING as u32;
        /// probe downstream data (buffers, buffer lists, and events)
        #[doc(alias = "GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM")]
        const DATA_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM as u32;
        /// probe upstream data (events)
        #[doc(alias = "GST_PAD_PROBE_TYPE_DATA_UPSTREAM")]
        const DATA_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_DATA_UPSTREAM as u32;
        /// probe upstream and downstream data (buffers, buffer lists, and events)
        #[doc(alias = "GST_PAD_PROBE_TYPE_DATA_BOTH")]
        const DATA_BOTH = ffi::GST_PAD_PROBE_TYPE_DATA_BOTH as u32;
        /// probe and block downstream data (buffers, buffer lists, and events)
        #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM")]
        const BLOCK_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM as u32;
        /// probe and block upstream data (events)
        #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM")]
        const BLOCK_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM as u32;
        /// probe upstream and downstream events
        #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_BOTH")]
        const EVENT_BOTH = ffi::GST_PAD_PROBE_TYPE_EVENT_BOTH as u32;
        /// probe upstream and downstream queries
        #[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_BOTH")]
        const QUERY_BOTH = ffi::GST_PAD_PROBE_TYPE_QUERY_BOTH as u32;
        /// probe upstream events and queries and downstream buffers, buffer lists, events and queries
        #[doc(alias = "GST_PAD_PROBE_TYPE_ALL_BOTH")]
        const ALL_BOTH = ffi::GST_PAD_PROBE_TYPE_ALL_BOTH as u32;
        /// probe push and pull
        #[doc(alias = "GST_PAD_PROBE_TYPE_SCHEDULING")]
        const SCHEDULING = ffi::GST_PAD_PROBE_TYPE_SCHEDULING as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for PadProbeType {
    type GlibType = ffi::GstPadProbeType;

    fn into_glib(self) -> ffi::GstPadProbeType {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPadProbeType> for PadProbeType {
    unsafe fn from_glib(value: ffi::GstPadProbeType) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for PadProbeType {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_pad_probe_type_get_type()) }
    }
}

impl glib::value::ValueType for PadProbeType {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for PadProbeType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for PadProbeType {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// Parsing options.
    #[doc(alias = "GstParseFlags")]
    pub struct ParseFlags: u32 {
        /// Always return [`None`] when an error occurs
        ///  (default behaviour is to return partially constructed bins or elements
        ///  in some cases)
        #[doc(alias = "GST_PARSE_FLAG_FATAL_ERRORS")]
        const FATAL_ERRORS = ffi::GST_PARSE_FLAG_FATAL_ERRORS as u32;
        /// If a bin only has a single element,
        ///  just return the element.
        #[doc(alias = "GST_PARSE_FLAG_NO_SINGLE_ELEMENT_BINS")]
        const NO_SINGLE_ELEMENT_BINS = ffi::GST_PARSE_FLAG_NO_SINGLE_ELEMENT_BINS as u32;
        /// If more than one toplevel element is described
        ///  by the pipeline description string, put them in a [`Bin`][crate::Bin] instead of a
        ///  [`Pipeline`][crate::Pipeline]. (Since: 1.10)
        #[cfg(any(feature = "v1_10", feature = "dox"))]
        #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
        #[doc(alias = "GST_PARSE_FLAG_PLACE_IN_BIN")]
        const PLACE_IN_BIN = ffi::GST_PARSE_FLAG_PLACE_IN_BIN as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for ParseFlags {
    type GlibType = ffi::GstParseFlags;

    fn into_glib(self) -> ffi::GstParseFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstParseFlags> for ParseFlags {
    unsafe fn from_glib(value: ffi::GstParseFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for ParseFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_parse_flags_get_type()) }
    }
}

impl glib::value::ValueType for ParseFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for ParseFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for ParseFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// Pipeline flags
    #[doc(alias = "GstPipelineFlags")]
    pub struct PipelineFlags: u32 {
        /// this pipeline works with a fixed clock
        #[doc(alias = "GST_PIPELINE_FLAG_FIXED_CLOCK")]
        const FIXED_CLOCK = ffi::GST_PIPELINE_FLAG_FIXED_CLOCK as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for PipelineFlags {
    type GlibType = ffi::GstPipelineFlags;

    fn into_glib(self) -> ffi::GstPipelineFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPipelineFlags> for PipelineFlags {
    unsafe fn from_glib(value: ffi::GstPipelineFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for PipelineFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_pipeline_flags_get_type()) }
    }
}

impl glib::value::ValueType for PipelineFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for PipelineFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for PipelineFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
bitflags! {
    #[doc(alias = "GstPluginAPIFlags")]
    pub struct PluginAPIFlags: u32 {
        /// Ignore enum members when generating
        ///  the plugins cache. This is useful if the members of the enum are generated
        ///  dynamically, in order not to expose incorrect documentation to the end user.
        #[doc(alias = "GST_PLUGIN_API_FLAG_IGNORE_ENUM_MEMBERS")]
        const MEMBERS = ffi::GST_PLUGIN_API_FLAG_IGNORE_ENUM_MEMBERS as u32;
    }
}

#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
#[doc(hidden)]
impl IntoGlib for PluginAPIFlags {
    type GlibType = ffi::GstPluginAPIFlags;

    fn into_glib(self) -> ffi::GstPluginAPIFlags {
        self.bits()
    }
}

#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
#[doc(hidden)]
impl FromGlib<ffi::GstPluginAPIFlags> for PluginAPIFlags {
    unsafe fn from_glib(value: ffi::GstPluginAPIFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
impl StaticType for PluginAPIFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_plugin_api_flags_get_type()) }
    }
}

#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
impl glib::value::ValueType for PluginAPIFlags {
    type Type = Self;
}

#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
unsafe impl<'a> FromValue<'a> for PluginAPIFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
impl ToValue for PluginAPIFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// Flags used in connection with [`Plugin::add_dependency()`][crate::Plugin::add_dependency()].
    #[doc(alias = "GstPluginDependencyFlags")]
    pub struct PluginDependencyFlags: u32 {
        /// recurse into subdirectories
        #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_RECURSE")]
        const RECURSE = ffi::GST_PLUGIN_DEPENDENCY_FLAG_RECURSE as u32;
        /// use paths
        ///  argument only if none of the environment variables is set
        #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY")]
        const PATHS_ARE_DEFAULT_ONLY = ffi::GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY as u32;
        /// interpret
        ///  filename argument as filter suffix and check all matching files in
        ///  the directory
        #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX")]
        const FILE_NAME_IS_SUFFIX = ffi::GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX as u32;
        /// interpret
        ///  filename argument as filter prefix and check all matching files in
        ///  the directory. Since: 1.8.
        #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_PREFIX")]
        const FILE_NAME_IS_PREFIX = ffi::GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_PREFIX as u32;
        /// interpret
        ///  non-absolute paths as relative to the main executable directory. Since
        ///  1.14.
        #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_RELATIVE_TO_EXE")]
        const PATHS_ARE_RELATIVE_TO_EXE = ffi::GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_RELATIVE_TO_EXE as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for PluginDependencyFlags {
    type GlibType = ffi::GstPluginDependencyFlags;

    fn into_glib(self) -> ffi::GstPluginDependencyFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPluginDependencyFlags> for PluginDependencyFlags {
    unsafe fn from_glib(value: ffi::GstPluginDependencyFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for PluginDependencyFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_plugin_dependency_flags_get_type()) }
    }
}

impl glib::value::ValueType for PluginDependencyFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for PluginDependencyFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for PluginDependencyFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// The plugin loading state
    #[doc(alias = "GstPluginFlags")]
    pub struct PluginFlags: u32 {
        /// Temporarily loaded plugins
        #[doc(alias = "GST_PLUGIN_FLAG_CACHED")]
        const CACHED = ffi::GST_PLUGIN_FLAG_CACHED as u32;
        /// The plugin won't be scanned (again)
        #[doc(alias = "GST_PLUGIN_FLAG_BLACKLISTED")]
        const BLACKLISTED = ffi::GST_PLUGIN_FLAG_BLACKLISTED as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for PluginFlags {
    type GlibType = ffi::GstPluginFlags;

    fn into_glib(self) -> ffi::GstPluginFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPluginFlags> for PluginFlags {
    unsafe fn from_glib(value: ffi::GstPluginFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for PluginFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_plugin_flags_get_type()) }
    }
}

impl glib::value::ValueType for PluginFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for PluginFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for PluginFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// The different scheduling flags.
    #[doc(alias = "GstSchedulingFlags")]
    pub struct SchedulingFlags: u32 {
        /// if seeking is possible
        #[doc(alias = "GST_SCHEDULING_FLAG_SEEKABLE")]
        const SEEKABLE = ffi::GST_SCHEDULING_FLAG_SEEKABLE as u32;
        /// if sequential access is recommended
        #[doc(alias = "GST_SCHEDULING_FLAG_SEQUENTIAL")]
        const SEQUENTIAL = ffi::GST_SCHEDULING_FLAG_SEQUENTIAL as u32;
        /// if bandwidth is limited and buffering possible (since 1.2)
        #[doc(alias = "GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED")]
        const BANDWIDTH_LIMITED = ffi::GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for SchedulingFlags {
    type GlibType = ffi::GstSchedulingFlags;

    fn into_glib(self) -> ffi::GstSchedulingFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstSchedulingFlags> for SchedulingFlags {
    unsafe fn from_glib(value: ffi::GstSchedulingFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for SchedulingFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_scheduling_flags_get_type()) }
    }
}

impl glib::value::ValueType for SchedulingFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for SchedulingFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for SchedulingFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// Flags to be used with [`ElementExtManual::seek()`][crate::prelude::ElementExtManual::seek()] or `gst_event_new_seek()`. All flags
    /// can be used together.
    ///
    /// A non flushing seek might take some time to perform as the currently
    /// playing data in the pipeline will not be cleared.
    ///
    /// An accurate seek might be slower for formats that don't have any indexes
    /// or timestamp markers in the stream. Specifying this flag might require a
    /// complete scan of the file in those cases.
    ///
    /// When performing a segment seek: after the playback of the segment completes,
    /// no EOS will be emitted by the element that performed the seek, but a
    /// `GST_MESSAGE_SEGMENT_DONE` message will be posted on the bus by the element.
    /// When this message is posted, it is possible to send a new seek event to
    /// continue playback. With this seek method it is possible to perform seamless
    /// looping or simple linear editing.
    ///
    /// When only changing the playback rate and not the direction, the
    /// [`INSTANT_RATE_CHANGE`][Self::INSTANT_RATE_CHANGE] flag can be used for a non-flushing seek
    /// to signal that the rate change should be applied immediately. This requires
    /// special support in the seek handlers (e.g. demuxers) and any elements
    /// synchronizing to the clock, and in general can't work in all cases (for example
    /// UDP streaming where the delivery rate is controlled by a remote server). The
    /// instant-rate-change mode supports changing the trickmode-related GST_SEEK_ flags,
    /// but can't be used in conjunction with other seek flags that affect the new
    /// playback position - as the playback position will not be changing.
    ///
    /// When doing fast forward (rate > 1.0) or fast reverse (rate < -1.0) trickmode
    /// playback, the [`TRICKMODE`][Self::TRICKMODE] flag can be used to instruct decoders
    /// and demuxers to adjust the playback rate by skipping frames. This can improve
    /// performance and decrease CPU usage because not all frames need to be decoded.
    ///
    /// Beyond that, the [`TRICKMODE_KEY_UNITS`][Self::TRICKMODE_KEY_UNITS] flag can be used to
    /// request that decoders skip all frames except key units, and
    /// [`TRICKMODE_NO_AUDIO`][Self::TRICKMODE_NO_AUDIO] flags can be used to request that audio
    /// decoders do no decoding at all, and simple output silence.
    ///
    /// The [`SNAP_BEFORE`][Self::SNAP_BEFORE] flag can be used to snap to the previous
    /// relevant location, and the [`SNAP_AFTER`][Self::SNAP_AFTER] flag can be used to
    /// select the next relevant location. If [`KEY_UNIT`][Self::KEY_UNIT] is specified,
    /// the relevant location is a keyframe. If both flags are specified, the nearest
    /// of these locations will be selected. If none are specified, the implementation is
    /// free to select whichever it wants.
    ///
    /// The before and after here are in running time, so when playing backwards,
    /// the next location refers to the one that will played in next, and not the
    /// one that is located after in the actual source stream.
    ///
    /// Also see part-seeking.txt in the GStreamer design documentation for more
    /// details on the meaning of these flags and the behaviour expected of
    /// elements that handle them.
    #[doc(alias = "GstSeekFlags")]
    pub struct SeekFlags: u32 {
        /// flush pipeline
        #[doc(alias = "GST_SEEK_FLAG_FLUSH")]
        const FLUSH = ffi::GST_SEEK_FLAG_FLUSH as u32;
        /// accurate position is requested, this might
        ///  be considerably slower for some formats.
        #[doc(alias = "GST_SEEK_FLAG_ACCURATE")]
        const ACCURATE = ffi::GST_SEEK_FLAG_ACCURATE as u32;
        /// seek to the nearest keyframe. This might be
        ///  faster but less accurate.
        #[doc(alias = "GST_SEEK_FLAG_KEY_UNIT")]
        const KEY_UNIT = ffi::GST_SEEK_FLAG_KEY_UNIT as u32;
        /// perform a segment seek.
        #[doc(alias = "GST_SEEK_FLAG_SEGMENT")]
        const SEGMENT = ffi::GST_SEEK_FLAG_SEGMENT as u32;
        /// when doing fast forward or fast reverse playback, allow
        ///  elements to skip frames instead of generating all
        ///  frames. (Since: 1.6)
        #[doc(alias = "GST_SEEK_FLAG_TRICKMODE")]
        const TRICKMODE = ffi::GST_SEEK_FLAG_TRICKMODE as u32;
        /// Deprecated backward compatibility flag, replaced
        ///  by [`TRICKMODE`][Self::TRICKMODE]
        #[doc(alias = "GST_SEEK_FLAG_SKIP")]
        const SKIP = ffi::GST_SEEK_FLAG_SKIP as u32;
        /// go to a location before the requested position,
        ///  if [`KEY_UNIT`][Self::KEY_UNIT] this means the keyframe at or before
        ///  the requested position the one at or before the seek target.
        #[doc(alias = "GST_SEEK_FLAG_SNAP_BEFORE")]
        const SNAP_BEFORE = ffi::GST_SEEK_FLAG_SNAP_BEFORE as u32;
        /// go to a location after the requested position,
        ///  if [`KEY_UNIT`][Self::KEY_UNIT] this means the keyframe at of after the
        ///  requested position.
        #[doc(alias = "GST_SEEK_FLAG_SNAP_AFTER")]
        const SNAP_AFTER = ffi::GST_SEEK_FLAG_SNAP_AFTER as u32;
        /// go to a position near the requested position,
        ///  if [`KEY_UNIT`][Self::KEY_UNIT] this means the keyframe closest
        ///  to the requested position, if both keyframes are at an equal
        ///  distance, behaves like [`SNAP_BEFORE`][Self::SNAP_BEFORE].
        #[doc(alias = "GST_SEEK_FLAG_SNAP_NEAREST")]
        const SNAP_NEAREST = ffi::GST_SEEK_FLAG_SNAP_NEAREST as u32;
        /// when doing fast forward or fast reverse
        ///  playback, request that elements only decode keyframes
        ///  and skip all other content, for formats that have
        ///  keyframes. (Since: 1.6)
        #[doc(alias = "GST_SEEK_FLAG_TRICKMODE_KEY_UNITS")]
        const TRICKMODE_KEY_UNITS = ffi::GST_SEEK_FLAG_TRICKMODE_KEY_UNITS as u32;
        /// when doing fast forward or fast reverse
        ///  playback, request that audio decoder elements skip
        ///  decoding and output only gap events or silence. (Since: 1.6)
        #[doc(alias = "GST_SEEK_FLAG_TRICKMODE_NO_AUDIO")]
        const TRICKMODE_NO_AUDIO = ffi::GST_SEEK_FLAG_TRICKMODE_NO_AUDIO as u32;
        /// When doing fast forward or fast reverse
        ///  playback, request that elements only decode keyframes and
        ///  forward predicted frames and skip all other content (for example
        ///  B-Frames), for formats that have keyframes and forward predicted
        ///  frames. (Since: 1.18)
        #[cfg(any(feature = "v1_18", feature = "dox"))]
        #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
        #[doc(alias = "GST_SEEK_FLAG_TRICKMODE_FORWARD_PREDICTED")]
        const TRICKMODE_FORWARD_PREDICTED = ffi::GST_SEEK_FLAG_TRICKMODE_FORWARD_PREDICTED as u32;
        /// Signals that a rate change should be
        ///  applied immediately. Only valid if start/stop position
        ///  are GST_CLOCK_TIME_NONE, the playback direction does not change
        ///  and the seek is not flushing. (Since: 1.18)
        #[cfg(any(feature = "v1_18", feature = "dox"))]
        #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
        #[doc(alias = "GST_SEEK_FLAG_INSTANT_RATE_CHANGE")]
        const INSTANT_RATE_CHANGE = ffi::GST_SEEK_FLAG_INSTANT_RATE_CHANGE as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for SeekFlags {
    type GlibType = ffi::GstSeekFlags;

    fn into_glib(self) -> ffi::GstSeekFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstSeekFlags> for SeekFlags {
    unsafe fn from_glib(value: ffi::GstSeekFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for SeekFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_seek_flags_get_type()) }
    }
}

impl glib::value::ValueType for SeekFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for SeekFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for SeekFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// Flags for the GstSegment structure. Currently mapped to the corresponding
    /// values of the seek flags.
    #[cfg_attr(feature = "ser_de", derive(serde::Serialize, serde::Deserialize))]
    #[doc(alias = "GstSegmentFlags")]
    pub struct SegmentFlags: u32 {
        /// reset the pipeline running_time to the segment
        ///  running_time
        #[doc(alias = "GST_SEGMENT_FLAG_RESET")]
        const RESET = ffi::GST_SEGMENT_FLAG_RESET as u32;
        /// perform skip playback (Since: 1.6)
        #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE")]
        const TRICKMODE = ffi::GST_SEGMENT_FLAG_TRICKMODE as u32;
        /// Deprecated backward compatibility flag, replaced
        ///  by [`TRICKMODE`][Self::TRICKMODE]
        #[doc(alias = "GST_SEGMENT_FLAG_SKIP")]
        const SKIP = ffi::GST_SEGMENT_FLAG_SKIP as u32;
        /// send SEGMENT_DONE instead of EOS
        #[doc(alias = "GST_SEGMENT_FLAG_SEGMENT")]
        const SEGMENT = ffi::GST_SEGMENT_FLAG_SEGMENT as u32;
        /// Decode only keyframes, where
        ///  possible (Since: 1.6)
        #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS")]
        const TRICKMODE_KEY_UNITS = ffi::GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS as u32;
        /// Decode only keyframes or forward
        ///  predicted frames, where possible (Since: 1.18)
        #[cfg(any(feature = "v1_18", feature = "dox"))]
        #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
        #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_FORWARD_PREDICTED")]
        const TRICKMODE_FORWARD_PREDICTED = ffi::GST_SEGMENT_FLAG_TRICKMODE_FORWARD_PREDICTED as u32;
        /// Do not decode any audio, where
        ///  possible (Since: 1.6)
        #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_NO_AUDIO")]
        const TRICKMODE_NO_AUDIO = ffi::GST_SEGMENT_FLAG_TRICKMODE_NO_AUDIO as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for SegmentFlags {
    type GlibType = ffi::GstSegmentFlags;

    fn into_glib(self) -> ffi::GstSegmentFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstSegmentFlags> for SegmentFlags {
    unsafe fn from_glib(value: ffi::GstSegmentFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for SegmentFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_segment_flags_get_type()) }
    }
}

impl glib::value::ValueType for SegmentFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for SegmentFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for SegmentFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
bitflags! {
    #[doc(alias = "GstSerializeFlags")]
    pub struct SerializeFlags: u32 {
        /// No special flags specified.
        #[doc(alias = "GST_SERIALIZE_FLAG_NONE")]
        const NONE = ffi::GST_SERIALIZE_FLAG_NONE as u32;
        /// Serialize using the old format for
        ///  nested structures.
        #[doc(alias = "GST_SERIALIZE_FLAG_BACKWARD_COMPAT")]
        const BACKWARD_COMPAT = ffi::GST_SERIALIZE_FLAG_BACKWARD_COMPAT as u32;
    }
}

#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
#[doc(hidden)]
impl IntoGlib for SerializeFlags {
    type GlibType = ffi::GstSerializeFlags;

    fn into_glib(self) -> ffi::GstSerializeFlags {
        self.bits()
    }
}

#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
#[doc(hidden)]
impl FromGlib<ffi::GstSerializeFlags> for SerializeFlags {
    unsafe fn from_glib(value: ffi::GstSerializeFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
impl StaticType for SerializeFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_serialize_flags_get_type()) }
    }
}

#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
impl glib::value::ValueType for SerializeFlags {
    type Type = Self;
}

#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
unsafe impl<'a> FromValue<'a> for SerializeFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
impl ToValue for SerializeFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(any(feature = "v1_12", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
bitflags! {
    #[doc(alias = "GstStackTraceFlags")]
    pub struct StackTraceFlags: u32 {
        /// Try to retrieve as much information as possible,
        ///  including source information when getting the
        ///  stack trace
        #[doc(alias = "GST_STACK_TRACE_SHOW_FULL")]
        const FULL = ffi::GST_STACK_TRACE_SHOW_FULL as u32;
    }
}

#[cfg(any(feature = "v1_12", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
#[doc(hidden)]
impl IntoGlib for StackTraceFlags {
    type GlibType = ffi::GstStackTraceFlags;

    fn into_glib(self) -> ffi::GstStackTraceFlags {
        self.bits()
    }
}

#[cfg(any(feature = "v1_12", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
#[doc(hidden)]
impl FromGlib<ffi::GstStackTraceFlags> for StackTraceFlags {
    unsafe fn from_glib(value: ffi::GstStackTraceFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

#[cfg(any(feature = "v1_12", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
impl StaticType for StackTraceFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_stack_trace_flags_get_type()) }
    }
}

#[cfg(any(feature = "v1_12", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
impl glib::value::ValueType for StackTraceFlags {
    type Type = Self;
}

#[cfg(any(feature = "v1_12", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
unsafe impl<'a> FromValue<'a> for StackTraceFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

#[cfg(any(feature = "v1_12", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
impl ToValue for StackTraceFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    #[doc(alias = "GstStreamFlags")]
    pub struct StreamFlags: u32 {
        /// This stream is a sparse stream (e.g. a subtitle
        ///  stream), data may flow only in irregular intervals with large gaps in
        ///  between.
        #[doc(alias = "GST_STREAM_FLAG_SPARSE")]
        const SPARSE = ffi::GST_STREAM_FLAG_SPARSE as u32;
        /// This stream should be selected by default. This
        ///  flag may be used by demuxers to signal that a stream should be selected
        ///  by default in a playback scenario.
        #[doc(alias = "GST_STREAM_FLAG_SELECT")]
        const SELECT = ffi::GST_STREAM_FLAG_SELECT as u32;
        /// This stream should not be selected by default.
        ///  This flag may be used by demuxers to signal that a stream should not
        ///  be selected by default in a playback scenario, but only if explicitly
        ///  selected by the user (e.g. an audio track for the hard of hearing or
        ///  a director's commentary track).
        #[doc(alias = "GST_STREAM_FLAG_UNSELECT")]
        const UNSELECT = ffi::GST_STREAM_FLAG_UNSELECT as u32;
    }
}

#[doc(hidden)]
impl IntoGlib for StreamFlags {
    type GlibType = ffi::GstStreamFlags;

    fn into_glib(self) -> ffi::GstStreamFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstStreamFlags> for StreamFlags {
    unsafe fn from_glib(value: ffi::GstStreamFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for StreamFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_stream_flags_get_type()) }
    }
}

impl glib::value::ValueType for StreamFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for StreamFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for StreamFlags {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
bitflags! {
    /// [`StreamType`][crate::StreamType] describes a high level classification set for
    /// flows of data in [`Stream`][crate::Stream] objects.
    ///
    /// Note that this is a flag, and therefore users should not assume it
    /// will be a single value. Do not use the equality operator for checking
    /// whether a stream is of a certain type.
    #[doc(alias = "GstStreamType")]
    pub struct StreamType: u32 {
        /// The stream is of unknown (unclassified) type.
        #[doc(alias = "GST_STREAM_TYPE_UNKNOWN")]
        const UNKNOWN = ffi::GST_STREAM_TYPE_UNKNOWN as u32;
        /// The stream is of audio data
        #[doc(alias = "GST_STREAM_TYPE_AUDIO")]
        const AUDIO = ffi::GST_STREAM_TYPE_AUDIO as u32;
        /// The stream carries video data
        #[doc(alias = "GST_STREAM_TYPE_VIDEO")]
        const VIDEO = ffi::GST_STREAM_TYPE_VIDEO as u32;
        /// The stream is a muxed container type
        #[doc(alias = "GST_STREAM_TYPE_CONTAINER")]
        const CONTAINER = ffi::GST_STREAM_TYPE_CONTAINER as u32;
        /// The stream contains subtitle / subpicture data.
        #[doc(alias = "GST_STREAM_TYPE_TEXT")]
        const TEXT = ffi::GST_STREAM_TYPE_TEXT as u32;
    }
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
impl StreamType {
    pub fn name<'a>(self) -> &'a str {
        unsafe {
            CStr::from_ptr(
                ffi::gst_stream_type_get_name(self.into_glib())
                    .as_ref()
                    .expect("gst_stream_type_get_name returned NULL"),
            )
            .to_str()
            .expect("gst_stream_type_get_name returned an invalid string")
        }
    }
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
impl fmt::Display for StreamType {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&self.name())
    }
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
#[doc(hidden)]
impl IntoGlib for StreamType {
    type GlibType = ffi::GstStreamType;

    fn into_glib(self) -> ffi::GstStreamType {
        self.bits()
    }
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
#[doc(hidden)]
impl FromGlib<ffi::GstStreamType> for StreamType {
    unsafe fn from_glib(value: ffi::GstStreamType) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
impl StaticType for StreamType {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gst_stream_type_get_type()) }
    }
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
impl glib::value::ValueType for StreamType {
    type Type = Self;
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
unsafe impl<'a> FromValue<'a> for StreamType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
impl ToValue for StreamType {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}