alsaseq 0.8.0

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::ffi;
use glib::{prelude::*, translate::*};

/// A set of enumerations for the type of client.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ALSASeqClientType")]
pub enum ClientType {
    #[doc(alias = "ALSASEQ_CLIENT_TYPE_NONE")]
    None,
    #[doc(alias = "ALSASEQ_CLIENT_TYPE_USER")]
    User,
    #[doc(alias = "ALSASEQ_CLIENT_TYPE_KERNEL")]
    Kernel,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ALSASeqClientType {
        match self {
            Self::None => ffi::ALSASEQ_CLIENT_TYPE_NONE,
            Self::User => ffi::ALSASEQ_CLIENT_TYPE_USER,
            Self::Kernel => ffi::ALSASEQ_CLIENT_TYPE_KERNEL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ALSASeqClientType> for ClientType {
    #[inline]
    unsafe fn from_glib(value: ffi::ALSASeqClientType) -> Self {
        match value {
            ffi::ALSASEQ_CLIENT_TYPE_NONE => Self::None,
            ffi::ALSASEQ_CLIENT_TYPE_USER => Self::User,
            ffi::ALSASEQ_CLIENT_TYPE_KERNEL => Self::Kernel,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ClientType {
    #[inline]
    #[doc(alias = "alsaseq_client_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::alsaseq_client_type_get_type()) }
    }
}

impl glib::HasParamSpec for ClientType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

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

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

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

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

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ClientType> for glib::Value {
    #[inline]
    fn from(v: ClientType) -> Self {
        ToValue::to_value(&v)
    }
}

/// A set of error code for [`glib::Error`][crate::glib::Error] with `struct@EventError` domain.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ALSASeqEventError")]
pub enum EventError {
    #[doc(alias = "ALSASEQ_EVENT_ERROR_FAILED")]
    Failed,
    #[doc(alias = "ALSASEQ_EVENT_ERROR_INVALID_DATA_TYPE")]
    InvalidDataType,
    #[doc(alias = "ALSASEQ_EVENT_ERROR_INVALID_LENGTH_MODE")]
    InvalidLengthMode,
    #[doc(alias = "ALSASEQ_EVENT_ERROR_INVALID_TSTAMP_MODE")]
    InvalidTstampMode,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ALSASeqEventError {
        match self {
            Self::Failed => ffi::ALSASEQ_EVENT_ERROR_FAILED,
            Self::InvalidDataType => ffi::ALSASEQ_EVENT_ERROR_INVALID_DATA_TYPE,
            Self::InvalidLengthMode => ffi::ALSASEQ_EVENT_ERROR_INVALID_LENGTH_MODE,
            Self::InvalidTstampMode => ffi::ALSASEQ_EVENT_ERROR_INVALID_TSTAMP_MODE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ALSASeqEventError> for EventError {
    #[inline]
    unsafe fn from_glib(value: ffi::ALSASeqEventError) -> Self {
        match value {
            ffi::ALSASEQ_EVENT_ERROR_FAILED => Self::Failed,
            ffi::ALSASEQ_EVENT_ERROR_INVALID_DATA_TYPE => Self::InvalidDataType,
            ffi::ALSASEQ_EVENT_ERROR_INVALID_LENGTH_MODE => Self::InvalidLengthMode,
            ffi::ALSASEQ_EVENT_ERROR_INVALID_TSTAMP_MODE => Self::InvalidTstampMode,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for EventError {
    #[inline]
    fn domain() -> glib::Quark {
        unsafe { from_glib(ffi::alsaseq_event_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        match unsafe { from_glib(code) } {
            Self::__Unknown(_) => Some(Self::Failed),
            value => Some(value),
        }
    }
}

impl StaticType for EventError {
    #[inline]
    #[doc(alias = "alsaseq_event_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::alsaseq_event_error_get_type()) }
    }
}

impl glib::HasParamSpec for EventError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

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

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

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

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

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<EventError> for glib::Value {
    #[inline]
    fn from(v: EventError) -> Self {
        ToValue::to_value(&v)
    }
}

/// A set of enumeration for the mode of data length.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ALSASeqEventLengthMode")]
pub enum EventLengthMode {
    #[doc(alias = "ALSASEQ_EVENT_LENGTH_MODE_FIXED")]
    Fixed,
    #[doc(alias = "ALSASEQ_EVENT_LENGTH_MODE_VARIABLE")]
    Variable,
    #[doc(alias = "ALSASEQ_EVENT_LENGTH_MODE_POINTER")]
    Pointer,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ALSASeqEventLengthMode {
        match self {
            Self::Fixed => ffi::ALSASEQ_EVENT_LENGTH_MODE_FIXED,
            Self::Variable => ffi::ALSASEQ_EVENT_LENGTH_MODE_VARIABLE,
            Self::Pointer => ffi::ALSASEQ_EVENT_LENGTH_MODE_POINTER,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ALSASeqEventLengthMode> for EventLengthMode {
    #[inline]
    unsafe fn from_glib(value: ffi::ALSASeqEventLengthMode) -> Self {
        match value {
            ffi::ALSASEQ_EVENT_LENGTH_MODE_FIXED => Self::Fixed,
            ffi::ALSASEQ_EVENT_LENGTH_MODE_VARIABLE => Self::Variable,
            ffi::ALSASEQ_EVENT_LENGTH_MODE_POINTER => Self::Pointer,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for EventLengthMode {
    #[inline]
    #[doc(alias = "alsaseq_event_length_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::alsaseq_event_length_mode_get_type()) }
    }
}

impl glib::HasParamSpec for EventLengthMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

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

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

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

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

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<EventLengthMode> for glib::Value {
    #[inline]
    fn from(v: EventLengthMode) -> Self {
        ToValue::to_value(&v)
    }
}

/// A set of enumerations for the mode of priority.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ALSASeqEventPriorityMode")]
pub enum EventPriorityMode {
    #[doc(alias = "ALSASEQ_EVENT_PRIORITY_MODE_NORMAL")]
    Normal,
    #[doc(alias = "ALSASEQ_EVENT_PRIORITY_MODE_HIGH")]
    High,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ALSASeqEventPriorityMode {
        match self {
            Self::Normal => ffi::ALSASEQ_EVENT_PRIORITY_MODE_NORMAL,
            Self::High => ffi::ALSASEQ_EVENT_PRIORITY_MODE_HIGH,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ALSASeqEventPriorityMode> for EventPriorityMode {
    #[inline]
    unsafe fn from_glib(value: ffi::ALSASeqEventPriorityMode) -> Self {
        match value {
            ffi::ALSASEQ_EVENT_PRIORITY_MODE_NORMAL => Self::Normal,
            ffi::ALSASEQ_EVENT_PRIORITY_MODE_HIGH => Self::High,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for EventPriorityMode {
    #[inline]
    #[doc(alias = "alsaseq_event_priority_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::alsaseq_event_priority_mode_get_type()) }
    }
}

impl glib::HasParamSpec for EventPriorityMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

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

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

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

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

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<EventPriorityMode> for glib::Value {
    #[inline]
    fn from(v: EventPriorityMode) -> Self {
        ToValue::to_value(&v)
    }
}

/// A set of enumerations for the mode of time.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ALSASeqEventTimeMode")]
pub enum EventTimeMode {
    #[doc(alias = "ALSASEQ_EVENT_TIME_MODE_ABS")]
    Abs,
    #[doc(alias = "ALSASEQ_EVENT_TIME_MODE_REL")]
    Rel,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ALSASeqEventTimeMode {
        match self {
            Self::Abs => ffi::ALSASEQ_EVENT_TIME_MODE_ABS,
            Self::Rel => ffi::ALSASEQ_EVENT_TIME_MODE_REL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ALSASeqEventTimeMode> for EventTimeMode {
    #[inline]
    unsafe fn from_glib(value: ffi::ALSASeqEventTimeMode) -> Self {
        match value {
            ffi::ALSASEQ_EVENT_TIME_MODE_ABS => Self::Abs,
            ffi::ALSASEQ_EVENT_TIME_MODE_REL => Self::Rel,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for EventTimeMode {
    #[inline]
    #[doc(alias = "alsaseq_event_time_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::alsaseq_event_time_mode_get_type()) }
    }
}

impl glib::HasParamSpec for EventTimeMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

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

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

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

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

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<EventTimeMode> for glib::Value {
    #[inline]
    fn from(v: EventTimeMode) -> Self {
        ToValue::to_value(&v)
    }
}

/// A set of enumeration for the mode of time stamp.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ALSASeqEventTstampMode")]
pub enum EventTstampMode {
    #[doc(alias = "ALSASEQ_EVENT_TSTAMP_MODE_TICK")]
    Tick,
    #[doc(alias = "ALSASEQ_EVENT_TSTAMP_MODE_REAL")]
    Real,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ALSASeqEventTstampMode {
        match self {
            Self::Tick => ffi::ALSASEQ_EVENT_TSTAMP_MODE_TICK,
            Self::Real => ffi::ALSASEQ_EVENT_TSTAMP_MODE_REAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ALSASeqEventTstampMode> for EventTstampMode {
    #[inline]
    unsafe fn from_glib(value: ffi::ALSASeqEventTstampMode) -> Self {
        match value {
            ffi::ALSASEQ_EVENT_TSTAMP_MODE_TICK => Self::Tick,
            ffi::ALSASEQ_EVENT_TSTAMP_MODE_REAL => Self::Real,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for EventTstampMode {
    #[inline]
    #[doc(alias = "alsaseq_event_tstamp_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::alsaseq_event_tstamp_mode_get_type()) }
    }
}

impl glib::HasParamSpec for EventTstampMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

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

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

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

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

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<EventTstampMode> for glib::Value {
    #[inline]
    fn from(v: EventTstampMode) -> Self {
        ToValue::to_value(&v)
    }
}

/// The type of event.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ALSASeqEventType")]
pub enum EventType {
    #[doc(alias = "ALSASEQ_EVENT_TYPE_SYSTEM")]
    System,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_RESULT")]
    Result,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_NOTE")]
    Note,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_NOTEON")]
    Noteon,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_NOTEOFF")]
    Noteoff,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_KEYPRESS")]
    Keypress,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_CONTROLLER")]
    Controller,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_PGMCHANGE")]
    Pgmchange,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_CHANPRESS")]
    Chanpress,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_PITCHBEND")]
    Pitchbend,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_CONTROL14")]
    Control14,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_NONREGPARAM")]
    Nonregparam,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_REGPARAM")]
    Regparam,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_SONGPOS")]
    Songpos,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_SONGSEL")]
    Songsel,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_QFRAME")]
    Qframe,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_TIMESIGN")]
    Timesign,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_KEYSIGN")]
    Keysign,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_START")]
    Start,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_CONTINUE")]
    Continue,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_STOP")]
    Stop,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_SETPOS_TICK")]
    SetposTick,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_SETPOS_TIME")]
    SetposTime,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_TEMPO")]
    Tempo,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_CLOCK")]
    Clock,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_TICK")]
    Tick,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_QUEUE_SKEW")]
    QueueSkew,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_TUNE_REQUEST")]
    TuneRequest,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_RESET")]
    Reset,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_SENSING")]
    Sensing,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_ECHO")]
    Echo,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_OSS")]
    Oss,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_CLIENT_START")]
    ClientStart,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_CLIENT_EXIT")]
    ClientExit,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_CLIENT_CHANGE")]
    ClientChange,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_PORT_START")]
    PortStart,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_PORT_EXIT")]
    PortExit,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_PORT_CHANGE")]
    PortChange,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_PORT_SUBSCRIBED")]
    PortSubscribed,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_PORT_UNSUBSCRIBED")]
    PortUnsubscribed,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_USR0")]
    Usr0,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_USR1")]
    Usr1,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_USR2")]
    Usr2,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_USR3")]
    Usr3,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_USR4")]
    Usr4,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_USR5")]
    Usr5,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_USR6")]
    Usr6,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_USR7")]
    Usr7,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_USR8")]
    Usr8,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_USR9")]
    Usr9,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_SYSEX")]
    Sysex,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_BOUNCE")]
    Bounce,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_USR_VAR0")]
    UsrVar0,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_USR_VAR1")]
    UsrVar1,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_USR_VAR2")]
    UsrVar2,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_USR_VAR3")]
    UsrVar3,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_USR_VAR4")]
    UsrVar4,
    #[doc(alias = "ALSASEQ_EVENT_TYPE_NONE")]
    None,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::ALSASeqEventType {
        match self {
            Self::System => ffi::ALSASEQ_EVENT_TYPE_SYSTEM,
            Self::Result => ffi::ALSASEQ_EVENT_TYPE_RESULT,
            Self::Note => ffi::ALSASEQ_EVENT_TYPE_NOTE,
            Self::Noteon => ffi::ALSASEQ_EVENT_TYPE_NOTEON,
            Self::Noteoff => ffi::ALSASEQ_EVENT_TYPE_NOTEOFF,
            Self::Keypress => ffi::ALSASEQ_EVENT_TYPE_KEYPRESS,
            Self::Controller => ffi::ALSASEQ_EVENT_TYPE_CONTROLLER,
            Self::Pgmchange => ffi::ALSASEQ_EVENT_TYPE_PGMCHANGE,
            Self::Chanpress => ffi::ALSASEQ_EVENT_TYPE_CHANPRESS,
            Self::Pitchbend => ffi::ALSASEQ_EVENT_TYPE_PITCHBEND,
            Self::Control14 => ffi::ALSASEQ_EVENT_TYPE_CONTROL14,
            Self::Nonregparam => ffi::ALSASEQ_EVENT_TYPE_NONREGPARAM,
            Self::Regparam => ffi::ALSASEQ_EVENT_TYPE_REGPARAM,
            Self::Songpos => ffi::ALSASEQ_EVENT_TYPE_SONGPOS,
            Self::Songsel => ffi::ALSASEQ_EVENT_TYPE_SONGSEL,
            Self::Qframe => ffi::ALSASEQ_EVENT_TYPE_QFRAME,
            Self::Timesign => ffi::ALSASEQ_EVENT_TYPE_TIMESIGN,
            Self::Keysign => ffi::ALSASEQ_EVENT_TYPE_KEYSIGN,
            Self::Start => ffi::ALSASEQ_EVENT_TYPE_START,
            Self::Continue => ffi::ALSASEQ_EVENT_TYPE_CONTINUE,
            Self::Stop => ffi::ALSASEQ_EVENT_TYPE_STOP,
            Self::SetposTick => ffi::ALSASEQ_EVENT_TYPE_SETPOS_TICK,
            Self::SetposTime => ffi::ALSASEQ_EVENT_TYPE_SETPOS_TIME,
            Self::Tempo => ffi::ALSASEQ_EVENT_TYPE_TEMPO,
            Self::Clock => ffi::ALSASEQ_EVENT_TYPE_CLOCK,
            Self::Tick => ffi::ALSASEQ_EVENT_TYPE_TICK,
            Self::QueueSkew => ffi::ALSASEQ_EVENT_TYPE_QUEUE_SKEW,
            Self::TuneRequest => ffi::ALSASEQ_EVENT_TYPE_TUNE_REQUEST,
            Self::Reset => ffi::ALSASEQ_EVENT_TYPE_RESET,
            Self::Sensing => ffi::ALSASEQ_EVENT_TYPE_SENSING,
            Self::Echo => ffi::ALSASEQ_EVENT_TYPE_ECHO,
            Self::Oss => ffi::ALSASEQ_EVENT_TYPE_OSS,
            Self::ClientStart => ffi::ALSASEQ_EVENT_TYPE_CLIENT_START,
            Self::ClientExit => ffi::ALSASEQ_EVENT_TYPE_CLIENT_EXIT,
            Self::ClientChange => ffi::ALSASEQ_EVENT_TYPE_CLIENT_CHANGE,
            Self::PortStart => ffi::ALSASEQ_EVENT_TYPE_PORT_START,
            Self::PortExit => ffi::ALSASEQ_EVENT_TYPE_PORT_EXIT,
            Self::PortChange => ffi::ALSASEQ_EVENT_TYPE_PORT_CHANGE,
            Self::PortSubscribed => ffi::ALSASEQ_EVENT_TYPE_PORT_SUBSCRIBED,
            Self::PortUnsubscribed => ffi::ALSASEQ_EVENT_TYPE_PORT_UNSUBSCRIBED,
            Self::Usr0 => ffi::ALSASEQ_EVENT_TYPE_USR0,
            Self::Usr1 => ffi::ALSASEQ_EVENT_TYPE_USR1,
            Self::Usr2 => ffi::ALSASEQ_EVENT_TYPE_USR2,
            Self::Usr3 => ffi::ALSASEQ_EVENT_TYPE_USR3,
            Self::Usr4 => ffi::ALSASEQ_EVENT_TYPE_USR4,
            Self::Usr5 => ffi::ALSASEQ_EVENT_TYPE_USR5,
            Self::Usr6 => ffi::ALSASEQ_EVENT_TYPE_USR6,
            Self::Usr7 => ffi::ALSASEQ_EVENT_TYPE_USR7,
            Self::Usr8 => ffi::ALSASEQ_EVENT_TYPE_USR8,
            Self::Usr9 => ffi::ALSASEQ_EVENT_TYPE_USR9,
            Self::Sysex => ffi::ALSASEQ_EVENT_TYPE_SYSEX,
            Self::Bounce => ffi::ALSASEQ_EVENT_TYPE_BOUNCE,
            Self::UsrVar0 => ffi::ALSASEQ_EVENT_TYPE_USR_VAR0,
            Self::UsrVar1 => ffi::ALSASEQ_EVENT_TYPE_USR_VAR1,
            Self::UsrVar2 => ffi::ALSASEQ_EVENT_TYPE_USR_VAR2,
            Self::UsrVar3 => ffi::ALSASEQ_EVENT_TYPE_USR_VAR3,
            Self::UsrVar4 => ffi::ALSASEQ_EVENT_TYPE_USR_VAR4,
            Self::None => ffi::ALSASEQ_EVENT_TYPE_NONE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ALSASeqEventType> for EventType {
    unsafe fn from_glib(value: ffi::ALSASeqEventType) -> Self {
        match value {
            ffi::ALSASEQ_EVENT_TYPE_SYSTEM => Self::System,
            ffi::ALSASEQ_EVENT_TYPE_RESULT => Self::Result,
            ffi::ALSASEQ_EVENT_TYPE_NOTE => Self::Note,
            ffi::ALSASEQ_EVENT_TYPE_NOTEON => Self::Noteon,
            ffi::ALSASEQ_EVENT_TYPE_NOTEOFF => Self::Noteoff,
            ffi::ALSASEQ_EVENT_TYPE_KEYPRESS => Self::Keypress,
            ffi::ALSASEQ_EVENT_TYPE_CONTROLLER => Self::Controller,
            ffi::ALSASEQ_EVENT_TYPE_PGMCHANGE => Self::Pgmchange,
            ffi::ALSASEQ_EVENT_TYPE_CHANPRESS => Self::Chanpress,
            ffi::ALSASEQ_EVENT_TYPE_PITCHBEND => Self::Pitchbend,
            ffi::ALSASEQ_EVENT_TYPE_CONTROL14 => Self::Control14,
            ffi::ALSASEQ_EVENT_TYPE_NONREGPARAM => Self::Nonregparam,
            ffi::ALSASEQ_EVENT_TYPE_REGPARAM => Self::Regparam,
            ffi::ALSASEQ_EVENT_TYPE_SONGPOS => Self::Songpos,
            ffi::ALSASEQ_EVENT_TYPE_SONGSEL => Self::Songsel,
            ffi::ALSASEQ_EVENT_TYPE_QFRAME => Self::Qframe,
            ffi::ALSASEQ_EVENT_TYPE_TIMESIGN => Self::Timesign,
            ffi::ALSASEQ_EVENT_TYPE_KEYSIGN => Self::Keysign,
            ffi::ALSASEQ_EVENT_TYPE_START => Self::Start,
            ffi::ALSASEQ_EVENT_TYPE_CONTINUE => Self::Continue,
            ffi::ALSASEQ_EVENT_TYPE_STOP => Self::Stop,
            ffi::ALSASEQ_EVENT_TYPE_SETPOS_TICK => Self::SetposTick,
            ffi::ALSASEQ_EVENT_TYPE_SETPOS_TIME => Self::SetposTime,
            ffi::ALSASEQ_EVENT_TYPE_TEMPO => Self::Tempo,
            ffi::ALSASEQ_EVENT_TYPE_CLOCK => Self::Clock,
            ffi::ALSASEQ_EVENT_TYPE_TICK => Self::Tick,
            ffi::ALSASEQ_EVENT_TYPE_QUEUE_SKEW => Self::QueueSkew,
            ffi::ALSASEQ_EVENT_TYPE_TUNE_REQUEST => Self::TuneRequest,
            ffi::ALSASEQ_EVENT_TYPE_RESET => Self::Reset,
            ffi::ALSASEQ_EVENT_TYPE_SENSING => Self::Sensing,
            ffi::ALSASEQ_EVENT_TYPE_ECHO => Self::Echo,
            ffi::ALSASEQ_EVENT_TYPE_OSS => Self::Oss,
            ffi::ALSASEQ_EVENT_TYPE_CLIENT_START => Self::ClientStart,
            ffi::ALSASEQ_EVENT_TYPE_CLIENT_EXIT => Self::ClientExit,
            ffi::ALSASEQ_EVENT_TYPE_CLIENT_CHANGE => Self::ClientChange,
            ffi::ALSASEQ_EVENT_TYPE_PORT_START => Self::PortStart,
            ffi::ALSASEQ_EVENT_TYPE_PORT_EXIT => Self::PortExit,
            ffi::ALSASEQ_EVENT_TYPE_PORT_CHANGE => Self::PortChange,
            ffi::ALSASEQ_EVENT_TYPE_PORT_SUBSCRIBED => Self::PortSubscribed,
            ffi::ALSASEQ_EVENT_TYPE_PORT_UNSUBSCRIBED => Self::PortUnsubscribed,
            ffi::ALSASEQ_EVENT_TYPE_USR0 => Self::Usr0,
            ffi::ALSASEQ_EVENT_TYPE_USR1 => Self::Usr1,
            ffi::ALSASEQ_EVENT_TYPE_USR2 => Self::Usr2,
            ffi::ALSASEQ_EVENT_TYPE_USR3 => Self::Usr3,
            ffi::ALSASEQ_EVENT_TYPE_USR4 => Self::Usr4,
            ffi::ALSASEQ_EVENT_TYPE_USR5 => Self::Usr5,
            ffi::ALSASEQ_EVENT_TYPE_USR6 => Self::Usr6,
            ffi::ALSASEQ_EVENT_TYPE_USR7 => Self::Usr7,
            ffi::ALSASEQ_EVENT_TYPE_USR8 => Self::Usr8,
            ffi::ALSASEQ_EVENT_TYPE_USR9 => Self::Usr9,
            ffi::ALSASEQ_EVENT_TYPE_SYSEX => Self::Sysex,
            ffi::ALSASEQ_EVENT_TYPE_BOUNCE => Self::Bounce,
            ffi::ALSASEQ_EVENT_TYPE_USR_VAR0 => Self::UsrVar0,
            ffi::ALSASEQ_EVENT_TYPE_USR_VAR1 => Self::UsrVar1,
            ffi::ALSASEQ_EVENT_TYPE_USR_VAR2 => Self::UsrVar2,
            ffi::ALSASEQ_EVENT_TYPE_USR_VAR3 => Self::UsrVar3,
            ffi::ALSASEQ_EVENT_TYPE_USR_VAR4 => Self::UsrVar4,
            ffi::ALSASEQ_EVENT_TYPE_NONE => Self::None,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for EventType {
    #[inline]
    #[doc(alias = "alsaseq_event_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::alsaseq_event_type_get_type()) }
    }
}

impl glib::HasParamSpec for EventType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

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

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

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

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

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<EventType> for glib::Value {
    #[inline]
    fn from(v: EventType) -> Self {
        ToValue::to_value(&v)
    }
}

/// A set of enumerations for the type to query subscription.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ALSASeqQuerySubscribeType")]
pub enum QuerySubscribeType {
    #[doc(alias = "ALSASEQ_QUERY_SUBSCRIBE_TYPE_READ")]
    Read,
    #[doc(alias = "ALSASEQ_QUERY_SUBSCRIBE_TYPE_WRITE")]
    Write,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ALSASeqQuerySubscribeType {
        match self {
            Self::Read => ffi::ALSASEQ_QUERY_SUBSCRIBE_TYPE_READ,
            Self::Write => ffi::ALSASEQ_QUERY_SUBSCRIBE_TYPE_WRITE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ALSASeqQuerySubscribeType> for QuerySubscribeType {
    #[inline]
    unsafe fn from_glib(value: ffi::ALSASeqQuerySubscribeType) -> Self {
        match value {
            ffi::ALSASEQ_QUERY_SUBSCRIBE_TYPE_READ => Self::Read,
            ffi::ALSASEQ_QUERY_SUBSCRIBE_TYPE_WRITE => Self::Write,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for QuerySubscribeType {
    #[inline]
    #[doc(alias = "alsaseq_query_subscribe_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::alsaseq_query_subscribe_type_get_type()) }
    }
}

impl glib::HasParamSpec for QuerySubscribeType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

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

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

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

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

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<QuerySubscribeType> for glib::Value {
    #[inline]
    fn from(v: QuerySubscribeType) -> Self {
        ToValue::to_value(&v)
    }
}

/// A set of enumerations for the type of timer source for the queue.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ALSASeqQueueTimerType")]
pub enum QueueTimerType {
    #[doc(alias = "ALSASEQ_QUEUE_TIMER_TYPE_ALSA")]
    Alsa,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ALSASeqQueueTimerType {
        match self {
            Self::Alsa => ffi::ALSASEQ_QUEUE_TIMER_TYPE_ALSA,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ALSASeqQueueTimerType> for QueueTimerType {
    #[inline]
    unsafe fn from_glib(value: ffi::ALSASeqQueueTimerType) -> Self {
        match value {
            ffi::ALSASEQ_QUEUE_TIMER_TYPE_ALSA => Self::Alsa,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for QueueTimerType {
    #[inline]
    #[doc(alias = "alsaseq_queue_timer_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::alsaseq_queue_timer_type_get_type()) }
    }
}

impl glib::HasParamSpec for QueueTimerType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

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

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

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

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

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<QueueTimerType> for glib::Value {
    #[inline]
    fn from(v: QueueTimerType) -> Self {
        ToValue::to_value(&v)
    }
}

/// A set of enumerations for specific addresses.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ALSASeqSpecificAddress")]
pub enum SpecificAddress {
    #[doc(alias = "ALSASEQ_SPECIFIC_ADDRESS_UNKNOWN")]
    Unknown,
    #[doc(alias = "ALSASEQ_SPECIFIC_ADDRESS_SUBSCRIBERS")]
    Subscribers,
    #[doc(alias = "ALSASEQ_SPECIFIC_ADDRESS_BROADCAST")]
    Broadcast,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ALSASeqSpecificAddress {
        match self {
            Self::Unknown => ffi::ALSASEQ_SPECIFIC_ADDRESS_UNKNOWN,
            Self::Subscribers => ffi::ALSASEQ_SPECIFIC_ADDRESS_SUBSCRIBERS,
            Self::Broadcast => ffi::ALSASEQ_SPECIFIC_ADDRESS_BROADCAST,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ALSASeqSpecificAddress> for SpecificAddress {
    #[inline]
    unsafe fn from_glib(value: ffi::ALSASeqSpecificAddress) -> Self {
        match value {
            ffi::ALSASEQ_SPECIFIC_ADDRESS_UNKNOWN => Self::Unknown,
            ffi::ALSASEQ_SPECIFIC_ADDRESS_SUBSCRIBERS => Self::Subscribers,
            ffi::ALSASEQ_SPECIFIC_ADDRESS_BROADCAST => Self::Broadcast,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SpecificAddress {
    #[inline]
    #[doc(alias = "alsaseq_specific_address_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::alsaseq_specific_address_get_type()) }
    }
}

impl glib::HasParamSpec for SpecificAddress {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

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

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

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

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

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SpecificAddress> for glib::Value {
    #[inline]
    fn from(v: SpecificAddress) -> Self {
        ToValue::to_value(&v)
    }
}

/// A set of enumerations for the numerical IDs of specific clients.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ALSASeqSpecificClientId")]
pub enum SpecificClientId {
    #[doc(alias = "ALSASEQ_SPECIFIC_CLIENT_ID_SYSTEM")]
    System,
    #[doc(alias = "ALSASEQ_SPECIFIC_CLIENT_ID_DUMMY")]
    Dummy,
    #[doc(alias = "ALSASEQ_SPECIFIC_CLIENT_ID_OSS")]
    Oss,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ALSASeqSpecificClientId {
        match self {
            Self::System => ffi::ALSASEQ_SPECIFIC_CLIENT_ID_SYSTEM,
            Self::Dummy => ffi::ALSASEQ_SPECIFIC_CLIENT_ID_DUMMY,
            Self::Oss => ffi::ALSASEQ_SPECIFIC_CLIENT_ID_OSS,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ALSASeqSpecificClientId> for SpecificClientId {
    #[inline]
    unsafe fn from_glib(value: ffi::ALSASeqSpecificClientId) -> Self {
        match value {
            ffi::ALSASEQ_SPECIFIC_CLIENT_ID_SYSTEM => Self::System,
            ffi::ALSASEQ_SPECIFIC_CLIENT_ID_DUMMY => Self::Dummy,
            ffi::ALSASEQ_SPECIFIC_CLIENT_ID_OSS => Self::Oss,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SpecificClientId {
    #[inline]
    #[doc(alias = "alsaseq_specific_client_id_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::alsaseq_specific_client_id_get_type()) }
    }
}

impl glib::HasParamSpec for SpecificClientId {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

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

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

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

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

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SpecificClientId> for glib::Value {
    #[inline]
    fn from(v: SpecificClientId) -> Self {
        ToValue::to_value(&v)
    }
}

/// A set of enumerations for the numerical IDs of port for specific purpose.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ALSASeqSpecificPortId")]
pub enum SpecificPortId {
    #[doc(alias = "ALSASEQ_SPECIFIC_PORT_ID_SYSTEM_TIMER")]
    Timer,
    #[doc(alias = "ALSASEQ_SPECIFIC_PORT_ID_SYSTEM_ANNOUNCE")]
    Announce,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ALSASeqSpecificPortId {
        match self {
            Self::Timer => ffi::ALSASEQ_SPECIFIC_PORT_ID_SYSTEM_TIMER,
            Self::Announce => ffi::ALSASEQ_SPECIFIC_PORT_ID_SYSTEM_ANNOUNCE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ALSASeqSpecificPortId> for SpecificPortId {
    #[inline]
    unsafe fn from_glib(value: ffi::ALSASeqSpecificPortId) -> Self {
        match value {
            ffi::ALSASEQ_SPECIFIC_PORT_ID_SYSTEM_TIMER => Self::Timer,
            ffi::ALSASEQ_SPECIFIC_PORT_ID_SYSTEM_ANNOUNCE => Self::Announce,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SpecificPortId {
    #[inline]
    #[doc(alias = "alsaseq_specific_port_id_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::alsaseq_specific_port_id_get_type()) }
    }
}

impl glib::HasParamSpec for SpecificPortId {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

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

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

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

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

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SpecificPortId> for glib::Value {
    #[inline]
    fn from(v: SpecificPortId) -> Self {
        ToValue::to_value(&v)
    }
}

/// A set of enumerations for the numerical IDs of queue for specific purpose.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ALSASeqSpecificQueueId")]
pub enum SpecificQueueId {
    #[doc(alias = "ALSASEQ_SPECIFIC_QUEUE_ID_DIRECT")]
    Direct,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ALSASeqSpecificQueueId {
        match self {
            Self::Direct => ffi::ALSASEQ_SPECIFIC_QUEUE_ID_DIRECT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ALSASeqSpecificQueueId> for SpecificQueueId {
    #[inline]
    unsafe fn from_glib(value: ffi::ALSASeqSpecificQueueId) -> Self {
        match value {
            ffi::ALSASEQ_SPECIFIC_QUEUE_ID_DIRECT => Self::Direct,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SpecificQueueId {
    #[inline]
    #[doc(alias = "alsaseq_specific_queue_id_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::alsaseq_specific_queue_id_get_type()) }
    }
}

impl glib::HasParamSpec for SpecificQueueId {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

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

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

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

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

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SpecificQueueId> for glib::Value {
    #[inline]
    fn from(v: SpecificQueueId) -> Self {
        ToValue::to_value(&v)
    }
}

/// A set of error code for [structGLib.Error] with `struct@UserClientError` domain.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ALSASeqUserClientError")]
pub enum UserClientError {
    #[doc(alias = "ALSASEQ_USER_CLIENT_ERROR_FAILED")]
    Failed,
    #[doc(alias = "ALSASEQ_USER_CLIENT_ERROR_PORT_PERMISSION")]
    PortPermission,
    #[doc(alias = "ALSASEQ_USER_CLIENT_ERROR_QUEUE_PERMISSION")]
    QueuePermission,
    #[doc(alias = "ALSASEQ_USER_CLIENT_ERROR_EVENT_UNDELIVERABLE")]
    EventUndeliverable,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ALSASeqUserClientError {
        match self {
            Self::Failed => ffi::ALSASEQ_USER_CLIENT_ERROR_FAILED,
            Self::PortPermission => ffi::ALSASEQ_USER_CLIENT_ERROR_PORT_PERMISSION,
            Self::QueuePermission => ffi::ALSASEQ_USER_CLIENT_ERROR_QUEUE_PERMISSION,
            Self::EventUndeliverable => ffi::ALSASEQ_USER_CLIENT_ERROR_EVENT_UNDELIVERABLE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ALSASeqUserClientError> for UserClientError {
    #[inline]
    unsafe fn from_glib(value: ffi::ALSASeqUserClientError) -> Self {
        match value {
            ffi::ALSASEQ_USER_CLIENT_ERROR_FAILED => Self::Failed,
            ffi::ALSASEQ_USER_CLIENT_ERROR_PORT_PERMISSION => Self::PortPermission,
            ffi::ALSASEQ_USER_CLIENT_ERROR_QUEUE_PERMISSION => Self::QueuePermission,
            ffi::ALSASEQ_USER_CLIENT_ERROR_EVENT_UNDELIVERABLE => Self::EventUndeliverable,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for UserClientError {
    #[inline]
    fn domain() -> glib::Quark {
        unsafe { from_glib(ffi::alsaseq_user_client_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        match unsafe { from_glib(code) } {
            Self::__Unknown(_) => Some(Self::Failed),
            value => Some(value),
        }
    }
}

impl StaticType for UserClientError {
    #[inline]
    #[doc(alias = "alsaseq_user_client_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::alsaseq_user_client_error_get_type()) }
    }
}

impl glib::HasParamSpec for UserClientError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

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

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

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

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

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<UserClientError> for glib::Value {
    #[inline]
    fn from(v: UserClientError) -> Self {
        ToValue::to_value(&v)
    }
}