binding.rs

/* automatically generated by rust-bindgen 0.68.1 */

pub const NAPI_VERSION: u32 = 8;
pub const true_: u32 = 1;
pub const false_: u32 = 0;
pub const __bool_true_false_are_defined: u32 = 1;
pub const NAPI_VERSION_EXPERIMENTAL: u32 = 2147483647;
pub const __WORDSIZE: u32 = 64;
pub const __DARWIN_ONLY_64_BIT_INO_T: u32 = 1;
pub const __DARWIN_ONLY_UNIX_CONFORMANCE: u32 = 1;
pub const __DARWIN_ONLY_VERS_1050: u32 = 1;
pub const __DARWIN_UNIX03: u32 = 1;
pub const __DARWIN_64_BIT_INO_T: u32 = 1;
pub const __DARWIN_VERS_1050: u32 = 1;
pub const __DARWIN_NON_CANCELABLE: u32 = 0;
pub const __DARWIN_SUF_EXTSN: &[u8; 14] = b"$DARWIN_EXTSN\0";
pub const __DARWIN_C_ANSI: u32 = 4096;
pub const __DARWIN_C_FULL: u32 = 900000;
pub const __DARWIN_C_LEVEL: u32 = 900000;
pub const __STDC_WANT_LIB_EXT1__: u32 = 1;
pub const __DARWIN_NO_LONG_LONG: u32 = 0;
pub const _DARWIN_FEATURE_64_BIT_INODE: u32 = 1;
pub const _DARWIN_FEATURE_ONLY_64_BIT_INODE: u32 = 1;
pub const _DARWIN_FEATURE_ONLY_VERS_1050: u32 = 1;
pub const _DARWIN_FEATURE_ONLY_UNIX_CONFORMANCE: u32 = 1;
pub const _DARWIN_FEATURE_UNIX_CONFORMANCE: u32 = 3;
pub const __has_ptrcheck: u32 = 0;
pub const __PTHREAD_SIZE__: u32 = 8176;
pub const __PTHREAD_ATTR_SIZE__: u32 = 56;
pub const __PTHREAD_MUTEXATTR_SIZE__: u32 = 8;
pub const __PTHREAD_MUTEX_SIZE__: u32 = 56;
pub const __PTHREAD_CONDATTR_SIZE__: u32 = 8;
pub const __PTHREAD_COND_SIZE__: u32 = 40;
pub const __PTHREAD_ONCE_SIZE__: u32 = 8;
pub const __PTHREAD_RWLOCK_SIZE__: u32 = 192;
pub const __PTHREAD_RWLOCKATTR_SIZE__: u32 = 16;
pub const INT8_MAX: u32 = 127;
pub const INT16_MAX: u32 = 32767;
pub const INT32_MAX: u32 = 2147483647;
pub const INT64_MAX: u64 = 9223372036854775807;
pub const INT8_MIN: i32 = -128;
pub const INT16_MIN: i32 = -32768;
pub const INT32_MIN: i32 = -2147483648;
pub const INT64_MIN: i64 = -9223372036854775808;
pub const UINT8_MAX: u32 = 255;
pub const UINT16_MAX: u32 = 65535;
pub const UINT32_MAX: u32 = 4294967295;
pub const UINT64_MAX: i32 = -1;
pub const INT_LEAST8_MIN: i32 = -128;
pub const INT_LEAST16_MIN: i32 = -32768;
pub const INT_LEAST32_MIN: i32 = -2147483648;
pub const INT_LEAST64_MIN: i64 = -9223372036854775808;
pub const INT_LEAST8_MAX: u32 = 127;
pub const INT_LEAST16_MAX: u32 = 32767;
pub const INT_LEAST32_MAX: u32 = 2147483647;
pub const INT_LEAST64_MAX: u64 = 9223372036854775807;
pub const UINT_LEAST8_MAX: u32 = 255;
pub const UINT_LEAST16_MAX: u32 = 65535;
pub const UINT_LEAST32_MAX: u32 = 4294967295;
pub const UINT_LEAST64_MAX: i32 = -1;
pub const INT_FAST8_MIN: i32 = -128;
pub const INT_FAST16_MIN: i32 = -32768;
pub const INT_FAST32_MIN: i32 = -2147483648;
pub const INT_FAST64_MIN: i64 = -9223372036854775808;
pub const INT_FAST8_MAX: u32 = 127;
pub const INT_FAST16_MAX: u32 = 32767;
pub const INT_FAST32_MAX: u32 = 2147483647;
pub const INT_FAST64_MAX: u64 = 9223372036854775807;
pub const UINT_FAST8_MAX: u32 = 255;
pub const UINT_FAST16_MAX: u32 = 65535;
pub const UINT_FAST32_MAX: u32 = 4294967295;
pub const UINT_FAST64_MAX: i32 = -1;
pub const INTPTR_MAX: u64 = 9223372036854775807;
pub const INTPTR_MIN: i64 = -9223372036854775808;
pub const UINTPTR_MAX: i32 = -1;
pub const SIZE_MAX: i32 = -1;
pub const RSIZE_MAX: i32 = -1;
pub const WINT_MIN: i32 = -2147483648;
pub const WINT_MAX: u32 = 2147483647;
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
pub const NAPI_AUTO_LENGTH: i32 = -1;
pub const NAPI_MODULE_VERSION: u32 = 1;
pub type wchar_t = ::std::os::raw::c_int;
pub type max_align_t = f64;
pub type int_least8_t = i8;
pub type int_least16_t = i16;
pub type int_least32_t = i32;
pub type int_least64_t = i64;
pub type uint_least8_t = u8;
pub type uint_least16_t = u16;
pub type uint_least32_t = u32;
pub type uint_least64_t = u64;
pub type int_fast8_t = i8;
pub type int_fast16_t = i16;
pub type int_fast32_t = i32;
pub type int_fast64_t = i64;
pub type uint_fast8_t = u8;
pub type uint_fast16_t = u16;
pub type uint_fast32_t = u32;
pub type uint_fast64_t = u64;
pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_longlong;
pub type __uint64_t = ::std::os::raw::c_ulonglong;
pub type __darwin_intptr_t = ::std::os::raw::c_long;
pub type __darwin_natural_t = ::std::os::raw::c_uint;
pub type __darwin_ct_rune_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __mbstate_t {
    pub __mbstate8: [::std::os::raw::c_char; 128usize],
    pub _mbstateL: ::std::os::raw::c_longlong,
}
#[test]
fn bindgen_test_layout___mbstate_t() {
    const UNINIT: ::std::mem::MaybeUninit<__mbstate_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__mbstate_t>(),
        128usize,
        concat!("Size of: ", stringify!(__mbstate_t))
    );
    assert_eq!(
        ::std::mem::align_of::<__mbstate_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__mbstate_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__mbstate8) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__mbstate_t),
            "::",
            stringify!(__mbstate8)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._mbstateL) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__mbstate_t),
            "::",
            stringify!(_mbstateL)
        )
    );
}
pub type __darwin_mbstate_t = __mbstate_t;
pub type __darwin_ptrdiff_t = ::std::os::raw::c_long;
pub type __darwin_size_t = ::std::os::raw::c_ulong;
pub type __darwin_va_list = __builtin_va_list;
pub type __darwin_wchar_t = ::std::os::raw::c_int;
pub type __darwin_rune_t = __darwin_wchar_t;
pub type __darwin_wint_t = ::std::os::raw::c_int;
pub type __darwin_clock_t = ::std::os::raw::c_ulong;
pub type __darwin_socklen_t = __uint32_t;
pub type __darwin_ssize_t = ::std::os::raw::c_long;
pub type __darwin_time_t = ::std::os::raw::c_long;
pub type __darwin_blkcnt_t = __int64_t;
pub type __darwin_blksize_t = __int32_t;
pub type __darwin_dev_t = __int32_t;
pub type __darwin_fsblkcnt_t = ::std::os::raw::c_uint;
pub type __darwin_fsfilcnt_t = ::std::os::raw::c_uint;
pub type __darwin_gid_t = __uint32_t;
pub type __darwin_id_t = __uint32_t;
pub type __darwin_ino64_t = __uint64_t;
pub type __darwin_ino_t = __darwin_ino64_t;
pub type __darwin_mach_port_name_t = __darwin_natural_t;
pub type __darwin_mach_port_t = __darwin_mach_port_name_t;
pub type __darwin_mode_t = __uint16_t;
pub type __darwin_off_t = __int64_t;
pub type __darwin_pid_t = __int32_t;
pub type __darwin_sigset_t = __uint32_t;
pub type __darwin_suseconds_t = __int32_t;
pub type __darwin_uid_t = __uint32_t;
pub type __darwin_useconds_t = __uint32_t;
pub type __darwin_uuid_t = [::std::os::raw::c_uchar; 16usize];
pub type __darwin_uuid_string_t = [::std::os::raw::c_char; 37usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __darwin_pthread_handler_rec {
    pub __routine: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
    pub __arg: *mut ::std::os::raw::c_void,
    pub __next: *mut __darwin_pthread_handler_rec,
}
#[test]
fn bindgen_test_layout___darwin_pthread_handler_rec() {
    const UNINIT: ::std::mem::MaybeUninit<__darwin_pthread_handler_rec> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__darwin_pthread_handler_rec>(),
        24usize,
        concat!("Size of: ", stringify!(__darwin_pthread_handler_rec))
    );
    assert_eq!(
        ::std::mem::align_of::<__darwin_pthread_handler_rec>(),
        8usize,
        concat!("Alignment of ", stringify!(__darwin_pthread_handler_rec))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__routine) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__darwin_pthread_handler_rec),
            "::",
            stringify!(__routine)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__arg) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(__darwin_pthread_handler_rec),
            "::",
            stringify!(__arg)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(__darwin_pthread_handler_rec),
            "::",
            stringify!(__next)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _opaque_pthread_attr_t {
    pub __sig: ::std::os::raw::c_long,
    pub __opaque: [::std::os::raw::c_char; 56usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_attr_t() {
    const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_attr_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<_opaque_pthread_attr_t>(),
        64usize,
        concat!("Size of: ", stringify!(_opaque_pthread_attr_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_opaque_pthread_attr_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_opaque_pthread_attr_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_attr_t),
            "::",
            stringify!(__sig)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_attr_t),
            "::",
            stringify!(__opaque)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _opaque_pthread_cond_t {
    pub __sig: ::std::os::raw::c_long,
    pub __opaque: [::std::os::raw::c_char; 40usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_cond_t() {
    const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_cond_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<_opaque_pthread_cond_t>(),
        48usize,
        concat!("Size of: ", stringify!(_opaque_pthread_cond_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_opaque_pthread_cond_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_opaque_pthread_cond_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_cond_t),
            "::",
            stringify!(__sig)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_cond_t),
            "::",
            stringify!(__opaque)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _opaque_pthread_condattr_t {
    pub __sig: ::std::os::raw::c_long,
    pub __opaque: [::std::os::raw::c_char; 8usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_condattr_t() {
    const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_condattr_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<_opaque_pthread_condattr_t>(),
        16usize,
        concat!("Size of: ", stringify!(_opaque_pthread_condattr_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_opaque_pthread_condattr_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_opaque_pthread_condattr_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_condattr_t),
            "::",
            stringify!(__sig)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_condattr_t),
            "::",
            stringify!(__opaque)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _opaque_pthread_mutex_t {
    pub __sig: ::std::os::raw::c_long,
    pub __opaque: [::std::os::raw::c_char; 56usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_mutex_t() {
    const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_mutex_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<_opaque_pthread_mutex_t>(),
        64usize,
        concat!("Size of: ", stringify!(_opaque_pthread_mutex_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_opaque_pthread_mutex_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_opaque_pthread_mutex_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_mutex_t),
            "::",
            stringify!(__sig)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_mutex_t),
            "::",
            stringify!(__opaque)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _opaque_pthread_mutexattr_t {
    pub __sig: ::std::os::raw::c_long,
    pub __opaque: [::std::os::raw::c_char; 8usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_mutexattr_t() {
    const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_mutexattr_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<_opaque_pthread_mutexattr_t>(),
        16usize,
        concat!("Size of: ", stringify!(_opaque_pthread_mutexattr_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_opaque_pthread_mutexattr_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_opaque_pthread_mutexattr_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_mutexattr_t),
            "::",
            stringify!(__sig)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_mutexattr_t),
            "::",
            stringify!(__opaque)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _opaque_pthread_once_t {
    pub __sig: ::std::os::raw::c_long,
    pub __opaque: [::std::os::raw::c_char; 8usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_once_t() {
    const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_once_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<_opaque_pthread_once_t>(),
        16usize,
        concat!("Size of: ", stringify!(_opaque_pthread_once_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_opaque_pthread_once_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_opaque_pthread_once_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_once_t),
            "::",
            stringify!(__sig)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_once_t),
            "::",
            stringify!(__opaque)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _opaque_pthread_rwlock_t {
    pub __sig: ::std::os::raw::c_long,
    pub __opaque: [::std::os::raw::c_char; 192usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_rwlock_t() {
    const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_rwlock_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<_opaque_pthread_rwlock_t>(),
        200usize,
        concat!("Size of: ", stringify!(_opaque_pthread_rwlock_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_opaque_pthread_rwlock_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_opaque_pthread_rwlock_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_rwlock_t),
            "::",
            stringify!(__sig)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_rwlock_t),
            "::",
            stringify!(__opaque)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _opaque_pthread_rwlockattr_t {
    pub __sig: ::std::os::raw::c_long,
    pub __opaque: [::std::os::raw::c_char; 16usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_rwlockattr_t() {
    const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_rwlockattr_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<_opaque_pthread_rwlockattr_t>(),
        24usize,
        concat!("Size of: ", stringify!(_opaque_pthread_rwlockattr_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_opaque_pthread_rwlockattr_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_opaque_pthread_rwlockattr_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_rwlockattr_t),
            "::",
            stringify!(__sig)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_rwlockattr_t),
            "::",
            stringify!(__opaque)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _opaque_pthread_t {
    pub __sig: ::std::os::raw::c_long,
    pub __cleanup_stack: *mut __darwin_pthread_handler_rec,
    pub __opaque: [::std::os::raw::c_char; 8176usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_t() {
    const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<_opaque_pthread_t>(),
        8192usize,
        concat!("Size of: ", stringify!(_opaque_pthread_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_opaque_pthread_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_opaque_pthread_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_t),
            "::",
            stringify!(__sig)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__cleanup_stack) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_t),
            "::",
            stringify!(__cleanup_stack)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_t),
            "::",
            stringify!(__opaque)
        )
    );
}
pub type __darwin_pthread_attr_t = _opaque_pthread_attr_t;
pub type __darwin_pthread_cond_t = _opaque_pthread_cond_t;
pub type __darwin_pthread_condattr_t = _opaque_pthread_condattr_t;
pub type __darwin_pthread_key_t = ::std::os::raw::c_ulong;
pub type __darwin_pthread_mutex_t = _opaque_pthread_mutex_t;
pub type __darwin_pthread_mutexattr_t = _opaque_pthread_mutexattr_t;
pub type __darwin_pthread_once_t = _opaque_pthread_once_t;
pub type __darwin_pthread_rwlock_t = _opaque_pthread_rwlock_t;
pub type __darwin_pthread_rwlockattr_t = _opaque_pthread_rwlockattr_t;
pub type __darwin_pthread_t = *mut _opaque_pthread_t;
pub type u_int8_t = ::std::os::raw::c_uchar;
pub type u_int16_t = ::std::os::raw::c_ushort;
pub type u_int32_t = ::std::os::raw::c_uint;
pub type u_int64_t = ::std::os::raw::c_ulonglong;
pub type register_t = i64;
pub type user_addr_t = u_int64_t;
pub type user_size_t = u_int64_t;
pub type user_ssize_t = i64;
pub type user_long_t = i64;
pub type user_ulong_t = u_int64_t;
pub type user_time_t = i64;
pub type user_off_t = i64;
pub type syscall_arg_t = u_int64_t;
pub type intmax_t = ::std::os::raw::c_long;
pub type uintmax_t = ::std::os::raw::c_ulong;
pub type char16_t = u16;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_env__ {
    _unused: [u8; 0],
}
pub type napi_env = *mut napi_env__;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_value__ {
    _unused: [u8; 0],
}
pub type napi_value = *mut napi_value__;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_ref__ {
    _unused: [u8; 0],
}
pub type napi_ref = *mut napi_ref__;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_handle_scope__ {
    _unused: [u8; 0],
}
pub type napi_handle_scope = *mut napi_handle_scope__;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_escapable_handle_scope__ {
    _unused: [u8; 0],
}
pub type napi_escapable_handle_scope = *mut napi_escapable_handle_scope__;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_callback_info__ {
    _unused: [u8; 0],
}
pub type napi_callback_info = *mut napi_callback_info__;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_deferred__ {
    _unused: [u8; 0],
}
pub type napi_deferred = *mut napi_deferred__;
pub const napi_property_attributes_napi_default: napi_property_attributes = 0;
pub const napi_property_attributes_napi_writable: napi_property_attributes = 1;
pub const napi_property_attributes_napi_enumerable: napi_property_attributes = 2;
pub const napi_property_attributes_napi_configurable: napi_property_attributes = 4;
pub const napi_property_attributes_napi_static: napi_property_attributes = 1024;
pub const napi_property_attributes_napi_default_method: napi_property_attributes = 5;
pub const napi_property_attributes_napi_default_jsproperty: napi_property_attributes = 7;
pub type napi_property_attributes = ::std::os::raw::c_uint;
pub const napi_valuetype_napi_undefined: napi_valuetype = 0;
pub const napi_valuetype_napi_null: napi_valuetype = 1;
pub const napi_valuetype_napi_boolean: napi_valuetype = 2;
pub const napi_valuetype_napi_number: napi_valuetype = 3;
pub const napi_valuetype_napi_string: napi_valuetype = 4;
pub const napi_valuetype_napi_symbol: napi_valuetype = 5;
pub const napi_valuetype_napi_object: napi_valuetype = 6;
pub const napi_valuetype_napi_function: napi_valuetype = 7;
pub const napi_valuetype_napi_external: napi_valuetype = 8;
pub const napi_valuetype_napi_bigint: napi_valuetype = 9;
pub type napi_valuetype = ::std::os::raw::c_uint;
pub const napi_typedarray_type_napi_int8_array: napi_typedarray_type = 0;
pub const napi_typedarray_type_napi_uint8_array: napi_typedarray_type = 1;
pub const napi_typedarray_type_napi_uint8_clamped_array: napi_typedarray_type = 2;
pub const napi_typedarray_type_napi_int16_array: napi_typedarray_type = 3;
pub const napi_typedarray_type_napi_uint16_array: napi_typedarray_type = 4;
pub const napi_typedarray_type_napi_int32_array: napi_typedarray_type = 5;
pub const napi_typedarray_type_napi_uint32_array: napi_typedarray_type = 6;
pub const napi_typedarray_type_napi_float32_array: napi_typedarray_type = 7;
pub const napi_typedarray_type_napi_float64_array: napi_typedarray_type = 8;
pub const napi_typedarray_type_napi_bigint64_array: napi_typedarray_type = 9;
pub const napi_typedarray_type_napi_biguint64_array: napi_typedarray_type = 10;
pub type napi_typedarray_type = ::std::os::raw::c_uint;
pub const napi_status_napi_ok: napi_status = 0;
pub const napi_status_napi_invalid_arg: napi_status = 1;
pub const napi_status_napi_object_expected: napi_status = 2;
pub const napi_status_napi_string_expected: napi_status = 3;
pub const napi_status_napi_name_expected: napi_status = 4;
pub const napi_status_napi_function_expected: napi_status = 5;
pub const napi_status_napi_number_expected: napi_status = 6;
pub const napi_status_napi_boolean_expected: napi_status = 7;
pub const napi_status_napi_array_expected: napi_status = 8;
pub const napi_status_napi_generic_failure: napi_status = 9;
pub const napi_status_napi_pending_exception: napi_status = 10;
pub const napi_status_napi_cancelled: napi_status = 11;
pub const napi_status_napi_escape_called_twice: napi_status = 12;
pub const napi_status_napi_handle_scope_mismatch: napi_status = 13;
pub const napi_status_napi_callback_scope_mismatch: napi_status = 14;
pub const napi_status_napi_queue_full: napi_status = 15;
pub const napi_status_napi_closing: napi_status = 16;
pub const napi_status_napi_bigint_expected: napi_status = 17;
pub const napi_status_napi_date_expected: napi_status = 18;
pub const napi_status_napi_arraybuffer_expected: napi_status = 19;
pub const napi_status_napi_detachable_arraybuffer_expected: napi_status = 20;
pub const napi_status_napi_would_deadlock: napi_status = 21;
pub const napi_status_napi_no_external_buffers_allowed: napi_status = 22;
pub const napi_status_napi_cannot_run_js: napi_status = 23;
pub type napi_status = ::std::os::raw::c_uint;
pub type napi_callback = ::std::option::Option<
    unsafe extern "C" fn(env: napi_env, info: napi_callback_info) -> napi_value,
>;
pub type napi_finalize = ::std::option::Option<
    unsafe extern "C" fn(
        env: napi_env,
        finalize_data: *mut ::std::os::raw::c_void,
        finalize_hint: *mut ::std::os::raw::c_void,
    ),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_property_descriptor {
    pub utf8name: *const ::std::os::raw::c_char,
    pub name: napi_value,
    pub method: napi_callback,
    pub getter: napi_callback,
    pub setter: napi_callback,
    pub value: napi_value,
    pub attributes: napi_property_attributes,
    pub data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_napi_property_descriptor() {
    const UNINIT: ::std::mem::MaybeUninit<napi_property_descriptor> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<napi_property_descriptor>(),
        64usize,
        concat!("Size of: ", stringify!(napi_property_descriptor))
    );
    assert_eq!(
        ::std::mem::align_of::<napi_property_descriptor>(),
        8usize,
        concat!("Alignment of ", stringify!(napi_property_descriptor))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).utf8name) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_property_descriptor),
            "::",
            stringify!(utf8name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_property_descriptor),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).method) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_property_descriptor),
            "::",
            stringify!(method)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).getter) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_property_descriptor),
            "::",
            stringify!(getter)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).setter) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_property_descriptor),
            "::",
            stringify!(setter)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_property_descriptor),
            "::",
            stringify!(value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).attributes) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_property_descriptor),
            "::",
            stringify!(attributes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_property_descriptor),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_extended_error_info {
    pub error_message: *const ::std::os::raw::c_char,
    pub engine_reserved: *mut ::std::os::raw::c_void,
    pub engine_error_code: u32,
    pub error_code: napi_status,
}
#[test]
fn bindgen_test_layout_napi_extended_error_info() {
    const UNINIT: ::std::mem::MaybeUninit<napi_extended_error_info> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<napi_extended_error_info>(),
        24usize,
        concat!("Size of: ", stringify!(napi_extended_error_info))
    );
    assert_eq!(
        ::std::mem::align_of::<napi_extended_error_info>(),
        8usize,
        concat!("Alignment of ", stringify!(napi_extended_error_info))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).error_message) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_extended_error_info),
            "::",
            stringify!(error_message)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).engine_reserved) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_extended_error_info),
            "::",
            stringify!(engine_reserved)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).engine_error_code) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_extended_error_info),
            "::",
            stringify!(engine_error_code)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).error_code) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_extended_error_info),
            "::",
            stringify!(error_code)
        )
    );
}
pub const napi_key_collection_mode_napi_key_include_prototypes: napi_key_collection_mode = 0;
pub const napi_key_collection_mode_napi_key_own_only: napi_key_collection_mode = 1;
pub type napi_key_collection_mode = ::std::os::raw::c_uint;
pub const napi_key_filter_napi_key_all_properties: napi_key_filter = 0;
pub const napi_key_filter_napi_key_writable: napi_key_filter = 1;
pub const napi_key_filter_napi_key_enumerable: napi_key_filter = 2;
pub const napi_key_filter_napi_key_configurable: napi_key_filter = 4;
pub const napi_key_filter_napi_key_skip_strings: napi_key_filter = 8;
pub const napi_key_filter_napi_key_skip_symbols: napi_key_filter = 16;
pub type napi_key_filter = ::std::os::raw::c_uint;
pub const napi_key_conversion_napi_key_keep_numbers: napi_key_conversion = 0;
pub const napi_key_conversion_napi_key_numbers_to_strings: napi_key_conversion = 1;
pub type napi_key_conversion = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_type_tag {
    pub lower: u64,
    pub upper: u64,
}
#[test]
fn bindgen_test_layout_napi_type_tag() {
    const UNINIT: ::std::mem::MaybeUninit<napi_type_tag> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<napi_type_tag>(),
        16usize,
        concat!("Size of: ", stringify!(napi_type_tag))
    );
    assert_eq!(
        ::std::mem::align_of::<napi_type_tag>(),
        8usize,
        concat!("Alignment of ", stringify!(napi_type_tag))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lower) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_type_tag),
            "::",
            stringify!(lower)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).upper) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_type_tag),
            "::",
            stringify!(upper)
        )
    );
}
extern "C" {
    pub fn napi_get_last_error_info(
        env: napi_env,
        result: *mut *const napi_extended_error_info,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_undefined(env: napi_env, result: *mut napi_value) -> napi_status;
}
extern "C" {
    pub fn napi_get_null(env: napi_env, result: *mut napi_value) -> napi_status;
}
extern "C" {
    pub fn napi_get_global(env: napi_env, result: *mut napi_value) -> napi_status;
}
extern "C" {
    pub fn napi_get_boolean(env: napi_env, value: bool, result: *mut napi_value) -> napi_status;
}
extern "C" {
    pub fn napi_create_object(env: napi_env, result: *mut napi_value) -> napi_status;
}
extern "C" {
    pub fn napi_create_array(env: napi_env, result: *mut napi_value) -> napi_status;
}
extern "C" {
    pub fn napi_create_array_with_length(
        env: napi_env,
        length: usize,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_double(env: napi_env, value: f64, result: *mut napi_value) -> napi_status;
}
extern "C" {
    pub fn napi_create_int32(env: napi_env, value: i32, result: *mut napi_value) -> napi_status;
}
extern "C" {
    pub fn napi_create_uint32(env: napi_env, value: u32, result: *mut napi_value) -> napi_status;
}
extern "C" {
    pub fn napi_create_int64(env: napi_env, value: i64, result: *mut napi_value) -> napi_status;
}
extern "C" {
    pub fn napi_create_string_latin1(
        env: napi_env,
        str_: *const ::std::os::raw::c_char,
        length: usize,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_string_utf8(
        env: napi_env,
        str_: *const ::std::os::raw::c_char,
        length: usize,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_string_utf16(
        env: napi_env,
        str_: *const char16_t,
        length: usize,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_symbol(
        env: napi_env,
        description: napi_value,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_function(
        env: napi_env,
        utf8name: *const ::std::os::raw::c_char,
        length: usize,
        cb: napi_callback,
        data: *mut ::std::os::raw::c_void,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_error(
        env: napi_env,
        code: napi_value,
        msg: napi_value,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_type_error(
        env: napi_env,
        code: napi_value,
        msg: napi_value,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_range_error(
        env: napi_env,
        code: napi_value,
        msg: napi_value,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_typeof(
        env: napi_env,
        value: napi_value,
        result: *mut napi_valuetype,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_value_double(env: napi_env, value: napi_value, result: *mut f64)
        -> napi_status;
}
extern "C" {
    pub fn napi_get_value_int32(env: napi_env, value: napi_value, result: *mut i32) -> napi_status;
}
extern "C" {
    pub fn napi_get_value_uint32(env: napi_env, value: napi_value, result: *mut u32)
        -> napi_status;
}
extern "C" {
    pub fn napi_get_value_int64(env: napi_env, value: napi_value, result: *mut i64) -> napi_status;
}
extern "C" {
    pub fn napi_get_value_bool(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
}
extern "C" {
    pub fn napi_get_value_string_latin1(
        env: napi_env,
        value: napi_value,
        buf: *mut ::std::os::raw::c_char,
        bufsize: usize,
        result: *mut usize,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_value_string_utf8(
        env: napi_env,
        value: napi_value,
        buf: *mut ::std::os::raw::c_char,
        bufsize: usize,
        result: *mut usize,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_value_string_utf16(
        env: napi_env,
        value: napi_value,
        buf: *mut char16_t,
        bufsize: usize,
        result: *mut usize,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_coerce_to_bool(
        env: napi_env,
        value: napi_value,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_coerce_to_number(
        env: napi_env,
        value: napi_value,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_coerce_to_object(
        env: napi_env,
        value: napi_value,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_coerce_to_string(
        env: napi_env,
        value: napi_value,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_prototype(
        env: napi_env,
        object: napi_value,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_property_names(
        env: napi_env,
        object: napi_value,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_set_property(
        env: napi_env,
        object: napi_value,
        key: napi_value,
        value: napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_has_property(
        env: napi_env,
        object: napi_value,
        key: napi_value,
        result: *mut bool,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_property(
        env: napi_env,
        object: napi_value,
        key: napi_value,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_delete_property(
        env: napi_env,
        object: napi_value,
        key: napi_value,
        result: *mut bool,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_has_own_property(
        env: napi_env,
        object: napi_value,
        key: napi_value,
        result: *mut bool,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_set_named_property(
        env: napi_env,
        object: napi_value,
        utf8name: *const ::std::os::raw::c_char,
        value: napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_has_named_property(
        env: napi_env,
        object: napi_value,
        utf8name: *const ::std::os::raw::c_char,
        result: *mut bool,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_named_property(
        env: napi_env,
        object: napi_value,
        utf8name: *const ::std::os::raw::c_char,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_set_element(
        env: napi_env,
        object: napi_value,
        index: u32,
        value: napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_has_element(
        env: napi_env,
        object: napi_value,
        index: u32,
        result: *mut bool,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_element(
        env: napi_env,
        object: napi_value,
        index: u32,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_delete_element(
        env: napi_env,
        object: napi_value,
        index: u32,
        result: *mut bool,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_define_properties(
        env: napi_env,
        object: napi_value,
        property_count: usize,
        properties: *const napi_property_descriptor,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_is_array(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
}
extern "C" {
    pub fn napi_get_array_length(env: napi_env, value: napi_value, result: *mut u32)
        -> napi_status;
}
extern "C" {
    pub fn napi_strict_equals(
        env: napi_env,
        lhs: napi_value,
        rhs: napi_value,
        result: *mut bool,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_call_function(
        env: napi_env,
        recv: napi_value,
        func: napi_value,
        argc: usize,
        argv: *const napi_value,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_new_instance(
        env: napi_env,
        constructor: napi_value,
        argc: usize,
        argv: *const napi_value,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_instanceof(
        env: napi_env,
        object: napi_value,
        constructor: napi_value,
        result: *mut bool,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_cb_info(
        env: napi_env,
        cbinfo: napi_callback_info,
        argc: *mut usize,
        argv: *mut napi_value,
        this_arg: *mut napi_value,
        data: *mut *mut ::std::os::raw::c_void,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_new_target(
        env: napi_env,
        cbinfo: napi_callback_info,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_define_class(
        env: napi_env,
        utf8name: *const ::std::os::raw::c_char,
        length: usize,
        constructor: napi_callback,
        data: *mut ::std::os::raw::c_void,
        property_count: usize,
        properties: *const napi_property_descriptor,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_wrap(
        env: napi_env,
        js_object: napi_value,
        native_object: *mut ::std::os::raw::c_void,
        finalize_cb: napi_finalize,
        finalize_hint: *mut ::std::os::raw::c_void,
        result: *mut napi_ref,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_unwrap(
        env: napi_env,
        js_object: napi_value,
        result: *mut *mut ::std::os::raw::c_void,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_remove_wrap(
        env: napi_env,
        js_object: napi_value,
        result: *mut *mut ::std::os::raw::c_void,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_external(
        env: napi_env,
        data: *mut ::std::os::raw::c_void,
        finalize_cb: napi_finalize,
        finalize_hint: *mut ::std::os::raw::c_void,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_value_external(
        env: napi_env,
        value: napi_value,
        result: *mut *mut ::std::os::raw::c_void,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_reference(
        env: napi_env,
        value: napi_value,
        initial_refcount: u32,
        result: *mut napi_ref,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_delete_reference(env: napi_env, ref_: napi_ref) -> napi_status;
}
extern "C" {
    pub fn napi_reference_ref(env: napi_env, ref_: napi_ref, result: *mut u32) -> napi_status;
}
extern "C" {
    pub fn napi_reference_unref(env: napi_env, ref_: napi_ref, result: *mut u32) -> napi_status;
}
extern "C" {
    pub fn napi_get_reference_value(
        env: napi_env,
        ref_: napi_ref,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_open_handle_scope(env: napi_env, result: *mut napi_handle_scope) -> napi_status;
}
extern "C" {
    pub fn napi_close_handle_scope(env: napi_env, scope: napi_handle_scope) -> napi_status;
}
extern "C" {
    pub fn napi_open_escapable_handle_scope(
        env: napi_env,
        result: *mut napi_escapable_handle_scope,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_close_escapable_handle_scope(
        env: napi_env,
        scope: napi_escapable_handle_scope,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_escape_handle(
        env: napi_env,
        scope: napi_escapable_handle_scope,
        escapee: napi_value,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_throw(env: napi_env, error: napi_value) -> napi_status;
}
extern "C" {
    pub fn napi_throw_error(
        env: napi_env,
        code: *const ::std::os::raw::c_char,
        msg: *const ::std::os::raw::c_char,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_throw_type_error(
        env: napi_env,
        code: *const ::std::os::raw::c_char,
        msg: *const ::std::os::raw::c_char,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_throw_range_error(
        env: napi_env,
        code: *const ::std::os::raw::c_char,
        msg: *const ::std::os::raw::c_char,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_is_error(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
}
extern "C" {
    pub fn napi_is_exception_pending(env: napi_env, result: *mut bool) -> napi_status;
}
extern "C" {
    pub fn napi_get_and_clear_last_exception(env: napi_env, result: *mut napi_value)
        -> napi_status;
}
extern "C" {
    pub fn napi_is_arraybuffer(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
}
extern "C" {
    pub fn napi_create_arraybuffer(
        env: napi_env,
        byte_length: usize,
        data: *mut *mut ::std::os::raw::c_void,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_external_arraybuffer(
        env: napi_env,
        external_data: *mut ::std::os::raw::c_void,
        byte_length: usize,
        finalize_cb: napi_finalize,
        finalize_hint: *mut ::std::os::raw::c_void,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_arraybuffer_info(
        env: napi_env,
        arraybuffer: napi_value,
        data: *mut *mut ::std::os::raw::c_void,
        byte_length: *mut usize,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_is_typedarray(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
}
extern "C" {
    pub fn napi_create_typedarray(
        env: napi_env,
        type_: napi_typedarray_type,
        length: usize,
        arraybuffer: napi_value,
        byte_offset: usize,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_typedarray_info(
        env: napi_env,
        typedarray: napi_value,
        type_: *mut napi_typedarray_type,
        length: *mut usize,
        data: *mut *mut ::std::os::raw::c_void,
        arraybuffer: *mut napi_value,
        byte_offset: *mut usize,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_dataview(
        env: napi_env,
        length: usize,
        arraybuffer: napi_value,
        byte_offset: usize,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_is_dataview(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
}
extern "C" {
    pub fn napi_get_dataview_info(
        env: napi_env,
        dataview: napi_value,
        bytelength: *mut usize,
        data: *mut *mut ::std::os::raw::c_void,
        arraybuffer: *mut napi_value,
        byte_offset: *mut usize,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_version(env: napi_env, result: *mut u32) -> napi_status;
}
extern "C" {
    pub fn napi_create_promise(
        env: napi_env,
        deferred: *mut napi_deferred,
        promise: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_resolve_deferred(
        env: napi_env,
        deferred: napi_deferred,
        resolution: napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_reject_deferred(
        env: napi_env,
        deferred: napi_deferred,
        rejection: napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_is_promise(env: napi_env, value: napi_value, is_promise: *mut bool) -> napi_status;
}
extern "C" {
    pub fn napi_run_script(
        env: napi_env,
        script: napi_value,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_adjust_external_memory(
        env: napi_env,
        change_in_bytes: i64,
        adjusted_value: *mut i64,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_date(env: napi_env, time: f64, result: *mut napi_value) -> napi_status;
}
extern "C" {
    pub fn napi_is_date(env: napi_env, value: napi_value, is_date: *mut bool) -> napi_status;
}
extern "C" {
    pub fn napi_get_date_value(env: napi_env, value: napi_value, result: *mut f64) -> napi_status;
}
extern "C" {
    pub fn napi_add_finalizer(
        env: napi_env,
        js_object: napi_value,
        finalize_data: *mut ::std::os::raw::c_void,
        finalize_cb: napi_finalize,
        finalize_hint: *mut ::std::os::raw::c_void,
        result: *mut napi_ref,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_bigint_int64(
        env: napi_env,
        value: i64,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_bigint_uint64(
        env: napi_env,
        value: u64,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_bigint_words(
        env: napi_env,
        sign_bit: ::std::os::raw::c_int,
        word_count: usize,
        words: *const u64,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_value_bigint_int64(
        env: napi_env,
        value: napi_value,
        result: *mut i64,
        lossless: *mut bool,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_value_bigint_uint64(
        env: napi_env,
        value: napi_value,
        result: *mut u64,
        lossless: *mut bool,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_value_bigint_words(
        env: napi_env,
        value: napi_value,
        sign_bit: *mut ::std::os::raw::c_int,
        word_count: *mut usize,
        words: *mut u64,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_all_property_names(
        env: napi_env,
        object: napi_value,
        key_mode: napi_key_collection_mode,
        key_filter: napi_key_filter,
        key_conversion: napi_key_conversion,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_set_instance_data(
        env: napi_env,
        data: *mut ::std::os::raw::c_void,
        finalize_cb: napi_finalize,
        finalize_hint: *mut ::std::os::raw::c_void,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_instance_data(
        env: napi_env,
        data: *mut *mut ::std::os::raw::c_void,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_detach_arraybuffer(env: napi_env, arraybuffer: napi_value) -> napi_status;
}
extern "C" {
    pub fn napi_is_detached_arraybuffer(
        env: napi_env,
        value: napi_value,
        result: *mut bool,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_type_tag_object(
        env: napi_env,
        value: napi_value,
        type_tag: *const napi_type_tag,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_check_object_type_tag(
        env: napi_env,
        value: napi_value,
        type_tag: *const napi_type_tag,
        result: *mut bool,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_object_freeze(env: napi_env, object: napi_value) -> napi_status;
}
extern "C" {
    pub fn napi_object_seal(env: napi_env, object: napi_value) -> napi_status;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_callback_scope__ {
    _unused: [u8; 0],
}
pub type napi_callback_scope = *mut napi_callback_scope__;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_async_context__ {
    _unused: [u8; 0],
}
pub type napi_async_context = *mut napi_async_context__;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_async_work__ {
    _unused: [u8; 0],
}
pub type napi_async_work = *mut napi_async_work__;
pub type napi_cleanup_hook =
    ::std::option::Option<unsafe extern "C" fn(arg: *mut ::std::os::raw::c_void)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_threadsafe_function__ {
    _unused: [u8; 0],
}
pub type napi_threadsafe_function = *mut napi_threadsafe_function__;
pub const napi_threadsafe_function_release_mode_napi_tsfn_release:
    napi_threadsafe_function_release_mode = 0;
pub const napi_threadsafe_function_release_mode_napi_tsfn_abort:
    napi_threadsafe_function_release_mode = 1;
pub type napi_threadsafe_function_release_mode = ::std::os::raw::c_uint;
pub const napi_threadsafe_function_call_mode_napi_tsfn_nonblocking:
    napi_threadsafe_function_call_mode = 0;
pub const napi_threadsafe_function_call_mode_napi_tsfn_blocking:
    napi_threadsafe_function_call_mode = 1;
pub type napi_threadsafe_function_call_mode = ::std::os::raw::c_uint;
pub type napi_async_execute_callback =
    ::std::option::Option<unsafe extern "C" fn(env: napi_env, data: *mut ::std::os::raw::c_void)>;
pub type napi_async_complete_callback = ::std::option::Option<
    unsafe extern "C" fn(env: napi_env, status: napi_status, data: *mut ::std::os::raw::c_void),
>;
pub type napi_threadsafe_function_call_js = ::std::option::Option<
    unsafe extern "C" fn(
        env: napi_env,
        js_callback: napi_value,
        context: *mut ::std::os::raw::c_void,
        data: *mut ::std::os::raw::c_void,
    ),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_node_version {
    pub major: u32,
    pub minor: u32,
    pub patch: u32,
    pub release: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_napi_node_version() {
    const UNINIT: ::std::mem::MaybeUninit<napi_node_version> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<napi_node_version>(),
        24usize,
        concat!("Size of: ", stringify!(napi_node_version))
    );
    assert_eq!(
        ::std::mem::align_of::<napi_node_version>(),
        8usize,
        concat!("Alignment of ", stringify!(napi_node_version))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).major) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_node_version),
            "::",
            stringify!(major)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).minor) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_node_version),
            "::",
            stringify!(minor)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).patch) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_node_version),
            "::",
            stringify!(patch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).release) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_node_version),
            "::",
            stringify!(release)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_async_cleanup_hook_handle__ {
    _unused: [u8; 0],
}
pub type napi_async_cleanup_hook_handle = *mut napi_async_cleanup_hook_handle__;
pub type napi_async_cleanup_hook = ::std::option::Option<
    unsafe extern "C" fn(handle: napi_async_cleanup_hook_handle, data: *mut ::std::os::raw::c_void),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct uv_loop_s {
    _unused: [u8; 0],
}
pub type napi_addon_register_func =
    ::std::option::Option<unsafe extern "C" fn(env: napi_env, exports: napi_value) -> napi_value>;
pub type node_api_addon_get_api_version_func = ::std::option::Option<unsafe extern "C" fn() -> i32>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct napi_module {
    pub nm_version: ::std::os::raw::c_int,
    pub nm_flags: ::std::os::raw::c_uint,
    pub nm_filename: *const ::std::os::raw::c_char,
    pub nm_register_func: napi_addon_register_func,
    pub nm_modname: *const ::std::os::raw::c_char,
    pub nm_priv: *mut ::std::os::raw::c_void,
    pub reserved: [*mut ::std::os::raw::c_void; 4usize],
}
#[test]
fn bindgen_test_layout_napi_module() {
    const UNINIT: ::std::mem::MaybeUninit<napi_module> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<napi_module>(),
        72usize,
        concat!("Size of: ", stringify!(napi_module))
    );
    assert_eq!(
        ::std::mem::align_of::<napi_module>(),
        8usize,
        concat!("Alignment of ", stringify!(napi_module))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nm_version) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_module),
            "::",
            stringify!(nm_version)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nm_flags) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_module),
            "::",
            stringify!(nm_flags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nm_filename) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_module),
            "::",
            stringify!(nm_filename)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nm_register_func) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_module),
            "::",
            stringify!(nm_register_func)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nm_modname) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_module),
            "::",
            stringify!(nm_modname)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nm_priv) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_module),
            "::",
            stringify!(nm_priv)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(napi_module),
            "::",
            stringify!(reserved)
        )
    );
}
extern "C" {
    pub fn napi_module_register(mod_: *mut napi_module);
}
extern "C" {
    pub fn napi_fatal_error(
        location: *const ::std::os::raw::c_char,
        location_len: usize,
        message: *const ::std::os::raw::c_char,
        message_len: usize,
    ) -> !;
}
extern "C" {
    pub fn napi_async_init(
        env: napi_env,
        async_resource: napi_value,
        async_resource_name: napi_value,
        result: *mut napi_async_context,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_async_destroy(env: napi_env, async_context: napi_async_context) -> napi_status;
}
extern "C" {
    pub fn napi_make_callback(
        env: napi_env,
        async_context: napi_async_context,
        recv: napi_value,
        func: napi_value,
        argc: usize,
        argv: *const napi_value,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_buffer(
        env: napi_env,
        length: usize,
        data: *mut *mut ::std::os::raw::c_void,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_external_buffer(
        env: napi_env,
        length: usize,
        data: *mut ::std::os::raw::c_void,
        finalize_cb: napi_finalize,
        finalize_hint: *mut ::std::os::raw::c_void,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_buffer_copy(
        env: napi_env,
        length: usize,
        data: *const ::std::os::raw::c_void,
        result_data: *mut *mut ::std::os::raw::c_void,
        result: *mut napi_value,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_is_buffer(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
}
extern "C" {
    pub fn napi_get_buffer_info(
        env: napi_env,
        value: napi_value,
        data: *mut *mut ::std::os::raw::c_void,
        length: *mut usize,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_create_async_work(
        env: napi_env,
        async_resource: napi_value,
        async_resource_name: napi_value,
        execute: napi_async_execute_callback,
        complete: napi_async_complete_callback,
        data: *mut ::std::os::raw::c_void,
        result: *mut napi_async_work,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_delete_async_work(env: napi_env, work: napi_async_work) -> napi_status;
}
extern "C" {
    pub fn napi_queue_async_work(env: napi_env, work: napi_async_work) -> napi_status;
}
extern "C" {
    pub fn napi_cancel_async_work(env: napi_env, work: napi_async_work) -> napi_status;
}
extern "C" {
    pub fn napi_get_node_version(
        env: napi_env,
        version: *mut *const napi_node_version,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_uv_event_loop(env: napi_env, loop_: *mut *mut uv_loop_s) -> napi_status;
}
extern "C" {
    pub fn napi_fatal_exception(env: napi_env, err: napi_value) -> napi_status;
}
extern "C" {
    pub fn napi_add_env_cleanup_hook(
        env: napi_env,
        fun: napi_cleanup_hook,
        arg: *mut ::std::os::raw::c_void,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_remove_env_cleanup_hook(
        env: napi_env,
        fun: napi_cleanup_hook,
        arg: *mut ::std::os::raw::c_void,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_open_callback_scope(
        env: napi_env,
        resource_object: napi_value,
        context: napi_async_context,
        result: *mut napi_callback_scope,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_close_callback_scope(env: napi_env, scope: napi_callback_scope) -> napi_status;
}
extern "C" {
    pub fn napi_create_threadsafe_function(
        env: napi_env,
        func: napi_value,
        async_resource: napi_value,
        async_resource_name: napi_value,
        max_queue_size: usize,
        initial_thread_count: usize,
        thread_finalize_data: *mut ::std::os::raw::c_void,
        thread_finalize_cb: napi_finalize,
        context: *mut ::std::os::raw::c_void,
        call_js_cb: napi_threadsafe_function_call_js,
        result: *mut napi_threadsafe_function,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_get_threadsafe_function_context(
        func: napi_threadsafe_function,
        result: *mut *mut ::std::os::raw::c_void,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_call_threadsafe_function(
        func: napi_threadsafe_function,
        data: *mut ::std::os::raw::c_void,
        is_blocking: napi_threadsafe_function_call_mode,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_acquire_threadsafe_function(func: napi_threadsafe_function) -> napi_status;
}
extern "C" {
    pub fn napi_release_threadsafe_function(
        func: napi_threadsafe_function,
        mode: napi_threadsafe_function_release_mode,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_unref_threadsafe_function(
        env: napi_env,
        func: napi_threadsafe_function,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_ref_threadsafe_function(
        env: napi_env,
        func: napi_threadsafe_function,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_add_async_cleanup_hook(
        env: napi_env,
        hook: napi_async_cleanup_hook,
        arg: *mut ::std::os::raw::c_void,
        remove_handle: *mut napi_async_cleanup_hook_handle,
    ) -> napi_status;
}
extern "C" {
    pub fn napi_remove_async_cleanup_hook(
        remove_handle: napi_async_cleanup_hook_handle,
    ) -> napi_status;
}
pub type __builtin_va_list = *mut ::std::os::raw::c_char;