// 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

#![doc = include_str!("../README.md")]
#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
    clippy::approx_constant,
    clippy::type_complexity,
    clippy::unreadable_literal,
    clippy::upper_case_acronyms
)]
#![cfg_attr(docsrs, feature(doc_cfg))]

use glib_sys as glib;
use gobject_sys as gobject;

#[allow(unused_imports)]
use libc::{
    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
    intptr_t, size_t, ssize_t, uintptr_t, FILE,
};

#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};

// Enums
pub type ALSASeqClientType = c_int;
pub const ALSASEQ_CLIENT_TYPE_NONE: ALSASeqClientType = 0;
pub const ALSASEQ_CLIENT_TYPE_USER: ALSASeqClientType = 1;
pub const ALSASEQ_CLIENT_TYPE_KERNEL: ALSASeqClientType = 2;

pub type ALSASeqEventError = c_int;
pub const ALSASEQ_EVENT_ERROR_FAILED: ALSASeqEventError = 0;
pub const ALSASEQ_EVENT_ERROR_INVALID_DATA_TYPE: ALSASeqEventError = 1;
pub const ALSASEQ_EVENT_ERROR_INVALID_LENGTH_MODE: ALSASeqEventError = 2;
pub const ALSASEQ_EVENT_ERROR_INVALID_TSTAMP_MODE: ALSASeqEventError = 3;

pub type ALSASeqEventLengthMode = c_int;
pub const ALSASEQ_EVENT_LENGTH_MODE_FIXED: ALSASeqEventLengthMode = 0;
pub const ALSASEQ_EVENT_LENGTH_MODE_VARIABLE: ALSASeqEventLengthMode = 4;
pub const ALSASEQ_EVENT_LENGTH_MODE_POINTER: ALSASeqEventLengthMode = 8;

pub type ALSASeqEventPriorityMode = c_int;
pub const ALSASEQ_EVENT_PRIORITY_MODE_NORMAL: ALSASeqEventPriorityMode = 0;
pub const ALSASEQ_EVENT_PRIORITY_MODE_HIGH: ALSASeqEventPriorityMode = 16;

pub type ALSASeqEventTimeMode = c_int;
pub const ALSASEQ_EVENT_TIME_MODE_ABS: ALSASeqEventTimeMode = 0;
pub const ALSASEQ_EVENT_TIME_MODE_REL: ALSASeqEventTimeMode = 2;

pub type ALSASeqEventTstampMode = c_int;
pub const ALSASEQ_EVENT_TSTAMP_MODE_TICK: ALSASeqEventTstampMode = 0;
pub const ALSASEQ_EVENT_TSTAMP_MODE_REAL: ALSASeqEventTstampMode = 1;

