gstreamer-rs/gstreamer/src/auto/enums.rs

// 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 crate::EventTypeFlags;
use glib::error::ErrorDomain;
use glib::translate::*;
use glib::value::FromValue;
use glib::value::ToValue;
use glib::Quark;
use glib::StaticType;
use glib::Type;
use std::ffi::CStr;
use std::fmt;

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstBufferingMode")]
pub enum BufferingMode {
    #[doc(alias = "GST_BUFFERING_STREAM")]
    Stream,
    #[doc(alias = "GST_BUFFERING_DOWNLOAD")]
    Download,
    #[doc(alias = "GST_BUFFERING_TIMESHIFT")]
    Timeshift,
    #[doc(alias = "GST_BUFFERING_LIVE")]
    Live,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstBufferingMode {
        match self {
            BufferingMode::Stream => ffi::GST_BUFFERING_STREAM,
            BufferingMode::Download => ffi::GST_BUFFERING_DOWNLOAD,
            BufferingMode::Timeshift => ffi::GST_BUFFERING_TIMESHIFT,
            BufferingMode::Live => ffi::GST_BUFFERING_LIVE,
            BufferingMode::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstBufferingMode> for BufferingMode {
    unsafe fn from_glib(value: ffi::GstBufferingMode) -> Self {
        skip_assert_initialized!();
        match value {
            0 => BufferingMode::Stream,
            1 => BufferingMode::Download,
            2 => BufferingMode::Timeshift,
            3 => BufferingMode::Live,
            value => BufferingMode::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for BufferingMode {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for BufferingMode {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<BufferingMode>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstBusSyncReply")]
pub enum BusSyncReply {
    #[doc(alias = "GST_BUS_DROP")]
    Drop,
    #[doc(alias = "GST_BUS_PASS")]
    Pass,
    #[doc(alias = "GST_BUS_ASYNC")]
    Async,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstBusSyncReply {
        match self {
            BusSyncReply::Drop => ffi::GST_BUS_DROP,
            BusSyncReply::Pass => ffi::GST_BUS_PASS,
            BusSyncReply::Async => ffi::GST_BUS_ASYNC,
            BusSyncReply::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstBusSyncReply> for BusSyncReply {
    unsafe fn from_glib(value: ffi::GstBusSyncReply) -> Self {
        skip_assert_initialized!();
        match value {
            0 => BusSyncReply::Drop,
            1 => BusSyncReply::Pass,
            2 => BusSyncReply::Async,
            value => BusSyncReply::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for BusSyncReply {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for BusSyncReply {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<BusSyncReply>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstCapsIntersectMode")]
pub enum CapsIntersectMode {
    #[doc(alias = "GST_CAPS_INTERSECT_ZIG_ZAG")]
    ZigZag,
    #[doc(alias = "GST_CAPS_INTERSECT_FIRST")]
    First,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstCapsIntersectMode {
        match self {
            CapsIntersectMode::ZigZag => ffi::GST_CAPS_INTERSECT_ZIG_ZAG,
            CapsIntersectMode::First => ffi::GST_CAPS_INTERSECT_FIRST,
            CapsIntersectMode::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstCapsIntersectMode> for CapsIntersectMode {
    unsafe fn from_glib(value: ffi::GstCapsIntersectMode) -> Self {
        skip_assert_initialized!();
        match value {
            0 => CapsIntersectMode::ZigZag,
            1 => CapsIntersectMode::First,
            value => CapsIntersectMode::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for CapsIntersectMode {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for CapsIntersectMode {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<CapsIntersectMode>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstClockEntryType")]
pub enum ClockEntryType {
    #[doc(alias = "GST_CLOCK_ENTRY_SINGLE")]
    Single,
    #[doc(alias = "GST_CLOCK_ENTRY_PERIODIC")]
    Periodic,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstClockEntryType {
        match self {
            ClockEntryType::Single => ffi::GST_CLOCK_ENTRY_SINGLE,
            ClockEntryType::Periodic => ffi::GST_CLOCK_ENTRY_PERIODIC,
            ClockEntryType::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstClockEntryType> for ClockEntryType {
    unsafe fn from_glib(value: ffi::GstClockEntryType) -> Self {
        skip_assert_initialized!();
        match value {
            0 => ClockEntryType::Single,
            1 => ClockEntryType::Periodic,
            value => ClockEntryType::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for ClockEntryType {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for ClockEntryType {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<ClockEntryType>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[must_use]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstClockReturn")]
pub enum ClockReturn {
    #[doc(alias = "GST_CLOCK_OK")]
    Ok,
    #[doc(alias = "GST_CLOCK_EARLY")]
    Early,
    #[doc(alias = "GST_CLOCK_UNSCHEDULED")]
    Unscheduled,
    #[doc(alias = "GST_CLOCK_BUSY")]
    Busy,
    #[doc(alias = "GST_CLOCK_BADTIME")]
    Badtime,
    #[doc(alias = "GST_CLOCK_ERROR")]
    Error,
    #[doc(alias = "GST_CLOCK_UNSUPPORTED")]
    Unsupported,
    #[doc(alias = "GST_CLOCK_DONE")]
    Done,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstClockReturn {
        match self {
            ClockReturn::Ok => ffi::GST_CLOCK_OK,
            ClockReturn::Early => ffi::GST_CLOCK_EARLY,
            ClockReturn::Unscheduled => ffi::GST_CLOCK_UNSCHEDULED,
            ClockReturn::Busy => ffi::GST_CLOCK_BUSY,
            ClockReturn::Badtime => ffi::GST_CLOCK_BADTIME,
            ClockReturn::Error => ffi::GST_CLOCK_ERROR,
            ClockReturn::Unsupported => ffi::GST_CLOCK_UNSUPPORTED,
            ClockReturn::Done => ffi::GST_CLOCK_DONE,
            ClockReturn::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstClockReturn> for ClockReturn {
    unsafe fn from_glib(value: ffi::GstClockReturn) -> Self {
        skip_assert_initialized!();
        match value {
            0 => ClockReturn::Ok,
            1 => ClockReturn::Early,
            2 => ClockReturn::Unscheduled,
            3 => ClockReturn::Busy,
            4 => ClockReturn::Badtime,
            5 => ClockReturn::Error,
            6 => ClockReturn::Unsupported,
            7 => ClockReturn::Done,
            value => ClockReturn::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for ClockReturn {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for ClockReturn {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<ClockReturn>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstClockType")]
pub enum ClockType {
    #[doc(alias = "GST_CLOCK_TYPE_REALTIME")]
    Realtime,
    #[doc(alias = "GST_CLOCK_TYPE_MONOTONIC")]
    Monotonic,
    #[doc(alias = "GST_CLOCK_TYPE_OTHER")]
    Other,
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "GST_CLOCK_TYPE_TAI")]
    Tai,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstClockType {
        match self {
            ClockType::Realtime => ffi::GST_CLOCK_TYPE_REALTIME,
            ClockType::Monotonic => ffi::GST_CLOCK_TYPE_MONOTONIC,
            ClockType::Other => ffi::GST_CLOCK_TYPE_OTHER,
            #[cfg(any(feature = "v1_18", feature = "dox"))]
            ClockType::Tai => ffi::GST_CLOCK_TYPE_TAI,
            ClockType::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstClockType> for ClockType {
    unsafe fn from_glib(value: ffi::GstClockType) -> Self {
        skip_assert_initialized!();
        match value {
            0 => ClockType::Realtime,
            1 => ClockType::Monotonic,
            2 => ClockType::Other,
            #[cfg(any(feature = "v1_18", feature = "dox"))]
            3 => ClockType::Tai,
            value => ClockType::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for ClockType {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for ClockType {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<ClockType>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstCoreError")]
pub enum CoreError {
    #[doc(alias = "GST_CORE_ERROR_FAILED")]
    Failed,
    #[doc(alias = "GST_CORE_ERROR_TOO_LAZY")]
    TooLazy,
    #[doc(alias = "GST_CORE_ERROR_NOT_IMPLEMENTED")]
    NotImplemented,
    #[doc(alias = "GST_CORE_ERROR_STATE_CHANGE")]
    StateChange,
    #[doc(alias = "GST_CORE_ERROR_PAD")]
    Pad,
    #[doc(alias = "GST_CORE_ERROR_THREAD")]
    Thread,
    #[doc(alias = "GST_CORE_ERROR_NEGOTIATION")]
    Negotiation,
    #[doc(alias = "GST_CORE_ERROR_EVENT")]
    Event,
    #[doc(alias = "GST_CORE_ERROR_SEEK")]
    Seek,
    #[doc(alias = "GST_CORE_ERROR_CAPS")]
    Caps,
    #[doc(alias = "GST_CORE_ERROR_TAG")]
    Tag,
    #[doc(alias = "GST_CORE_ERROR_MISSING_PLUGIN")]
    MissingPlugin,
    #[doc(alias = "GST_CORE_ERROR_CLOCK")]
    Clock,
    #[doc(alias = "GST_CORE_ERROR_DISABLED")]
    Disabled,
    #[doc(alias = "GST_CORE_ERROR_NUM_ERRORS")]
    NumErrors,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstCoreError {
        match self {
            CoreError::Failed => ffi::GST_CORE_ERROR_FAILED,
            CoreError::TooLazy => ffi::GST_CORE_ERROR_TOO_LAZY,
            CoreError::NotImplemented => ffi::GST_CORE_ERROR_NOT_IMPLEMENTED,
            CoreError::StateChange => ffi::GST_CORE_ERROR_STATE_CHANGE,
            CoreError::Pad => ffi::GST_CORE_ERROR_PAD,
            CoreError::Thread => ffi::GST_CORE_ERROR_THREAD,
            CoreError::Negotiation => ffi::GST_CORE_ERROR_NEGOTIATION,
            CoreError::Event => ffi::GST_CORE_ERROR_EVENT,
            CoreError::Seek => ffi::GST_CORE_ERROR_SEEK,
            CoreError::Caps => ffi::GST_CORE_ERROR_CAPS,
            CoreError::Tag => ffi::GST_CORE_ERROR_TAG,
            CoreError::MissingPlugin => ffi::GST_CORE_ERROR_MISSING_PLUGIN,
            CoreError::Clock => ffi::GST_CORE_ERROR_CLOCK,
            CoreError::Disabled => ffi::GST_CORE_ERROR_DISABLED,
            CoreError::NumErrors => ffi::GST_CORE_ERROR_NUM_ERRORS,
            CoreError::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstCoreError> for CoreError {
    unsafe fn from_glib(value: ffi::GstCoreError) -> Self {
        skip_assert_initialized!();
        match value {
            1 => CoreError::Failed,
            2 => CoreError::TooLazy,
            3 => CoreError::NotImplemented,
            4 => CoreError::StateChange,
            5 => CoreError::Pad,
            6 => CoreError::Thread,
            7 => CoreError::Negotiation,
            8 => CoreError::Event,
            9 => CoreError::Seek,
            10 => CoreError::Caps,
            11 => CoreError::Tag,
            12 => CoreError::MissingPlugin,
            13 => CoreError::Clock,
            14 => CoreError::Disabled,
            15 => CoreError::NumErrors,
            value => CoreError::__Unknown(value),
        }
    }
}

impl ErrorDomain for CoreError {
    fn domain() -> Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gst_core_error_quark()) }
    }

    fn code(self) -> i32 {
        self.into_glib()
    }

    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match code {
            1 => Some(CoreError::Failed),
            2 => Some(CoreError::TooLazy),
            3 => Some(CoreError::NotImplemented),
            4 => Some(CoreError::StateChange),
            5 => Some(CoreError::Pad),
            6 => Some(CoreError::Thread),
            7 => Some(CoreError::Negotiation),
            8 => Some(CoreError::Event),
            9 => Some(CoreError::Seek),
            10 => Some(CoreError::Caps),
            11 => Some(CoreError::Tag),
            12 => Some(CoreError::MissingPlugin),
            13 => Some(CoreError::Clock),
            14 => Some(CoreError::Disabled),
            15 => Some(CoreError::NumErrors),
            _ => Some(CoreError::Failed),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for CoreError {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for CoreError {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<CoreError>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstDebugLevel")]
pub enum DebugLevel {
    #[doc(alias = "GST_LEVEL_NONE")]
    None,
    #[doc(alias = "GST_LEVEL_ERROR")]
    Error,
    #[doc(alias = "GST_LEVEL_WARNING")]
    Warning,
    #[doc(alias = "GST_LEVEL_FIXME")]
    Fixme,
    #[doc(alias = "GST_LEVEL_INFO")]
    Info,
    #[doc(alias = "GST_LEVEL_DEBUG")]
    Debug,
    #[doc(alias = "GST_LEVEL_LOG")]
    Log,
    #[doc(alias = "GST_LEVEL_TRACE")]
    Trace,
    #[doc(alias = "GST_LEVEL_MEMDUMP")]
    Memdump,
    #[doc(alias = "GST_LEVEL_COUNT")]
    Count,
    #[doc(hidden)]
    __Unknown(i32),
}

impl DebugLevel {
    pub fn name<'a>(self) -> &'a str {
        unsafe {
            CStr::from_ptr(
                ffi::gst_debug_level_get_name(self.into_glib())
                    .as_ref()
                    .expect("gst_debug_level_get_name returned NULL"),
            )
            .to_str()
            .expect("gst_debug_level_get_name returned an invalid string")
        }
    }
}

impl fmt::Display for DebugLevel {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&self.name())
    }
}

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

    fn into_glib(self) -> ffi::GstDebugLevel {
        match self {
            DebugLevel::None => ffi::GST_LEVEL_NONE,
            DebugLevel::Error => ffi::GST_LEVEL_ERROR,
            DebugLevel::Warning => ffi::GST_LEVEL_WARNING,
            DebugLevel::Fixme => ffi::GST_LEVEL_FIXME,
            DebugLevel::Info => ffi::GST_LEVEL_INFO,
            DebugLevel::Debug => ffi::GST_LEVEL_DEBUG,
            DebugLevel::Log => ffi::GST_LEVEL_LOG,
            DebugLevel::Trace => ffi::GST_LEVEL_TRACE,
            DebugLevel::Memdump => ffi::GST_LEVEL_MEMDUMP,
            DebugLevel::Count => ffi::GST_LEVEL_COUNT,
            DebugLevel::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstDebugLevel> for DebugLevel {
    unsafe fn from_glib(value: ffi::GstDebugLevel) -> Self {
        skip_assert_initialized!();
        match value {
            0 => DebugLevel::None,
            1 => DebugLevel::Error,
            2 => DebugLevel::Warning,
            3 => DebugLevel::Fixme,
            4 => DebugLevel::Info,
            5 => DebugLevel::Debug,
            6 => DebugLevel::Log,
            7 => DebugLevel::Trace,
            9 => DebugLevel::Memdump,
            10 => DebugLevel::Count,
            value => DebugLevel::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for DebugLevel {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for DebugLevel {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<DebugLevel>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstEventType")]
pub enum EventType {
    #[doc(alias = "GST_EVENT_UNKNOWN")]
    Unknown,
    #[doc(alias = "GST_EVENT_FLUSH_START")]
    FlushStart,
    #[doc(alias = "GST_EVENT_FLUSH_STOP")]
    FlushStop,
    #[doc(alias = "GST_EVENT_STREAM_START")]
    StreamStart,
    #[doc(alias = "GST_EVENT_CAPS")]
    Caps,
    #[doc(alias = "GST_EVENT_SEGMENT")]
    Segment,
    #[doc(alias = "GST_EVENT_STREAM_COLLECTION")]
    StreamCollection,
    #[doc(alias = "GST_EVENT_TAG")]
    Tag,
    #[doc(alias = "GST_EVENT_BUFFERSIZE")]
    Buffersize,
    #[doc(alias = "GST_EVENT_SINK_MESSAGE")]
    SinkMessage,
    #[cfg(any(feature = "v1_10", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
    #[doc(alias = "GST_EVENT_STREAM_GROUP_DONE")]
    StreamGroupDone,
    #[doc(alias = "GST_EVENT_EOS")]
    Eos,
    #[doc(alias = "GST_EVENT_TOC")]
    Toc,
    #[doc(alias = "GST_EVENT_PROTECTION")]
    Protection,
    #[doc(alias = "GST_EVENT_SEGMENT_DONE")]
    SegmentDone,
    #[doc(alias = "GST_EVENT_GAP")]
    Gap,
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "GST_EVENT_INSTANT_RATE_CHANGE")]
    InstantRateChange,
    #[doc(alias = "GST_EVENT_QOS")]
    Qos,
    #[doc(alias = "GST_EVENT_SEEK")]
    Seek,
    #[doc(alias = "GST_EVENT_NAVIGATION")]
    Navigation,
    #[doc(alias = "GST_EVENT_LATENCY")]
    Latency,
    #[doc(alias = "GST_EVENT_STEP")]
    Step,
    #[doc(alias = "GST_EVENT_RECONFIGURE")]
    Reconfigure,
    #[doc(alias = "GST_EVENT_TOC_SELECT")]
    TocSelect,
    #[cfg(any(feature = "v1_10", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
    #[doc(alias = "GST_EVENT_SELECT_STREAMS")]
    SelectStreams,
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "GST_EVENT_INSTANT_RATE_SYNC_TIME")]
    InstantRateSyncTime,
    #[doc(alias = "GST_EVENT_CUSTOM_UPSTREAM")]
    CustomUpstream,
    #[doc(alias = "GST_EVENT_CUSTOM_DOWNSTREAM")]
    CustomDownstream,
    #[doc(alias = "GST_EVENT_CUSTOM_DOWNSTREAM_OOB")]
    CustomDownstreamOob,
    #[doc(alias = "GST_EVENT_CUSTOM_DOWNSTREAM_STICKY")]
    CustomDownstreamSticky,
    #[doc(alias = "GST_EVENT_CUSTOM_BOTH")]
    CustomBoth,
    #[doc(alias = "GST_EVENT_CUSTOM_BOTH_OOB")]
    CustomBothOob,
    #[doc(hidden)]
    __Unknown(i32),
}

impl EventType {
    #[doc(alias = "gst_event_type_get_flags")]
    pub fn flags(self) -> EventTypeFlags {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::gst_event_type_get_flags(self.into_glib())) }
    }

    pub fn name<'a>(self) -> &'a str {
        unsafe {
            CStr::from_ptr(
                ffi::gst_event_type_get_name(self.into_glib())
                    .as_ref()
                    .expect("gst_event_type_get_name returned NULL"),
            )
            .to_str()
            .expect("gst_event_type_get_name returned an invalid string")
        }
    }

    #[doc(alias = "gst_event_type_to_quark")]
    pub fn to_quark(self) -> glib::Quark {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::gst_event_type_to_quark(self.into_glib())) }
    }
}

impl fmt::Display for EventType {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&self.name())
    }
}

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

    fn into_glib(self) -> ffi::GstEventType {
        match self {
            EventType::Unknown => ffi::GST_EVENT_UNKNOWN,
            EventType::FlushStart => ffi::GST_EVENT_FLUSH_START,
            EventType::FlushStop => ffi::GST_EVENT_FLUSH_STOP,
            EventType::StreamStart => ffi::GST_EVENT_STREAM_START,
            EventType::Caps => ffi::GST_EVENT_CAPS,
            EventType::Segment => ffi::GST_EVENT_SEGMENT,
            EventType::StreamCollection => ffi::GST_EVENT_STREAM_COLLECTION,
            EventType::Tag => ffi::GST_EVENT_TAG,
            EventType::Buffersize => ffi::GST_EVENT_BUFFERSIZE,
            EventType::SinkMessage => ffi::GST_EVENT_SINK_MESSAGE,
            #[cfg(any(feature = "v1_10", feature = "dox"))]
            EventType::StreamGroupDone => ffi::GST_EVENT_STREAM_GROUP_DONE,
            EventType::Eos => ffi::GST_EVENT_EOS,
            EventType::Toc => ffi::GST_EVENT_TOC,
            EventType::Protection => ffi::GST_EVENT_PROTECTION,
            EventType::SegmentDone => ffi::GST_EVENT_SEGMENT_DONE,
            EventType::Gap => ffi::GST_EVENT_GAP,
            #[cfg(any(feature = "v1_18", feature = "dox"))]
            EventType::InstantRateChange => ffi::GST_EVENT_INSTANT_RATE_CHANGE,
            EventType::Qos => ffi::GST_EVENT_QOS,
            EventType::Seek => ffi::GST_EVENT_SEEK,
            EventType::Navigation => ffi::GST_EVENT_NAVIGATION,
            EventType::Latency => ffi::GST_EVENT_LATENCY,
            EventType::Step => ffi::GST_EVENT_STEP,
            EventType::Reconfigure => ffi::GST_EVENT_RECONFIGURE,
            EventType::TocSelect => ffi::GST_EVENT_TOC_SELECT,
            #[cfg(any(feature = "v1_10", feature = "dox"))]
            EventType::SelectStreams => ffi::GST_EVENT_SELECT_STREAMS,
            #[cfg(any(feature = "v1_18", feature = "dox"))]
            EventType::InstantRateSyncTime => ffi::GST_EVENT_INSTANT_RATE_SYNC_TIME,
            EventType::CustomUpstream => ffi::GST_EVENT_CUSTOM_UPSTREAM,
            EventType::CustomDownstream => ffi::GST_EVENT_CUSTOM_DOWNSTREAM,
            EventType::CustomDownstreamOob => ffi::GST_EVENT_CUSTOM_DOWNSTREAM_OOB,
            EventType::CustomDownstreamSticky => ffi::GST_EVENT_CUSTOM_DOWNSTREAM_STICKY,
            EventType::CustomBoth => ffi::GST_EVENT_CUSTOM_BOTH,
            EventType::CustomBothOob => ffi::GST_EVENT_CUSTOM_BOTH_OOB,
            EventType::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstEventType> for EventType {
    unsafe fn from_glib(value: ffi::GstEventType) -> Self {
        skip_assert_initialized!();
        match value {
            0 => EventType::Unknown,
            2563 => EventType::FlushStart,
            5127 => EventType::FlushStop,
            10254 => EventType::StreamStart,
            12814 => EventType::Caps,
            17934 => EventType::Segment,
            19230 => EventType::StreamCollection,
            20510 => EventType::Tag,
            23054 => EventType::Buffersize,
            25630 => EventType::SinkMessage,
            #[cfg(any(feature = "v1_10", feature = "dox"))]
            26894 => EventType::StreamGroupDone,
            28174 => EventType::Eos,
            30750 => EventType::Toc,
            33310 => EventType::Protection,
            38406 => EventType::SegmentDone,
            40966 => EventType::Gap,
            #[cfg(any(feature = "v1_18", feature = "dox"))]
            46090 => EventType::InstantRateChange,
            48641 => EventType::Qos,
            51201 => EventType::Seek,
            53761 => EventType::Navigation,
            56321 => EventType::Latency,
            58881 => EventType::Step,
            61441 => EventType::Reconfigure,
            64001 => EventType::TocSelect,
            #[cfg(any(feature = "v1_10", feature = "dox"))]
            66561 => EventType::SelectStreams,
            #[cfg(any(feature = "v1_18", feature = "dox"))]
            66817 => EventType::InstantRateSyncTime,
            69121 => EventType::CustomUpstream,
            71686 => EventType::CustomDownstream,
            74242 => EventType::CustomDownstreamOob,
            76830 => EventType::CustomDownstreamSticky,
            79367 => EventType::CustomBoth,
            81923 => EventType::CustomBothOob,
            value => EventType::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for EventType {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for EventType {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<EventType>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[must_use]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstFlowReturn")]
pub enum FlowReturn {
    #[doc(alias = "GST_FLOW_CUSTOM_SUCCESS_2")]
    CustomSuccess2,
    #[doc(alias = "GST_FLOW_CUSTOM_SUCCESS_1")]
    CustomSuccess1,
    #[doc(alias = "GST_FLOW_CUSTOM_SUCCESS")]
    CustomSuccess,
    #[doc(alias = "GST_FLOW_OK")]
    Ok,
    #[doc(alias = "GST_FLOW_NOT_LINKED")]
    NotLinked,
    #[doc(alias = "GST_FLOW_FLUSHING")]
    Flushing,
    #[doc(alias = "GST_FLOW_EOS")]
    Eos,
    #[doc(alias = "GST_FLOW_NOT_NEGOTIATED")]
    NotNegotiated,
    #[doc(alias = "GST_FLOW_ERROR")]
    Error,
    #[doc(alias = "GST_FLOW_NOT_SUPPORTED")]
    NotSupported,
    #[doc(alias = "GST_FLOW_CUSTOM_ERROR")]
    CustomError,
    #[doc(alias = "GST_FLOW_CUSTOM_ERROR_1")]
    CustomError1,
    #[doc(alias = "GST_FLOW_CUSTOM_ERROR_2")]
    CustomError2,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstFlowReturn {
        match self {
            FlowReturn::CustomSuccess2 => ffi::GST_FLOW_CUSTOM_SUCCESS_2,
            FlowReturn::CustomSuccess1 => ffi::GST_FLOW_CUSTOM_SUCCESS_1,
            FlowReturn::CustomSuccess => ffi::GST_FLOW_CUSTOM_SUCCESS,
            FlowReturn::Ok => ffi::GST_FLOW_OK,
            FlowReturn::NotLinked => ffi::GST_FLOW_NOT_LINKED,
            FlowReturn::Flushing => ffi::GST_FLOW_FLUSHING,
            FlowReturn::Eos => ffi::GST_FLOW_EOS,
            FlowReturn::NotNegotiated => ffi::GST_FLOW_NOT_NEGOTIATED,
            FlowReturn::Error => ffi::GST_FLOW_ERROR,
            FlowReturn::NotSupported => ffi::GST_FLOW_NOT_SUPPORTED,
            FlowReturn::CustomError => ffi::GST_FLOW_CUSTOM_ERROR,
            FlowReturn::CustomError1 => ffi::GST_FLOW_CUSTOM_ERROR_1,
            FlowReturn::CustomError2 => ffi::GST_FLOW_CUSTOM_ERROR_2,
            FlowReturn::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstFlowReturn> for FlowReturn {
    unsafe fn from_glib(value: ffi::GstFlowReturn) -> Self {
        skip_assert_initialized!();
        match value {
            102 => FlowReturn::CustomSuccess2,
            101 => FlowReturn::CustomSuccess1,
            100 => FlowReturn::CustomSuccess,
            0 => FlowReturn::Ok,
            -1 => FlowReturn::NotLinked,
            -2 => FlowReturn::Flushing,
            -3 => FlowReturn::Eos,
            -4 => FlowReturn::NotNegotiated,
            -5 => FlowReturn::Error,
            -6 => FlowReturn::NotSupported,
            -100 => FlowReturn::CustomError,
            -101 => FlowReturn::CustomError1,
            -102 => FlowReturn::CustomError2,
            value => FlowReturn::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for FlowReturn {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for FlowReturn {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<FlowReturn>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[cfg_attr(feature = "ser_de", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstFormat")]
pub enum Format {
    #[doc(alias = "GST_FORMAT_UNDEFINED")]
    Undefined,
    #[doc(alias = "GST_FORMAT_DEFAULT")]
    Default,
    #[doc(alias = "GST_FORMAT_BYTES")]
    Bytes,
    #[doc(alias = "GST_FORMAT_TIME")]
    Time,
    #[doc(alias = "GST_FORMAT_BUFFERS")]
    Buffers,
    #[doc(alias = "GST_FORMAT_PERCENT")]
    Percent,
    #[doc(hidden)]
    __Unknown(i32),
}

impl Format {
    #[doc(alias = "gst_format_get_by_nick")]
    pub fn by_nick(nick: &str) -> Format {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::gst_format_get_by_nick(nick.to_glib_none().0)) }
    }

    //#[doc(alias = "gst_format_get_details")]
    //pub fn details(self) -> /*Ignored*/Option<FormatDefinition> {
    //    unsafe { TODO: call ffi:gst_format_get_details() }
    //}

    #[doc(alias = "gst_format_get_name")]
    pub fn name(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::gst_format_get_name(self.into_glib())) }
    }

    //#[doc(alias = "gst_format_iterate_definitions")]
    //pub fn iterate_definitions() -> /*Ignored*/Iterator {
    //    unsafe { TODO: call ffi:gst_format_iterate_definitions() }
    //}

    #[doc(alias = "gst_format_to_quark")]
    pub fn to_quark(self) -> glib::Quark {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::gst_format_to_quark(self.into_glib())) }
    }
}

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

    fn into_glib(self) -> ffi::GstFormat {
        match self {
            Format::Undefined => ffi::GST_FORMAT_UNDEFINED,
            Format::Default => ffi::GST_FORMAT_DEFAULT,
            Format::Bytes => ffi::GST_FORMAT_BYTES,
            Format::Time => ffi::GST_FORMAT_TIME,
            Format::Buffers => ffi::GST_FORMAT_BUFFERS,
            Format::Percent => ffi::GST_FORMAT_PERCENT,
            Format::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstFormat> for Format {
    unsafe fn from_glib(value: ffi::GstFormat) -> Self {
        skip_assert_initialized!();
        match value {
            0 => Format::Undefined,
            1 => Format::Default,
            2 => Format::Bytes,
            3 => Format::Time,
            4 => Format::Buffers,
            5 => Format::Percent,
            value => Format::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for Format {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for Format {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Format>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstLibraryError")]
pub enum LibraryError {
    #[doc(alias = "GST_LIBRARY_ERROR_FAILED")]
    Failed,
    #[doc(alias = "GST_LIBRARY_ERROR_TOO_LAZY")]
    TooLazy,
    #[doc(alias = "GST_LIBRARY_ERROR_INIT")]
    Init,
    #[doc(alias = "GST_LIBRARY_ERROR_SHUTDOWN")]
    Shutdown,
    #[doc(alias = "GST_LIBRARY_ERROR_SETTINGS")]
    Settings,
    #[doc(alias = "GST_LIBRARY_ERROR_ENCODE")]
    Encode,
    #[doc(alias = "GST_LIBRARY_ERROR_NUM_ERRORS")]
    NumErrors,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstLibraryError {
        match self {
            LibraryError::Failed => ffi::GST_LIBRARY_ERROR_FAILED,
            LibraryError::TooLazy => ffi::GST_LIBRARY_ERROR_TOO_LAZY,
            LibraryError::Init => ffi::GST_LIBRARY_ERROR_INIT,
            LibraryError::Shutdown => ffi::GST_LIBRARY_ERROR_SHUTDOWN,
            LibraryError::Settings => ffi::GST_LIBRARY_ERROR_SETTINGS,
            LibraryError::Encode => ffi::GST_LIBRARY_ERROR_ENCODE,
            LibraryError::NumErrors => ffi::GST_LIBRARY_ERROR_NUM_ERRORS,
            LibraryError::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstLibraryError> for LibraryError {
    unsafe fn from_glib(value: ffi::GstLibraryError) -> Self {
        skip_assert_initialized!();
        match value {
            1 => LibraryError::Failed,
            2 => LibraryError::TooLazy,
            3 => LibraryError::Init,
            4 => LibraryError::Shutdown,
            5 => LibraryError::Settings,
            6 => LibraryError::Encode,
            7 => LibraryError::NumErrors,
            value => LibraryError::__Unknown(value),
        }
    }
}

impl ErrorDomain for LibraryError {
    fn domain() -> Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gst_library_error_quark()) }
    }

    fn code(self) -> i32 {
        self.into_glib()
    }

    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match code {
            1 => Some(LibraryError::Failed),
            2 => Some(LibraryError::TooLazy),
            3 => Some(LibraryError::Init),
            4 => Some(LibraryError::Shutdown),
            5 => Some(LibraryError::Settings),
            6 => Some(LibraryError::Encode),
            7 => Some(LibraryError::NumErrors),
            _ => Some(LibraryError::Failed),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for LibraryError {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for LibraryError {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<LibraryError>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstPadDirection")]
pub enum PadDirection {
    #[doc(alias = "GST_PAD_UNKNOWN")]
    Unknown,
    #[doc(alias = "GST_PAD_SRC")]
    Src,
    #[doc(alias = "GST_PAD_SINK")]
    Sink,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstPadDirection {
        match self {
            PadDirection::Unknown => ffi::GST_PAD_UNKNOWN,
            PadDirection::Src => ffi::GST_PAD_SRC,
            PadDirection::Sink => ffi::GST_PAD_SINK,
            PadDirection::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPadDirection> for PadDirection {
    unsafe fn from_glib(value: ffi::GstPadDirection) -> Self {
        skip_assert_initialized!();
        match value {
            0 => PadDirection::Unknown,
            1 => PadDirection::Src,
            2 => PadDirection::Sink,
            value => PadDirection::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for PadDirection {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for PadDirection {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<PadDirection>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[must_use]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstPadLinkReturn")]
pub enum PadLinkReturn {
    #[doc(alias = "GST_PAD_LINK_OK")]
    Ok,
    #[doc(alias = "GST_PAD_LINK_WRONG_HIERARCHY")]
    WrongHierarchy,
    #[doc(alias = "GST_PAD_LINK_WAS_LINKED")]
    WasLinked,
    #[doc(alias = "GST_PAD_LINK_WRONG_DIRECTION")]
    WrongDirection,
    #[doc(alias = "GST_PAD_LINK_NOFORMAT")]
    Noformat,
    #[doc(alias = "GST_PAD_LINK_NOSCHED")]
    Nosched,
    #[doc(alias = "GST_PAD_LINK_REFUSED")]
    Refused,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstPadLinkReturn {
        match self {
            PadLinkReturn::Ok => ffi::GST_PAD_LINK_OK,
            PadLinkReturn::WrongHierarchy => ffi::GST_PAD_LINK_WRONG_HIERARCHY,
            PadLinkReturn::WasLinked => ffi::GST_PAD_LINK_WAS_LINKED,
            PadLinkReturn::WrongDirection => ffi::GST_PAD_LINK_WRONG_DIRECTION,
            PadLinkReturn::Noformat => ffi::GST_PAD_LINK_NOFORMAT,
            PadLinkReturn::Nosched => ffi::GST_PAD_LINK_NOSCHED,
            PadLinkReturn::Refused => ffi::GST_PAD_LINK_REFUSED,
            PadLinkReturn::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPadLinkReturn> for PadLinkReturn {
    unsafe fn from_glib(value: ffi::GstPadLinkReturn) -> Self {
        skip_assert_initialized!();
        match value {
            0 => PadLinkReturn::Ok,
            -1 => PadLinkReturn::WrongHierarchy,
            -2 => PadLinkReturn::WasLinked,
            -3 => PadLinkReturn::WrongDirection,
            -4 => PadLinkReturn::Noformat,
            -5 => PadLinkReturn::Nosched,
            -6 => PadLinkReturn::Refused,
            value => PadLinkReturn::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for PadLinkReturn {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for PadLinkReturn {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<PadLinkReturn>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstPadMode")]
pub enum PadMode {
    #[doc(alias = "GST_PAD_MODE_NONE")]
    None,
    #[doc(alias = "GST_PAD_MODE_PUSH")]
    Push,
    #[doc(alias = "GST_PAD_MODE_PULL")]
    Pull,
    #[doc(hidden)]
    __Unknown(i32),
}

impl PadMode {
    pub fn name<'a>(self) -> &'a str {
        unsafe {
            CStr::from_ptr(
                ffi::gst_pad_mode_get_name(self.into_glib())
                    .as_ref()
                    .expect("gst_pad_mode_get_name returned NULL"),
            )
            .to_str()
            .expect("gst_pad_mode_get_name returned an invalid string")
        }
    }
}

impl fmt::Display for PadMode {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&self.name())
    }
}

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

    fn into_glib(self) -> ffi::GstPadMode {
        match self {
            PadMode::None => ffi::GST_PAD_MODE_NONE,
            PadMode::Push => ffi::GST_PAD_MODE_PUSH,
            PadMode::Pull => ffi::GST_PAD_MODE_PULL,
            PadMode::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPadMode> for PadMode {
    unsafe fn from_glib(value: ffi::GstPadMode) -> Self {
        skip_assert_initialized!();
        match value {
            0 => PadMode::None,
            1 => PadMode::Push,
            2 => PadMode::Pull,
            value => PadMode::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for PadMode {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for PadMode {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<PadMode>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstPadPresence")]
pub enum PadPresence {
    #[doc(alias = "GST_PAD_ALWAYS")]
    Always,
    #[doc(alias = "GST_PAD_SOMETIMES")]
    Sometimes,
    #[doc(alias = "GST_PAD_REQUEST")]
    Request,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstPadPresence {
        match self {
            PadPresence::Always => ffi::GST_PAD_ALWAYS,
            PadPresence::Sometimes => ffi::GST_PAD_SOMETIMES,
            PadPresence::Request => ffi::GST_PAD_REQUEST,
            PadPresence::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPadPresence> for PadPresence {
    unsafe fn from_glib(value: ffi::GstPadPresence) -> Self {
        skip_assert_initialized!();
        match value {
            0 => PadPresence::Always,
            1 => PadPresence::Sometimes,
            2 => PadPresence::Request,
            value => PadPresence::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for PadPresence {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for PadPresence {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<PadPresence>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstPadProbeReturn")]
pub enum PadProbeReturn {
    #[doc(alias = "GST_PAD_PROBE_DROP")]
    Drop,
    #[doc(alias = "GST_PAD_PROBE_OK")]
    Ok,
    #[doc(alias = "GST_PAD_PROBE_REMOVE")]
    Remove,
    #[doc(alias = "GST_PAD_PROBE_PASS")]
    Pass,
    #[doc(alias = "GST_PAD_PROBE_HANDLED")]
    Handled,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstPadProbeReturn {
        match self {
            PadProbeReturn::Drop => ffi::GST_PAD_PROBE_DROP,
            PadProbeReturn::Ok => ffi::GST_PAD_PROBE_OK,
            PadProbeReturn::Remove => ffi::GST_PAD_PROBE_REMOVE,
            PadProbeReturn::Pass => ffi::GST_PAD_PROBE_PASS,
            PadProbeReturn::Handled => ffi::GST_PAD_PROBE_HANDLED,
            PadProbeReturn::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPadProbeReturn> for PadProbeReturn {
    unsafe fn from_glib(value: ffi::GstPadProbeReturn) -> Self {
        skip_assert_initialized!();
        match value {
            0 => PadProbeReturn::Drop,
            1 => PadProbeReturn::Ok,
            2 => PadProbeReturn::Remove,
            3 => PadProbeReturn::Pass,
            4 => PadProbeReturn::Handled,
            value => PadProbeReturn::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for PadProbeReturn {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for PadProbeReturn {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<PadProbeReturn>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstParseError")]
pub enum ParseError {
    #[doc(alias = "GST_PARSE_ERROR_SYNTAX")]
    Syntax,
    #[doc(alias = "GST_PARSE_ERROR_NO_SUCH_ELEMENT")]
    NoSuchElement,
    #[doc(alias = "GST_PARSE_ERROR_NO_SUCH_PROPERTY")]
    NoSuchProperty,
    #[doc(alias = "GST_PARSE_ERROR_LINK")]
    Link,
    #[doc(alias = "GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY")]
    CouldNotSetProperty,
    #[doc(alias = "GST_PARSE_ERROR_EMPTY_BIN")]
    EmptyBin,
    #[doc(alias = "GST_PARSE_ERROR_EMPTY")]
    Empty,
    #[doc(alias = "GST_PARSE_ERROR_DELAYED_LINK")]
    DelayedLink,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstParseError {
        match self {
            ParseError::Syntax => ffi::GST_PARSE_ERROR_SYNTAX,
            ParseError::NoSuchElement => ffi::GST_PARSE_ERROR_NO_SUCH_ELEMENT,
            ParseError::NoSuchProperty => ffi::GST_PARSE_ERROR_NO_SUCH_PROPERTY,
            ParseError::Link => ffi::GST_PARSE_ERROR_LINK,
            ParseError::CouldNotSetProperty => ffi::GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY,
            ParseError::EmptyBin => ffi::GST_PARSE_ERROR_EMPTY_BIN,
            ParseError::Empty => ffi::GST_PARSE_ERROR_EMPTY,
            ParseError::DelayedLink => ffi::GST_PARSE_ERROR_DELAYED_LINK,
            ParseError::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstParseError> for ParseError {
    unsafe fn from_glib(value: ffi::GstParseError) -> Self {
        skip_assert_initialized!();
        match value {
            0 => ParseError::Syntax,
            1 => ParseError::NoSuchElement,
            2 => ParseError::NoSuchProperty,
            3 => ParseError::Link,
            4 => ParseError::CouldNotSetProperty,
            5 => ParseError::EmptyBin,
            6 => ParseError::Empty,
            7 => ParseError::DelayedLink,
            value => ParseError::__Unknown(value),
        }
    }
}

impl ErrorDomain for ParseError {
    fn domain() -> Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gst_parse_error_quark()) }
    }

    fn code(self) -> i32 {
        self.into_glib()
    }

    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match code {
            0 => Some(ParseError::Syntax),
            1 => Some(ParseError::NoSuchElement),
            2 => Some(ParseError::NoSuchProperty),
            3 => Some(ParseError::Link),
            4 => Some(ParseError::CouldNotSetProperty),
            5 => Some(ParseError::EmptyBin),
            6 => Some(ParseError::Empty),
            7 => Some(ParseError::DelayedLink),
            value => Some(ParseError::__Unknown(value)),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for ParseError {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for ParseError {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<ParseError>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstPluginError")]
pub enum PluginError {
    #[doc(alias = "GST_PLUGIN_ERROR_MODULE")]
    Module,
    #[doc(alias = "GST_PLUGIN_ERROR_DEPENDENCIES")]
    Dependencies,
    #[doc(alias = "GST_PLUGIN_ERROR_NAME_MISMATCH")]
    NameMismatch,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstPluginError {
        match self {
            PluginError::Module => ffi::GST_PLUGIN_ERROR_MODULE,
            PluginError::Dependencies => ffi::GST_PLUGIN_ERROR_DEPENDENCIES,
            PluginError::NameMismatch => ffi::GST_PLUGIN_ERROR_NAME_MISMATCH,
            PluginError::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPluginError> for PluginError {
    unsafe fn from_glib(value: ffi::GstPluginError) -> Self {
        skip_assert_initialized!();
        match value {
            0 => PluginError::Module,
            1 => PluginError::Dependencies,
            2 => PluginError::NameMismatch,
            value => PluginError::__Unknown(value),
        }
    }
}

impl ErrorDomain for PluginError {
    fn domain() -> Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gst_plugin_error_quark()) }
    }

    fn code(self) -> i32 {
        self.into_glib()
    }

    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match code {
            0 => Some(PluginError::Module),
            1 => Some(PluginError::Dependencies),
            2 => Some(PluginError::NameMismatch),
            value => Some(PluginError::__Unknown(value)),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for PluginError {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for PluginError {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<PluginError>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstProgressType")]
pub enum ProgressType {
    #[doc(alias = "GST_PROGRESS_TYPE_START")]
    Start,
    #[doc(alias = "GST_PROGRESS_TYPE_CONTINUE")]
    Continue,
    #[doc(alias = "GST_PROGRESS_TYPE_COMPLETE")]
    Complete,
    #[doc(alias = "GST_PROGRESS_TYPE_CANCELED")]
    Canceled,
    #[doc(alias = "GST_PROGRESS_TYPE_ERROR")]
    Error,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstProgressType {
        match self {
            ProgressType::Start => ffi::GST_PROGRESS_TYPE_START,
            ProgressType::Continue => ffi::GST_PROGRESS_TYPE_CONTINUE,
            ProgressType::Complete => ffi::GST_PROGRESS_TYPE_COMPLETE,
            ProgressType::Canceled => ffi::GST_PROGRESS_TYPE_CANCELED,
            ProgressType::Error => ffi::GST_PROGRESS_TYPE_ERROR,
            ProgressType::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstProgressType> for ProgressType {
    unsafe fn from_glib(value: ffi::GstProgressType) -> Self {
        skip_assert_initialized!();
        match value {
            0 => ProgressType::Start,
            1 => ProgressType::Continue,
            2 => ProgressType::Complete,
            3 => ProgressType::Canceled,
            4 => ProgressType::Error,
            value => ProgressType::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for ProgressType {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for ProgressType {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<ProgressType>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[cfg(any(feature = "v1_14", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstPromiseResult")]
pub enum PromiseResult {
    #[doc(alias = "GST_PROMISE_RESULT_PENDING")]
    Pending,
    #[doc(alias = "GST_PROMISE_RESULT_INTERRUPTED")]
    Interrupted,
    #[doc(alias = "GST_PROMISE_RESULT_REPLIED")]
    Replied,
    #[doc(alias = "GST_PROMISE_RESULT_EXPIRED")]
    Expired,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstPromiseResult {
        match self {
            PromiseResult::Pending => ffi::GST_PROMISE_RESULT_PENDING,
            PromiseResult::Interrupted => ffi::GST_PROMISE_RESULT_INTERRUPTED,
            PromiseResult::Replied => ffi::GST_PROMISE_RESULT_REPLIED,
            PromiseResult::Expired => ffi::GST_PROMISE_RESULT_EXPIRED,
            PromiseResult::__Unknown(value) => value,
        }
    }
}

#[cfg(any(feature = "v1_14", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
#[doc(hidden)]
impl FromGlib<ffi::GstPromiseResult> for PromiseResult {
    unsafe fn from_glib(value: ffi::GstPromiseResult) -> Self {
        skip_assert_initialized!();
        match value {
            0 => PromiseResult::Pending,
            1 => PromiseResult::Interrupted,
            2 => PromiseResult::Replied,
            3 => PromiseResult::Expired,
            value => PromiseResult::__Unknown(value),
        }
    }
}

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

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

#[cfg(any(feature = "v1_14", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
unsafe impl<'a> FromValue<'a> for PromiseResult {
    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_enum(value.to_glib_none().0))
    }
}

#[cfg(any(feature = "v1_14", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
impl ToValue for PromiseResult {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<PromiseResult>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstQOSType")]
pub enum QOSType {
    #[doc(alias = "GST_QOS_TYPE_OVERFLOW")]
    Overflow,
    #[doc(alias = "GST_QOS_TYPE_UNDERFLOW")]
    Underflow,
    #[doc(alias = "GST_QOS_TYPE_THROTTLE")]
    Throttle,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstQOSType {
        match self {
            QOSType::Overflow => ffi::GST_QOS_TYPE_OVERFLOW,
            QOSType::Underflow => ffi::GST_QOS_TYPE_UNDERFLOW,
            QOSType::Throttle => ffi::GST_QOS_TYPE_THROTTLE,
            QOSType::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstQOSType> for QOSType {
    unsafe fn from_glib(value: ffi::GstQOSType) -> Self {
        skip_assert_initialized!();
        match value {
            0 => QOSType::Overflow,
            1 => QOSType::Underflow,
            2 => QOSType::Throttle,
            value => QOSType::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for QOSType {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for QOSType {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<QOSType>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstRank")]
pub enum Rank {
    #[doc(alias = "GST_RANK_NONE")]
    None,
    #[doc(alias = "GST_RANK_MARGINAL")]
    Marginal,
    #[doc(alias = "GST_RANK_SECONDARY")]
    Secondary,
    #[doc(alias = "GST_RANK_PRIMARY")]
    Primary,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstRank {
        match self {
            Rank::None => ffi::GST_RANK_NONE,
            Rank::Marginal => ffi::GST_RANK_MARGINAL,
            Rank::Secondary => ffi::GST_RANK_SECONDARY,
            Rank::Primary => ffi::GST_RANK_PRIMARY,
            Rank::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstRank> for Rank {
    unsafe fn from_glib(value: ffi::GstRank) -> Self {
        skip_assert_initialized!();
        match value {
            0 => Rank::None,
            64 => Rank::Marginal,
            128 => Rank::Secondary,
            256 => Rank::Primary,
            value => Rank::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for Rank {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for Rank {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Rank>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstResourceError")]
pub enum ResourceError {
    #[doc(alias = "GST_RESOURCE_ERROR_FAILED")]
    Failed,
    #[doc(alias = "GST_RESOURCE_ERROR_TOO_LAZY")]
    TooLazy,
    #[doc(alias = "GST_RESOURCE_ERROR_NOT_FOUND")]
    NotFound,
    #[doc(alias = "GST_RESOURCE_ERROR_BUSY")]
    Busy,
    #[doc(alias = "GST_RESOURCE_ERROR_OPEN_READ")]
    OpenRead,
    #[doc(alias = "GST_RESOURCE_ERROR_OPEN_WRITE")]
    OpenWrite,
    #[doc(alias = "GST_RESOURCE_ERROR_OPEN_READ_WRITE")]
    OpenReadWrite,
    #[doc(alias = "GST_RESOURCE_ERROR_CLOSE")]
    Close,
    #[doc(alias = "GST_RESOURCE_ERROR_READ")]
    Read,
    #[doc(alias = "GST_RESOURCE_ERROR_WRITE")]
    Write,
    #[doc(alias = "GST_RESOURCE_ERROR_SEEK")]
    Seek,
    #[doc(alias = "GST_RESOURCE_ERROR_SYNC")]
    Sync,
    #[doc(alias = "GST_RESOURCE_ERROR_SETTINGS")]
    Settings,
    #[doc(alias = "GST_RESOURCE_ERROR_NO_SPACE_LEFT")]
    NoSpaceLeft,
    #[doc(alias = "GST_RESOURCE_ERROR_NOT_AUTHORIZED")]
    NotAuthorized,
    #[doc(alias = "GST_RESOURCE_ERROR_NUM_ERRORS")]
    NumErrors,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstResourceError {
        match self {
            ResourceError::Failed => ffi::GST_RESOURCE_ERROR_FAILED,
            ResourceError::TooLazy => ffi::GST_RESOURCE_ERROR_TOO_LAZY,
            ResourceError::NotFound => ffi::GST_RESOURCE_ERROR_NOT_FOUND,
            ResourceError::Busy => ffi::GST_RESOURCE_ERROR_BUSY,
            ResourceError::OpenRead => ffi::GST_RESOURCE_ERROR_OPEN_READ,
            ResourceError::OpenWrite => ffi::GST_RESOURCE_ERROR_OPEN_WRITE,
            ResourceError::OpenReadWrite => ffi::GST_RESOURCE_ERROR_OPEN_READ_WRITE,
            ResourceError::Close => ffi::GST_RESOURCE_ERROR_CLOSE,
            ResourceError::Read => ffi::GST_RESOURCE_ERROR_READ,
            ResourceError::Write => ffi::GST_RESOURCE_ERROR_WRITE,
            ResourceError::Seek => ffi::GST_RESOURCE_ERROR_SEEK,
            ResourceError::Sync => ffi::GST_RESOURCE_ERROR_SYNC,
            ResourceError::Settings => ffi::GST_RESOURCE_ERROR_SETTINGS,
            ResourceError::NoSpaceLeft => ffi::GST_RESOURCE_ERROR_NO_SPACE_LEFT,
            ResourceError::NotAuthorized => ffi::GST_RESOURCE_ERROR_NOT_AUTHORIZED,
            ResourceError::NumErrors => ffi::GST_RESOURCE_ERROR_NUM_ERRORS,
            ResourceError::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstResourceError> for ResourceError {
    unsafe fn from_glib(value: ffi::GstResourceError) -> Self {
        skip_assert_initialized!();
        match value {
            1 => ResourceError::Failed,
            2 => ResourceError::TooLazy,
            3 => ResourceError::NotFound,
            4 => ResourceError::Busy,
            5 => ResourceError::OpenRead,
            6 => ResourceError::OpenWrite,
            7 => ResourceError::OpenReadWrite,
            8 => ResourceError::Close,
            9 => ResourceError::Read,
            10 => ResourceError::Write,
            11 => ResourceError::Seek,
            12 => ResourceError::Sync,
            13 => ResourceError::Settings,
            14 => ResourceError::NoSpaceLeft,
            15 => ResourceError::NotAuthorized,
            16 => ResourceError::NumErrors,
            value => ResourceError::__Unknown(value),
        }
    }
}

impl ErrorDomain for ResourceError {
    fn domain() -> Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gst_resource_error_quark()) }
    }

    fn code(self) -> i32 {
        self.into_glib()
    }

    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match code {
            1 => Some(ResourceError::Failed),
            2 => Some(ResourceError::TooLazy),
            3 => Some(ResourceError::NotFound),
            4 => Some(ResourceError::Busy),
            5 => Some(ResourceError::OpenRead),
            6 => Some(ResourceError::OpenWrite),
            7 => Some(ResourceError::OpenReadWrite),
            8 => Some(ResourceError::Close),
            9 => Some(ResourceError::Read),
            10 => Some(ResourceError::Write),
            11 => Some(ResourceError::Seek),
            12 => Some(ResourceError::Sync),
            13 => Some(ResourceError::Settings),
            14 => Some(ResourceError::NoSpaceLeft),
            15 => Some(ResourceError::NotAuthorized),
            16 => Some(ResourceError::NumErrors),
            _ => Some(ResourceError::Failed),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for ResourceError {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for ResourceError {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<ResourceError>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstSeekType")]
pub enum SeekType {
    #[doc(alias = "GST_SEEK_TYPE_NONE")]
    None,
    #[doc(alias = "GST_SEEK_TYPE_SET")]
    Set,
    #[doc(alias = "GST_SEEK_TYPE_END")]
    End,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstSeekType {
        match self {
            SeekType::None => ffi::GST_SEEK_TYPE_NONE,
            SeekType::Set => ffi::GST_SEEK_TYPE_SET,
            SeekType::End => ffi::GST_SEEK_TYPE_END,
            SeekType::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstSeekType> for SeekType {
    unsafe fn from_glib(value: ffi::GstSeekType) -> Self {
        skip_assert_initialized!();
        match value {
            0 => SeekType::None,
            1 => SeekType::Set,
            2 => SeekType::End,
            value => SeekType::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for SeekType {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for SeekType {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<SeekType>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstState")]
pub enum State {
    #[doc(alias = "GST_STATE_VOID_PENDING")]
    VoidPending,
    #[doc(alias = "GST_STATE_NULL")]
    Null,
    #[doc(alias = "GST_STATE_READY")]
    Ready,
    #[doc(alias = "GST_STATE_PAUSED")]
    Paused,
    #[doc(alias = "GST_STATE_PLAYING")]
    Playing,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstState {
        match self {
            State::VoidPending => ffi::GST_STATE_VOID_PENDING,
            State::Null => ffi::GST_STATE_NULL,
            State::Ready => ffi::GST_STATE_READY,
            State::Paused => ffi::GST_STATE_PAUSED,
            State::Playing => ffi::GST_STATE_PLAYING,
            State::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstState> for State {
    unsafe fn from_glib(value: ffi::GstState) -> Self {
        skip_assert_initialized!();
        match value {
            0 => State::VoidPending,
            1 => State::Null,
            2 => State::Ready,
            3 => State::Paused,
            4 => State::Playing,
            value => State::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for State {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for State {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<State>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstStateChange")]
pub enum StateChange {
    #[doc(alias = "GST_STATE_CHANGE_NULL_TO_READY")]
    NullToReady,
    #[doc(alias = "GST_STATE_CHANGE_READY_TO_PAUSED")]
    ReadyToPaused,
    #[doc(alias = "GST_STATE_CHANGE_PAUSED_TO_PLAYING")]
    PausedToPlaying,
    #[doc(alias = "GST_STATE_CHANGE_PLAYING_TO_PAUSED")]
    PlayingToPaused,
    #[doc(alias = "GST_STATE_CHANGE_PAUSED_TO_READY")]
    PausedToReady,
    #[doc(alias = "GST_STATE_CHANGE_READY_TO_NULL")]
    ReadyToNull,
    #[doc(alias = "GST_STATE_CHANGE_NULL_TO_NULL")]
    NullToNull,
    #[doc(alias = "GST_STATE_CHANGE_READY_TO_READY")]
    ReadyToReady,
    #[doc(alias = "GST_STATE_CHANGE_PAUSED_TO_PAUSED")]
    PausedToPaused,
    #[doc(alias = "GST_STATE_CHANGE_PLAYING_TO_PLAYING")]
    PlayingToPlaying,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for StateChange {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&self.name())
    }
}

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

    fn into_glib(self) -> ffi::GstStateChange {
        match self {
            StateChange::NullToReady => ffi::GST_STATE_CHANGE_NULL_TO_READY,
            StateChange::ReadyToPaused => ffi::GST_STATE_CHANGE_READY_TO_PAUSED,
            StateChange::PausedToPlaying => ffi::GST_STATE_CHANGE_PAUSED_TO_PLAYING,
            StateChange::PlayingToPaused => ffi::GST_STATE_CHANGE_PLAYING_TO_PAUSED,
            StateChange::PausedToReady => ffi::GST_STATE_CHANGE_PAUSED_TO_READY,
            StateChange::ReadyToNull => ffi::GST_STATE_CHANGE_READY_TO_NULL,
            StateChange::NullToNull => ffi::GST_STATE_CHANGE_NULL_TO_NULL,
            StateChange::ReadyToReady => ffi::GST_STATE_CHANGE_READY_TO_READY,
            StateChange::PausedToPaused => ffi::GST_STATE_CHANGE_PAUSED_TO_PAUSED,
            StateChange::PlayingToPlaying => ffi::GST_STATE_CHANGE_PLAYING_TO_PLAYING,
            StateChange::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstStateChange> for StateChange {
    unsafe fn from_glib(value: ffi::GstStateChange) -> Self {
        skip_assert_initialized!();
        match value {
            10 => StateChange::NullToReady,
            19 => StateChange::ReadyToPaused,
            28 => StateChange::PausedToPlaying,
            35 => StateChange::PlayingToPaused,
            26 => StateChange::PausedToReady,
            17 => StateChange::ReadyToNull,
            9 => StateChange::NullToNull,
            18 => StateChange::ReadyToReady,
            27 => StateChange::PausedToPaused,
            36 => StateChange::PlayingToPlaying,
            value => StateChange::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for StateChange {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for StateChange {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<StateChange>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[must_use]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstStateChangeReturn")]
pub enum StateChangeReturn {
    #[doc(alias = "GST_STATE_CHANGE_FAILURE")]
    Failure,
    #[doc(alias = "GST_STATE_CHANGE_SUCCESS")]
    Success,
    #[doc(alias = "GST_STATE_CHANGE_ASYNC")]
    Async,
    #[doc(alias = "GST_STATE_CHANGE_NO_PREROLL")]
    NoPreroll,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstStateChangeReturn {
        match self {
            StateChangeReturn::Failure => ffi::GST_STATE_CHANGE_FAILURE,
            StateChangeReturn::Success => ffi::GST_STATE_CHANGE_SUCCESS,
            StateChangeReturn::Async => ffi::GST_STATE_CHANGE_ASYNC,
            StateChangeReturn::NoPreroll => ffi::GST_STATE_CHANGE_NO_PREROLL,
            StateChangeReturn::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstStateChangeReturn> for StateChangeReturn {
    unsafe fn from_glib(value: ffi::GstStateChangeReturn) -> Self {
        skip_assert_initialized!();
        match value {
            0 => StateChangeReturn::Failure,
            1 => StateChangeReturn::Success,
            2 => StateChangeReturn::Async,
            3 => StateChangeReturn::NoPreroll,
            value => StateChangeReturn::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for StateChangeReturn {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for StateChangeReturn {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<StateChangeReturn>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstStreamError")]
pub enum StreamError {
    #[doc(alias = "GST_STREAM_ERROR_FAILED")]
    Failed,
    #[doc(alias = "GST_STREAM_ERROR_TOO_LAZY")]
    TooLazy,
    #[doc(alias = "GST_STREAM_ERROR_NOT_IMPLEMENTED")]
    NotImplemented,
    #[doc(alias = "GST_STREAM_ERROR_TYPE_NOT_FOUND")]
    TypeNotFound,
    #[doc(alias = "GST_STREAM_ERROR_WRONG_TYPE")]
    WrongType,
    #[doc(alias = "GST_STREAM_ERROR_CODEC_NOT_FOUND")]
    CodecNotFound,
    #[doc(alias = "GST_STREAM_ERROR_DECODE")]
    Decode,
    #[doc(alias = "GST_STREAM_ERROR_ENCODE")]
    Encode,
    #[doc(alias = "GST_STREAM_ERROR_DEMUX")]
    Demux,
    #[doc(alias = "GST_STREAM_ERROR_MUX")]
    Mux,
    #[doc(alias = "GST_STREAM_ERROR_FORMAT")]
    Format,
    #[doc(alias = "GST_STREAM_ERROR_DECRYPT")]
    Decrypt,
    #[doc(alias = "GST_STREAM_ERROR_DECRYPT_NOKEY")]
    DecryptNokey,
    #[doc(alias = "GST_STREAM_ERROR_NUM_ERRORS")]
    NumErrors,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstStreamError {
        match self {
            StreamError::Failed => ffi::GST_STREAM_ERROR_FAILED,
            StreamError::TooLazy => ffi::GST_STREAM_ERROR_TOO_LAZY,
            StreamError::NotImplemented => ffi::GST_STREAM_ERROR_NOT_IMPLEMENTED,
            StreamError::TypeNotFound => ffi::GST_STREAM_ERROR_TYPE_NOT_FOUND,
            StreamError::WrongType => ffi::GST_STREAM_ERROR_WRONG_TYPE,
            StreamError::CodecNotFound => ffi::GST_STREAM_ERROR_CODEC_NOT_FOUND,
            StreamError::Decode => ffi::GST_STREAM_ERROR_DECODE,
            StreamError::Encode => ffi::GST_STREAM_ERROR_ENCODE,
            StreamError::Demux => ffi::GST_STREAM_ERROR_DEMUX,
            StreamError::Mux => ffi::GST_STREAM_ERROR_MUX,
            StreamError::Format => ffi::GST_STREAM_ERROR_FORMAT,
            StreamError::Decrypt => ffi::GST_STREAM_ERROR_DECRYPT,
            StreamError::DecryptNokey => ffi::GST_STREAM_ERROR_DECRYPT_NOKEY,
            StreamError::NumErrors => ffi::GST_STREAM_ERROR_NUM_ERRORS,
            StreamError::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstStreamError> for StreamError {
    unsafe fn from_glib(value: ffi::GstStreamError) -> Self {
        skip_assert_initialized!();
        match value {
            1 => StreamError::Failed,
            2 => StreamError::TooLazy,
            3 => StreamError::NotImplemented,
            4 => StreamError::TypeNotFound,
            5 => StreamError::WrongType,
            6 => StreamError::CodecNotFound,
            7 => StreamError::Decode,
            8 => StreamError::Encode,
            9 => StreamError::Demux,
            10 => StreamError::Mux,
            11 => StreamError::Format,
            12 => StreamError::Decrypt,
            13 => StreamError::DecryptNokey,
            14 => StreamError::NumErrors,
            value => StreamError::__Unknown(value),
        }
    }
}

impl ErrorDomain for StreamError {
    fn domain() -> Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gst_stream_error_quark()) }
    }

    fn code(self) -> i32 {
        self.into_glib()
    }

    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match code {
            1 => Some(StreamError::Failed),
            2 => Some(StreamError::TooLazy),
            3 => Some(StreamError::NotImplemented),
            4 => Some(StreamError::TypeNotFound),
            5 => Some(StreamError::WrongType),
            6 => Some(StreamError::CodecNotFound),
            7 => Some(StreamError::Decode),
            8 => Some(StreamError::Encode),
            9 => Some(StreamError::Demux),
            10 => Some(StreamError::Mux),
            11 => Some(StreamError::Format),
            12 => Some(StreamError::Decrypt),
            13 => Some(StreamError::DecryptNokey),
            14 => Some(StreamError::NumErrors),
            _ => Some(StreamError::Failed),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for StreamError {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for StreamError {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<StreamError>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstStreamStatusType")]
pub enum StreamStatusType {
    #[doc(alias = "GST_STREAM_STATUS_TYPE_CREATE")]
    Create,
    #[doc(alias = "GST_STREAM_STATUS_TYPE_ENTER")]
    Enter,
    #[doc(alias = "GST_STREAM_STATUS_TYPE_LEAVE")]
    Leave,
    #[doc(alias = "GST_STREAM_STATUS_TYPE_DESTROY")]
    Destroy,
    #[doc(alias = "GST_STREAM_STATUS_TYPE_START")]
    Start,
    #[doc(alias = "GST_STREAM_STATUS_TYPE_PAUSE")]
    Pause,
    #[doc(alias = "GST_STREAM_STATUS_TYPE_STOP")]
    Stop,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstStreamStatusType {
        match self {
            StreamStatusType::Create => ffi::GST_STREAM_STATUS_TYPE_CREATE,
            StreamStatusType::Enter => ffi::GST_STREAM_STATUS_TYPE_ENTER,
            StreamStatusType::Leave => ffi::GST_STREAM_STATUS_TYPE_LEAVE,
            StreamStatusType::Destroy => ffi::GST_STREAM_STATUS_TYPE_DESTROY,
            StreamStatusType::Start => ffi::GST_STREAM_STATUS_TYPE_START,
            StreamStatusType::Pause => ffi::GST_STREAM_STATUS_TYPE_PAUSE,
            StreamStatusType::Stop => ffi::GST_STREAM_STATUS_TYPE_STOP,
            StreamStatusType::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstStreamStatusType> for StreamStatusType {
    unsafe fn from_glib(value: ffi::GstStreamStatusType) -> Self {
        skip_assert_initialized!();
        match value {
            0 => StreamStatusType::Create,
            1 => StreamStatusType::Enter,
            2 => StreamStatusType::Leave,
            3 => StreamStatusType::Destroy,
            8 => StreamStatusType::Start,
            9 => StreamStatusType::Pause,
            10 => StreamStatusType::Stop,
            value => StreamStatusType::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for StreamStatusType {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for StreamStatusType {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<StreamStatusType>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstStructureChangeType")]
pub enum StructureChangeType {
    #[doc(alias = "GST_STRUCTURE_CHANGE_TYPE_PAD_LINK")]
    Link,
    #[doc(alias = "GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK")]
    Unlink,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstStructureChangeType {
        match self {
            StructureChangeType::Link => ffi::GST_STRUCTURE_CHANGE_TYPE_PAD_LINK,
            StructureChangeType::Unlink => ffi::GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK,
            StructureChangeType::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstStructureChangeType> for StructureChangeType {
    unsafe fn from_glib(value: ffi::GstStructureChangeType) -> Self {
        skip_assert_initialized!();
        match value {
            0 => StructureChangeType::Link,
            1 => StructureChangeType::Unlink,
            value => StructureChangeType::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for StructureChangeType {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for StructureChangeType {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<StructureChangeType>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstTagFlag")]
pub enum TagFlag {
    #[doc(alias = "GST_TAG_FLAG_UNDEFINED")]
    Undefined,
    #[doc(alias = "GST_TAG_FLAG_META")]
    Meta,
    #[doc(alias = "GST_TAG_FLAG_ENCODED")]
    Encoded,
    #[doc(alias = "GST_TAG_FLAG_DECODED")]
    Decoded,
    #[doc(alias = "GST_TAG_FLAG_COUNT")]
    Count,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstTagFlag {
        match self {
            TagFlag::Undefined => ffi::GST_TAG_FLAG_UNDEFINED,
            TagFlag::Meta => ffi::GST_TAG_FLAG_META,
            TagFlag::Encoded => ffi::GST_TAG_FLAG_ENCODED,
            TagFlag::Decoded => ffi::GST_TAG_FLAG_DECODED,
            TagFlag::Count => ffi::GST_TAG_FLAG_COUNT,
            TagFlag::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstTagFlag> for TagFlag {
    unsafe fn from_glib(value: ffi::GstTagFlag) -> Self {
        skip_assert_initialized!();
        match value {
            0 => TagFlag::Undefined,
            1 => TagFlag::Meta,
            2 => TagFlag::Encoded,
            3 => TagFlag::Decoded,
            4 => TagFlag::Count,
            value => TagFlag::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for TagFlag {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for TagFlag {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<TagFlag>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstTagMergeMode")]
pub enum TagMergeMode {
    #[doc(alias = "GST_TAG_MERGE_UNDEFINED")]
    Undefined,
    #[doc(alias = "GST_TAG_MERGE_REPLACE_ALL")]
    ReplaceAll,
    #[doc(alias = "GST_TAG_MERGE_REPLACE")]
    Replace,
    #[doc(alias = "GST_TAG_MERGE_APPEND")]
    Append,
    #[doc(alias = "GST_TAG_MERGE_PREPEND")]
    Prepend,
    #[doc(alias = "GST_TAG_MERGE_KEEP")]
    Keep,
    #[doc(alias = "GST_TAG_MERGE_KEEP_ALL")]
    KeepAll,
    #[doc(alias = "GST_TAG_MERGE_COUNT")]
    Count,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstTagMergeMode {
        match self {
            TagMergeMode::Undefined => ffi::GST_TAG_MERGE_UNDEFINED,
            TagMergeMode::ReplaceAll => ffi::GST_TAG_MERGE_REPLACE_ALL,
            TagMergeMode::Replace => ffi::GST_TAG_MERGE_REPLACE,
            TagMergeMode::Append => ffi::GST_TAG_MERGE_APPEND,
            TagMergeMode::Prepend => ffi::GST_TAG_MERGE_PREPEND,
            TagMergeMode::Keep => ffi::GST_TAG_MERGE_KEEP,
            TagMergeMode::KeepAll => ffi::GST_TAG_MERGE_KEEP_ALL,
            TagMergeMode::Count => ffi::GST_TAG_MERGE_COUNT,
            TagMergeMode::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstTagMergeMode> for TagMergeMode {
    unsafe fn from_glib(value: ffi::GstTagMergeMode) -> Self {
        skip_assert_initialized!();
        match value {
            0 => TagMergeMode::Undefined,
            1 => TagMergeMode::ReplaceAll,
            2 => TagMergeMode::Replace,
            3 => TagMergeMode::Append,
            4 => TagMergeMode::Prepend,
            5 => TagMergeMode::Keep,
            6 => TagMergeMode::KeepAll,
            7 => TagMergeMode::Count,
            value => TagMergeMode::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for TagMergeMode {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for TagMergeMode {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<TagMergeMode>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[cfg_attr(feature = "ser_de", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstTagScope")]
pub enum TagScope {
    #[doc(alias = "GST_TAG_SCOPE_STREAM")]
    Stream,
    #[doc(alias = "GST_TAG_SCOPE_GLOBAL")]
    Global,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstTagScope {
        match self {
            TagScope::Stream => ffi::GST_TAG_SCOPE_STREAM,
            TagScope::Global => ffi::GST_TAG_SCOPE_GLOBAL,
            TagScope::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstTagScope> for TagScope {
    unsafe fn from_glib(value: ffi::GstTagScope) -> Self {
        skip_assert_initialized!();
        match value {
            0 => TagScope::Stream,
            1 => TagScope::Global,
            value => TagScope::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for TagScope {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for TagScope {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<TagScope>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstTaskState")]
pub enum TaskState {
    #[doc(alias = "GST_TASK_STARTED")]
    Started,
    #[doc(alias = "GST_TASK_STOPPED")]
    Stopped,
    #[doc(alias = "GST_TASK_PAUSED")]
    Paused,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstTaskState {
        match self {
            TaskState::Started => ffi::GST_TASK_STARTED,
            TaskState::Stopped => ffi::GST_TASK_STOPPED,
            TaskState::Paused => ffi::GST_TASK_PAUSED,
            TaskState::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstTaskState> for TaskState {
    unsafe fn from_glib(value: ffi::GstTaskState) -> Self {
        skip_assert_initialized!();
        match value {
            0 => TaskState::Started,
            1 => TaskState::Stopped,
            2 => TaskState::Paused,
            value => TaskState::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for TaskState {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for TaskState {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<TaskState>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[cfg_attr(feature = "ser_de", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstTocEntryType")]
pub enum TocEntryType {
    #[doc(alias = "GST_TOC_ENTRY_TYPE_ANGLE")]
    Angle,
    #[doc(alias = "GST_TOC_ENTRY_TYPE_VERSION")]
    Version,
    #[doc(alias = "GST_TOC_ENTRY_TYPE_EDITION")]
    Edition,
    #[doc(alias = "GST_TOC_ENTRY_TYPE_INVALID")]
    Invalid,
    #[doc(alias = "GST_TOC_ENTRY_TYPE_TITLE")]
    Title,
    #[doc(alias = "GST_TOC_ENTRY_TYPE_TRACK")]
    Track,
    #[doc(alias = "GST_TOC_ENTRY_TYPE_CHAPTER")]
    Chapter,
    #[doc(hidden)]
    __Unknown(i32),
}

impl TocEntryType {
    pub fn nick<'a>(self) -> &'a str {
        unsafe {
            CStr::from_ptr(
                ffi::gst_toc_entry_type_get_nick(self.into_glib())
                    .as_ref()
                    .expect("gst_toc_entry_type_get_nick returned NULL"),
            )
            .to_str()
            .expect("gst_toc_entry_type_get_nick returned an invalid string")
        }
    }
}

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

    fn into_glib(self) -> ffi::GstTocEntryType {
        match self {
            TocEntryType::Angle => ffi::GST_TOC_ENTRY_TYPE_ANGLE,
            TocEntryType::Version => ffi::GST_TOC_ENTRY_TYPE_VERSION,
            TocEntryType::Edition => ffi::GST_TOC_ENTRY_TYPE_EDITION,
            TocEntryType::Invalid => ffi::GST_TOC_ENTRY_TYPE_INVALID,
            TocEntryType::Title => ffi::GST_TOC_ENTRY_TYPE_TITLE,
            TocEntryType::Track => ffi::GST_TOC_ENTRY_TYPE_TRACK,
            TocEntryType::Chapter => ffi::GST_TOC_ENTRY_TYPE_CHAPTER,
            TocEntryType::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstTocEntryType> for TocEntryType {
    unsafe fn from_glib(value: ffi::GstTocEntryType) -> Self {
        skip_assert_initialized!();
        match value {
            -3 => TocEntryType::Angle,
            -2 => TocEntryType::Version,
            -1 => TocEntryType::Edition,
            0 => TocEntryType::Invalid,
            1 => TocEntryType::Title,
            2 => TocEntryType::Track,
            3 => TocEntryType::Chapter,
            value => TocEntryType::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for TocEntryType {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for TocEntryType {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<TocEntryType>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[cfg_attr(feature = "ser_de", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstTocLoopType")]
pub enum TocLoopType {
    #[doc(alias = "GST_TOC_LOOP_NONE")]
    None,
    #[doc(alias = "GST_TOC_LOOP_FORWARD")]
    Forward,
    #[doc(alias = "GST_TOC_LOOP_REVERSE")]
    Reverse,
    #[doc(alias = "GST_TOC_LOOP_PING_PONG")]
    PingPong,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstTocLoopType {
        match self {
            TocLoopType::None => ffi::GST_TOC_LOOP_NONE,
            TocLoopType::Forward => ffi::GST_TOC_LOOP_FORWARD,
            TocLoopType::Reverse => ffi::GST_TOC_LOOP_REVERSE,
            TocLoopType::PingPong => ffi::GST_TOC_LOOP_PING_PONG,
            TocLoopType::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstTocLoopType> for TocLoopType {
    unsafe fn from_glib(value: ffi::GstTocLoopType) -> Self {
        skip_assert_initialized!();
        match value {
            0 => TocLoopType::None,
            1 => TocLoopType::Forward,
            2 => TocLoopType::Reverse,
            3 => TocLoopType::PingPong,
            value => TocLoopType::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for TocLoopType {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for TocLoopType {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<TocLoopType>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[cfg_attr(feature = "ser_de", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstTocScope")]
pub enum TocScope {
    #[doc(alias = "GST_TOC_SCOPE_GLOBAL")]
    Global,
    #[doc(alias = "GST_TOC_SCOPE_CURRENT")]
    Current,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstTocScope {
        match self {
            TocScope::Global => ffi::GST_TOC_SCOPE_GLOBAL,
            TocScope::Current => ffi::GST_TOC_SCOPE_CURRENT,
            TocScope::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstTocScope> for TocScope {
    unsafe fn from_glib(value: ffi::GstTocScope) -> Self {
        skip_assert_initialized!();
        match value {
            1 => TocScope::Global,
            2 => TocScope::Current,
            value => TocScope::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for TocScope {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for TocScope {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<TocScope>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstTypeFindProbability")]
pub enum TypeFindProbability {
    #[doc(alias = "GST_TYPE_FIND_NONE")]
    None,
    #[doc(alias = "GST_TYPE_FIND_MINIMUM")]
    Minimum,
    #[doc(alias = "GST_TYPE_FIND_POSSIBLE")]
    Possible,
    #[doc(alias = "GST_TYPE_FIND_LIKELY")]
    Likely,
    #[doc(alias = "GST_TYPE_FIND_NEARLY_CERTAIN")]
    NearlyCertain,
    #[doc(alias = "GST_TYPE_FIND_MAXIMUM")]
    Maximum,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstTypeFindProbability {
        match self {
            TypeFindProbability::None => ffi::GST_TYPE_FIND_NONE,
            TypeFindProbability::Minimum => ffi::GST_TYPE_FIND_MINIMUM,
            TypeFindProbability::Possible => ffi::GST_TYPE_FIND_POSSIBLE,
            TypeFindProbability::Likely => ffi::GST_TYPE_FIND_LIKELY,
            TypeFindProbability::NearlyCertain => ffi::GST_TYPE_FIND_NEARLY_CERTAIN,
            TypeFindProbability::Maximum => ffi::GST_TYPE_FIND_MAXIMUM,
            TypeFindProbability::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstTypeFindProbability> for TypeFindProbability {
    unsafe fn from_glib(value: ffi::GstTypeFindProbability) -> Self {
        skip_assert_initialized!();
        match value {
            0 => TypeFindProbability::None,
            1 => TypeFindProbability::Minimum,
            50 => TypeFindProbability::Possible,
            80 => TypeFindProbability::Likely,
            99 => TypeFindProbability::NearlyCertain,
            100 => TypeFindProbability::Maximum,
            value => TypeFindProbability::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for TypeFindProbability {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for TypeFindProbability {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<TypeFindProbability>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstURIError")]
pub enum URIError {
    #[doc(alias = "GST_URI_ERROR_UNSUPPORTED_PROTOCOL")]
    UnsupportedProtocol,
    #[doc(alias = "GST_URI_ERROR_BAD_URI")]
    BadUri,
    #[doc(alias = "GST_URI_ERROR_BAD_STATE")]
    BadState,
    #[doc(alias = "GST_URI_ERROR_BAD_REFERENCE")]
    BadReference,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstURIError {
        match self {
            URIError::UnsupportedProtocol => ffi::GST_URI_ERROR_UNSUPPORTED_PROTOCOL,
            URIError::BadUri => ffi::GST_URI_ERROR_BAD_URI,
            URIError::BadState => ffi::GST_URI_ERROR_BAD_STATE,
            URIError::BadReference => ffi::GST_URI_ERROR_BAD_REFERENCE,
            URIError::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstURIError> for URIError {
    unsafe fn from_glib(value: ffi::GstURIError) -> Self {
        skip_assert_initialized!();
        match value {
            0 => URIError::UnsupportedProtocol,
            1 => URIError::BadUri,
            2 => URIError::BadState,
            3 => URIError::BadReference,
            value => URIError::__Unknown(value),
        }
    }
}

impl ErrorDomain for URIError {
    fn domain() -> Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gst_uri_error_quark()) }
    }

    fn code(self) -> i32 {
        self.into_glib()
    }

    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match code {
            0 => Some(URIError::UnsupportedProtocol),
            1 => Some(URIError::BadUri),
            2 => Some(URIError::BadState),
            3 => Some(URIError::BadReference),
            value => Some(URIError::__Unknown(value)),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for URIError {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for URIError {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<URIError>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstURIType")]
pub enum URIType {
    #[doc(alias = "GST_URI_UNKNOWN")]
    Unknown,
    #[doc(alias = "GST_URI_SINK")]
    Sink,
    #[doc(alias = "GST_URI_SRC")]
    Src,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GstURIType {
        match self {
            URIType::Unknown => ffi::GST_URI_UNKNOWN,
            URIType::Sink => ffi::GST_URI_SINK,
            URIType::Src => ffi::GST_URI_SRC,
            URIType::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstURIType> for URIType {
    unsafe fn from_glib(value: ffi::GstURIType) -> Self {
        skip_assert_initialized!();
        match value {
            0 => URIType::Unknown,
            1 => URIType::Sink,
            2 => URIType::Src,
            value => URIType::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for URIType {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for URIType {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<URIType>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

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