/* automatically generated by rust-bindgen 0.63.0 */

pub const HELIOS_SUCCESS: u32 = 1;
pub const HELIOS_ERROR_NOT_INITIALIZED: i32 = -1;
pub const HELIOS_ERROR_INVALID_DEVNUM: i32 = -2;
pub const HELIOS_ERROR_NULL_POINTS: i32 = -3;
pub const HELIOS_ERROR_TOO_MANY_POINTS: i32 = -4;
pub const HELIOS_ERROR_PPS_TOO_HIGH: i32 = -5;
pub const HELIOS_ERROR_PPS_TOO_LOW: i32 = -6;
pub const HELIOS_ERROR_DEVICE_CLOSED: i32 = -1000;
pub const HELIOS_ERROR_DEVICE_FRAME_READY: i32 = -1001;
pub const HELIOS_ERROR_DEVICE_SEND_CONTROL: i32 = -1002;
pub const HELIOS_ERROR_DEVICE_RESULT: i32 = -1003;
pub const HELIOS_ERROR_DEVICE_NULL_BUFFER: i32 = -1004;
pub const HELIOS_ERROR_DEVICE_SIGNAL_TOO_LONG: i32 = -1005;
pub const HELIOS_ERROR_LIBUSB_BASE: i32 = -5000;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct libusb_device_handle {
    _unused: [u8; 0],
}
#[doc = " \\ingroup libusb_asyncio\n The generic USB transfer structure. The user populates this structure and\n then submits it in order to request a transfer. After the transfer has\n completed, the library populates the transfer with the results and passes\n it back to the user."]
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Copy, Clone)]
pub struct libusb_transfer {
    pub _bindgen_opaque_blob: [u64; 8usize],
}
#[test]
fn bindgen_test_layout_libusb_transfer() {
    assert_eq!(
        ::std::mem::size_of::<libusb_transfer>(),
        64usize,
        concat!("Size of: ", stringify!(libusb_transfer))
    );
    assert_eq!(
        ::std::mem::align_of::<libusb_transfer>(),
        8usize,
        concat!("Alignment of ", stringify!(libusb_transfer))
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_allocator {
    pub _address: u8,
}
pub type std_allocator_value_type = u8;
pub type std_allocator_size_type = u64;
pub type std_allocator_difference_type = u64;
pub type std_allocator_pointer = u8;
pub type std_allocator_const_pointer = u8;
pub type std_allocator_reference = u8;
pub type std_allocator_const_reference = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_allocator_rebind {
    pub _address: u8,
}
pub type std_allocator_rebind_other = u8;
pub type std_allocator_propagate_on_container_move_assignment = u8;
pub type std_allocator_is_always_equal = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_default_delete {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_unique_ptr {
    pub _address: u8,
}
pub type std_unique_ptr__DeleterConstraint = u8;
pub type std_unique_ptr_pointer = u8;
pub type std_unique_ptr_element_type = u8;
pub type std_unique_ptr_deleter_type = u8;
pub type std_unique_ptr___safe_conversion_up = u8;
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Copy, Clone)]
pub struct std_mutex {
    pub _bindgen_opaque_blob: [u64; 5usize],
}
pub type std_mutex_native_handle_type = u64;
#[test]
fn bindgen_test_layout_std_mutex() {
    assert_eq!(
        ::std::mem::size_of::<std_mutex>(),
        40usize,
        concat!("Size of: ", stringify!(std_mutex))
    );
    assert_eq!(
        ::std::mem::align_of::<std_mutex>(),
        8usize,
        concat!("Alignment of ", stringify!(std_mutex))
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_vector {
    pub _address: u8,
}
pub type std_vector__Base = u8;
pub type std_vector__Tp_alloc_type = u8;
pub type std_vector__Alloc_traits = u8;
pub type std_vector_value_type = u8;
pub type std_vector_pointer = u8;
pub type std_vector_const_pointer = u8;
pub type std_vector_reference = u8;
pub type std_vector_const_reference = u8;
pub type std_vector_iterator = u8;
pub type std_vector_const_iterator = u8;
pub type std_vector_const_reverse_iterator = u8;
pub type std_vector_reverse_iterator = u8;
pub type std_vector_size_type = u64;
pub type std_vector_difference_type = u64;
pub type std_vector_allocator_type = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_vector__Temporary_value {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct HeliosPoint {
    pub x: u16,
    pub y: u16,
    pub r: u8,
    pub g: u8,
    pub b: u8,
    pub i: u8,
}
#[test]
fn bindgen_test_layout_HeliosPoint() {
    const UNINIT: ::std::mem::MaybeUninit<HeliosPoint> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<HeliosPoint>(),
        8usize,
        concat!("Size of: ", stringify!(HeliosPoint))
    );
    assert_eq!(
        ::std::mem::align_of::<HeliosPoint>(),
        2usize,
        concat!("Alignment of ", stringify!(HeliosPoint))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosPoint),
            "::",
            stringify!(x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosPoint),
            "::",
            stringify!(y)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosPoint),
            "::",
            stringify!(r)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
        5usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosPoint),
            "::",
            stringify!(g)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosPoint),
            "::",
            stringify!(b)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
        7usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosPoint),
            "::",
            stringify!(i)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct HeliosDac {
    pub deviceList: [u64; 3usize],
    pub threadLock: std_mutex,
    pub inited: bool,
}
#[repr(C)]
#[derive(Debug)]
pub struct HeliosDac_HeliosDacDevice {
    pub interruptTransfer: *mut libusb_transfer,
    pub usbHandle: *mut libusb_device_handle,
    pub frameLock: std_mutex,
    pub frameReady: bool,
    pub firmwareVersion: ::std::os::raw::c_int,
    pub name: [::std::os::raw::c_char; 32usize],
    pub closed: bool,
    pub frameBuffer: *mut u8,
    pub frameBufferSize: ::std::os::raw::c_uint,
    pub frameResult: ::std::os::raw::c_int,
    pub shutterIsOpen: bool,
}
#[test]
fn bindgen_test_layout_HeliosDac_HeliosDacDevice() {
    const UNINIT: ::std::mem::MaybeUninit<HeliosDac_HeliosDacDevice> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<HeliosDac_HeliosDacDevice>(),
        128usize,
        concat!("Size of: ", stringify!(HeliosDac_HeliosDacDevice))
    );
    assert_eq!(
        ::std::mem::align_of::<HeliosDac_HeliosDacDevice>(),
        8usize,
        concat!("Alignment of ", stringify!(HeliosDac_HeliosDacDevice))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).interruptTransfer) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosDac_HeliosDacDevice),
            "::",
            stringify!(interruptTransfer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).usbHandle) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosDac_HeliosDacDevice),
            "::",
            stringify!(usbHandle)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).frameLock) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosDac_HeliosDacDevice),
            "::",
            stringify!(frameLock)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).frameReady) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosDac_HeliosDacDevice),
            "::",
            stringify!(frameReady)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).firmwareVersion) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosDac_HeliosDacDevice),
            "::",
            stringify!(firmwareVersion)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosDac_HeliosDacDevice),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).closed) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosDac_HeliosDacDevice),
            "::",
            stringify!(closed)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).frameBuffer) as usize - ptr as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosDac_HeliosDacDevice),
            "::",
            stringify!(frameBuffer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).frameBufferSize) as usize - ptr as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosDac_HeliosDacDevice),
            "::",
            stringify!(frameBufferSize)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).frameResult) as usize - ptr as usize },
        116usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosDac_HeliosDacDevice),
            "::",
            stringify!(frameResult)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).shutterIsOpen) as usize - ptr as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosDac_HeliosDacDevice),
            "::",
            stringify!(shutterIsOpen)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac15HeliosDacDevice9SendFrameEjhP11HeliosPointj"]
    pub fn HeliosDac_HeliosDacDevice_SendFrame(
        this: *mut HeliosDac_HeliosDacDevice,
        pps: ::std::os::raw::c_uint,
        flags: u8,
        points: *mut HeliosPoint,
        numOfPoints: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac15HeliosDacDevice9GetStatusEv"]
    pub fn HeliosDac_HeliosDacDevice_GetStatus(
        this: *mut HeliosDac_HeliosDacDevice,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac15HeliosDacDevice18GetFirmwareVersionEv"]
    pub fn HeliosDac_HeliosDacDevice_GetFirmwareVersion(
        this: *mut HeliosDac_HeliosDacDevice,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac15HeliosDacDevice7GetNameEPc"]
    pub fn HeliosDac_HeliosDacDevice_GetName(
        this: *mut HeliosDac_HeliosDacDevice,
        name: *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac15HeliosDacDevice7SetNameEPc"]
    pub fn HeliosDac_HeliosDacDevice_SetName(
        this: *mut HeliosDac_HeliosDacDevice,
        name: *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac15HeliosDacDevice10SetShutterEb"]
    pub fn HeliosDac_HeliosDacDevice_SetShutter(
        this: *mut HeliosDac_HeliosDacDevice,
        level: bool,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac15HeliosDacDevice4StopEv"]
    pub fn HeliosDac_HeliosDacDevice_Stop(
        this: *mut HeliosDac_HeliosDacDevice,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac15HeliosDacDevice13EraseFirmwareEv"]
    pub fn HeliosDac_HeliosDacDevice_EraseFirmware(
        this: *mut HeliosDac_HeliosDacDevice,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac15HeliosDacDeviceC1EP20libusb_device_handle"]
    pub fn HeliosDac_HeliosDacDevice_HeliosDacDevice(
        this: *mut HeliosDac_HeliosDacDevice,
        arg1: *mut libusb_device_handle,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac15HeliosDacDeviceD1Ev"]
    pub fn HeliosDac_HeliosDacDevice_HeliosDacDevice_destructor(
        this: *mut HeliosDac_HeliosDacDevice,
    );
}
impl HeliosDac_HeliosDacDevice {
    #[inline]
    pub unsafe fn SendFrame(
        &mut self,
        pps: ::std::os::raw::c_uint,
        flags: u8,
        points: *mut HeliosPoint,
        numOfPoints: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int {
        HeliosDac_HeliosDacDevice_SendFrame(self, pps, flags, points, numOfPoints)
    }
    #[inline]
    pub unsafe fn GetStatus(&mut self) -> ::std::os::raw::c_int {
        HeliosDac_HeliosDacDevice_GetStatus(self)
    }
    #[inline]
    pub unsafe fn GetFirmwareVersion(&mut self) -> ::std::os::raw::c_int {
        HeliosDac_HeliosDacDevice_GetFirmwareVersion(self)
    }
    #[inline]
    pub unsafe fn GetName(&mut self, name: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int {
        HeliosDac_HeliosDacDevice_GetName(self, name)
    }
    #[inline]
    pub unsafe fn SetName(&mut self, name: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int {
        HeliosDac_HeliosDacDevice_SetName(self, name)
    }
    #[inline]
    pub unsafe fn SetShutter(&mut self, level: bool) -> ::std::os::raw::c_int {
        HeliosDac_HeliosDacDevice_SetShutter(self, level)
    }
    #[inline]
    pub unsafe fn Stop(&mut self) -> ::std::os::raw::c_int {
        HeliosDac_HeliosDacDevice_Stop(self)
    }
    #[inline]
    pub unsafe fn EraseFirmware(&mut self) -> ::std::os::raw::c_int {
        HeliosDac_HeliosDacDevice_EraseFirmware(self)
    }
    #[inline]
    pub unsafe fn new(arg1: *mut libusb_device_handle) -> Self {
        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
        HeliosDac_HeliosDacDevice_HeliosDacDevice(__bindgen_tmp.as_mut_ptr(), arg1);
        __bindgen_tmp.assume_init()
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        HeliosDac_HeliosDacDevice_HeliosDacDevice_destructor(self)
    }
}
#[test]
fn bindgen_test_layout_HeliosDac() {
    const UNINIT: ::std::mem::MaybeUninit<HeliosDac> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<HeliosDac>(),
        72usize,
        concat!("Size of: ", stringify!(HeliosDac))
    );
    assert_eq!(
        ::std::mem::align_of::<HeliosDac>(),
        8usize,
        concat!("Alignment of ", stringify!(HeliosDac))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).deviceList) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosDac),
            "::",
            stringify!(deviceList)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).threadLock) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosDac),
            "::",
            stringify!(threadLock)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).inited) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(HeliosDac),
            "::",
            stringify!(inited)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac11OpenDevicesEv"]
    pub fn HeliosDac_OpenDevices(this: *mut HeliosDac) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac12CloseDevicesEv"]
    pub fn HeliosDac_CloseDevices(this: *mut HeliosDac) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac22SetLibusbDebugLogLevelEi"]
    pub fn HeliosDac_SetLibusbDebugLogLevel(
        this: *mut HeliosDac,
        logLevel: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac10WriteFrameEjjhP11HeliosPointj"]
    pub fn HeliosDac_WriteFrame(
        this: *mut HeliosDac,
        devNum: ::std::os::raw::c_uint,
        pps: ::std::os::raw::c_uint,
        flags: u8,
        points: *mut HeliosPoint,
        numOfPoints: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac9GetStatusEj"]
    pub fn HeliosDac_GetStatus(
        this: *mut HeliosDac,
        devNum: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac18GetFirmwareVersionEj"]
    pub fn HeliosDac_GetFirmwareVersion(
        this: *mut HeliosDac,
        devNum: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac7GetNameEjPc"]
    pub fn HeliosDac_GetName(
        this: *mut HeliosDac,
        devNum: ::std::os::raw::c_uint,
        name: *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac7SetNameEjPc"]
    pub fn HeliosDac_SetName(
        this: *mut HeliosDac,
        devNum: ::std::os::raw::c_uint,
        name: *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac4StopEj"]
    pub fn HeliosDac_Stop(
        this: *mut HeliosDac,
        devNum: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac10SetShutterEjb"]
    pub fn HeliosDac_SetShutter(
        this: *mut HeliosDac,
        devNum: ::std::os::raw::c_uint,
        level: bool,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDac13EraseFirmwareEj"]
    pub fn HeliosDac_EraseFirmware(
        this: *mut HeliosDac,
        devNum: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDacC1Ev"]
    pub fn HeliosDac_HeliosDac(this: *mut HeliosDac);
}
extern "C" {
    #[link_name = "\u{1}_ZN9HeliosDacD1Ev"]
    pub fn HeliosDac_HeliosDac_destructor(this: *mut HeliosDac);
}
impl HeliosDac {
    #[inline]
    pub unsafe fn OpenDevices(&mut self) -> ::std::os::raw::c_int {
        HeliosDac_OpenDevices(self)
    }
    #[inline]
    pub unsafe fn CloseDevices(&mut self) -> ::std::os::raw::c_int {
        HeliosDac_CloseDevices(self)
    }
    #[inline]
    pub unsafe fn SetLibusbDebugLogLevel(
        &mut self,
        logLevel: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        HeliosDac_SetLibusbDebugLogLevel(self, logLevel)
    }
    #[inline]
    pub unsafe fn WriteFrame(
        &mut self,
        devNum: ::std::os::raw::c_uint,
        pps: ::std::os::raw::c_uint,
        flags: u8,
        points: *mut HeliosPoint,
        numOfPoints: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int {
        HeliosDac_WriteFrame(self, devNum, pps, flags, points, numOfPoints)
    }
    #[inline]
    pub unsafe fn GetStatus(&mut self, devNum: ::std::os::raw::c_uint) -> ::std::os::raw::c_int {
        HeliosDac_GetStatus(self, devNum)
    }
    #[inline]
    pub unsafe fn GetFirmwareVersion(
        &mut self,
        devNum: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int {
        HeliosDac_GetFirmwareVersion(self, devNum)
    }
    #[inline]
    pub unsafe fn GetName(
        &mut self,
        devNum: ::std::os::raw::c_uint,
        name: *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        HeliosDac_GetName(self, devNum, name)
    }
    #[inline]
    pub unsafe fn SetName(
        &mut self,
        devNum: ::std::os::raw::c_uint,
        name: *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        HeliosDac_SetName(self, devNum, name)
    }
    #[inline]
    pub unsafe fn Stop(&mut self, devNum: ::std::os::raw::c_uint) -> ::std::os::raw::c_int {
        HeliosDac_Stop(self, devNum)
    }
    #[inline]
    pub unsafe fn SetShutter(
        &mut self,
        devNum: ::std::os::raw::c_uint,
        level: bool,
    ) -> ::std::os::raw::c_int {
        HeliosDac_SetShutter(self, devNum, level)
    }
    #[inline]
    pub unsafe fn EraseFirmware(
        &mut self,
        devNum: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int {
        HeliosDac_EraseFirmware(self, devNum)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
        HeliosDac_HeliosDac(__bindgen_tmp.as_mut_ptr());
        __bindgen_tmp.assume_init()
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        HeliosDac_HeliosDac_destructor(self)
    }
}