pub type ALSASeqEventType = c_int;
pub const ALSASEQ_EVENT_TYPE_SYSTEM: ALSASeqEventType = 0;
pub const ALSASEQ_EVENT_TYPE_RESULT: ALSASeqEventType = 1;
pub const ALSASEQ_EVENT_TYPE_NOTE: ALSASeqEventType = 5;
pub const ALSASEQ_EVENT_TYPE_NOTEON: ALSASeqEventType = 6;
pub const ALSASEQ_EVENT_TYPE_NOTEOFF: ALSASeqEventType = 7;
pub const ALSASEQ_EVENT_TYPE_KEYPRESS: ALSASeqEventType = 8;
pub const ALSASEQ_EVENT_TYPE_CONTROLLER: ALSASeqEventType = 10;
pub const ALSASEQ_EVENT_TYPE_PGMCHANGE: ALSASeqEventType = 11;
pub const ALSASEQ_EVENT_TYPE_CHANPRESS: ALSASeqEventType = 12;
pub const ALSASEQ_EVENT_TYPE_PITCHBEND: ALSASeqEventType = 13;
pub const ALSASEQ_EVENT_TYPE_CONTROL14: ALSASeqEventType = 14;
pub const ALSASEQ_EVENT_TYPE_NONREGPARAM: ALSASeqEventType = 15;
pub const ALSASEQ_EVENT_TYPE_REGPARAM: ALSASeqEventType = 16;
pub const ALSASEQ_EVENT_TYPE_SONGPOS: ALSASeqEventType = 20;
pub const ALSASEQ_EVENT_TYPE_SONGSEL: ALSASeqEventType = 21;
pub const ALSASEQ_EVENT_TYPE_QFRAME: ALSASeqEventType = 22;
pub const ALSASEQ_EVENT_TYPE_TIMESIGN: ALSASeqEventType = 23;
pub const ALSASEQ_EVENT_TYPE_KEYSIGN: ALSASeqEventType = 24;
pub const ALSASEQ_EVENT_TYPE_START: ALSASeqEventType = 30;
pub const ALSASEQ_EVENT_TYPE_CONTINUE: ALSASeqEventType = 31;
pub const ALSASEQ_EVENT_TYPE_STOP: ALSASeqEventType = 32;
pub const ALSASEQ_EVENT_TYPE_SETPOS_TICK: ALSASeqEventType = 33;
pub const ALSASEQ_EVENT_TYPE_SETPOS_TIME: ALSASeqEventType = 34;
pub const ALSASEQ_EVENT_TYPE_TEMPO: ALSASeqEventType = 35;
pub const ALSASEQ_EVENT_TYPE_CLOCK: ALSASeqEventType = 36;
pub const ALSASEQ_EVENT_TYPE_TICK: ALSASeqEventType = 37;
pub const ALSASEQ_EVENT_TYPE_QUEUE_SKEW: ALSASeqEventType = 38;
pub const ALSASEQ_EVENT_TYPE_TUNE_REQUEST: ALSASeqEventType = 40;
pub const ALSASEQ_EVENT_TYPE_RESET: ALSASeqEventType = 41;
pub const ALSASEQ_EVENT_TYPE_SENSING: ALSASeqEventType = 42;
pub const ALSASEQ_EVENT_TYPE_ECHO: ALSASeqEventType = 50;
pub const ALSASEQ_EVENT_TYPE_OSS: ALSASeqEventType = 51;
pub const ALSASEQ_EVENT_TYPE_CLIENT_START: ALSASeqEventType = 60;
pub const ALSASEQ_EVENT_TYPE_CLIENT_EXIT: ALSASeqEventType = 61;
pub const ALSASEQ_EVENT_TYPE_CLIENT_CHANGE: ALSASeqEventType = 62;
pub const ALSASEQ_EVENT_TYPE_PORT_START: ALSASeqEventType = 63;
pub const ALSASEQ_EVENT_TYPE_PORT_EXIT: ALSASeqEventType = 64;
pub const ALSASEQ_EVENT_TYPE_PORT_CHANGE: ALSASeqEventType = 65;
pub const ALSASEQ_EVENT_TYPE_PORT_SUBSCRIBED: ALSASeqEventType = 66;
pub const ALSASEQ_EVENT_TYPE_PORT_UNSUBSCRIBED: ALSASeqEventType = 67;
pub const ALSASEQ_EVENT_TYPE_USR0: ALSASeqEventType = 90;
pub const ALSASEQ_EVENT_TYPE_USR1: ALSASeqEventType = 91;
pub const ALSASEQ_EVENT_TYPE_USR2: ALSASeqEventType = 92;
pub const ALSASEQ_EVENT_TYPE_USR3: ALSASeqEventType = 93;
pub const ALSASEQ_EVENT_TYPE_USR4: ALSASeqEventType = 94;
pub const ALSASEQ_EVENT_TYPE_USR5: ALSASeqEventType = 95;
pub const ALSASEQ_EVENT_TYPE_USR6: ALSASeqEventType = 96;
pub const ALSASEQ_EVENT_TYPE_USR7: ALSASeqEventType = 97;
pub const ALSASEQ_EVENT_TYPE_USR8: ALSASeqEventType = 98;
pub const ALSASEQ_EVENT_TYPE_USR9: ALSASeqEventType = 99;
pub const ALSASEQ_EVENT_TYPE_SYSEX: ALSASeqEventType = 130;
pub const ALSASEQ_EVENT_TYPE_BOUNCE: ALSASeqEventType = 131;
pub const ALSASEQ_EVENT_TYPE_USR_VAR0: ALSASeqEventType = 135;
pub const ALSASEQ_EVENT_TYPE_USR_VAR1: ALSASeqEventType = 136;
pub const ALSASEQ_EVENT_TYPE_USR_VAR2: ALSASeqEventType = 137;
pub const ALSASEQ_EVENT_TYPE_USR_VAR3: ALSASeqEventType = 138;
pub const ALSASEQ_EVENT_TYPE_USR_VAR4: ALSASeqEventType = 139;
pub const ALSASEQ_EVENT_TYPE_NONE: ALSASeqEventType = 255;

pub type ALSASeqQuerySubscribeType = c_int;
pub const ALSASEQ_QUERY_SUBSCRIBE_TYPE_READ: ALSASeqQuerySubscribeType = 0;
pub const ALSASEQ_QUERY_SUBSCRIBE_TYPE_WRITE: ALSASeqQuerySubscribeType = 1;

pub type ALSASeqQueueTimerType = c_int;
pub const ALSASEQ_QUEUE_TIMER_TYPE_ALSA: ALSASeqQueueTimerType = 0;

pub type ALSASeqSpecificAddress = c_int;
pub const ALSASEQ_SPECIFIC_ADDRESS_UNKNOWN: ALSASeqSpecificAddress = 253;
pub const ALSASEQ_SPECIFIC_ADDRESS_SUBSCRIBERS: ALSASeqSpecificAddress = 254;
pub const ALSASEQ_SPECIFIC_ADDRESS_BROADCAST: ALSASeqSpecificAddress = 255;

pub type ALSASeqSpecificClientId = c_int;
pub const ALSASEQ_SPECIFIC_CLIENT_ID_SYSTEM: ALSASeqSpecificClientId = 0;
pub const ALSASEQ_SPECIFIC_CLIENT_ID_DUMMY: ALSASeqSpecificClientId = 14;
pub const ALSASEQ_SPECIFIC_CLIENT_ID_OSS: ALSASeqSpecificClientId = 15;

pub type ALSASeqSpecificPortId = c_int;
pub const ALSASEQ_SPECIFIC_PORT_ID_SYSTEM_TIMER: ALSASeqSpecificPortId = 0;
pub const ALSASEQ_SPECIFIC_PORT_ID_SYSTEM_ANNOUNCE: ALSASeqSpecificPortId = 1;

pub type ALSASeqSpecificQueueId = c_int;
pub const ALSASEQ_SPECIFIC_QUEUE_ID_DIRECT: ALSASeqSpecificQueueId = 253;

pub type ALSASeqUserClientError = c_int;
pub const ALSASEQ_USER_CLIENT_ERROR_FAILED: ALSASeqUserClientError = 0;
pub const ALSASEQ_USER_CLIENT_ERROR_PORT_PERMISSION: ALSASeqUserClientError = 1;
pub const ALSASEQ_USER_CLIENT_ERROR_QUEUE_PERMISSION: ALSASeqUserClientError = 2;
pub const ALSASEQ_USER_CLIENT_ERROR_EVENT_UNDELIVERABLE: ALSASeqUserClientError = 3;

// Flags
pub type ALSASeqFilterAttrFlag = c_uint;
pub const ALSASEQ_FILTER_ATTR_FLAG_BROADCAST: ALSASeqFilterAttrFlag = 1;
pub const ALSASEQ_FILTER_ATTR_FLAG_MULTICAST: ALSASeqFilterAttrFlag = 2;
pub const ALSASEQ_FILTER_ATTR_FLAG_BOUNCE: ALSASeqFilterAttrFlag = 4;

pub type ALSASeqPortAttrFlag = c_uint;
pub const ALSASEQ_PORT_ATTR_FLAG_SPECIFIC: ALSASeqPortAttrFlag = 1;
pub const ALSASEQ_PORT_ATTR_FLAG_MIDI_GENERIC: ALSASeqPortAttrFlag = 2;
pub const ALSASEQ_PORT_ATTR_FLAG_MIDI_GM: ALSASeqPortAttrFlag = 4;
pub const ALSASEQ_PORT_ATTR_FLAG_MIDI_GS: ALSASeqPortAttrFlag = 8;
pub const ALSASEQ_PORT_ATTR_FLAG_MIDI_XG: ALSASeqPortAttrFlag = 16;
pub const ALSASEQ_PORT_ATTR_FLAG_MIDI_MT32: ALSASeqPortAttrFlag = 32;
pub const ALSASEQ_PORT_ATTR_FLAG_MIDI_GM2: ALSASeqPortAttrFlag = 64;
pub const ALSASEQ_PORT_ATTR_FLAG_HARDWARE: ALSASeqPortAttrFlag = 65536;
pub const ALSASEQ_PORT_ATTR_FLAG_SOFTWARE: ALSASeqPortAttrFlag = 131072;
pub const ALSASEQ_PORT_ATTR_FLAG_SYNTHESIZER: ALSASeqPortAttrFlag = 262144;
pub const ALSASEQ_PORT_ATTR_FLAG_PORT: ALSASeqPortAttrFlag = 524288;
pub const ALSASEQ_PORT_ATTR_FLAG_APPLICATION: ALSASeqPortAttrFlag = 1048576;

pub type ALSASeqPortCapFlag = c_uint;
pub const ALSASEQ_PORT_CAP_FLAG_READ: ALSASeqPortCapFlag = 1;
pub const ALSASEQ_PORT_CAP_FLAG_WRITE: ALSASeqPortCapFlag = 2;
pub const ALSASEQ_PORT_CAP_FLAG_DUPLEX: ALSASeqPortCapFlag = 16;
pub const ALSASEQ_PORT_CAP_FLAG_SUBS_READ: ALSASeqPortCapFlag = 32;
pub const ALSASEQ_PORT_CAP_FLAG_SUBS_WRITE: ALSASeqPortCapFlag = 64;
pub const ALSASEQ_PORT_CAP_FLAG_NO_EXPORT: ALSASeqPortCapFlag = 128;

pub type ALSASeqRemoveFilterFlag = c_uint;
pub const ALSASEQ_REMOVE_FILTER_FLAG_INPUT: ALSASeqRemoveFilterFlag = 1;
pub const ALSASEQ_REMOVE_FILTER_FLAG_OUTPUT: ALSASeqRemoveFilterFlag = 2;
pub const ALSASEQ_REMOVE_FILTER_FLAG_DEST: ALSASeqRemoveFilterFlag = 4;
pub const ALSASEQ_REMOVE_FILTER_FLAG_DEST_CHANNEL: ALSASeqRemoveFilterFlag = 8;
pub const ALSASEQ_REMOVE_FILTER_FLAG_TIME_BEFORE: ALSASeqRemoveFilterFlag = 16;
pub const ALSASEQ_REMOVE_FILTER_FLAG_TIME_AFTER: ALSASeqRemoveFilterFlag = 32;
pub const ALSASEQ_REMOVE_FILTER_FLAG_TIME_TICK: ALSASeqRemoveFilterFlag = 64;
pub const ALSASEQ_REMOVE_FILTER_FLAG_EVENT_TYPE: ALSASeqRemoveFilterFlag = 128;
pub const ALSASEQ_REMOVE_FILTER_FLAG_IGNORE_OFF: ALSASeqRemoveFilterFlag = 256;
pub const ALSASEQ_REMOVE_FILTER_FLAG_TAG_MATCH: ALSASeqRemoveFilterFlag = 512;

// Records
#[repr(C)]
pub struct ALSASeqAddr {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ALSASeqAddr {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqAddr @ {self:p}")).finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqClientInfoClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ALSASeqClientInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqClientInfoClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqClientPoolClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ALSASeqClientPoolClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqClientPoolClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[repr(C)]
pub struct ALSASeqEvent {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ALSASeqEvent {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqEvent @ {self:p}")).finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqEventCntr {
    pub buf: *mut u8,
    pub length: size_t,
    pub aligned: gboolean,
}

impl ::std::fmt::Debug for ALSASeqEventCntr {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqEventCntr @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
pub struct ALSASeqEventDataConnect {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ALSASeqEventDataConnect {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqEventDataConnect @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
pub struct ALSASeqEventDataCtl {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ALSASeqEventDataCtl {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqEventDataCtl @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
pub struct ALSASeqEventDataNote {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ALSASeqEventDataNote {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqEventDataNote @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
pub struct ALSASeqEventDataQueue {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ALSASeqEventDataQueue {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqEventDataQueue @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
pub struct ALSASeqEventDataResult {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ALSASeqEventDataResult {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqEventDataResult @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqPortInfoClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ALSASeqPortInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqPortInfoClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqQueueInfoClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ALSASeqQueueInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqQueueInfoClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqQueueStatusClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ALSASeqQueueStatusClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqQueueStatusClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqQueueTempoClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ALSASeqQueueTempoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqQueueTempoClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqQueueTimerAlsaClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ALSASeqQueueTimerAlsaClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqQueueTimerAlsaClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqQueueTimerCommonInterface {
    pub parent_iface: gobject::GTypeInterface,
}

impl ::std::fmt::Debug for ALSASeqQueueTimerCommonInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqQueueTimerCommonInterface @ {self:p}"))
            .field("parent_iface", &self.parent_iface)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqRemoveFilterClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ALSASeqRemoveFilterClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqRemoveFilterClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqSubscribeDataClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ALSASeqSubscribeDataClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqSubscribeDataClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqSystemInfoClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ALSASeqSystemInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqSystemInfoClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqUserClientClass {
    pub parent_class: gobject::GObjectClass,
    pub handle_event: Option<unsafe extern "C" fn(*mut ALSASeqUserClient, *const ALSASeqEventCntr)>,
}

impl ::std::fmt::Debug for ALSASeqUserClientClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqUserClientClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("handle_event", &self.handle_event)
            .finish()
    }
}

// Classes
#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqClientInfo {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for ALSASeqClientInfo {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqClientInfo @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqClientPool {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for ALSASeqClientPool {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqClientPool @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqPortInfo {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for ALSASeqPortInfo {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqPortInfo @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqQueueInfo {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for ALSASeqQueueInfo {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqQueueInfo @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqQueueStatus {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for ALSASeqQueueStatus {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqQueueStatus @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqQueueTempo {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for ALSASeqQueueTempo {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqQueueTempo @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqQueueTimerAlsa {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for ALSASeqQueueTimerAlsa {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqQueueTimerAlsa @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqRemoveFilter {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for ALSASeqRemoveFilter {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqRemoveFilter @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqSubscribeData {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for ALSASeqSubscribeData {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqSubscribeData @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqSystemInfo {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for ALSASeqSystemInfo {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqSystemInfo @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ALSASeqUserClient {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for ALSASeqUserClient {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ALSASeqUserClient @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

// Interfaces
#[repr(C)]
pub struct ALSASeqQueueTimerCommon {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ALSASeqQueueTimerCommon {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "ALSASeqQueueTimerCommon @ {self:p}")
    }
}

#[link(name = "alsaseq")]
extern "C" {

    //=========================================================================
    // ALSASeqClientType
    //=========================================================================
    pub fn alsaseq_client_type_get_type() -> GType;

    //=========================================================================
    // ALSASeqEventError
    //=========================================================================
    pub fn alsaseq_event_error_get_type() -> GType;
    pub fn alsaseq_event_error_quark() -> glib::GQuark;

    //=========================================================================
    // ALSASeqEventLengthMode
    //=========================================================================
    pub fn alsaseq_event_length_mode_get_type() -> GType;

    //=========================================================================
    // ALSASeqEventPriorityMode
    //=========================================================================
    pub fn alsaseq_event_priority_mode_get_type() -> GType;

    //=========================================================================
    // ALSASeqEventTimeMode
    //=========================================================================
    pub fn alsaseq_event_time_mode_get_type() -> GType;

    //=========================================================================
    // ALSASeqEventTstampMode
    //=========================================================================
    pub fn alsaseq_event_tstamp_mode_get_type() -> GType;

    //=========================================================================
    // ALSASeqEventType
    //=========================================================================
    pub fn alsaseq_event_type_get_type() -> GType;

    //=========================================================================
    // ALSASeqQuerySubscribeType
    //=========================================================================
    pub fn alsaseq_query_subscribe_type_get_type() -> GType;

    //=========================================================================
    // ALSASeqQueueTimerType
    //=========================================================================
    pub fn alsaseq_queue_timer_type_get_type() -> GType;

    //=========================================================================
    // ALSASeqSpecificAddress
    //=========================================================================
    pub fn alsaseq_specific_address_get_type() -> GType;

    //=========================================================================
    // ALSASeqSpecificClientId
    //=========================================================================
    pub fn alsaseq_specific_client_id_get_type() -> GType;

    //=========================================================================
    // ALSASeqSpecificPortId
    //=========================================================================
    pub fn alsaseq_specific_port_id_get_type() -> GType;

    //=========================================================================
    // ALSASeqSpecificQueueId
    //=========================================================================
    pub fn alsaseq_specific_queue_id_get_type() -> GType;

    //=========================================================================
    // ALSASeqUserClientError
    //=========================================================================
    pub fn alsaseq_user_client_error_get_type() -> GType;
    pub fn alsaseq_user_client_error_quark() -> glib::GQuark;

    //=========================================================================
    // ALSASeqFilterAttrFlag
    //=========================================================================
    pub fn alsaseq_filter_attr_flag_get_type() -> GType;

    //=========================================================================
    // ALSASeqPortAttrFlag
    //=========================================================================
    pub fn alsaseq_port_attr_flag_get_type() -> GType;

    //=========================================================================
    // ALSASeqPortCapFlag
    //=========================================================================
    pub fn alsaseq_port_cap_flag_get_type() -> GType;

    //=========================================================================
    // ALSASeqRemoveFilterFlag
    //=========================================================================
    pub fn alsaseq_remove_filter_flag_get_type() -> GType;

    //=========================================================================
    // ALSASeqAddr
    //=========================================================================
    pub fn alsaseq_addr_get_type() -> GType;
    pub fn alsaseq_addr_new(client_id: u8, port_id: u8) -> *mut ALSASeqAddr;
    pub fn alsaseq_addr_equal(self_: *const ALSASeqAddr, target: *const ALSASeqAddr) -> gboolean;
    pub fn alsaseq_addr_get_client_id(self_: *const ALSASeqAddr, client_id: *mut u8);
    pub fn alsaseq_addr_get_port_id(self_: *const ALSASeqAddr, port_id: *mut u8);

    //=========================================================================
    // ALSASeqEvent
    //=========================================================================
    pub fn alsaseq_event_get_type() -> GType;
    pub fn alsaseq_event_new(event_type: ALSASeqEventType) -> *mut ALSASeqEvent;
    pub fn alsaseq_event_calculate_pool_consumption(self_: *const ALSASeqEvent, cells: *mut c_uint);
    pub fn alsaseq_event_get_addr_data(
        self_: *const ALSASeqEvent,
        data: *mut *const ALSASeqAddr,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_get_blob_data(
        self_: *const ALSASeqEvent,
        data: *mut *const u8,
        length: *mut size_t,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_get_byte_data(
        self_: *const ALSASeqEvent,
        data: *mut *const [u8; 12],
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_get_connect_data(
        self_: *const ALSASeqEvent,
        data: *mut *const ALSASeqEventDataConnect,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_get_ctl_data(
        self_: *const ALSASeqEvent,
        data: *mut *const ALSASeqEventDataCtl,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_get_destination(self_: *const ALSASeqEvent, addr: *mut *const ALSASeqAddr);
    pub fn alsaseq_event_get_event_type(
        self_: *const ALSASeqEvent,
        event_type: *mut ALSASeqEventType,
    );
    pub fn alsaseq_event_get_length_mode(
        self_: *const ALSASeqEvent,
        length_mode: *mut ALSASeqEventLengthMode,
    );
    pub fn alsaseq_event_get_note_data(
        self_: *const ALSASeqEvent,
        data: *mut *const ALSASeqEventDataNote,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_get_pointer_data(
        self_: *const ALSASeqEvent,
        data: *mut gconstpointer,
        length: *mut size_t,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_get_priority_mode(
        self_: *const ALSASeqEvent,
        priority_mode: *mut ALSASeqEventPriorityMode,
    );
    pub fn alsaseq_event_get_quadlet_data(
        self_: *const ALSASeqEvent,
        data: *mut *const [u32; 3],
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_get_queue_data(
        self_: *const ALSASeqEvent,
        data: *mut *const ALSASeqEventDataQueue,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_get_queue_id(self_: *const ALSASeqEvent, queue_id: *mut u8);
    pub fn alsaseq_event_get_real_time(
        self_: *const ALSASeqEvent,
        real_time: *mut *const [u32; 2],
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_get_real_time_data(
        self_: *const ALSASeqEvent,
        real_time: *mut *const [u32; 2],
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_get_result_data(
        self_: *const ALSASeqEvent,
        data: *mut *const ALSASeqEventDataResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_get_source(self_: *const ALSASeqEvent, addr: *mut *const ALSASeqAddr);
    pub fn alsaseq_event_get_tag(self_: *const ALSASeqEvent, tag: *mut i8);
    pub fn alsaseq_event_get_tick_time(
        self_: *const ALSASeqEvent,
        tick_time: *mut c_uint,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_get_tick_time_data(
        self_: *const ALSASeqEvent,
        tick_time: *mut c_uint,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_get_time_mode(
        self_: *const ALSASeqEvent,
        time_mode: *mut ALSASeqEventTimeMode,
    );
    pub fn alsaseq_event_get_tstamp_mode(
        self_: *const ALSASeqEvent,
        tstamp_mode: *mut ALSASeqEventTstampMode,
    );
    pub fn alsaseq_event_set_addr_data(
        self_: *mut ALSASeqEvent,
        data: *const ALSASeqAddr,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_set_blob_data(
        self_: *mut ALSASeqEvent,
        data: *const u8,
        length: size_t,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_set_byte_data(
        self_: *mut ALSASeqEvent,
        data: *const [u8; 12],
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_set_connect_data(
        self_: *mut ALSASeqEvent,
        data: *const ALSASeqEventDataConnect,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_set_ctl_data(
        self_: *mut ALSASeqEvent,
        data: *const ALSASeqEventDataCtl,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_set_destination(self_: *mut ALSASeqEvent, addr: *const ALSASeqAddr);
    pub fn alsaseq_event_set_note_data(
        self_: *mut ALSASeqEvent,
        data: *const ALSASeqEventDataNote,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_set_pointer_data(
        self_: *mut ALSASeqEvent,
        data: gpointer,
        length: size_t,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_set_priority_mode(
        self_: *mut ALSASeqEvent,
        priority_mode: ALSASeqEventPriorityMode,
    );
    pub fn alsaseq_event_set_quadlet_data(
        self_: *mut ALSASeqEvent,
        data: *const [u32; 3],
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_set_queue_data(
        self_: *mut ALSASeqEvent,
        data: *const ALSASeqEventDataQueue,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_set_queue_id(self_: *mut ALSASeqEvent, queue_id: u8);
    pub fn alsaseq_event_set_real_time(
        self_: *mut ALSASeqEvent,
        real_time: *const [u32; 2],
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_set_real_time_data(
        self_: *mut ALSASeqEvent,
        real_time: *const [u32; 2],
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_set_result_data(
        self_: *mut ALSASeqEvent,
        data: *const ALSASeqEventDataResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_set_source(self_: *mut ALSASeqEvent, addr: *const ALSASeqAddr);
    pub fn alsaseq_event_set_tag(self_: *mut ALSASeqEvent, tag: i8);
    pub fn alsaseq_event_set_tick_time(
        self_: *mut ALSASeqEvent,
        tick_time: c_uint,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_set_tick_time_data(
        self_: *mut ALSASeqEvent,
        tick_time: c_uint,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_event_set_time_mode(self_: *mut ALSASeqEvent, time_mode: ALSASeqEventTimeMode);

    //=========================================================================
    // ALSASeqEventCntr
    //=========================================================================
    pub fn alsaseq_event_cntr_get_type() -> GType;
    pub fn alsaseq_event_cntr_deserialize(
        self_: *const ALSASeqEventCntr,
        events: *mut *mut glib::GList,
    );

    //=========================================================================
    // ALSASeqEventDataConnect
    //=========================================================================
    pub fn alsaseq_event_data_connect_get_type() -> GType;
    pub fn alsaseq_event_data_connect_get_dst(
        self_: *const ALSASeqEventDataConnect,
        dst: *mut *const ALSASeqAddr,
    );
    pub fn alsaseq_event_data_connect_get_src(
        self_: *const ALSASeqEventDataConnect,
        src: *mut *const ALSASeqAddr,
    );
    pub fn alsaseq_event_data_connect_set_dst(
        self_: *mut ALSASeqEventDataConnect,
        dst: *const ALSASeqAddr,
    );
    pub fn alsaseq_event_data_connect_set_src(
        self_: *mut ALSASeqEventDataConnect,
        src: *const ALSASeqAddr,
    );

    //=========================================================================
    // ALSASeqEventDataCtl
    //=========================================================================
    pub fn alsaseq_event_data_ctl_get_type() -> GType;
    pub fn alsaseq_event_data_ctl_get_channel(self_: *const ALSASeqEventDataCtl, channel: *mut u8);
    pub fn alsaseq_event_data_ctl_get_param(self_: *const ALSASeqEventDataCtl, param: *mut c_uint);
    pub fn alsaseq_event_data_ctl_get_value(self_: *const ALSASeqEventDataCtl, value: *mut c_int);
    pub fn alsaseq_event_data_ctl_set_channel(self_: *mut ALSASeqEventDataCtl, channel: u8);
    pub fn alsaseq_event_data_ctl_set_param(self_: *mut ALSASeqEventDataCtl, param: c_uint);
    pub fn alsaseq_event_data_ctl_set_value(self_: *mut ALSASeqEventDataCtl, value: c_int);

    //=========================================================================
    // ALSASeqEventDataNote
    //=========================================================================
    pub fn alsaseq_event_data_note_get_type() -> GType;
    pub fn alsaseq_event_data_note_get_channel(
        self_: *const ALSASeqEventDataNote,
        channel: *mut u8,
    );
    pub fn alsaseq_event_data_note_get_duration(
        self_: *const ALSASeqEventDataNote,
        duration: *mut u8,
    );
    pub fn alsaseq_event_data_note_get_note(self_: *const ALSASeqEventDataNote, note: *mut u8);
    pub fn alsaseq_event_data_note_get_off_velocity(
        self_: *const ALSASeqEventDataNote,
        off_velocity: *mut u8,
    );
    pub fn alsaseq_event_data_note_get_velocity(
        self_: *const ALSASeqEventDataNote,
        velocity: *mut u8,
    );
    pub fn alsaseq_event_data_note_set_channel(self_: *mut ALSASeqEventDataNote, channel: u8);
    pub fn alsaseq_event_data_note_set_duration(self_: *mut ALSASeqEventDataNote, duration: u8);
    pub fn alsaseq_event_data_note_set_note(self_: *mut ALSASeqEventDataNote, note: u8);
    pub fn alsaseq_event_data_note_set_off_velocity(
        self_: *mut ALSASeqEventDataNote,
        off_velocity: u8,
    );
    pub fn alsaseq_event_data_note_set_velocity(self_: *mut ALSASeqEventDataNote, velocity: u8);

    //=========================================================================
    // ALSASeqEventDataQueue
    //=========================================================================
    pub fn alsaseq_event_data_queue_get_type() -> GType;
    pub fn alsaseq_event_data_queue_get_byte_param(
        self_: *const ALSASeqEventDataQueue,
        bytes: *mut *const [u8; 8],
    );
    pub fn alsaseq_event_data_queue_get_position_param(
        self_: *const ALSASeqEventDataQueue,
        position: *mut c_uint,
    );
    pub fn alsaseq_event_data_queue_get_quadlet_param(
        self_: *const ALSASeqEventDataQueue,
        quadlets: *mut *const [u32; 2],
    );
    pub fn alsaseq_event_data_queue_get_queue_id(
        self_: *const ALSASeqEventDataQueue,
        queue_id: *mut u8,
    );
    pub fn alsaseq_event_data_queue_get_real_time_param(
        self_: *const ALSASeqEventDataQueue,
        real_time: *mut *const [u32; 2],
    );
    pub fn alsaseq_event_data_queue_get_skew_param(
        self_: *const ALSASeqEventDataQueue,
        skew: *mut *const [c_uint; 2],
    );
    pub fn alsaseq_event_data_queue_get_tick_time_param(
        self_: *const ALSASeqEventDataQueue,
        tick_time: *mut c_uint,
    );
    pub fn alsaseq_event_data_queue_get_value_param(
        self_: *const ALSASeqEventDataQueue,
        value: *mut c_int,
    );
    pub fn alsaseq_event_data_queue_set_byte_param(
        self_: *mut ALSASeqEventDataQueue,
        bytes: *const [u8; 8],
    );
    pub fn alsaseq_event_data_queue_set_position_param(
        self_: *mut ALSASeqEventDataQueue,
        position: c_uint,
    );
    pub fn alsaseq_event_data_queue_set_quadlet_param(
        self_: *mut ALSASeqEventDataQueue,
        quadlets: *const [u32; 2],
    );
    pub fn alsaseq_event_data_queue_set_queue_id(self_: *mut ALSASeqEventDataQueue, queue_id: u8);
    pub fn alsaseq_event_data_queue_set_real_time_param(
        self_: *mut ALSASeqEventDataQueue,
        real_time: *const [u32; 2],
    );
    pub fn alsaseq_event_data_queue_set_skew_param(
        self_: *mut ALSASeqEventDataQueue,
        skew: *const [c_uint; 2],
    );
    pub fn alsaseq_event_data_queue_set_tick_time_param(
        self_: *mut ALSASeqEventDataQueue,
        tick_time: c_uint,
    );
    pub fn alsaseq_event_data_queue_set_value_param(
        self_: *mut ALSASeqEventDataQueue,
        value: c_int,
    );

    //=========================================================================
    // ALSASeqEventDataResult
    //=========================================================================
    pub fn alsaseq_event_data_result_get_type() -> GType;
    pub fn alsaseq_event_data_result_get_event(
        self_: *const ALSASeqEventDataResult,
        event_type: *mut ALSASeqEventType,
    );
    pub fn alsaseq_event_data_result_get_result(
        self_: *const ALSASeqEventDataResult,
        result: *mut c_int,
    );
    pub fn alsaseq_event_data_result_set_event(
        self_: *mut ALSASeqEventDataResult,
        event_type: ALSASeqEventType,
    );
    pub fn alsaseq_event_data_result_set_result(self_: *mut ALSASeqEventDataResult, result: c_int);

    //=========================================================================
    // ALSASeqClientInfo
    //=========================================================================
    pub fn alsaseq_client_info_get_type() -> GType;
    pub fn alsaseq_client_info_new() -> *mut ALSASeqClientInfo;
    pub fn alsaseq_client_info_get_event_filter(
        self_: *mut ALSASeqClientInfo,
        event_types: *mut *mut ALSASeqEventType,
        event_type_count: *mut size_t,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_client_info_set_event_filter(
        self_: *mut ALSASeqClientInfo,
        event_types: *const ALSASeqEventType,
        event_type_count: size_t,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // ALSASeqClientPool
    //=========================================================================
    pub fn alsaseq_client_pool_get_type() -> GType;
    pub fn alsaseq_client_pool_new() -> *mut ALSASeqClientPool;

    //=========================================================================
    // ALSASeqPortInfo
    //=========================================================================
    pub fn alsaseq_port_info_get_type() -> GType;
    pub fn alsaseq_port_info_new() -> *mut ALSASeqPortInfo;

    //=========================================================================
    // ALSASeqQueueInfo
    //=========================================================================
    pub fn alsaseq_queue_info_get_type() -> GType;
    pub fn alsaseq_queue_info_new() -> *mut ALSASeqQueueInfo;

    //=========================================================================
    // ALSASeqQueueStatus
    //=========================================================================
    pub fn alsaseq_queue_status_get_type() -> GType;
    pub fn alsaseq_queue_status_new() -> *mut ALSASeqQueueStatus;
    pub fn alsaseq_queue_status_get_real_time(
        self_: *mut ALSASeqQueueStatus,
        real_time: *mut *const [u32; 2],
    );
    pub fn alsaseq_queue_status_get_tick_time(
        self_: *mut ALSASeqQueueStatus,
        tick_time: *mut c_uint,
    );

    //=========================================================================
    // ALSASeqQueueTempo
    //=========================================================================
    pub fn alsaseq_queue_tempo_get_type() -> GType;
    pub fn alsaseq_queue_tempo_new() -> *mut ALSASeqQueueTempo;
    pub fn alsaseq_queue_tempo_get_skew(self_: *mut ALSASeqQueueTempo, skew: *mut *const [u32; 2]);
    pub fn alsaseq_queue_tempo_set_skew(self_: *mut ALSASeqQueueTempo, skew: *const [u32; 2]);

    //=========================================================================
    // ALSASeqQueueTimerAlsa
    //=========================================================================
    pub fn alsaseq_queue_timer_alsa_get_type() -> GType;
    pub fn alsaseq_queue_timer_alsa_new() -> *mut ALSASeqQueueTimerAlsa;

    //=========================================================================
    // ALSASeqRemoveFilter
    //=========================================================================
    pub fn alsaseq_remove_filter_get_type() -> GType;
    pub fn alsaseq_remove_filter_new() -> *mut ALSASeqRemoveFilter;
    pub fn alsaseq_remove_filter_get_real_time(
        self_: *mut ALSASeqRemoveFilter,
        real_time: *mut *const [u32; 2],
    );
    pub fn alsaseq_remove_filter_get_tick_time(
        self_: *mut ALSASeqRemoveFilter,
        tick_time: *mut c_uint,
    );
    pub fn alsaseq_remove_filter_set_real_time(
        self_: *mut ALSASeqRemoveFilter,
        real_time: *const [u32; 2],
    );
    pub fn alsaseq_remove_filter_set_tick_time(self_: *mut ALSASeqRemoveFilter, tick_time: c_uint);

    //=========================================================================
    // ALSASeqSubscribeData
    //=========================================================================
    pub fn alsaseq_subscribe_data_get_type() -> GType;
    pub fn alsaseq_subscribe_data_new() -> *mut ALSASeqSubscribeData;

    //=========================================================================
    // ALSASeqSystemInfo
    //=========================================================================
    pub fn alsaseq_system_info_get_type() -> GType;

    //=========================================================================
    // ALSASeqUserClient
    //=========================================================================
    pub fn alsaseq_user_client_get_type() -> GType;
    pub fn alsaseq_user_client_new() -> *mut ALSASeqUserClient;
    pub fn alsaseq_user_client_create_port(
        self_: *mut ALSASeqUserClient,
        port_info: *const *mut ALSASeqPortInfo,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_create_port_at(
        self_: *mut ALSASeqUserClient,
        port_info: *const *mut ALSASeqPortInfo,
        port_id: u8,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_create_queue(
        self_: *mut ALSASeqUserClient,
        queue_info: *const *mut ALSASeqQueueInfo,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_create_source(
        self_: *mut ALSASeqUserClient,
        gsrc: *mut *mut glib::GSource,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_delete_port(
        self_: *mut ALSASeqUserClient,
        port_id: u8,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_delete_queue(
        self_: *mut ALSASeqUserClient,
        queue_id: u8,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_get_info(
        self_: *mut ALSASeqUserClient,
        client_info: *const *mut ALSASeqClientInfo,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_get_pool(
        self_: *mut ALSASeqUserClient,
        client_pool: *const *mut ALSASeqClientPool,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_get_protocol_version(
        self_: *mut ALSASeqUserClient,
        proto_ver_triplet: *mut *const [u16; 3],
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_get_queue_tempo(
        self_: *mut ALSASeqUserClient,
        queue_id: u8,
        queue_tempo: *mut *mut ALSASeqQueueTempo,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_get_queue_timer(
        self_: *mut ALSASeqUserClient,
        queue_id: u8,
        queue_timer: *mut *mut ALSASeqQueueTimerCommon,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_get_queue_usage(
        self_: *mut ALSASeqUserClient,
        queue_id: u8,
        use_: *mut gboolean,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_open(
        self_: *mut ALSASeqUserClient,
        open_flag: c_int,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_operate_subscription(
        self_: *mut ALSASeqUserClient,
        subs_data: *mut ALSASeqSubscribeData,
        establish: gboolean,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_remove_events(
        self_: *mut ALSASeqUserClient,
        filter: *mut ALSASeqRemoveFilter,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_schedule_event(
        self_: *mut ALSASeqUserClient,
        event: *const ALSASeqEvent,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_schedule_events(
        self_: *mut ALSASeqUserClient,
        events: *const glib::GList,
        count: *mut size_t,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_set_info(
        self_: *mut ALSASeqUserClient,
        client_info: *mut ALSASeqClientInfo,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_set_pool(
        self_: *mut ALSASeqUserClient,
        client_pool: *mut ALSASeqClientPool,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_set_queue_tempo(
        self_: *mut ALSASeqUserClient,
        queue_id: u8,
        queue_tempo: *mut ALSASeqQueueTempo,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_set_queue_timer(
        self_: *mut ALSASeqUserClient,
        queue_id: u8,
        queue_timer: *mut ALSASeqQueueTimerCommon,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_set_queue_usage(
        self_: *mut ALSASeqUserClient,
        queue_id: u8,
        use_: gboolean,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_update_port(
        self_: *mut ALSASeqUserClient,
        port_info: *mut ALSASeqPortInfo,
        port_id: u8,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_user_client_update_queue(
        self_: *mut ALSASeqUserClient,
        queue_info: *mut ALSASeqQueueInfo,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // ALSASeqQueueTimerCommon
    //=========================================================================
    pub fn alsaseq_queue_timer_common_get_type() -> GType;

    //=========================================================================
    // Other functions
    //=========================================================================
    pub fn alsaseq_get_client_id_list(
        entries: *mut *mut u8,
        entry_count: *mut size_t,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_get_client_info(
        client_id: u8,
        client_info: *mut *mut ALSASeqClientInfo,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_get_client_pool(
        client_id: u8,
        client_pool: *mut *mut ALSASeqClientPool,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_get_port_id_list(
        client_id: u8,
        entries: *mut *mut u8,
        entry_count: *mut size_t,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_get_port_info(
        client_id: u8,
        port_id: u8,
        port_info: *mut *mut ALSASeqPortInfo,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_get_queue_id_list(
        entries: *mut *mut u8,
        entry_count: *mut size_t,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_get_queue_info_by_id(
        queue_id: u8,
        queue_info: *mut *mut ALSASeqQueueInfo,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_get_queue_info_by_name(
        name: *const c_char,
        queue_info: *mut *mut ALSASeqQueueInfo,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_get_queue_status(
        queue_id: u8,
        queue_status: *const *mut ALSASeqQueueStatus,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_get_seq_devnode(
        devnode: *mut *mut c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_get_seq_sysname(
        sysname: *mut *mut c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_get_subscription_list(
        addr: *const ALSASeqAddr,
        query_type: ALSASeqQuerySubscribeType,
        entries: *mut *mut glib::GList,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn alsaseq_get_system_info(
        system_info: *mut *mut ALSASeqSystemInfo,
        error: *mut *mut glib::GError,
    ) -> gboolean;

}