diff --git a/www/deno/files/patch-cargo-crates_libuv-sys-lite b/www/deno/files/patch-cargo-crates_libuv-sys-lite new file mode 100644 index 000000000000..831f3a80453a --- /dev/null +++ b/www/deno/files/patch-cargo-crates_libuv-sys-lite @@ -0,0 +1,7400 @@ +--- cargo-crates/libuv-sys-lite-1.48.3/build.rs.orig 2026-04-06 17:29:47 UTC ++++ cargo-crates/libuv-sys-lite-1.48.3/build.rs +@@ -40,7 +40,7 @@ fn main() { + let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default(); + let target_arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default(); + match (&*target_os, &*target_arch) { +- ("windows", "x86_64") | ("linux" | "macos", "x86_64" | "aarch64") => { ++ ("windows", "x86_64") | ("linux" | "macos" | "freebsd", "x86_64" | "aarch64") => { + let path = PathBuf::from("src").join(format!("bindings_{}_{}.rs", target_os, target_arch)); + let dest = PathBuf::from(std::env::var("OUT_DIR").unwrap()).join("bindings.rs"); + std::fs::copy(&path, &dest).unwrap(); + +--- cargo-crates/libuv-sys-lite-1.48.3/src/bindings_freebsd_x86_64.rs.orig 2026-04-06 17:27:53 UTC ++++ cargo-crates/libuv-sys-lite-1.48.3/src/bindings_freebsd_x86_64.rs +@@ -0,0 +1,3875 @@ ++/* automatically generated by rust-bindgen 0.70.1 */ ++ ++pub const UV__EOF: i32 = -4095; ++pub const UV__UNKNOWN: i32 = -4094; ++pub const UV__EAI_ADDRFAMILY: i32 = -3000; ++pub const UV__EAI_AGAIN: i32 = -3001; ++pub const UV__EAI_BADFLAGS: i32 = -3002; ++pub const UV__EAI_CANCELED: i32 = -3003; ++pub const UV__EAI_FAIL: i32 = -3004; ++pub const UV__EAI_FAMILY: i32 = -3005; ++pub const UV__EAI_MEMORY: i32 = -3006; ++pub const UV__EAI_NODATA: i32 = -3007; ++pub const UV__EAI_NONAME: i32 = -3008; ++pub const UV__EAI_OVERFLOW: i32 = -3009; ++pub const UV__EAI_SERVICE: i32 = -3010; ++pub const UV__EAI_SOCKTYPE: i32 = -3011; ++pub const UV__EAI_BADHINTS: i32 = -3013; ++pub const UV__EAI_PROTOCOL: i32 = -3014; ++pub const UV__ECHARSET: i32 = -4080; ++pub const UV__ENONET: i32 = -4056; ++pub const UV__EREMOTEIO: i32 = -4030; ++pub const UV__ENODATA: i32 = -9919; ++pub const UV__EUNATCH: i32 = -4023; ++pub const UV_VERSION_MAJOR: u32 = 1; ++pub const UV_VERSION_MINOR: u32 = 48; ++pub const UV_VERSION_PATCH: u32 = 0; ++pub const UV_VERSION_IS_RELEASE: u32 = 1; ++pub const UV_VERSION_SUFFIX: &[u8; 1] = b"\0"; ++pub const UV_VERSION_HEX: u32 = 77824; ++pub const UV_HAVE_KQUEUE: u32 = 1; ++pub const UV__DT_FILE: u32 = 8; ++pub const UV__DT_DIR: u32 = 4; ++pub const UV__DT_LINK: u32 = 10; ++pub const UV__DT_FIFO: u32 = 1; ++pub const UV__DT_SOCKET: u32 = 12; ++pub const UV__DT_CHAR: u32 = 2; ++pub const UV__DT_BLOCK: u32 = 6; ++pub const UV_FS_O_APPEND: u32 = 8; ++pub const UV_FS_O_CREAT: u32 = 512; ++pub const UV_FS_O_DIRECT: u32 = 65536; ++pub const UV_FS_O_DIRECTORY: u32 = 131072; ++pub const UV_FS_O_DSYNC: u32 = 16777216; ++pub const UV_FS_O_EXCL: u32 = 2048; ++pub const UV_FS_O_EXLOCK: u32 = 32; ++pub const UV_FS_O_NOATIME: u32 = 0; ++pub const UV_FS_O_NOCTTY: u32 = 32768; ++pub const UV_FS_O_NOFOLLOW: u32 = 256; ++pub const UV_FS_O_NONBLOCK: u32 = 4; ++pub const UV_FS_O_RDONLY: u32 = 0; ++pub const UV_FS_O_RDWR: u32 = 2; ++pub const UV_FS_O_SYMLINK: u32 = 0; ++pub const UV_FS_O_SYNC: u32 = 128; ++pub const UV_FS_O_TRUNC: u32 = 1024; ++pub const UV_FS_O_WRONLY: u32 = 1; ++pub const UV_FS_O_FILEMAP: u32 = 0; ++pub const UV_FS_O_RANDOM: u32 = 0; ++pub const UV_FS_O_SHORT_LIVED: u32 = 0; ++pub const UV_FS_O_SEQUENTIAL: u32 = 0; ++pub const UV_FS_O_TEMPORARY: u32 = 0; ++pub const UV_PRIORITY_LOW: u32 = 19; ++pub const UV_PRIORITY_BELOW_NORMAL: u32 = 10; ++pub const UV_PRIORITY_NORMAL: u32 = 0; ++pub const UV_PRIORITY_ABOVE_NORMAL: i32 = -7; ++pub const UV_PRIORITY_HIGH: i32 = -14; ++pub const UV_PRIORITY_HIGHEST: i32 = -20; ++pub const UV_MAXHOSTNAMESIZE: u32 = 257; ++pub const UV_FS_COPYFILE_EXCL: u32 = 1; ++pub const UV_FS_COPYFILE_FICLONE: u32 = 2; ++pub const UV_FS_COPYFILE_FICLONE_FORCE: u32 = 4; ++pub const UV_FS_SYMLINK_DIR: u32 = 1; ++pub const UV_FS_SYMLINK_JUNCTION: u32 = 2; ++pub const UV_IF_NAMESIZE: u32 = 17; ++pub type __uint8_t = ::std::os::raw::c_uchar; ++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_long; ++pub type __uint64_t = ::std::os::raw::c_ulong; ++pub type __gid_t = __uint32_t; ++pub type __ino_t = __uint64_t; ++pub type __mode_t = __uint16_t; ++pub type __off_t = __int64_t; ++pub type __pid_t = __int32_t; ++pub type __sa_family_t = __uint8_t; ++pub type __socklen_t = __uint32_t; ++pub type __uid_t = __uint32_t; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union __mbstate_t { ++ pub __mbstate8: [::std::os::raw::c_char; 128usize], ++ pub _mbstateL: __int64_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __mbstate_t"][::std::mem::size_of::<__mbstate_t>() - 128usize]; ++ ["Alignment of __mbstate_t"][::std::mem::align_of::<__mbstate_t>() - 8usize]; ++ ["Offset of field: __mbstate_t::__mbstate8"] ++ [::std::mem::offset_of!(__mbstate_t, __mbstate8) - 0usize]; ++ ["Offset of field: __mbstate_t::_mbstateL"] ++ [::std::mem::offset_of!(__mbstate_t, _mbstateL) - 0usize]; ++}; ++pub type fpos_t = __off_t; ++pub type off_t = __off_t; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __sbuf { ++ pub _base: *mut ::std::os::raw::c_uchar, ++ pub _size: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __sbuf"][::std::mem::size_of::<__sbuf>() - 16usize]; ++ ["Alignment of __sbuf"][::std::mem::align_of::<__sbuf>() - 8usize]; ++ ["Offset of field: __sbuf::_base"] ++ [::std::mem::offset_of!(__sbuf, _base) - 0usize]; ++ ["Offset of field: __sbuf::_size"] ++ [::std::mem::offset_of!(__sbuf, _size) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct __sFILE { ++ pub _p: *mut ::std::os::raw::c_uchar, ++ pub _r: ::std::os::raw::c_int, ++ pub _w: ::std::os::raw::c_int, ++ pub _flags: ::std::os::raw::c_short, ++ pub _file: ::std::os::raw::c_short, ++ pub _bf: __sbuf, ++ pub _lbfsize: ::std::os::raw::c_int, ++ pub _cookie: *mut ::std::os::raw::c_void, ++ pub _close: ::std::option::Option< ++ unsafe extern "C" fn( ++ arg1: *mut ::std::os::raw::c_void, ++ ) -> ::std::os::raw::c_int, ++ >, ++ pub _read: ::std::option::Option< ++ unsafe extern "C" fn( ++ arg1: *mut ::std::os::raw::c_void, ++ arg2: *mut ::std::os::raw::c_char, ++ arg3: ::std::os::raw::c_int, ++ ) -> ::std::os::raw::c_int, ++ >, ++ pub _seek: ::std::option::Option< ++ unsafe extern "C" fn( ++ arg1: *mut ::std::os::raw::c_void, ++ arg2: fpos_t, ++ arg3: ::std::os::raw::c_int, ++ ) -> fpos_t, ++ >, ++ pub _write: ::std::option::Option< ++ unsafe extern "C" fn( ++ arg1: *mut ::std::os::raw::c_void, ++ arg2: *const ::std::os::raw::c_char, ++ arg3: ::std::os::raw::c_int, ++ ) -> ::std::os::raw::c_int, ++ >, ++ pub _ub: __sbuf, ++ pub _up: *mut ::std::os::raw::c_uchar, ++ pub _ur: ::std::os::raw::c_int, ++ pub _ubuf: [::std::os::raw::c_uchar; 3usize], ++ pub _nbuf: [::std::os::raw::c_uchar; 1usize], ++ pub _lb: __sbuf, ++ pub _blksize: ::std::os::raw::c_int, ++ pub _offset: fpos_t, ++ pub _fl_mutex: *mut pthread_mutex, ++ pub _fl_owner: *mut pthread, ++ pub _fl_count: ::std::os::raw::c_int, ++ pub _orientation: ::std::os::raw::c_int, ++ pub _mbstate: __mbstate_t, ++ pub _flags2: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __sFILE"][::std::mem::size_of::<__sFILE>() - 312usize]; ++ ["Alignment of __sFILE"][::std::mem::align_of::<__sFILE>() - 8usize]; ++ ["Offset of field: __sFILE::_p"] ++ [::std::mem::offset_of!(__sFILE, _p) - 0usize]; ++ ["Offset of field: __sFILE::_r"] ++ [::std::mem::offset_of!(__sFILE, _r) - 8usize]; ++ ["Offset of field: __sFILE::_w"] ++ [::std::mem::offset_of!(__sFILE, _w) - 12usize]; ++ ["Offset of field: __sFILE::_flags"] ++ [::std::mem::offset_of!(__sFILE, _flags) - 16usize]; ++ ["Offset of field: __sFILE::_file"] ++ [::std::mem::offset_of!(__sFILE, _file) - 18usize]; ++ ["Offset of field: __sFILE::_bf"] ++ [::std::mem::offset_of!(__sFILE, _bf) - 24usize]; ++ ["Offset of field: __sFILE::_lbfsize"] ++ [::std::mem::offset_of!(__sFILE, _lbfsize) - 40usize]; ++ ["Offset of field: __sFILE::_cookie"] ++ [::std::mem::offset_of!(__sFILE, _cookie) - 48usize]; ++ ["Offset of field: __sFILE::_close"] ++ [::std::mem::offset_of!(__sFILE, _close) - 56usize]; ++ ["Offset of field: __sFILE::_read"] ++ [::std::mem::offset_of!(__sFILE, _read) - 64usize]; ++ ["Offset of field: __sFILE::_seek"] ++ [::std::mem::offset_of!(__sFILE, _seek) - 72usize]; ++ ["Offset of field: __sFILE::_write"] ++ [::std::mem::offset_of!(__sFILE, _write) - 80usize]; ++ ["Offset of field: __sFILE::_ub"] ++ [::std::mem::offset_of!(__sFILE, _ub) - 88usize]; ++ ["Offset of field: __sFILE::_up"] ++ [::std::mem::offset_of!(__sFILE, _up) - 104usize]; ++ ["Offset of field: __sFILE::_ur"] ++ [::std::mem::offset_of!(__sFILE, _ur) - 112usize]; ++ ["Offset of field: __sFILE::_ubuf"] ++ [::std::mem::offset_of!(__sFILE, _ubuf) - 116usize]; ++ ["Offset of field: __sFILE::_nbuf"] ++ [::std::mem::offset_of!(__sFILE, _nbuf) - 119usize]; ++ ["Offset of field: __sFILE::_lb"] ++ [::std::mem::offset_of!(__sFILE, _lb) - 120usize]; ++ ["Offset of field: __sFILE::_blksize"] ++ [::std::mem::offset_of!(__sFILE, _blksize) - 136usize]; ++ ["Offset of field: __sFILE::_offset"] ++ [::std::mem::offset_of!(__sFILE, _offset) - 144usize]; ++ ["Offset of field: __sFILE::_fl_mutex"] ++ [::std::mem::offset_of!(__sFILE, _fl_mutex) - 152usize]; ++ ["Offset of field: __sFILE::_fl_owner"] ++ [::std::mem::offset_of!(__sFILE, _fl_owner) - 160usize]; ++ ["Offset of field: __sFILE::_fl_count"] ++ [::std::mem::offset_of!(__sFILE, _fl_count) - 168usize]; ++ ["Offset of field: __sFILE::_orientation"] ++ [::std::mem::offset_of!(__sFILE, _orientation) - 172usize]; ++ ["Offset of field: __sFILE::_mbstate"] ++ [::std::mem::offset_of!(__sFILE, _mbstate) - 176usize]; ++ ["Offset of field: __sFILE::_flags2"] ++ [::std::mem::offset_of!(__sFILE, _flags2) - 304usize]; ++}; ++pub type FILE = __sFILE; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv__queue { ++ pub next: *mut uv__queue, ++ pub prev: *mut uv__queue, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv__queue"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv__queue"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv__queue::next"] ++ [::std::mem::offset_of!(uv__queue, next) - 0usize]; ++ ["Offset of field: uv__queue::prev"] ++ [::std::mem::offset_of!(uv__queue, prev) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread { ++ _unused: [u8; 0], ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_cond { ++ _unused: [u8; 0], ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_mutex { ++ _unused: [u8; 0], ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_rwlock { ++ _unused: [u8; 0], ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_barrier { ++ _unused: [u8; 0], ++} ++pub type pthread_t = *mut pthread; ++pub type pthread_mutex_t = *mut pthread_mutex; ++pub type pthread_cond_t = *mut pthread_cond; ++pub type pthread_key_t = ::std::os::raw::c_int; ++pub type pthread_once_t = pthread_once; ++pub type pthread_rwlock_t = *mut pthread_rwlock; ++pub type pthread_barrier_t = *mut pthread_barrier; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_once { ++ pub state: ::std::os::raw::c_int, ++ pub mutex: pthread_mutex_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_once"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of pthread_once"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_once::state"] ++ [::std::mem::offset_of!(pthread_once, state) - 0usize]; ++ ["Offset of field: pthread_once::mutex"] ++ [::std::mem::offset_of!(pthread_once, mutex) - 8usize]; ++}; ++pub type gid_t = __gid_t; ++pub type in_addr_t = __uint32_t; ++pub type in_port_t = __uint16_t; ++pub type ino_t = __ino_t; ++pub type mode_t = __mode_t; ++pub type pid_t = __pid_t; ++pub type uid_t = __uid_t; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct dirent { ++ pub d_fileno: ino_t, ++ pub d_off: off_t, ++ pub d_reclen: __uint16_t, ++ pub d_type: __uint8_t, ++ pub d_pad0: __uint8_t, ++ pub d_namlen: __uint16_t, ++ pub d_pad1: __uint16_t, ++ pub d_name: [::std::os::raw::c_char; 256usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of dirent"][::std::mem::size_of::() - 280usize]; ++ ["Alignment of dirent"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: dirent::d_fileno"] ++ [::std::mem::offset_of!(dirent, d_fileno) - 0usize]; ++ ["Offset of field: dirent::d_off"] ++ [::std::mem::offset_of!(dirent, d_off) - 8usize]; ++ ["Offset of field: dirent::d_reclen"] ++ [::std::mem::offset_of!(dirent, d_reclen) - 16usize]; ++ ["Offset of field: dirent::d_type"] ++ [::std::mem::offset_of!(dirent, d_type) - 18usize]; ++ ["Offset of field: dirent::d_pad0"] ++ [::std::mem::offset_of!(dirent, d_pad0) - 19usize]; ++ ["Offset of field: dirent::d_namlen"] ++ [::std::mem::offset_of!(dirent, d_namlen) - 20usize]; ++ ["Offset of field: dirent::d_pad1"] ++ [::std::mem::offset_of!(dirent, d_pad1) - 22usize]; ++ ["Offset of field: dirent::d_name"] ++ [::std::mem::offset_of!(dirent, d_name) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct _dirdesc { ++ _unused: [u8; 0], ++} ++pub type DIR = _dirdesc; ++pub type sa_family_t = __sa_family_t; ++pub type socklen_t = __socklen_t; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct sockaddr { ++ pub sa_len: ::std::os::raw::c_uchar, ++ pub sa_family: sa_family_t, ++ pub sa_data: [::std::os::raw::c_char; 14usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sockaddr"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of sockaddr"][::std::mem::align_of::() - 1usize]; ++ ["Offset of field: sockaddr::sa_len"] ++ [::std::mem::offset_of!(sockaddr, sa_len) - 0usize]; ++ ["Offset of field: sockaddr::sa_family"] ++ [::std::mem::offset_of!(sockaddr, sa_family) - 1usize]; ++ ["Offset of field: sockaddr::sa_data"] ++ [::std::mem::offset_of!(sockaddr, sa_data) - 2usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct sockaddr_storage { ++ pub ss_len: ::std::os::raw::c_uchar, ++ pub ss_family: sa_family_t, ++ pub __ss_pad1: [::std::os::raw::c_char; 6usize], ++ pub __ss_align: __int64_t, ++ pub __ss_pad2: [::std::os::raw::c_char; 112usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sockaddr_storage"] ++ [::std::mem::size_of::() - 128usize]; ++ ["Alignment of sockaddr_storage"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: sockaddr_storage::ss_len"] ++ [::std::mem::offset_of!(sockaddr_storage, ss_len) - 0usize]; ++ ["Offset of field: sockaddr_storage::ss_family"] ++ [::std::mem::offset_of!(sockaddr_storage, ss_family) - 1usize]; ++ ["Offset of field: sockaddr_storage::__ss_pad1"] ++ [::std::mem::offset_of!(sockaddr_storage, __ss_pad1) - 2usize]; ++ ["Offset of field: sockaddr_storage::__ss_align"] ++ [::std::mem::offset_of!(sockaddr_storage, __ss_align) - 8usize]; ++ ["Offset of field: sockaddr_storage::__ss_pad2"] ++ [::std::mem::offset_of!(sockaddr_storage, __ss_pad2) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct in_addr { ++ pub s_addr: in_addr_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of in_addr"][::std::mem::size_of::() - 4usize]; ++ ["Alignment of in_addr"][::std::mem::align_of::() - 4usize]; ++ ["Offset of field: in_addr::s_addr"] ++ [::std::mem::offset_of!(in_addr, s_addr) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct sockaddr_in { ++ pub sin_len: u8, ++ pub sin_family: sa_family_t, ++ pub sin_port: in_port_t, ++ pub sin_addr: in_addr, ++ pub sin_zero: [::std::os::raw::c_char; 8usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sockaddr_in"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of sockaddr_in"][::std::mem::align_of::() - 4usize]; ++ ["Offset of field: sockaddr_in::sin_len"] ++ [::std::mem::offset_of!(sockaddr_in, sin_len) - 0usize]; ++ ["Offset of field: sockaddr_in::sin_family"] ++ [::std::mem::offset_of!(sockaddr_in, sin_family) - 1usize]; ++ ["Offset of field: sockaddr_in::sin_port"] ++ [::std::mem::offset_of!(sockaddr_in, sin_port) - 2usize]; ++ ["Offset of field: sockaddr_in::sin_addr"] ++ [::std::mem::offset_of!(sockaddr_in, sin_addr) - 4usize]; ++ ["Offset of field: sockaddr_in::sin_zero"] ++ [::std::mem::offset_of!(sockaddr_in, sin_zero) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct in6_addr { ++ pub __u6_addr: in6_addr__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union in6_addr__bindgen_ty_1 { ++ pub __u6_addr8: [u8; 16usize], ++ pub __u6_addr16: [u16; 8usize], ++ pub __u6_addr32: [u32; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of in6_addr__bindgen_ty_1"] ++ [::std::mem::size_of::() - 16usize]; ++ ["Alignment of in6_addr__bindgen_ty_1"] ++ [::std::mem::align_of::() - 4usize]; ++ ["Offset of field: in6_addr__bindgen_ty_1::__u6_addr8"] ++ [::std::mem::offset_of!(in6_addr__bindgen_ty_1, __u6_addr8) - 0usize]; ++ ["Offset of field: in6_addr__bindgen_ty_1::__u6_addr16"] ++ [::std::mem::offset_of!(in6_addr__bindgen_ty_1, __u6_addr16) - 0usize]; ++ ["Offset of field: in6_addr__bindgen_ty_1::__u6_addr32"] ++ [::std::mem::offset_of!(in6_addr__bindgen_ty_1, __u6_addr32) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of in6_addr"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of in6_addr"][::std::mem::align_of::() - 4usize]; ++ ["Offset of field: in6_addr::__u6_addr"] ++ [::std::mem::offset_of!(in6_addr, __u6_addr) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct sockaddr_in6 { ++ pub sin6_len: u8, ++ pub sin6_family: sa_family_t, ++ pub sin6_port: in_port_t, ++ pub sin6_flowinfo: u32, ++ pub sin6_addr: in6_addr, ++ pub sin6_scope_id: u32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sockaddr_in6"][::std::mem::size_of::() - 28usize]; ++ ["Alignment of sockaddr_in6"] ++ [::std::mem::align_of::() - 4usize]; ++ ["Offset of field: sockaddr_in6::sin6_len"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_len) - 0usize]; ++ ["Offset of field: sockaddr_in6::sin6_family"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_family) - 1usize]; ++ ["Offset of field: sockaddr_in6::sin6_port"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_port) - 2usize]; ++ ["Offset of field: sockaddr_in6::sin6_flowinfo"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_flowinfo) - 4usize]; ++ ["Offset of field: sockaddr_in6::sin6_addr"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_addr) - 8usize]; ++ ["Offset of field: sockaddr_in6::sin6_scope_id"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_scope_id) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct addrinfo { ++ pub ai_flags: ::std::os::raw::c_int, ++ pub ai_family: ::std::os::raw::c_int, ++ pub ai_socktype: ::std::os::raw::c_int, ++ pub ai_protocol: ::std::os::raw::c_int, ++ pub ai_addrlen: socklen_t, ++ pub ai_canonname: *mut ::std::os::raw::c_char, ++ pub ai_addr: *mut sockaddr, ++ pub ai_next: *mut addrinfo, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of addrinfo"][::std::mem::size_of::() - 48usize]; ++ ["Alignment of addrinfo"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: addrinfo::ai_flags"] ++ [::std::mem::offset_of!(addrinfo, ai_flags) - 0usize]; ++ ["Offset of field: addrinfo::ai_family"] ++ [::std::mem::offset_of!(addrinfo, ai_family) - 4usize]; ++ ["Offset of field: addrinfo::ai_socktype"] ++ [::std::mem::offset_of!(addrinfo, ai_socktype) - 8usize]; ++ ["Offset of field: addrinfo::ai_protocol"] ++ [::std::mem::offset_of!(addrinfo, ai_protocol) - 12usize]; ++ ["Offset of field: addrinfo::ai_addrlen"] ++ [::std::mem::offset_of!(addrinfo, ai_addrlen) - 16usize]; ++ ["Offset of field: addrinfo::ai_canonname"] ++ [::std::mem::offset_of!(addrinfo, ai_canonname) - 24usize]; ++ ["Offset of field: addrinfo::ai_addr"] ++ [::std::mem::offset_of!(addrinfo, ai_addr) - 32usize]; ++ ["Offset of field: addrinfo::ai_next"] ++ [::std::mem::offset_of!(addrinfo, ai_next) - 40usize]; ++}; ++pub type tcflag_t = ::std::os::raw::c_uint; ++pub type cc_t = ::std::os::raw::c_uchar; ++pub type speed_t = ::std::os::raw::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct termios { ++ pub c_iflag: tcflag_t, ++ pub c_oflag: tcflag_t, ++ pub c_cflag: tcflag_t, ++ pub c_lflag: tcflag_t, ++ pub c_cc: [cc_t; 20usize], ++ pub c_ispeed: speed_t, ++ pub c_ospeed: speed_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of termios"][::std::mem::size_of::() - 44usize]; ++ ["Alignment of termios"][::std::mem::align_of::() - 4usize]; ++ ["Offset of field: termios::c_iflag"] ++ [::std::mem::offset_of!(termios, c_iflag) - 0usize]; ++ ["Offset of field: termios::c_oflag"] ++ [::std::mem::offset_of!(termios, c_oflag) - 4usize]; ++ ["Offset of field: termios::c_cflag"] ++ [::std::mem::offset_of!(termios, c_cflag) - 8usize]; ++ ["Offset of field: termios::c_lflag"] ++ [::std::mem::offset_of!(termios, c_lflag) - 12usize]; ++ ["Offset of field: termios::c_cc"] ++ [::std::mem::offset_of!(termios, c_cc) - 16usize]; ++ ["Offset of field: termios::c_ispeed"] ++ [::std::mem::offset_of!(termios, c_ispeed) - 36usize]; ++ ["Offset of field: termios::c_ospeed"] ++ [::std::mem::offset_of!(termios, c_ospeed) - 40usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct _usem2 { ++ pub _count: __uint32_t, ++ pub _flags: __uint32_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of _usem2"][::std::mem::size_of::<_usem2>() - 8usize]; ++ ["Alignment of _usem2"][::std::mem::align_of::<_usem2>() - 4usize]; ++ ["Offset of field: _usem2::_count"] ++ [::std::mem::offset_of!(_usem2, _count) - 0usize]; ++ ["Offset of field: _usem2::_flags"] ++ [::std::mem::offset_of!(_usem2, _flags) - 4usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct _sem { ++ pub _magic: __uint32_t, ++ pub _kern: _usem2, ++ pub _padding: __uint32_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of _sem"][::std::mem::size_of::<_sem>() - 16usize]; ++ ["Alignment of _sem"][::std::mem::align_of::<_sem>() - 4usize]; ++ ["Offset of field: _sem::_magic"] ++ [::std::mem::offset_of!(_sem, _magic) - 0usize]; ++ ["Offset of field: _sem::_kern"] ++ [::std::mem::offset_of!(_sem, _kern) - 4usize]; ++ ["Offset of field: _sem::_padding"] ++ [::std::mem::offset_of!(_sem, _padding) - 12usize]; ++}; ++pub type sem_t = _sem; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv__work { ++ pub work: ::std::option::Option, ++ pub done: ::std::option::Option< ++ unsafe extern "C" fn(w: *mut uv__work, status: ::std::os::raw::c_int), ++ >, ++ pub loop_: *mut uv_loop_s, ++ pub wq: uv__queue, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv__work"][::std::mem::size_of::() - 40usize]; ++ ["Alignment of uv__work"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv__work::work"] ++ [::std::mem::offset_of!(uv__work, work) - 0usize]; ++ ["Offset of field: uv__work::done"] ++ [::std::mem::offset_of!(uv__work, done) - 8usize]; ++ ["Offset of field: uv__work::loop_"] ++ [::std::mem::offset_of!(uv__work, loop_) - 16usize]; ++ ["Offset of field: uv__work::wq"] ++ [::std::mem::offset_of!(uv__work, wq) - 24usize]; ++}; ++pub type uv__io_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ loop_: *mut uv_loop_s, ++ w: *mut uv__io_s, ++ events: ::std::os::raw::c_uint, ++ ), ++>; ++pub type uv__io_t = uv__io_s; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv__io_s { ++ pub cb: uv__io_cb, ++ pub pending_queue: uv__queue, ++ pub watcher_queue: uv__queue, ++ pub pevents: ::std::os::raw::c_uint, ++ pub events: ::std::os::raw::c_uint, ++ pub fd: ::std::os::raw::c_int, ++ pub rcount: ::std::os::raw::c_int, ++ pub wcount: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv__io_s"][::std::mem::size_of::() - 64usize]; ++ ["Alignment of uv__io_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv__io_s::cb"] ++ [::std::mem::offset_of!(uv__io_s, cb) - 0usize]; ++ ["Offset of field: uv__io_s::pending_queue"] ++ [::std::mem::offset_of!(uv__io_s, pending_queue) - 8usize]; ++ ["Offset of field: uv__io_s::watcher_queue"] ++ [::std::mem::offset_of!(uv__io_s, watcher_queue) - 24usize]; ++ ["Offset of field: uv__io_s::pevents"] ++ [::std::mem::offset_of!(uv__io_s, pevents) - 40usize]; ++ ["Offset of field: uv__io_s::events"] ++ [::std::mem::offset_of!(uv__io_s, events) - 44usize]; ++ ["Offset of field: uv__io_s::fd"] ++ [::std::mem::offset_of!(uv__io_s, fd) - 48usize]; ++ ["Offset of field: uv__io_s::rcount"] ++ [::std::mem::offset_of!(uv__io_s, rcount) - 52usize]; ++ ["Offset of field: uv__io_s::wcount"] ++ [::std::mem::offset_of!(uv__io_s, wcount) - 56usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_buf_t { ++ pub base: *mut ::std::os::raw::c_char, ++ pub len: usize, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_buf_t"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_buf_t"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_buf_t::base"] ++ [::std::mem::offset_of!(uv_buf_t, base) - 0usize]; ++ ["Offset of field: uv_buf_t::len"] ++ [::std::mem::offset_of!(uv_buf_t, len) - 8usize]; ++}; ++pub type uv_file = ::std::os::raw::c_int; ++pub type uv_os_sock_t = ::std::os::raw::c_int; ++pub type uv_os_fd_t = ::std::os::raw::c_int; ++pub type uv_pid_t = pid_t; ++pub type uv_once_t = pthread_once_t; ++pub type uv_thread_t = pthread_t; ++pub type uv_mutex_t = pthread_mutex_t; ++pub type uv_rwlock_t = pthread_rwlock_t; ++pub type uv_sem_t = sem_t; ++pub type uv_cond_t = pthread_cond_t; ++pub type uv_key_t = pthread_key_t; ++pub type uv_barrier_t = pthread_barrier_t; ++pub type uv_gid_t = gid_t; ++pub type uv_uid_t = uid_t; ++pub type uv__dirent_t = dirent; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_lib_t { ++ pub handle: *mut ::std::os::raw::c_void, ++ pub errmsg: *mut ::std::os::raw::c_char, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_lib_t"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_lib_t"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_lib_t::handle"] ++ [::std::mem::offset_of!(uv_lib_t, handle) - 0usize]; ++ ["Offset of field: uv_lib_t::errmsg"] ++ [::std::mem::offset_of!(uv_lib_t, errmsg) - 8usize]; ++}; ++impl uv_errno_t { ++ pub const UV_E2BIG: uv_errno_t = uv_errno_t(-7); ++} ++impl uv_errno_t { ++ pub const UV_EACCES: uv_errno_t = uv_errno_t(-13); ++} ++impl uv_errno_t { ++ pub const UV_EADDRINUSE: uv_errno_t = uv_errno_t(-48); ++} ++impl uv_errno_t { ++ pub const UV_EADDRNOTAVAIL: uv_errno_t = uv_errno_t(-49); ++} ++impl uv_errno_t { ++ pub const UV_EAFNOSUPPORT: uv_errno_t = uv_errno_t(-47); ++} ++impl uv_errno_t { ++ pub const UV_EAGAIN: uv_errno_t = uv_errno_t(-35); ++} ++impl uv_errno_t { ++ pub const UV_EAI_ADDRFAMILY: uv_errno_t = uv_errno_t(-3000); ++} ++impl uv_errno_t { ++ pub const UV_EAI_AGAIN: uv_errno_t = uv_errno_t(-3001); ++} ++impl uv_errno_t { ++ pub const UV_EAI_BADFLAGS: uv_errno_t = uv_errno_t(-3002); ++} ++impl uv_errno_t { ++ pub const UV_EAI_BADHINTS: uv_errno_t = uv_errno_t(-3013); ++} ++impl uv_errno_t { ++ pub const UV_EAI_CANCELED: uv_errno_t = uv_errno_t(-3003); ++} ++impl uv_errno_t { ++ pub const UV_EAI_FAIL: uv_errno_t = uv_errno_t(-3004); ++} ++impl uv_errno_t { ++ pub const UV_EAI_FAMILY: uv_errno_t = uv_errno_t(-3005); ++} ++impl uv_errno_t { ++ pub const UV_EAI_MEMORY: uv_errno_t = uv_errno_t(-3006); ++} ++impl uv_errno_t { ++ pub const UV_EAI_NODATA: uv_errno_t = uv_errno_t(-3007); ++} ++impl uv_errno_t { ++ pub const UV_EAI_NONAME: uv_errno_t = uv_errno_t(-3008); ++} ++impl uv_errno_t { ++ pub const UV_EAI_OVERFLOW: uv_errno_t = uv_errno_t(-3009); ++} ++impl uv_errno_t { ++ pub const UV_EAI_PROTOCOL: uv_errno_t = uv_errno_t(-3014); ++} ++impl uv_errno_t { ++ pub const UV_EAI_SERVICE: uv_errno_t = uv_errno_t(-3010); ++} ++impl uv_errno_t { ++ pub const UV_EAI_SOCKTYPE: uv_errno_t = uv_errno_t(-3011); ++} ++impl uv_errno_t { ++ pub const UV_EALREADY: uv_errno_t = uv_errno_t(-37); ++} ++impl uv_errno_t { ++ pub const UV_EBADF: uv_errno_t = uv_errno_t(-9); ++} ++impl uv_errno_t { ++ pub const UV_EBUSY: uv_errno_t = uv_errno_t(-16); ++} ++impl uv_errno_t { ++ pub const UV_ECANCELED: uv_errno_t = uv_errno_t(-85); ++} ++impl uv_errno_t { ++ pub const UV_ECHARSET: uv_errno_t = uv_errno_t(-4080); ++} ++impl uv_errno_t { ++ pub const UV_ECONNABORTED: uv_errno_t = uv_errno_t(-53); ++} ++impl uv_errno_t { ++ pub const UV_ECONNREFUSED: uv_errno_t = uv_errno_t(-61); ++} ++impl uv_errno_t { ++ pub const UV_ECONNRESET: uv_errno_t = uv_errno_t(-54); ++} ++impl uv_errno_t { ++ pub const UV_EDESTADDRREQ: uv_errno_t = uv_errno_t(-39); ++} ++impl uv_errno_t { ++ pub const UV_EEXIST: uv_errno_t = uv_errno_t(-17); ++} ++impl uv_errno_t { ++ pub const UV_EFAULT: uv_errno_t = uv_errno_t(-14); ++} ++impl uv_errno_t { ++ pub const UV_EFBIG: uv_errno_t = uv_errno_t(-27); ++} ++impl uv_errno_t { ++ pub const UV_EHOSTUNREACH: uv_errno_t = uv_errno_t(-65); ++} ++impl uv_errno_t { ++ pub const UV_EINTR: uv_errno_t = uv_errno_t(-4); ++} ++impl uv_errno_t { ++ pub const UV_EINVAL: uv_errno_t = uv_errno_t(-22); ++} ++impl uv_errno_t { ++ pub const UV_EIO: uv_errno_t = uv_errno_t(-5); ++} ++impl uv_errno_t { ++ pub const UV_EISCONN: uv_errno_t = uv_errno_t(-56); ++} ++impl uv_errno_t { ++ pub const UV_EISDIR: uv_errno_t = uv_errno_t(-21); ++} ++impl uv_errno_t { ++ pub const UV_ELOOP: uv_errno_t = uv_errno_t(-62); ++} ++impl uv_errno_t { ++ pub const UV_EMFILE: uv_errno_t = uv_errno_t(-24); ++} ++impl uv_errno_t { ++ pub const UV_EMSGSIZE: uv_errno_t = uv_errno_t(-40); ++} ++impl uv_errno_t { ++ pub const UV_ENAMETOOLONG: uv_errno_t = uv_errno_t(-63); ++} ++impl uv_errno_t { ++ pub const UV_ENETDOWN: uv_errno_t = uv_errno_t(-50); ++} ++impl uv_errno_t { ++ pub const UV_ENETUNREACH: uv_errno_t = uv_errno_t(-51); ++} ++impl uv_errno_t { ++ pub const UV_ENFILE: uv_errno_t = uv_errno_t(-23); ++} ++impl uv_errno_t { ++ pub const UV_ENOBUFS: uv_errno_t = uv_errno_t(-55); ++} ++impl uv_errno_t { ++ pub const UV_ENODEV: uv_errno_t = uv_errno_t(-19); ++} ++impl uv_errno_t { ++ pub const UV_ENOENT: uv_errno_t = uv_errno_t(-2); ++} ++impl uv_errno_t { ++ pub const UV_ENOMEM: uv_errno_t = uv_errno_t(-12); ++} ++impl uv_errno_t { ++ pub const UV_ENONET: uv_errno_t = uv_errno_t(-4056); ++} ++impl uv_errno_t { ++ pub const UV_ENOPROTOOPT: uv_errno_t = uv_errno_t(-42); ++} ++impl uv_errno_t { ++ pub const UV_ENOSPC: uv_errno_t = uv_errno_t(-28); ++} ++impl uv_errno_t { ++ pub const UV_ENOSYS: uv_errno_t = uv_errno_t(-78); ++} ++impl uv_errno_t { ++ pub const UV_ENOTCONN: uv_errno_t = uv_errno_t(-57); ++} ++impl uv_errno_t { ++ pub const UV_ENOTDIR: uv_errno_t = uv_errno_t(-20); ++} ++impl uv_errno_t { ++ pub const UV_ENOTEMPTY: uv_errno_t = uv_errno_t(-66); ++} ++impl uv_errno_t { ++ pub const UV_ENOTSOCK: uv_errno_t = uv_errno_t(-38); ++} ++impl uv_errno_t { ++ pub const UV_ENOTSUP: uv_errno_t = uv_errno_t(-45); ++} ++impl uv_errno_t { ++ pub const UV_EOVERFLOW: uv_errno_t = uv_errno_t(-84); ++} ++impl uv_errno_t { ++ pub const UV_EPERM: uv_errno_t = uv_errno_t(-1); ++} ++impl uv_errno_t { ++ pub const UV_EPIPE: uv_errno_t = uv_errno_t(-32); ++} ++impl uv_errno_t { ++ pub const UV_EPROTO: uv_errno_t = uv_errno_t(-92); ++} ++impl uv_errno_t { ++ pub const UV_EPROTONOSUPPORT: uv_errno_t = uv_errno_t(-43); ++} ++impl uv_errno_t { ++ pub const UV_EPROTOTYPE: uv_errno_t = uv_errno_t(-41); ++} ++impl uv_errno_t { ++ pub const UV_ERANGE: uv_errno_t = uv_errno_t(-34); ++} ++impl uv_errno_t { ++ pub const UV_EROFS: uv_errno_t = uv_errno_t(-30); ++} ++impl uv_errno_t { ++ pub const UV_ESHUTDOWN: uv_errno_t = uv_errno_t(-58); ++} ++impl uv_errno_t { ++ pub const UV_ESPIPE: uv_errno_t = uv_errno_t(-29); ++} ++impl uv_errno_t { ++ pub const UV_ESRCH: uv_errno_t = uv_errno_t(-3); ++} ++impl uv_errno_t { ++ pub const UV_ETIMEDOUT: uv_errno_t = uv_errno_t(-60); ++} ++impl uv_errno_t { ++ pub const UV_ETXTBSY: uv_errno_t = uv_errno_t(-26); ++} ++impl uv_errno_t { ++ pub const UV_EXDEV: uv_errno_t = uv_errno_t(-18); ++} ++impl uv_errno_t { ++ pub const UV_UNKNOWN: uv_errno_t = uv_errno_t(-4094); ++} ++impl uv_errno_t { ++ pub const UV_EOF: uv_errno_t = uv_errno_t(-4095); ++} ++impl uv_errno_t { ++ pub const UV_ENXIO: uv_errno_t = uv_errno_t(-6); ++} ++impl uv_errno_t { ++ pub const UV_EMLINK: uv_errno_t = uv_errno_t(-31); ++} ++impl uv_errno_t { ++ pub const UV_EHOSTDOWN: uv_errno_t = uv_errno_t(-64); ++} ++impl uv_errno_t { ++ pub const UV_EREMOTEIO: uv_errno_t = uv_errno_t(-4030); ++} ++impl uv_errno_t { ++ pub const UV_ENOTTY: uv_errno_t = uv_errno_t(-25); ++} ++impl uv_errno_t { ++ pub const UV_EFTYPE: uv_errno_t = uv_errno_t(-79); ++} ++impl uv_errno_t { ++ pub const UV_EILSEQ: uv_errno_t = uv_errno_t(-86); ++} ++impl uv_errno_t { ++ pub const UV_ESOCKTNOSUPPORT: uv_errno_t = uv_errno_t(-44); ++} ++impl uv_errno_t { ++ pub const UV_ENODATA: uv_errno_t = uv_errno_t(-9919); ++} ++impl uv_errno_t { ++ pub const UV_EUNATCH: uv_errno_t = uv_errno_t(-4023); ++} ++impl uv_errno_t { ++ pub const UV_ERRNO_MAX: uv_errno_t = uv_errno_t(-4096); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_errno_t(pub ::std::os::raw::c_int); ++impl uv_handle_type { ++ pub const UV_UNKNOWN_HANDLE: uv_handle_type = uv_handle_type(0); ++} ++impl uv_handle_type { ++ pub const UV_ASYNC: uv_handle_type = uv_handle_type(1); ++} ++impl uv_handle_type { ++ pub const UV_CHECK: uv_handle_type = uv_handle_type(2); ++} ++impl uv_handle_type { ++ pub const UV_FS_EVENT: uv_handle_type = uv_handle_type(3); ++} ++impl uv_handle_type { ++ pub const UV_FS_POLL: uv_handle_type = uv_handle_type(4); ++} ++impl uv_handle_type { ++ pub const UV_HANDLE: uv_handle_type = uv_handle_type(5); ++} ++impl uv_handle_type { ++ pub const UV_IDLE: uv_handle_type = uv_handle_type(6); ++} ++impl uv_handle_type { ++ pub const UV_NAMED_PIPE: uv_handle_type = uv_handle_type(7); ++} ++impl uv_handle_type { ++ pub const UV_POLL: uv_handle_type = uv_handle_type(8); ++} ++impl uv_handle_type { ++ pub const UV_PREPARE: uv_handle_type = uv_handle_type(9); ++} ++impl uv_handle_type { ++ pub const UV_PROCESS: uv_handle_type = uv_handle_type(10); ++} ++impl uv_handle_type { ++ pub const UV_STREAM: uv_handle_type = uv_handle_type(11); ++} ++impl uv_handle_type { ++ pub const UV_TCP: uv_handle_type = uv_handle_type(12); ++} ++impl uv_handle_type { ++ pub const UV_TIMER: uv_handle_type = uv_handle_type(13); ++} ++impl uv_handle_type { ++ pub const UV_TTY: uv_handle_type = uv_handle_type(14); ++} ++impl uv_handle_type { ++ pub const UV_UDP: uv_handle_type = uv_handle_type(15); ++} ++impl uv_handle_type { ++ pub const UV_SIGNAL: uv_handle_type = uv_handle_type(16); ++} ++impl uv_handle_type { ++ pub const UV_FILE: uv_handle_type = uv_handle_type(17); ++} ++impl uv_handle_type { ++ pub const UV_HANDLE_TYPE_MAX: uv_handle_type = uv_handle_type(18); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_handle_type(pub ::std::os::raw::c_uint); ++impl uv_req_type { ++ pub const UV_UNKNOWN_REQ: uv_req_type = uv_req_type(0); ++} ++impl uv_req_type { ++ pub const UV_REQ: uv_req_type = uv_req_type(1); ++} ++impl uv_req_type { ++ pub const UV_CONNECT: uv_req_type = uv_req_type(2); ++} ++impl uv_req_type { ++ pub const UV_WRITE: uv_req_type = uv_req_type(3); ++} ++impl uv_req_type { ++ pub const UV_SHUTDOWN: uv_req_type = uv_req_type(4); ++} ++impl uv_req_type { ++ pub const UV_UDP_SEND: uv_req_type = uv_req_type(5); ++} ++impl uv_req_type { ++ pub const UV_FS: uv_req_type = uv_req_type(6); ++} ++impl uv_req_type { ++ pub const UV_WORK: uv_req_type = uv_req_type(7); ++} ++impl uv_req_type { ++ pub const UV_GETADDRINFO: uv_req_type = uv_req_type(8); ++} ++impl uv_req_type { ++ pub const UV_GETNAMEINFO: uv_req_type = uv_req_type(9); ++} ++impl uv_req_type { ++ pub const UV_RANDOM: uv_req_type = uv_req_type(10); ++} ++impl uv_req_type { ++ pub const UV_REQ_TYPE_MAX: uv_req_type = uv_req_type(11); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_req_type(pub ::std::os::raw::c_uint); ++pub type uv_loop_t = uv_loop_s; ++pub type uv_handle_t = uv_handle_s; ++pub type uv_dir_t = uv_dir_s; ++pub type uv_stream_t = uv_stream_s; ++pub type uv_tcp_t = uv_tcp_s; ++pub type uv_udp_t = uv_udp_s; ++pub type uv_pipe_t = uv_pipe_s; ++pub type uv_tty_t = uv_tty_s; ++pub type uv_poll_t = uv_poll_s; ++pub type uv_timer_t = uv_timer_s; ++pub type uv_prepare_t = uv_prepare_s; ++pub type uv_check_t = uv_check_s; ++pub type uv_idle_t = uv_idle_s; ++pub type uv_async_t = uv_async_s; ++pub type uv_process_t = uv_process_s; ++pub type uv_fs_event_t = uv_fs_event_s; ++pub type uv_fs_poll_t = uv_fs_poll_s; ++pub type uv_signal_t = uv_signal_s; ++pub type uv_req_t = uv_req_s; ++pub type uv_getaddrinfo_t = uv_getaddrinfo_s; ++pub type uv_getnameinfo_t = uv_getnameinfo_s; ++pub type uv_shutdown_t = uv_shutdown_s; ++pub type uv_write_t = uv_write_s; ++pub type uv_connect_t = uv_connect_s; ++pub type uv_udp_send_t = uv_udp_send_s; ++pub type uv_fs_t = uv_fs_s; ++pub type uv_work_t = uv_work_s; ++pub type uv_random_t = uv_random_s; ++pub type uv_env_item_t = uv_env_item_s; ++pub type uv_cpu_info_t = uv_cpu_info_s; ++pub type uv_interface_address_t = uv_interface_address_s; ++pub type uv_dirent_t = uv_dirent_s; ++pub type uv_passwd_t = uv_passwd_s; ++pub type uv_group_t = uv_group_s; ++pub type uv_utsname_t = uv_utsname_s; ++pub type uv_statfs_t = uv_statfs_s; ++pub type uv_metrics_t = uv_metrics_s; ++impl uv_loop_option { ++ pub const UV_LOOP_BLOCK_SIGNAL: uv_loop_option = uv_loop_option(0); ++} ++impl uv_loop_option { ++ pub const UV_METRICS_IDLE_TIME: uv_loop_option = uv_loop_option(1); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_loop_option(pub ::std::os::raw::c_uint); ++impl uv_run_mode { ++ pub const UV_RUN_DEFAULT: uv_run_mode = uv_run_mode(0); ++} ++impl uv_run_mode { ++ pub const UV_RUN_ONCE: uv_run_mode = uv_run_mode(1); ++} ++impl uv_run_mode { ++ pub const UV_RUN_NOWAIT: uv_run_mode = uv_run_mode(2); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_run_mode(pub ::std::os::raw::c_uint); ++pub type uv_malloc_func = ::std::option::Option< ++ unsafe extern "C" fn(size: usize) -> *mut ::std::os::raw::c_void, ++>; ++pub type uv_realloc_func = ::std::option::Option< ++ unsafe extern "C" fn( ++ ptr: *mut ::std::os::raw::c_void, ++ size: usize, ++ ) -> *mut ::std::os::raw::c_void, ++>; ++pub type uv_calloc_func = ::std::option::Option< ++ unsafe extern "C" fn( ++ count: usize, ++ size: usize, ++ ) -> *mut ::std::os::raw::c_void, ++>; ++pub type uv_free_func = ++ ::std::option::Option; ++pub type uv_alloc_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ handle: *mut uv_handle_t, ++ suggested_size: usize, ++ buf: *mut uv_buf_t, ++ ), ++>; ++pub type uv_read_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ stream: *mut uv_stream_t, ++ nread: isize, ++ buf: *const uv_buf_t, ++ ), ++>; ++pub type uv_write_cb = ::std::option::Option< ++ unsafe extern "C" fn(req: *mut uv_write_t, status: ::std::os::raw::c_int), ++>; ++pub type uv_connect_cb = ::std::option::Option< ++ unsafe extern "C" fn(req: *mut uv_connect_t, status: ::std::os::raw::c_int), ++>; ++pub type uv_shutdown_cb = ::std::option::Option< ++ unsafe extern "C" fn(req: *mut uv_shutdown_t, status: ::std::os::raw::c_int), ++>; ++pub type uv_connection_cb = ::std::option::Option< ++ unsafe extern "C" fn(server: *mut uv_stream_t, status: ::std::os::raw::c_int), ++>; ++pub type uv_close_cb = ++ ::std::option::Option; ++pub type uv_poll_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ handle: *mut uv_poll_t, ++ status: ::std::os::raw::c_int, ++ events: ::std::os::raw::c_int, ++ ), ++>; ++pub type uv_timer_cb = ++ ::std::option::Option; ++pub type uv_async_cb = ++ ::std::option::Option; ++pub type uv_prepare_cb = ++ ::std::option::Option; ++pub type uv_check_cb = ++ ::std::option::Option; ++pub type uv_idle_cb = ++ ::std::option::Option; ++pub type uv_exit_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ arg1: *mut uv_process_t, ++ exit_status: i64, ++ term_signal: ::std::os::raw::c_int, ++ ), ++>; ++pub type uv_walk_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ handle: *mut uv_handle_t, ++ arg: *mut ::std::os::raw::c_void, ++ ), ++>; ++pub type uv_fs_cb = ++ ::std::option::Option; ++pub type uv_work_cb = ++ ::std::option::Option; ++pub type uv_after_work_cb = ::std::option::Option< ++ unsafe extern "C" fn(req: *mut uv_work_t, status: ::std::os::raw::c_int), ++>; ++pub type uv_getaddrinfo_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ req: *mut uv_getaddrinfo_t, ++ status: ::std::os::raw::c_int, ++ res: *mut addrinfo, ++ ), ++>; ++pub type uv_getnameinfo_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ req: *mut uv_getnameinfo_t, ++ status: ::std::os::raw::c_int, ++ hostname: *const ::std::os::raw::c_char, ++ service: *const ::std::os::raw::c_char, ++ ), ++>; ++pub type uv_random_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ req: *mut uv_random_t, ++ status: ::std::os::raw::c_int, ++ buf: *mut ::std::os::raw::c_void, ++ buflen: usize, ++ ), ++>; ++impl uv_clock_id { ++ pub const UV_CLOCK_MONOTONIC: uv_clock_id = uv_clock_id(0); ++} ++impl uv_clock_id { ++ pub const UV_CLOCK_REALTIME: uv_clock_id = uv_clock_id(1); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_clock_id(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_timespec_t { ++ pub tv_sec: ::std::os::raw::c_long, ++ pub tv_nsec: ::std::os::raw::c_long, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_timespec_t"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_timespec_t"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_timespec_t::tv_sec"] ++ [::std::mem::offset_of!(uv_timespec_t, tv_sec) - 0usize]; ++ ["Offset of field: uv_timespec_t::tv_nsec"] ++ [::std::mem::offset_of!(uv_timespec_t, tv_nsec) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_timespec64_t { ++ pub tv_sec: i64, ++ pub tv_nsec: i32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_timespec64_t"] ++ [::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_timespec64_t"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_timespec64_t::tv_sec"] ++ [::std::mem::offset_of!(uv_timespec64_t, tv_sec) - 0usize]; ++ ["Offset of field: uv_timespec64_t::tv_nsec"] ++ [::std::mem::offset_of!(uv_timespec64_t, tv_nsec) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_timeval_t { ++ pub tv_sec: ::std::os::raw::c_long, ++ pub tv_usec: ::std::os::raw::c_long, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_timeval_t"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_timeval_t"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_timeval_t::tv_sec"] ++ [::std::mem::offset_of!(uv_timeval_t, tv_sec) - 0usize]; ++ ["Offset of field: uv_timeval_t::tv_usec"] ++ [::std::mem::offset_of!(uv_timeval_t, tv_usec) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_timeval64_t { ++ pub tv_sec: i64, ++ pub tv_usec: i32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_timeval64_t"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_timeval64_t"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_timeval64_t::tv_sec"] ++ [::std::mem::offset_of!(uv_timeval64_t, tv_sec) - 0usize]; ++ ["Offset of field: uv_timeval64_t::tv_usec"] ++ [::std::mem::offset_of!(uv_timeval64_t, tv_usec) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_stat_t { ++ pub st_dev: u64, ++ pub st_mode: u64, ++ pub st_nlink: u64, ++ pub st_uid: u64, ++ pub st_gid: u64, ++ pub st_rdev: u64, ++ pub st_ino: u64, ++ pub st_size: u64, ++ pub st_blksize: u64, ++ pub st_blocks: u64, ++ pub st_flags: u64, ++ pub st_gen: u64, ++ pub st_atim: uv_timespec_t, ++ pub st_mtim: uv_timespec_t, ++ pub st_ctim: uv_timespec_t, ++ pub st_birthtim: uv_timespec_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_stat_t"][::std::mem::size_of::() - 160usize]; ++ ["Alignment of uv_stat_t"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_stat_t::st_dev"] ++ [::std::mem::offset_of!(uv_stat_t, st_dev) - 0usize]; ++ ["Offset of field: uv_stat_t::st_mode"] ++ [::std::mem::offset_of!(uv_stat_t, st_mode) - 8usize]; ++ ["Offset of field: uv_stat_t::st_nlink"] ++ [::std::mem::offset_of!(uv_stat_t, st_nlink) - 16usize]; ++ ["Offset of field: uv_stat_t::st_uid"] ++ [::std::mem::offset_of!(uv_stat_t, st_uid) - 24usize]; ++ ["Offset of field: uv_stat_t::st_gid"] ++ [::std::mem::offset_of!(uv_stat_t, st_gid) - 32usize]; ++ ["Offset of field: uv_stat_t::st_rdev"] ++ [::std::mem::offset_of!(uv_stat_t, st_rdev) - 40usize]; ++ ["Offset of field: uv_stat_t::st_ino"] ++ [::std::mem::offset_of!(uv_stat_t, st_ino) - 48usize]; ++ ["Offset of field: uv_stat_t::st_size"] ++ [::std::mem::offset_of!(uv_stat_t, st_size) - 56usize]; ++ ["Offset of field: uv_stat_t::st_blksize"] ++ [::std::mem::offset_of!(uv_stat_t, st_blksize) - 64usize]; ++ ["Offset of field: uv_stat_t::st_blocks"] ++ [::std::mem::offset_of!(uv_stat_t, st_blocks) - 72usize]; ++ ["Offset of field: uv_stat_t::st_flags"] ++ [::std::mem::offset_of!(uv_stat_t, st_flags) - 80usize]; ++ ["Offset of field: uv_stat_t::st_gen"] ++ [::std::mem::offset_of!(uv_stat_t, st_gen) - 88usize]; ++ ["Offset of field: uv_stat_t::st_atim"] ++ [::std::mem::offset_of!(uv_stat_t, st_atim) - 96usize]; ++ ["Offset of field: uv_stat_t::st_mtim"] ++ [::std::mem::offset_of!(uv_stat_t, st_mtim) - 112usize]; ++ ["Offset of field: uv_stat_t::st_ctim"] ++ [::std::mem::offset_of!(uv_stat_t, st_ctim) - 128usize]; ++ ["Offset of field: uv_stat_t::st_birthtim"] ++ [::std::mem::offset_of!(uv_stat_t, st_birthtim) - 144usize]; ++}; ++pub type uv_fs_event_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ handle: *mut uv_fs_event_t, ++ filename: *const ::std::os::raw::c_char, ++ events: ::std::os::raw::c_int, ++ status: ::std::os::raw::c_int, ++ ), ++>; ++pub type uv_fs_poll_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ handle: *mut uv_fs_poll_t, ++ status: ::std::os::raw::c_int, ++ prev: *const uv_stat_t, ++ curr: *const uv_stat_t, ++ ), ++>; ++pub type uv_signal_cb = ::std::option::Option< ++ unsafe extern "C" fn(handle: *mut uv_signal_t, signum: ::std::os::raw::c_int), ++>; ++impl uv_membership { ++ pub const UV_LEAVE_GROUP: uv_membership = uv_membership(0); ++} ++impl uv_membership { ++ pub const UV_JOIN_GROUP: uv_membership = uv_membership(1); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_membership(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_req_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_req_s"][::std::mem::size_of::() - 64usize]; ++ ["Alignment of uv_req_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_req_s::data"] ++ [::std::mem::offset_of!(uv_req_s, data) - 0usize]; ++ ["Offset of field: uv_req_s::type_"] ++ [::std::mem::offset_of!(uv_req_s, type_) - 8usize]; ++ ["Offset of field: uv_req_s::reserved"] ++ [::std::mem::offset_of!(uv_req_s, reserved) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_shutdown_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub handle: *mut uv_stream_t, ++ pub cb: uv_shutdown_cb, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_shutdown_s"][::std::mem::size_of::() - 80usize]; ++ ["Alignment of uv_shutdown_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_shutdown_s::data"] ++ [::std::mem::offset_of!(uv_shutdown_s, data) - 0usize]; ++ ["Offset of field: uv_shutdown_s::type_"] ++ [::std::mem::offset_of!(uv_shutdown_s, type_) - 8usize]; ++ ["Offset of field: uv_shutdown_s::reserved"] ++ [::std::mem::offset_of!(uv_shutdown_s, reserved) - 16usize]; ++ ["Offset of field: uv_shutdown_s::handle"] ++ [::std::mem::offset_of!(uv_shutdown_s, handle) - 64usize]; ++ ["Offset of field: uv_shutdown_s::cb"] ++ [::std::mem::offset_of!(uv_shutdown_s, cb) - 72usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_handle_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_handle_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_handle_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_handle_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_handle_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_handle_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_handle_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_handle_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_handle_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_handle_s"][::std::mem::size_of::() - 96usize]; ++ ["Alignment of uv_handle_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_handle_s::data"] ++ [::std::mem::offset_of!(uv_handle_s, data) - 0usize]; ++ ["Offset of field: uv_handle_s::loop_"] ++ [::std::mem::offset_of!(uv_handle_s, loop_) - 8usize]; ++ ["Offset of field: uv_handle_s::type_"] ++ [::std::mem::offset_of!(uv_handle_s, type_) - 16usize]; ++ ["Offset of field: uv_handle_s::close_cb"] ++ [::std::mem::offset_of!(uv_handle_s, close_cb) - 24usize]; ++ ["Offset of field: uv_handle_s::handle_queue"] ++ [::std::mem::offset_of!(uv_handle_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_handle_s::u"] ++ [::std::mem::offset_of!(uv_handle_s, u) - 48usize]; ++ ["Offset of field: uv_handle_s::next_closing"] ++ [::std::mem::offset_of!(uv_handle_s, next_closing) - 80usize]; ++ ["Offset of field: uv_handle_s::flags"] ++ [::std::mem::offset_of!(uv_handle_s, flags) - 88usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_stream_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_stream_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub write_queue_size: usize, ++ pub alloc_cb: uv_alloc_cb, ++ pub read_cb: uv_read_cb, ++ pub connect_req: *mut uv_connect_t, ++ pub shutdown_req: *mut uv_shutdown_t, ++ pub io_watcher: uv__io_t, ++ pub write_queue: uv__queue, ++ pub write_completed_queue: uv__queue, ++ pub connection_cb: uv_connection_cb, ++ pub delayed_error: ::std::os::raw::c_int, ++ pub accepted_fd: ::std::os::raw::c_int, ++ pub queued_fds: *mut ::std::os::raw::c_void, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_stream_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_stream_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_stream_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_stream_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_stream_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_stream_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_stream_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_stream_s"][::std::mem::size_of::() - 256usize]; ++ ["Alignment of uv_stream_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_stream_s::data"] ++ [::std::mem::offset_of!(uv_stream_s, data) - 0usize]; ++ ["Offset of field: uv_stream_s::loop_"] ++ [::std::mem::offset_of!(uv_stream_s, loop_) - 8usize]; ++ ["Offset of field: uv_stream_s::type_"] ++ [::std::mem::offset_of!(uv_stream_s, type_) - 16usize]; ++ ["Offset of field: uv_stream_s::close_cb"] ++ [::std::mem::offset_of!(uv_stream_s, close_cb) - 24usize]; ++ ["Offset of field: uv_stream_s::handle_queue"] ++ [::std::mem::offset_of!(uv_stream_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_stream_s::u"] ++ [::std::mem::offset_of!(uv_stream_s, u) - 48usize]; ++ ["Offset of field: uv_stream_s::next_closing"] ++ [::std::mem::offset_of!(uv_stream_s, next_closing) - 80usize]; ++ ["Offset of field: uv_stream_s::flags"] ++ [::std::mem::offset_of!(uv_stream_s, flags) - 88usize]; ++ ["Offset of field: uv_stream_s::write_queue_size"] ++ [::std::mem::offset_of!(uv_stream_s, write_queue_size) - 96usize]; ++ ["Offset of field: uv_stream_s::alloc_cb"] ++ [::std::mem::offset_of!(uv_stream_s, alloc_cb) - 104usize]; ++ ["Offset of field: uv_stream_s::read_cb"] ++ [::std::mem::offset_of!(uv_stream_s, read_cb) - 112usize]; ++ ["Offset of field: uv_stream_s::connect_req"] ++ [::std::mem::offset_of!(uv_stream_s, connect_req) - 120usize]; ++ ["Offset of field: uv_stream_s::shutdown_req"] ++ [::std::mem::offset_of!(uv_stream_s, shutdown_req) - 128usize]; ++ ["Offset of field: uv_stream_s::io_watcher"] ++ [::std::mem::offset_of!(uv_stream_s, io_watcher) - 136usize]; ++ ["Offset of field: uv_stream_s::write_queue"] ++ [::std::mem::offset_of!(uv_stream_s, write_queue) - 200usize]; ++ ["Offset of field: uv_stream_s::write_completed_queue"] ++ [::std::mem::offset_of!(uv_stream_s, write_completed_queue) - 216usize]; ++ ["Offset of field: uv_stream_s::connection_cb"] ++ [::std::mem::offset_of!(uv_stream_s, connection_cb) - 232usize]; ++ ["Offset of field: uv_stream_s::delayed_error"] ++ [::std::mem::offset_of!(uv_stream_s, delayed_error) - 240usize]; ++ ["Offset of field: uv_stream_s::accepted_fd"] ++ [::std::mem::offset_of!(uv_stream_s, accepted_fd) - 244usize]; ++ ["Offset of field: uv_stream_s::queued_fds"] ++ [::std::mem::offset_of!(uv_stream_s, queued_fds) - 248usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_write_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub cb: uv_write_cb, ++ pub send_handle: *mut uv_stream_t, ++ pub handle: *mut uv_stream_t, ++ pub queue: uv__queue, ++ pub write_index: ::std::os::raw::c_uint, ++ pub bufs: *mut uv_buf_t, ++ pub nbufs: ::std::os::raw::c_uint, ++ pub error: ::std::os::raw::c_int, ++ pub bufsml: [uv_buf_t; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_write_s"][::std::mem::size_of::() - 192usize]; ++ ["Alignment of uv_write_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_write_s::data"] ++ [::std::mem::offset_of!(uv_write_s, data) - 0usize]; ++ ["Offset of field: uv_write_s::type_"] ++ [::std::mem::offset_of!(uv_write_s, type_) - 8usize]; ++ ["Offset of field: uv_write_s::reserved"] ++ [::std::mem::offset_of!(uv_write_s, reserved) - 16usize]; ++ ["Offset of field: uv_write_s::cb"] ++ [::std::mem::offset_of!(uv_write_s, cb) - 64usize]; ++ ["Offset of field: uv_write_s::send_handle"] ++ [::std::mem::offset_of!(uv_write_s, send_handle) - 72usize]; ++ ["Offset of field: uv_write_s::handle"] ++ [::std::mem::offset_of!(uv_write_s, handle) - 80usize]; ++ ["Offset of field: uv_write_s::queue"] ++ [::std::mem::offset_of!(uv_write_s, queue) - 88usize]; ++ ["Offset of field: uv_write_s::write_index"] ++ [::std::mem::offset_of!(uv_write_s, write_index) - 104usize]; ++ ["Offset of field: uv_write_s::bufs"] ++ [::std::mem::offset_of!(uv_write_s, bufs) - 112usize]; ++ ["Offset of field: uv_write_s::nbufs"] ++ [::std::mem::offset_of!(uv_write_s, nbufs) - 120usize]; ++ ["Offset of field: uv_write_s::error"] ++ [::std::mem::offset_of!(uv_write_s, error) - 124usize]; ++ ["Offset of field: uv_write_s::bufsml"] ++ [::std::mem::offset_of!(uv_write_s, bufsml) - 128usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_tcp_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_tcp_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub write_queue_size: usize, ++ pub alloc_cb: uv_alloc_cb, ++ pub read_cb: uv_read_cb, ++ pub connect_req: *mut uv_connect_t, ++ pub shutdown_req: *mut uv_shutdown_t, ++ pub io_watcher: uv__io_t, ++ pub write_queue: uv__queue, ++ pub write_completed_queue: uv__queue, ++ pub connection_cb: uv_connection_cb, ++ pub delayed_error: ::std::os::raw::c_int, ++ pub accepted_fd: ::std::os::raw::c_int, ++ pub queued_fds: *mut ::std::os::raw::c_void, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_tcp_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_tcp_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_tcp_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_tcp_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_tcp_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_tcp_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_tcp_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_tcp_s"][::std::mem::size_of::() - 256usize]; ++ ["Alignment of uv_tcp_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_tcp_s::data"] ++ [::std::mem::offset_of!(uv_tcp_s, data) - 0usize]; ++ ["Offset of field: uv_tcp_s::loop_"] ++ [::std::mem::offset_of!(uv_tcp_s, loop_) - 8usize]; ++ ["Offset of field: uv_tcp_s::type_"] ++ [::std::mem::offset_of!(uv_tcp_s, type_) - 16usize]; ++ ["Offset of field: uv_tcp_s::close_cb"] ++ [::std::mem::offset_of!(uv_tcp_s, close_cb) - 24usize]; ++ ["Offset of field: uv_tcp_s::handle_queue"] ++ [::std::mem::offset_of!(uv_tcp_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_tcp_s::u"] ++ [::std::mem::offset_of!(uv_tcp_s, u) - 48usize]; ++ ["Offset of field: uv_tcp_s::next_closing"] ++ [::std::mem::offset_of!(uv_tcp_s, next_closing) - 80usize]; ++ ["Offset of field: uv_tcp_s::flags"] ++ [::std::mem::offset_of!(uv_tcp_s, flags) - 88usize]; ++ ["Offset of field: uv_tcp_s::write_queue_size"] ++ [::std::mem::offset_of!(uv_tcp_s, write_queue_size) - 96usize]; ++ ["Offset of field: uv_tcp_s::alloc_cb"] ++ [::std::mem::offset_of!(uv_tcp_s, alloc_cb) - 104usize]; ++ ["Offset of field: uv_tcp_s::read_cb"] ++ [::std::mem::offset_of!(uv_tcp_s, read_cb) - 112usize]; ++ ["Offset of field: uv_tcp_s::connect_req"] ++ [::std::mem::offset_of!(uv_tcp_s, connect_req) - 120usize]; ++ ["Offset of field: uv_tcp_s::shutdown_req"] ++ [::std::mem::offset_of!(uv_tcp_s, shutdown_req) - 128usize]; ++ ["Offset of field: uv_tcp_s::io_watcher"] ++ [::std::mem::offset_of!(uv_tcp_s, io_watcher) - 136usize]; ++ ["Offset of field: uv_tcp_s::write_queue"] ++ [::std::mem::offset_of!(uv_tcp_s, write_queue) - 200usize]; ++ ["Offset of field: uv_tcp_s::write_completed_queue"] ++ [::std::mem::offset_of!(uv_tcp_s, write_completed_queue) - 216usize]; ++ ["Offset of field: uv_tcp_s::connection_cb"] ++ [::std::mem::offset_of!(uv_tcp_s, connection_cb) - 232usize]; ++ ["Offset of field: uv_tcp_s::delayed_error"] ++ [::std::mem::offset_of!(uv_tcp_s, delayed_error) - 240usize]; ++ ["Offset of field: uv_tcp_s::accepted_fd"] ++ [::std::mem::offset_of!(uv_tcp_s, accepted_fd) - 244usize]; ++ ["Offset of field: uv_tcp_s::queued_fds"] ++ [::std::mem::offset_of!(uv_tcp_s, queued_fds) - 248usize]; ++}; ++impl uv_tcp_flags { ++ pub const UV_TCP_IPV6ONLY: uv_tcp_flags = uv_tcp_flags(1); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_tcp_flags(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_connect_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub cb: uv_connect_cb, ++ pub handle: *mut uv_stream_t, ++ pub queue: uv__queue, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_connect_s"][::std::mem::size_of::() - 96usize]; ++ ["Alignment of uv_connect_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_connect_s::data"] ++ [::std::mem::offset_of!(uv_connect_s, data) - 0usize]; ++ ["Offset of field: uv_connect_s::type_"] ++ [::std::mem::offset_of!(uv_connect_s, type_) - 8usize]; ++ ["Offset of field: uv_connect_s::reserved"] ++ [::std::mem::offset_of!(uv_connect_s, reserved) - 16usize]; ++ ["Offset of field: uv_connect_s::cb"] ++ [::std::mem::offset_of!(uv_connect_s, cb) - 64usize]; ++ ["Offset of field: uv_connect_s::handle"] ++ [::std::mem::offset_of!(uv_connect_s, handle) - 72usize]; ++ ["Offset of field: uv_connect_s::queue"] ++ [::std::mem::offset_of!(uv_connect_s, queue) - 80usize]; ++}; ++impl uv_udp_flags { ++ pub const UV_UDP_IPV6ONLY: uv_udp_flags = uv_udp_flags(1); ++} ++impl uv_udp_flags { ++ pub const UV_UDP_PARTIAL: uv_udp_flags = uv_udp_flags(2); ++} ++impl uv_udp_flags { ++ pub const UV_UDP_REUSEADDR: uv_udp_flags = uv_udp_flags(4); ++} ++impl uv_udp_flags { ++ pub const UV_UDP_MMSG_CHUNK: uv_udp_flags = uv_udp_flags(8); ++} ++impl uv_udp_flags { ++ pub const UV_UDP_MMSG_FREE: uv_udp_flags = uv_udp_flags(16); ++} ++impl uv_udp_flags { ++ pub const UV_UDP_LINUX_RECVERR: uv_udp_flags = uv_udp_flags(32); ++} ++impl uv_udp_flags { ++ pub const UV_UDP_RECVMMSG: uv_udp_flags = uv_udp_flags(256); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_udp_flags(pub ::std::os::raw::c_uint); ++pub type uv_udp_send_cb = ::std::option::Option< ++ unsafe extern "C" fn(req: *mut uv_udp_send_t, status: ::std::os::raw::c_int), ++>; ++pub type uv_udp_recv_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ handle: *mut uv_udp_t, ++ nread: isize, ++ buf: *const uv_buf_t, ++ addr: *const sockaddr, ++ flags: ::std::os::raw::c_uint, ++ ), ++>; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_udp_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_udp_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub send_queue_size: usize, ++ pub send_queue_count: usize, ++ pub alloc_cb: uv_alloc_cb, ++ pub recv_cb: uv_udp_recv_cb, ++ pub io_watcher: uv__io_t, ++ pub write_queue: uv__queue, ++ pub write_completed_queue: uv__queue, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_udp_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_udp_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_udp_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_udp_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_udp_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_udp_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_udp_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_udp_s"][::std::mem::size_of::() - 224usize]; ++ ["Alignment of uv_udp_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_udp_s::data"] ++ [::std::mem::offset_of!(uv_udp_s, data) - 0usize]; ++ ["Offset of field: uv_udp_s::loop_"] ++ [::std::mem::offset_of!(uv_udp_s, loop_) - 8usize]; ++ ["Offset of field: uv_udp_s::type_"] ++ [::std::mem::offset_of!(uv_udp_s, type_) - 16usize]; ++ ["Offset of field: uv_udp_s::close_cb"] ++ [::std::mem::offset_of!(uv_udp_s, close_cb) - 24usize]; ++ ["Offset of field: uv_udp_s::handle_queue"] ++ [::std::mem::offset_of!(uv_udp_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_udp_s::u"] ++ [::std::mem::offset_of!(uv_udp_s, u) - 48usize]; ++ ["Offset of field: uv_udp_s::next_closing"] ++ [::std::mem::offset_of!(uv_udp_s, next_closing) - 80usize]; ++ ["Offset of field: uv_udp_s::flags"] ++ [::std::mem::offset_of!(uv_udp_s, flags) - 88usize]; ++ ["Offset of field: uv_udp_s::send_queue_size"] ++ [::std::mem::offset_of!(uv_udp_s, send_queue_size) - 96usize]; ++ ["Offset of field: uv_udp_s::send_queue_count"] ++ [::std::mem::offset_of!(uv_udp_s, send_queue_count) - 104usize]; ++ ["Offset of field: uv_udp_s::alloc_cb"] ++ [::std::mem::offset_of!(uv_udp_s, alloc_cb) - 112usize]; ++ ["Offset of field: uv_udp_s::recv_cb"] ++ [::std::mem::offset_of!(uv_udp_s, recv_cb) - 120usize]; ++ ["Offset of field: uv_udp_s::io_watcher"] ++ [::std::mem::offset_of!(uv_udp_s, io_watcher) - 128usize]; ++ ["Offset of field: uv_udp_s::write_queue"] ++ [::std::mem::offset_of!(uv_udp_s, write_queue) - 192usize]; ++ ["Offset of field: uv_udp_s::write_completed_queue"] ++ [::std::mem::offset_of!(uv_udp_s, write_completed_queue) - 208usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_udp_send_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub handle: *mut uv_udp_t, ++ pub cb: uv_udp_send_cb, ++ pub queue: uv__queue, ++ pub addr: sockaddr_storage, ++ pub nbufs: ::std::os::raw::c_uint, ++ pub bufs: *mut uv_buf_t, ++ pub status: isize, ++ pub send_cb: uv_udp_send_cb, ++ pub bufsml: [uv_buf_t; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_udp_send_s"][::std::mem::size_of::() - 320usize]; ++ ["Alignment of uv_udp_send_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_udp_send_s::data"] ++ [::std::mem::offset_of!(uv_udp_send_s, data) - 0usize]; ++ ["Offset of field: uv_udp_send_s::type_"] ++ [::std::mem::offset_of!(uv_udp_send_s, type_) - 8usize]; ++ ["Offset of field: uv_udp_send_s::reserved"] ++ [::std::mem::offset_of!(uv_udp_send_s, reserved) - 16usize]; ++ ["Offset of field: uv_udp_send_s::handle"] ++ [::std::mem::offset_of!(uv_udp_send_s, handle) - 64usize]; ++ ["Offset of field: uv_udp_send_s::cb"] ++ [::std::mem::offset_of!(uv_udp_send_s, cb) - 72usize]; ++ ["Offset of field: uv_udp_send_s::queue"] ++ [::std::mem::offset_of!(uv_udp_send_s, queue) - 80usize]; ++ ["Offset of field: uv_udp_send_s::addr"] ++ [::std::mem::offset_of!(uv_udp_send_s, addr) - 96usize]; ++ ["Offset of field: uv_udp_send_s::nbufs"] ++ [::std::mem::offset_of!(uv_udp_send_s, nbufs) - 224usize]; ++ ["Offset of field: uv_udp_send_s::bufs"] ++ [::std::mem::offset_of!(uv_udp_send_s, bufs) - 232usize]; ++ ["Offset of field: uv_udp_send_s::status"] ++ [::std::mem::offset_of!(uv_udp_send_s, status) - 240usize]; ++ ["Offset of field: uv_udp_send_s::send_cb"] ++ [::std::mem::offset_of!(uv_udp_send_s, send_cb) - 248usize]; ++ ["Offset of field: uv_udp_send_s::bufsml"] ++ [::std::mem::offset_of!(uv_udp_send_s, bufsml) - 256usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_tty_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_tty_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub write_queue_size: usize, ++ pub alloc_cb: uv_alloc_cb, ++ pub read_cb: uv_read_cb, ++ pub connect_req: *mut uv_connect_t, ++ pub shutdown_req: *mut uv_shutdown_t, ++ pub io_watcher: uv__io_t, ++ pub write_queue: uv__queue, ++ pub write_completed_queue: uv__queue, ++ pub connection_cb: uv_connection_cb, ++ pub delayed_error: ::std::os::raw::c_int, ++ pub accepted_fd: ::std::os::raw::c_int, ++ pub queued_fds: *mut ::std::os::raw::c_void, ++ pub orig_termios: termios, ++ pub mode: ::std::os::raw::c_int, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_tty_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_tty_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_tty_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_tty_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_tty_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_tty_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_tty_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_tty_s"][::std::mem::size_of::() - 304usize]; ++ ["Alignment of uv_tty_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_tty_s::data"] ++ [::std::mem::offset_of!(uv_tty_s, data) - 0usize]; ++ ["Offset of field: uv_tty_s::loop_"] ++ [::std::mem::offset_of!(uv_tty_s, loop_) - 8usize]; ++ ["Offset of field: uv_tty_s::type_"] ++ [::std::mem::offset_of!(uv_tty_s, type_) - 16usize]; ++ ["Offset of field: uv_tty_s::close_cb"] ++ [::std::mem::offset_of!(uv_tty_s, close_cb) - 24usize]; ++ ["Offset of field: uv_tty_s::handle_queue"] ++ [::std::mem::offset_of!(uv_tty_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_tty_s::u"] ++ [::std::mem::offset_of!(uv_tty_s, u) - 48usize]; ++ ["Offset of field: uv_tty_s::next_closing"] ++ [::std::mem::offset_of!(uv_tty_s, next_closing) - 80usize]; ++ ["Offset of field: uv_tty_s::flags"] ++ [::std::mem::offset_of!(uv_tty_s, flags) - 88usize]; ++ ["Offset of field: uv_tty_s::write_queue_size"] ++ [::std::mem::offset_of!(uv_tty_s, write_queue_size) - 96usize]; ++ ["Offset of field: uv_tty_s::alloc_cb"] ++ [::std::mem::offset_of!(uv_tty_s, alloc_cb) - 104usize]; ++ ["Offset of field: uv_tty_s::read_cb"] ++ [::std::mem::offset_of!(uv_tty_s, read_cb) - 112usize]; ++ ["Offset of field: uv_tty_s::connect_req"] ++ [::std::mem::offset_of!(uv_tty_s, connect_req) - 120usize]; ++ ["Offset of field: uv_tty_s::shutdown_req"] ++ [::std::mem::offset_of!(uv_tty_s, shutdown_req) - 128usize]; ++ ["Offset of field: uv_tty_s::io_watcher"] ++ [::std::mem::offset_of!(uv_tty_s, io_watcher) - 136usize]; ++ ["Offset of field: uv_tty_s::write_queue"] ++ [::std::mem::offset_of!(uv_tty_s, write_queue) - 200usize]; ++ ["Offset of field: uv_tty_s::write_completed_queue"] ++ [::std::mem::offset_of!(uv_tty_s, write_completed_queue) - 216usize]; ++ ["Offset of field: uv_tty_s::connection_cb"] ++ [::std::mem::offset_of!(uv_tty_s, connection_cb) - 232usize]; ++ ["Offset of field: uv_tty_s::delayed_error"] ++ [::std::mem::offset_of!(uv_tty_s, delayed_error) - 240usize]; ++ ["Offset of field: uv_tty_s::accepted_fd"] ++ [::std::mem::offset_of!(uv_tty_s, accepted_fd) - 244usize]; ++ ["Offset of field: uv_tty_s::queued_fds"] ++ [::std::mem::offset_of!(uv_tty_s, queued_fds) - 248usize]; ++ ["Offset of field: uv_tty_s::orig_termios"] ++ [::std::mem::offset_of!(uv_tty_s, orig_termios) - 256usize]; ++ ["Offset of field: uv_tty_s::mode"] ++ [::std::mem::offset_of!(uv_tty_s, mode) - 300usize]; ++}; ++impl uv_tty_mode_t { ++ pub const UV_TTY_MODE_NORMAL: uv_tty_mode_t = uv_tty_mode_t(0); ++} ++impl uv_tty_mode_t { ++ pub const UV_TTY_MODE_RAW: uv_tty_mode_t = uv_tty_mode_t(1); ++} ++impl uv_tty_mode_t { ++ pub const UV_TTY_MODE_IO: uv_tty_mode_t = uv_tty_mode_t(2); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_tty_mode_t(pub ::std::os::raw::c_uint); ++impl uv_tty_vtermstate_t { ++ pub const UV_TTY_SUPPORTED: uv_tty_vtermstate_t = uv_tty_vtermstate_t(0); ++} ++impl uv_tty_vtermstate_t { ++ pub const UV_TTY_UNSUPPORTED: uv_tty_vtermstate_t = uv_tty_vtermstate_t(1); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_tty_vtermstate_t(pub ::std::os::raw::c_uint); ++pub const UV_PIPE_NO_TRUNCATE: _bindgen_ty_1 = _bindgen_ty_1(1); ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct _bindgen_ty_1(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_pipe_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_pipe_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub write_queue_size: usize, ++ pub alloc_cb: uv_alloc_cb, ++ pub read_cb: uv_read_cb, ++ pub connect_req: *mut uv_connect_t, ++ pub shutdown_req: *mut uv_shutdown_t, ++ pub io_watcher: uv__io_t, ++ pub write_queue: uv__queue, ++ pub write_completed_queue: uv__queue, ++ pub connection_cb: uv_connection_cb, ++ pub delayed_error: ::std::os::raw::c_int, ++ pub accepted_fd: ::std::os::raw::c_int, ++ pub queued_fds: *mut ::std::os::raw::c_void, ++ pub ipc: ::std::os::raw::c_int, ++ pub pipe_fname: *const ::std::os::raw::c_char, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_pipe_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_pipe_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_pipe_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_pipe_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_pipe_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_pipe_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_pipe_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_pipe_s"][::std::mem::size_of::() - 272usize]; ++ ["Alignment of uv_pipe_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_pipe_s::data"] ++ [::std::mem::offset_of!(uv_pipe_s, data) - 0usize]; ++ ["Offset of field: uv_pipe_s::loop_"] ++ [::std::mem::offset_of!(uv_pipe_s, loop_) - 8usize]; ++ ["Offset of field: uv_pipe_s::type_"] ++ [::std::mem::offset_of!(uv_pipe_s, type_) - 16usize]; ++ ["Offset of field: uv_pipe_s::close_cb"] ++ [::std::mem::offset_of!(uv_pipe_s, close_cb) - 24usize]; ++ ["Offset of field: uv_pipe_s::handle_queue"] ++ [::std::mem::offset_of!(uv_pipe_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_pipe_s::u"] ++ [::std::mem::offset_of!(uv_pipe_s, u) - 48usize]; ++ ["Offset of field: uv_pipe_s::next_closing"] ++ [::std::mem::offset_of!(uv_pipe_s, next_closing) - 80usize]; ++ ["Offset of field: uv_pipe_s::flags"] ++ [::std::mem::offset_of!(uv_pipe_s, flags) - 88usize]; ++ ["Offset of field: uv_pipe_s::write_queue_size"] ++ [::std::mem::offset_of!(uv_pipe_s, write_queue_size) - 96usize]; ++ ["Offset of field: uv_pipe_s::alloc_cb"] ++ [::std::mem::offset_of!(uv_pipe_s, alloc_cb) - 104usize]; ++ ["Offset of field: uv_pipe_s::read_cb"] ++ [::std::mem::offset_of!(uv_pipe_s, read_cb) - 112usize]; ++ ["Offset of field: uv_pipe_s::connect_req"] ++ [::std::mem::offset_of!(uv_pipe_s, connect_req) - 120usize]; ++ ["Offset of field: uv_pipe_s::shutdown_req"] ++ [::std::mem::offset_of!(uv_pipe_s, shutdown_req) - 128usize]; ++ ["Offset of field: uv_pipe_s::io_watcher"] ++ [::std::mem::offset_of!(uv_pipe_s, io_watcher) - 136usize]; ++ ["Offset of field: uv_pipe_s::write_queue"] ++ [::std::mem::offset_of!(uv_pipe_s, write_queue) - 200usize]; ++ ["Offset of field: uv_pipe_s::write_completed_queue"] ++ [::std::mem::offset_of!(uv_pipe_s, write_completed_queue) - 216usize]; ++ ["Offset of field: uv_pipe_s::connection_cb"] ++ [::std::mem::offset_of!(uv_pipe_s, connection_cb) - 232usize]; ++ ["Offset of field: uv_pipe_s::delayed_error"] ++ [::std::mem::offset_of!(uv_pipe_s, delayed_error) - 240usize]; ++ ["Offset of field: uv_pipe_s::accepted_fd"] ++ [::std::mem::offset_of!(uv_pipe_s, accepted_fd) - 244usize]; ++ ["Offset of field: uv_pipe_s::queued_fds"] ++ [::std::mem::offset_of!(uv_pipe_s, queued_fds) - 248usize]; ++ ["Offset of field: uv_pipe_s::ipc"] ++ [::std::mem::offset_of!(uv_pipe_s, ipc) - 256usize]; ++ ["Offset of field: uv_pipe_s::pipe_fname"] ++ [::std::mem::offset_of!(uv_pipe_s, pipe_fname) - 264usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_poll_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_poll_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub poll_cb: uv_poll_cb, ++ pub io_watcher: uv__io_t, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_poll_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_poll_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_poll_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_poll_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_poll_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_poll_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_poll_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_poll_s"][::std::mem::size_of::() - 168usize]; ++ ["Alignment of uv_poll_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_poll_s::data"] ++ [::std::mem::offset_of!(uv_poll_s, data) - 0usize]; ++ ["Offset of field: uv_poll_s::loop_"] ++ [::std::mem::offset_of!(uv_poll_s, loop_) - 8usize]; ++ ["Offset of field: uv_poll_s::type_"] ++ [::std::mem::offset_of!(uv_poll_s, type_) - 16usize]; ++ ["Offset of field: uv_poll_s::close_cb"] ++ [::std::mem::offset_of!(uv_poll_s, close_cb) - 24usize]; ++ ["Offset of field: uv_poll_s::handle_queue"] ++ [::std::mem::offset_of!(uv_poll_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_poll_s::u"] ++ [::std::mem::offset_of!(uv_poll_s, u) - 48usize]; ++ ["Offset of field: uv_poll_s::next_closing"] ++ [::std::mem::offset_of!(uv_poll_s, next_closing) - 80usize]; ++ ["Offset of field: uv_poll_s::flags"] ++ [::std::mem::offset_of!(uv_poll_s, flags) - 88usize]; ++ ["Offset of field: uv_poll_s::poll_cb"] ++ [::std::mem::offset_of!(uv_poll_s, poll_cb) - 96usize]; ++ ["Offset of field: uv_poll_s::io_watcher"] ++ [::std::mem::offset_of!(uv_poll_s, io_watcher) - 104usize]; ++}; ++impl uv_poll_event { ++ pub const UV_READABLE: uv_poll_event = uv_poll_event(1); ++} ++impl uv_poll_event { ++ pub const UV_WRITABLE: uv_poll_event = uv_poll_event(2); ++} ++impl uv_poll_event { ++ pub const UV_DISCONNECT: uv_poll_event = uv_poll_event(4); ++} ++impl uv_poll_event { ++ pub const UV_PRIORITIZED: uv_poll_event = uv_poll_event(8); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_poll_event(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_prepare_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_prepare_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub prepare_cb: uv_prepare_cb, ++ pub queue: uv__queue, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_prepare_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_prepare_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_prepare_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_prepare_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_prepare_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_prepare_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_prepare_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_prepare_s"][::std::mem::size_of::() - 120usize]; ++ ["Alignment of uv_prepare_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_prepare_s::data"] ++ [::std::mem::offset_of!(uv_prepare_s, data) - 0usize]; ++ ["Offset of field: uv_prepare_s::loop_"] ++ [::std::mem::offset_of!(uv_prepare_s, loop_) - 8usize]; ++ ["Offset of field: uv_prepare_s::type_"] ++ [::std::mem::offset_of!(uv_prepare_s, type_) - 16usize]; ++ ["Offset of field: uv_prepare_s::close_cb"] ++ [::std::mem::offset_of!(uv_prepare_s, close_cb) - 24usize]; ++ ["Offset of field: uv_prepare_s::handle_queue"] ++ [::std::mem::offset_of!(uv_prepare_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_prepare_s::u"] ++ [::std::mem::offset_of!(uv_prepare_s, u) - 48usize]; ++ ["Offset of field: uv_prepare_s::next_closing"] ++ [::std::mem::offset_of!(uv_prepare_s, next_closing) - 80usize]; ++ ["Offset of field: uv_prepare_s::flags"] ++ [::std::mem::offset_of!(uv_prepare_s, flags) - 88usize]; ++ ["Offset of field: uv_prepare_s::prepare_cb"] ++ [::std::mem::offset_of!(uv_prepare_s, prepare_cb) - 96usize]; ++ ["Offset of field: uv_prepare_s::queue"] ++ [::std::mem::offset_of!(uv_prepare_s, queue) - 104usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_check_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_check_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub check_cb: uv_check_cb, ++ pub queue: uv__queue, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_check_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_check_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_check_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_check_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_check_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_check_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_check_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_check_s"][::std::mem::size_of::() - 120usize]; ++ ["Alignment of uv_check_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_check_s::data"] ++ [::std::mem::offset_of!(uv_check_s, data) - 0usize]; ++ ["Offset of field: uv_check_s::loop_"] ++ [::std::mem::offset_of!(uv_check_s, loop_) - 8usize]; ++ ["Offset of field: uv_check_s::type_"] ++ [::std::mem::offset_of!(uv_check_s, type_) - 16usize]; ++ ["Offset of field: uv_check_s::close_cb"] ++ [::std::mem::offset_of!(uv_check_s, close_cb) - 24usize]; ++ ["Offset of field: uv_check_s::handle_queue"] ++ [::std::mem::offset_of!(uv_check_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_check_s::u"] ++ [::std::mem::offset_of!(uv_check_s, u) - 48usize]; ++ ["Offset of field: uv_check_s::next_closing"] ++ [::std::mem::offset_of!(uv_check_s, next_closing) - 80usize]; ++ ["Offset of field: uv_check_s::flags"] ++ [::std::mem::offset_of!(uv_check_s, flags) - 88usize]; ++ ["Offset of field: uv_check_s::check_cb"] ++ [::std::mem::offset_of!(uv_check_s, check_cb) - 96usize]; ++ ["Offset of field: uv_check_s::queue"] ++ [::std::mem::offset_of!(uv_check_s, queue) - 104usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_idle_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_idle_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub idle_cb: uv_idle_cb, ++ pub queue: uv__queue, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_idle_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_idle_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_idle_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_idle_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_idle_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_idle_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_idle_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_idle_s"][::std::mem::size_of::() - 120usize]; ++ ["Alignment of uv_idle_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_idle_s::data"] ++ [::std::mem::offset_of!(uv_idle_s, data) - 0usize]; ++ ["Offset of field: uv_idle_s::loop_"] ++ [::std::mem::offset_of!(uv_idle_s, loop_) - 8usize]; ++ ["Offset of field: uv_idle_s::type_"] ++ [::std::mem::offset_of!(uv_idle_s, type_) - 16usize]; ++ ["Offset of field: uv_idle_s::close_cb"] ++ [::std::mem::offset_of!(uv_idle_s, close_cb) - 24usize]; ++ ["Offset of field: uv_idle_s::handle_queue"] ++ [::std::mem::offset_of!(uv_idle_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_idle_s::u"] ++ [::std::mem::offset_of!(uv_idle_s, u) - 48usize]; ++ ["Offset of field: uv_idle_s::next_closing"] ++ [::std::mem::offset_of!(uv_idle_s, next_closing) - 80usize]; ++ ["Offset of field: uv_idle_s::flags"] ++ [::std::mem::offset_of!(uv_idle_s, flags) - 88usize]; ++ ["Offset of field: uv_idle_s::idle_cb"] ++ [::std::mem::offset_of!(uv_idle_s, idle_cb) - 96usize]; ++ ["Offset of field: uv_idle_s::queue"] ++ [::std::mem::offset_of!(uv_idle_s, queue) - 104usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_async_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_async_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub async_cb: uv_async_cb, ++ pub queue: uv__queue, ++ pub pending: ::std::os::raw::c_int, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_async_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_async_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_async_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_async_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_async_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_async_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_async_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_async_s"][::std::mem::size_of::() - 128usize]; ++ ["Alignment of uv_async_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_async_s::data"] ++ [::std::mem::offset_of!(uv_async_s, data) - 0usize]; ++ ["Offset of field: uv_async_s::loop_"] ++ [::std::mem::offset_of!(uv_async_s, loop_) - 8usize]; ++ ["Offset of field: uv_async_s::type_"] ++ [::std::mem::offset_of!(uv_async_s, type_) - 16usize]; ++ ["Offset of field: uv_async_s::close_cb"] ++ [::std::mem::offset_of!(uv_async_s, close_cb) - 24usize]; ++ ["Offset of field: uv_async_s::handle_queue"] ++ [::std::mem::offset_of!(uv_async_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_async_s::u"] ++ [::std::mem::offset_of!(uv_async_s, u) - 48usize]; ++ ["Offset of field: uv_async_s::next_closing"] ++ [::std::mem::offset_of!(uv_async_s, next_closing) - 80usize]; ++ ["Offset of field: uv_async_s::flags"] ++ [::std::mem::offset_of!(uv_async_s, flags) - 88usize]; ++ ["Offset of field: uv_async_s::async_cb"] ++ [::std::mem::offset_of!(uv_async_s, async_cb) - 96usize]; ++ ["Offset of field: uv_async_s::queue"] ++ [::std::mem::offset_of!(uv_async_s, queue) - 104usize]; ++ ["Offset of field: uv_async_s::pending"] ++ [::std::mem::offset_of!(uv_async_s, pending) - 120usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_timer_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_timer_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub timer_cb: uv_timer_cb, ++ pub node: uv_timer_s__bindgen_ty_2, ++ pub timeout: u64, ++ pub repeat: u64, ++ pub start_id: u64, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_timer_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_timer_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_timer_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_timer_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_timer_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_timer_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_timer_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_timer_s__bindgen_ty_2 { ++ pub heap: [*mut ::std::os::raw::c_void; 3usize], ++ pub queue: uv__queue, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_timer_s__bindgen_ty_2"] ++ [::std::mem::size_of::() - 24usize]; ++ ["Alignment of uv_timer_s__bindgen_ty_2"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_timer_s__bindgen_ty_2::heap"] ++ [::std::mem::offset_of!(uv_timer_s__bindgen_ty_2, heap) - 0usize]; ++ ["Offset of field: uv_timer_s__bindgen_ty_2::queue"] ++ [::std::mem::offset_of!(uv_timer_s__bindgen_ty_2, queue) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_timer_s"][::std::mem::size_of::() - 152usize]; ++ ["Alignment of uv_timer_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_timer_s::data"] ++ [::std::mem::offset_of!(uv_timer_s, data) - 0usize]; ++ ["Offset of field: uv_timer_s::loop_"] ++ [::std::mem::offset_of!(uv_timer_s, loop_) - 8usize]; ++ ["Offset of field: uv_timer_s::type_"] ++ [::std::mem::offset_of!(uv_timer_s, type_) - 16usize]; ++ ["Offset of field: uv_timer_s::close_cb"] ++ [::std::mem::offset_of!(uv_timer_s, close_cb) - 24usize]; ++ ["Offset of field: uv_timer_s::handle_queue"] ++ [::std::mem::offset_of!(uv_timer_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_timer_s::u"] ++ [::std::mem::offset_of!(uv_timer_s, u) - 48usize]; ++ ["Offset of field: uv_timer_s::next_closing"] ++ [::std::mem::offset_of!(uv_timer_s, next_closing) - 80usize]; ++ ["Offset of field: uv_timer_s::flags"] ++ [::std::mem::offset_of!(uv_timer_s, flags) - 88usize]; ++ ["Offset of field: uv_timer_s::timer_cb"] ++ [::std::mem::offset_of!(uv_timer_s, timer_cb) - 96usize]; ++ ["Offset of field: uv_timer_s::node"] ++ [::std::mem::offset_of!(uv_timer_s, node) - 104usize]; ++ ["Offset of field: uv_timer_s::timeout"] ++ [::std::mem::offset_of!(uv_timer_s, timeout) - 128usize]; ++ ["Offset of field: uv_timer_s::repeat"] ++ [::std::mem::offset_of!(uv_timer_s, repeat) - 136usize]; ++ ["Offset of field: uv_timer_s::start_id"] ++ [::std::mem::offset_of!(uv_timer_s, start_id) - 144usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_getaddrinfo_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub loop_: *mut uv_loop_t, ++ pub work_req: uv__work, ++ pub cb: uv_getaddrinfo_cb, ++ pub hints: *mut addrinfo, ++ pub hostname: *mut ::std::os::raw::c_char, ++ pub service: *mut ::std::os::raw::c_char, ++ pub addrinfo: *mut addrinfo, ++ pub retcode: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_getaddrinfo_s"] ++ [::std::mem::size_of::() - 160usize]; ++ ["Alignment of uv_getaddrinfo_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_getaddrinfo_s::data"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, data) - 0usize]; ++ ["Offset of field: uv_getaddrinfo_s::type_"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, type_) - 8usize]; ++ ["Offset of field: uv_getaddrinfo_s::reserved"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, reserved) - 16usize]; ++ ["Offset of field: uv_getaddrinfo_s::loop_"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, loop_) - 64usize]; ++ ["Offset of field: uv_getaddrinfo_s::work_req"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, work_req) - 72usize]; ++ ["Offset of field: uv_getaddrinfo_s::cb"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, cb) - 112usize]; ++ ["Offset of field: uv_getaddrinfo_s::hints"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, hints) - 120usize]; ++ ["Offset of field: uv_getaddrinfo_s::hostname"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, hostname) - 128usize]; ++ ["Offset of field: uv_getaddrinfo_s::service"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, service) - 136usize]; ++ ["Offset of field: uv_getaddrinfo_s::addrinfo"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, addrinfo) - 144usize]; ++ ["Offset of field: uv_getaddrinfo_s::retcode"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, retcode) - 152usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_getnameinfo_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub loop_: *mut uv_loop_t, ++ pub work_req: uv__work, ++ pub getnameinfo_cb: uv_getnameinfo_cb, ++ pub storage: sockaddr_storage, ++ pub flags: ::std::os::raw::c_int, ++ pub host: [::std::os::raw::c_char; 1025usize], ++ pub service: [::std::os::raw::c_char; 32usize], ++ pub retcode: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_getnameinfo_s"] ++ [::std::mem::size_of::() - 1320usize]; ++ ["Alignment of uv_getnameinfo_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_getnameinfo_s::data"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, data) - 0usize]; ++ ["Offset of field: uv_getnameinfo_s::type_"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, type_) - 8usize]; ++ ["Offset of field: uv_getnameinfo_s::reserved"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, reserved) - 16usize]; ++ ["Offset of field: uv_getnameinfo_s::loop_"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, loop_) - 64usize]; ++ ["Offset of field: uv_getnameinfo_s::work_req"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, work_req) - 72usize]; ++ ["Offset of field: uv_getnameinfo_s::getnameinfo_cb"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, getnameinfo_cb) - 112usize]; ++ ["Offset of field: uv_getnameinfo_s::storage"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, storage) - 120usize]; ++ ["Offset of field: uv_getnameinfo_s::flags"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, flags) - 248usize]; ++ ["Offset of field: uv_getnameinfo_s::host"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, host) - 252usize]; ++ ["Offset of field: uv_getnameinfo_s::service"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, service) - 1277usize]; ++ ["Offset of field: uv_getnameinfo_s::retcode"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, retcode) - 1312usize]; ++}; ++impl uv_stdio_flags { ++ pub const UV_IGNORE: uv_stdio_flags = uv_stdio_flags(0); ++} ++impl uv_stdio_flags { ++ pub const UV_CREATE_PIPE: uv_stdio_flags = uv_stdio_flags(1); ++} ++impl uv_stdio_flags { ++ pub const UV_INHERIT_FD: uv_stdio_flags = uv_stdio_flags(2); ++} ++impl uv_stdio_flags { ++ pub const UV_INHERIT_STREAM: uv_stdio_flags = uv_stdio_flags(4); ++} ++impl uv_stdio_flags { ++ pub const UV_READABLE_PIPE: uv_stdio_flags = uv_stdio_flags(16); ++} ++impl uv_stdio_flags { ++ pub const UV_WRITABLE_PIPE: uv_stdio_flags = uv_stdio_flags(32); ++} ++impl uv_stdio_flags { ++ pub const UV_NONBLOCK_PIPE: uv_stdio_flags = uv_stdio_flags(64); ++} ++impl uv_stdio_flags { ++ pub const UV_OVERLAPPED_PIPE: uv_stdio_flags = uv_stdio_flags(64); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_stdio_flags(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_stdio_container_s { ++ pub flags: uv_stdio_flags, ++ pub data: uv_stdio_container_s__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_stdio_container_s__bindgen_ty_1 { ++ pub stream: *mut uv_stream_t, ++ pub fd: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_stdio_container_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 8usize]; ++ ["Alignment of uv_stdio_container_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_stdio_container_s__bindgen_ty_1::stream"][::std::mem::offset_of!( ++ uv_stdio_container_s__bindgen_ty_1, ++ stream ++ ) - 0usize]; ++ ["Offset of field: uv_stdio_container_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_stdio_container_s__bindgen_ty_1, fd) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_stdio_container_s"] ++ [::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_stdio_container_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_stdio_container_s::flags"] ++ [::std::mem::offset_of!(uv_stdio_container_s, flags) - 0usize]; ++ ["Offset of field: uv_stdio_container_s::data"] ++ [::std::mem::offset_of!(uv_stdio_container_s, data) - 8usize]; ++}; ++pub type uv_stdio_container_t = uv_stdio_container_s; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_process_options_s { ++ pub exit_cb: uv_exit_cb, ++ pub file: *const ::std::os::raw::c_char, ++ pub args: *mut *mut ::std::os::raw::c_char, ++ pub env: *mut *mut ::std::os::raw::c_char, ++ pub cwd: *const ::std::os::raw::c_char, ++ pub flags: ::std::os::raw::c_uint, ++ pub stdio_count: ::std::os::raw::c_int, ++ pub stdio: *mut uv_stdio_container_t, ++ pub uid: uv_uid_t, ++ pub gid: uv_gid_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_process_options_s"] ++ [::std::mem::size_of::() - 64usize]; ++ ["Alignment of uv_process_options_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_process_options_s::exit_cb"] ++ [::std::mem::offset_of!(uv_process_options_s, exit_cb) - 0usize]; ++ ["Offset of field: uv_process_options_s::file"] ++ [::std::mem::offset_of!(uv_process_options_s, file) - 8usize]; ++ ["Offset of field: uv_process_options_s::args"] ++ [::std::mem::offset_of!(uv_process_options_s, args) - 16usize]; ++ ["Offset of field: uv_process_options_s::env"] ++ [::std::mem::offset_of!(uv_process_options_s, env) - 24usize]; ++ ["Offset of field: uv_process_options_s::cwd"] ++ [::std::mem::offset_of!(uv_process_options_s, cwd) - 32usize]; ++ ["Offset of field: uv_process_options_s::flags"] ++ [::std::mem::offset_of!(uv_process_options_s, flags) - 40usize]; ++ ["Offset of field: uv_process_options_s::stdio_count"] ++ [::std::mem::offset_of!(uv_process_options_s, stdio_count) - 44usize]; ++ ["Offset of field: uv_process_options_s::stdio"] ++ [::std::mem::offset_of!(uv_process_options_s, stdio) - 48usize]; ++ ["Offset of field: uv_process_options_s::uid"] ++ [::std::mem::offset_of!(uv_process_options_s, uid) - 56usize]; ++ ["Offset of field: uv_process_options_s::gid"] ++ [::std::mem::offset_of!(uv_process_options_s, gid) - 60usize]; ++}; ++pub type uv_process_options_t = uv_process_options_s; ++impl uv_process_flags { ++ pub const UV_PROCESS_SETUID: uv_process_flags = uv_process_flags(1); ++} ++impl uv_process_flags { ++ pub const UV_PROCESS_SETGID: uv_process_flags = uv_process_flags(2); ++} ++impl uv_process_flags { ++ pub const UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS: uv_process_flags = ++ uv_process_flags(4); ++} ++impl uv_process_flags { ++ pub const UV_PROCESS_DETACHED: uv_process_flags = uv_process_flags(8); ++} ++impl uv_process_flags { ++ pub const UV_PROCESS_WINDOWS_HIDE: uv_process_flags = uv_process_flags(16); ++} ++impl uv_process_flags { ++ pub const UV_PROCESS_WINDOWS_HIDE_CONSOLE: uv_process_flags = ++ uv_process_flags(32); ++} ++impl uv_process_flags { ++ pub const UV_PROCESS_WINDOWS_HIDE_GUI: uv_process_flags = ++ uv_process_flags(64); ++} ++impl uv_process_flags { ++ pub const UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME: uv_process_flags = ++ uv_process_flags(128); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_process_flags(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_process_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_process_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub exit_cb: uv_exit_cb, ++ pub pid: ::std::os::raw::c_int, ++ pub queue: uv__queue, ++ pub status: ::std::os::raw::c_int, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_process_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_process_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_process_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_process_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_process_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_process_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_process_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_process_s"][::std::mem::size_of::() - 136usize]; ++ ["Alignment of uv_process_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_process_s::data"] ++ [::std::mem::offset_of!(uv_process_s, data) - 0usize]; ++ ["Offset of field: uv_process_s::loop_"] ++ [::std::mem::offset_of!(uv_process_s, loop_) - 8usize]; ++ ["Offset of field: uv_process_s::type_"] ++ [::std::mem::offset_of!(uv_process_s, type_) - 16usize]; ++ ["Offset of field: uv_process_s::close_cb"] ++ [::std::mem::offset_of!(uv_process_s, close_cb) - 24usize]; ++ ["Offset of field: uv_process_s::handle_queue"] ++ [::std::mem::offset_of!(uv_process_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_process_s::u"] ++ [::std::mem::offset_of!(uv_process_s, u) - 48usize]; ++ ["Offset of field: uv_process_s::next_closing"] ++ [::std::mem::offset_of!(uv_process_s, next_closing) - 80usize]; ++ ["Offset of field: uv_process_s::flags"] ++ [::std::mem::offset_of!(uv_process_s, flags) - 88usize]; ++ ["Offset of field: uv_process_s::exit_cb"] ++ [::std::mem::offset_of!(uv_process_s, exit_cb) - 96usize]; ++ ["Offset of field: uv_process_s::pid"] ++ [::std::mem::offset_of!(uv_process_s, pid) - 104usize]; ++ ["Offset of field: uv_process_s::queue"] ++ [::std::mem::offset_of!(uv_process_s, queue) - 112usize]; ++ ["Offset of field: uv_process_s::status"] ++ [::std::mem::offset_of!(uv_process_s, status) - 128usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_work_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub loop_: *mut uv_loop_t, ++ pub work_cb: uv_work_cb, ++ pub after_work_cb: uv_after_work_cb, ++ pub work_req: uv__work, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_work_s"][::std::mem::size_of::() - 128usize]; ++ ["Alignment of uv_work_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_work_s::data"] ++ [::std::mem::offset_of!(uv_work_s, data) - 0usize]; ++ ["Offset of field: uv_work_s::type_"] ++ [::std::mem::offset_of!(uv_work_s, type_) - 8usize]; ++ ["Offset of field: uv_work_s::reserved"] ++ [::std::mem::offset_of!(uv_work_s, reserved) - 16usize]; ++ ["Offset of field: uv_work_s::loop_"] ++ [::std::mem::offset_of!(uv_work_s, loop_) - 64usize]; ++ ["Offset of field: uv_work_s::work_cb"] ++ [::std::mem::offset_of!(uv_work_s, work_cb) - 72usize]; ++ ["Offset of field: uv_work_s::after_work_cb"] ++ [::std::mem::offset_of!(uv_work_s, after_work_cb) - 80usize]; ++ ["Offset of field: uv_work_s::work_req"] ++ [::std::mem::offset_of!(uv_work_s, work_req) - 88usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_cpu_times_s { ++ pub user: u64, ++ pub nice: u64, ++ pub sys: u64, ++ pub idle: u64, ++ pub irq: u64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_cpu_times_s"][::std::mem::size_of::() - 40usize]; ++ ["Alignment of uv_cpu_times_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_cpu_times_s::user"] ++ [::std::mem::offset_of!(uv_cpu_times_s, user) - 0usize]; ++ ["Offset of field: uv_cpu_times_s::nice"] ++ [::std::mem::offset_of!(uv_cpu_times_s, nice) - 8usize]; ++ ["Offset of field: uv_cpu_times_s::sys"] ++ [::std::mem::offset_of!(uv_cpu_times_s, sys) - 16usize]; ++ ["Offset of field: uv_cpu_times_s::idle"] ++ [::std::mem::offset_of!(uv_cpu_times_s, idle) - 24usize]; ++ ["Offset of field: uv_cpu_times_s::irq"] ++ [::std::mem::offset_of!(uv_cpu_times_s, irq) - 32usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_cpu_info_s { ++ pub model: *mut ::std::os::raw::c_char, ++ pub speed: ::std::os::raw::c_int, ++ pub cpu_times: uv_cpu_times_s, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_cpu_info_s"][::std::mem::size_of::() - 56usize]; ++ ["Alignment of uv_cpu_info_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_cpu_info_s::model"] ++ [::std::mem::offset_of!(uv_cpu_info_s, model) - 0usize]; ++ ["Offset of field: uv_cpu_info_s::speed"] ++ [::std::mem::offset_of!(uv_cpu_info_s, speed) - 8usize]; ++ ["Offset of field: uv_cpu_info_s::cpu_times"] ++ [::std::mem::offset_of!(uv_cpu_info_s, cpu_times) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_interface_address_s { ++ pub name: *mut ::std::os::raw::c_char, ++ pub phys_addr: [::std::os::raw::c_char; 6usize], ++ pub is_internal: ::std::os::raw::c_int, ++ pub address: uv_interface_address_s__bindgen_ty_1, ++ pub netmask: uv_interface_address_s__bindgen_ty_2, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_interface_address_s__bindgen_ty_1 { ++ pub address4: sockaddr_in, ++ pub address6: sockaddr_in6, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_interface_address_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 28usize]; ++ ["Alignment of uv_interface_address_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 4usize]; ++ ["Offset of field: uv_interface_address_s__bindgen_ty_1::address4"][::std::mem::offset_of!( ++ uv_interface_address_s__bindgen_ty_1, ++ address4 ++ ) ++ - 0usize]; ++ ["Offset of field: uv_interface_address_s__bindgen_ty_1::address6"][::std::mem::offset_of!( ++ uv_interface_address_s__bindgen_ty_1, ++ address6 ++ ) ++ - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_interface_address_s__bindgen_ty_2 { ++ pub netmask4: sockaddr_in, ++ pub netmask6: sockaddr_in6, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_interface_address_s__bindgen_ty_2"] ++ [::std::mem::size_of::() - 28usize]; ++ ["Alignment of uv_interface_address_s__bindgen_ty_2"] ++ [::std::mem::align_of::() - 4usize]; ++ ["Offset of field: uv_interface_address_s__bindgen_ty_2::netmask4"][::std::mem::offset_of!( ++ uv_interface_address_s__bindgen_ty_2, ++ netmask4 ++ ) ++ - 0usize]; ++ ["Offset of field: uv_interface_address_s__bindgen_ty_2::netmask6"][::std::mem::offset_of!( ++ uv_interface_address_s__bindgen_ty_2, ++ netmask6 ++ ) ++ - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_interface_address_s"] ++ [::std::mem::size_of::() - 80usize]; ++ ["Alignment of uv_interface_address_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_interface_address_s::name"] ++ [::std::mem::offset_of!(uv_interface_address_s, name) - 0usize]; ++ ["Offset of field: uv_interface_address_s::phys_addr"] ++ [::std::mem::offset_of!(uv_interface_address_s, phys_addr) - 8usize]; ++ ["Offset of field: uv_interface_address_s::is_internal"] ++ [::std::mem::offset_of!(uv_interface_address_s, is_internal) - 16usize]; ++ ["Offset of field: uv_interface_address_s::address"] ++ [::std::mem::offset_of!(uv_interface_address_s, address) - 20usize]; ++ ["Offset of field: uv_interface_address_s::netmask"] ++ [::std::mem::offset_of!(uv_interface_address_s, netmask) - 48usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_passwd_s { ++ pub username: *mut ::std::os::raw::c_char, ++ pub uid: ::std::os::raw::c_ulong, ++ pub gid: ::std::os::raw::c_ulong, ++ pub shell: *mut ::std::os::raw::c_char, ++ pub homedir: *mut ::std::os::raw::c_char, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_passwd_s"][::std::mem::size_of::() - 40usize]; ++ ["Alignment of uv_passwd_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_passwd_s::username"] ++ [::std::mem::offset_of!(uv_passwd_s, username) - 0usize]; ++ ["Offset of field: uv_passwd_s::uid"] ++ [::std::mem::offset_of!(uv_passwd_s, uid) - 8usize]; ++ ["Offset of field: uv_passwd_s::gid"] ++ [::std::mem::offset_of!(uv_passwd_s, gid) - 16usize]; ++ ["Offset of field: uv_passwd_s::shell"] ++ [::std::mem::offset_of!(uv_passwd_s, shell) - 24usize]; ++ ["Offset of field: uv_passwd_s::homedir"] ++ [::std::mem::offset_of!(uv_passwd_s, homedir) - 32usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_group_s { ++ pub groupname: *mut ::std::os::raw::c_char, ++ pub gid: ::std::os::raw::c_ulong, ++ pub members: *mut *mut ::std::os::raw::c_char, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_group_s"][::std::mem::size_of::() - 24usize]; ++ ["Alignment of uv_group_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_group_s::groupname"] ++ [::std::mem::offset_of!(uv_group_s, groupname) - 0usize]; ++ ["Offset of field: uv_group_s::gid"] ++ [::std::mem::offset_of!(uv_group_s, gid) - 8usize]; ++ ["Offset of field: uv_group_s::members"] ++ [::std::mem::offset_of!(uv_group_s, members) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_utsname_s { ++ pub sysname: [::std::os::raw::c_char; 256usize], ++ pub release: [::std::os::raw::c_char; 256usize], ++ pub version: [::std::os::raw::c_char; 256usize], ++ pub machine: [::std::os::raw::c_char; 256usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_utsname_s"][::std::mem::size_of::() - 1024usize]; ++ ["Alignment of uv_utsname_s"] ++ [::std::mem::align_of::() - 1usize]; ++ ["Offset of field: uv_utsname_s::sysname"] ++ [::std::mem::offset_of!(uv_utsname_s, sysname) - 0usize]; ++ ["Offset of field: uv_utsname_s::release"] ++ [::std::mem::offset_of!(uv_utsname_s, release) - 256usize]; ++ ["Offset of field: uv_utsname_s::version"] ++ [::std::mem::offset_of!(uv_utsname_s, version) - 512usize]; ++ ["Offset of field: uv_utsname_s::machine"] ++ [::std::mem::offset_of!(uv_utsname_s, machine) - 768usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_statfs_s { ++ pub f_type: u64, ++ pub f_bsize: u64, ++ pub f_blocks: u64, ++ pub f_bfree: u64, ++ pub f_bavail: u64, ++ pub f_files: u64, ++ pub f_ffree: u64, ++ pub f_spare: [u64; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_statfs_s"][::std::mem::size_of::() - 88usize]; ++ ["Alignment of uv_statfs_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_statfs_s::f_type"] ++ [::std::mem::offset_of!(uv_statfs_s, f_type) - 0usize]; ++ ["Offset of field: uv_statfs_s::f_bsize"] ++ [::std::mem::offset_of!(uv_statfs_s, f_bsize) - 8usize]; ++ ["Offset of field: uv_statfs_s::f_blocks"] ++ [::std::mem::offset_of!(uv_statfs_s, f_blocks) - 16usize]; ++ ["Offset of field: uv_statfs_s::f_bfree"] ++ [::std::mem::offset_of!(uv_statfs_s, f_bfree) - 24usize]; ++ ["Offset of field: uv_statfs_s::f_bavail"] ++ [::std::mem::offset_of!(uv_statfs_s, f_bavail) - 32usize]; ++ ["Offset of field: uv_statfs_s::f_files"] ++ [::std::mem::offset_of!(uv_statfs_s, f_files) - 40usize]; ++ ["Offset of field: uv_statfs_s::f_ffree"] ++ [::std::mem::offset_of!(uv_statfs_s, f_ffree) - 48usize]; ++ ["Offset of field: uv_statfs_s::f_spare"] ++ [::std::mem::offset_of!(uv_statfs_s, f_spare) - 56usize]; ++}; ++impl uv_dirent_type_t { ++ pub const UV_DIRENT_UNKNOWN: uv_dirent_type_t = uv_dirent_type_t(0); ++} ++impl uv_dirent_type_t { ++ pub const UV_DIRENT_FILE: uv_dirent_type_t = uv_dirent_type_t(1); ++} ++impl uv_dirent_type_t { ++ pub const UV_DIRENT_DIR: uv_dirent_type_t = uv_dirent_type_t(2); ++} ++impl uv_dirent_type_t { ++ pub const UV_DIRENT_LINK: uv_dirent_type_t = uv_dirent_type_t(3); ++} ++impl uv_dirent_type_t { ++ pub const UV_DIRENT_FIFO: uv_dirent_type_t = uv_dirent_type_t(4); ++} ++impl uv_dirent_type_t { ++ pub const UV_DIRENT_SOCKET: uv_dirent_type_t = uv_dirent_type_t(5); ++} ++impl uv_dirent_type_t { ++ pub const UV_DIRENT_CHAR: uv_dirent_type_t = uv_dirent_type_t(6); ++} ++impl uv_dirent_type_t { ++ pub const UV_DIRENT_BLOCK: uv_dirent_type_t = uv_dirent_type_t(7); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_dirent_type_t(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_dirent_s { ++ pub name: *const ::std::os::raw::c_char, ++ pub type_: uv_dirent_type_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_dirent_s"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_dirent_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_dirent_s::name"] ++ [::std::mem::offset_of!(uv_dirent_s, name) - 0usize]; ++ ["Offset of field: uv_dirent_s::type_"] ++ [::std::mem::offset_of!(uv_dirent_s, type_) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_rusage_t { ++ pub ru_utime: uv_timeval_t, ++ pub ru_stime: uv_timeval_t, ++ pub ru_maxrss: u64, ++ pub ru_ixrss: u64, ++ pub ru_idrss: u64, ++ pub ru_isrss: u64, ++ pub ru_minflt: u64, ++ pub ru_majflt: u64, ++ pub ru_nswap: u64, ++ pub ru_inblock: u64, ++ pub ru_oublock: u64, ++ pub ru_msgsnd: u64, ++ pub ru_msgrcv: u64, ++ pub ru_nsignals: u64, ++ pub ru_nvcsw: u64, ++ pub ru_nivcsw: u64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_rusage_t"][::std::mem::size_of::() - 144usize]; ++ ["Alignment of uv_rusage_t"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_rusage_t::ru_utime"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_utime) - 0usize]; ++ ["Offset of field: uv_rusage_t::ru_stime"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_stime) - 16usize]; ++ ["Offset of field: uv_rusage_t::ru_maxrss"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_maxrss) - 32usize]; ++ ["Offset of field: uv_rusage_t::ru_ixrss"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_ixrss) - 40usize]; ++ ["Offset of field: uv_rusage_t::ru_idrss"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_idrss) - 48usize]; ++ ["Offset of field: uv_rusage_t::ru_isrss"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_isrss) - 56usize]; ++ ["Offset of field: uv_rusage_t::ru_minflt"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_minflt) - 64usize]; ++ ["Offset of field: uv_rusage_t::ru_majflt"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_majflt) - 72usize]; ++ ["Offset of field: uv_rusage_t::ru_nswap"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_nswap) - 80usize]; ++ ["Offset of field: uv_rusage_t::ru_inblock"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_inblock) - 88usize]; ++ ["Offset of field: uv_rusage_t::ru_oublock"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_oublock) - 96usize]; ++ ["Offset of field: uv_rusage_t::ru_msgsnd"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_msgsnd) - 104usize]; ++ ["Offset of field: uv_rusage_t::ru_msgrcv"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_msgrcv) - 112usize]; ++ ["Offset of field: uv_rusage_t::ru_nsignals"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_nsignals) - 120usize]; ++ ["Offset of field: uv_rusage_t::ru_nvcsw"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_nvcsw) - 128usize]; ++ ["Offset of field: uv_rusage_t::ru_nivcsw"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_nivcsw) - 136usize]; ++}; ++pub const UV_THREAD_PRIORITY_HIGHEST: _bindgen_ty_2 = _bindgen_ty_2(2); ++pub const UV_THREAD_PRIORITY_ABOVE_NORMAL: _bindgen_ty_2 = _bindgen_ty_2(1); ++pub const UV_THREAD_PRIORITY_NORMAL: _bindgen_ty_2 = _bindgen_ty_2(0); ++pub const UV_THREAD_PRIORITY_BELOW_NORMAL: _bindgen_ty_2 = _bindgen_ty_2(-1); ++pub const UV_THREAD_PRIORITY_LOWEST: _bindgen_ty_2 = _bindgen_ty_2(-2); ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct _bindgen_ty_2(pub ::std::os::raw::c_int); ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_env_item_s { ++ pub name: *mut ::std::os::raw::c_char, ++ pub value: *mut ::std::os::raw::c_char, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_env_item_s"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_env_item_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_env_item_s::name"] ++ [::std::mem::offset_of!(uv_env_item_s, name) - 0usize]; ++ ["Offset of field: uv_env_item_s::value"] ++ [::std::mem::offset_of!(uv_env_item_s, value) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_metrics_s { ++ pub loop_count: u64, ++ pub events: u64, ++ pub events_waiting: u64, ++ pub reserved: [*mut u64; 13usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_metrics_s"][::std::mem::size_of::() - 128usize]; ++ ["Alignment of uv_metrics_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_metrics_s::loop_count"] ++ [::std::mem::offset_of!(uv_metrics_s, loop_count) - 0usize]; ++ ["Offset of field: uv_metrics_s::events"] ++ [::std::mem::offset_of!(uv_metrics_s, events) - 8usize]; ++ ["Offset of field: uv_metrics_s::events_waiting"] ++ [::std::mem::offset_of!(uv_metrics_s, events_waiting) - 16usize]; ++ ["Offset of field: uv_metrics_s::reserved"] ++ [::std::mem::offset_of!(uv_metrics_s, reserved) - 24usize]; ++}; ++impl uv_fs_type { ++ pub const UV_FS_UNKNOWN: uv_fs_type = uv_fs_type(-1); ++} ++impl uv_fs_type { ++ pub const UV_FS_CUSTOM: uv_fs_type = uv_fs_type(0); ++} ++impl uv_fs_type { ++ pub const UV_FS_OPEN: uv_fs_type = uv_fs_type(1); ++} ++impl uv_fs_type { ++ pub const UV_FS_CLOSE: uv_fs_type = uv_fs_type(2); ++} ++impl uv_fs_type { ++ pub const UV_FS_READ: uv_fs_type = uv_fs_type(3); ++} ++impl uv_fs_type { ++ pub const UV_FS_WRITE: uv_fs_type = uv_fs_type(4); ++} ++impl uv_fs_type { ++ pub const UV_FS_SENDFILE: uv_fs_type = uv_fs_type(5); ++} ++impl uv_fs_type { ++ pub const UV_FS_STAT: uv_fs_type = uv_fs_type(6); ++} ++impl uv_fs_type { ++ pub const UV_FS_LSTAT: uv_fs_type = uv_fs_type(7); ++} ++impl uv_fs_type { ++ pub const UV_FS_FSTAT: uv_fs_type = uv_fs_type(8); ++} ++impl uv_fs_type { ++ pub const UV_FS_FTRUNCATE: uv_fs_type = uv_fs_type(9); ++} ++impl uv_fs_type { ++ pub const UV_FS_UTIME: uv_fs_type = uv_fs_type(10); ++} ++impl uv_fs_type { ++ pub const UV_FS_FUTIME: uv_fs_type = uv_fs_type(11); ++} ++impl uv_fs_type { ++ pub const UV_FS_ACCESS: uv_fs_type = uv_fs_type(12); ++} ++impl uv_fs_type { ++ pub const UV_FS_CHMOD: uv_fs_type = uv_fs_type(13); ++} ++impl uv_fs_type { ++ pub const UV_FS_FCHMOD: uv_fs_type = uv_fs_type(14); ++} ++impl uv_fs_type { ++ pub const UV_FS_FSYNC: uv_fs_type = uv_fs_type(15); ++} ++impl uv_fs_type { ++ pub const UV_FS_FDATASYNC: uv_fs_type = uv_fs_type(16); ++} ++impl uv_fs_type { ++ pub const UV_FS_UNLINK: uv_fs_type = uv_fs_type(17); ++} ++impl uv_fs_type { ++ pub const UV_FS_RMDIR: uv_fs_type = uv_fs_type(18); ++} ++impl uv_fs_type { ++ pub const UV_FS_MKDIR: uv_fs_type = uv_fs_type(19); ++} ++impl uv_fs_type { ++ pub const UV_FS_MKDTEMP: uv_fs_type = uv_fs_type(20); ++} ++impl uv_fs_type { ++ pub const UV_FS_RENAME: uv_fs_type = uv_fs_type(21); ++} ++impl uv_fs_type { ++ pub const UV_FS_SCANDIR: uv_fs_type = uv_fs_type(22); ++} ++impl uv_fs_type { ++ pub const UV_FS_LINK: uv_fs_type = uv_fs_type(23); ++} ++impl uv_fs_type { ++ pub const UV_FS_SYMLINK: uv_fs_type = uv_fs_type(24); ++} ++impl uv_fs_type { ++ pub const UV_FS_READLINK: uv_fs_type = uv_fs_type(25); ++} ++impl uv_fs_type { ++ pub const UV_FS_CHOWN: uv_fs_type = uv_fs_type(26); ++} ++impl uv_fs_type { ++ pub const UV_FS_FCHOWN: uv_fs_type = uv_fs_type(27); ++} ++impl uv_fs_type { ++ pub const UV_FS_REALPATH: uv_fs_type = uv_fs_type(28); ++} ++impl uv_fs_type { ++ pub const UV_FS_COPYFILE: uv_fs_type = uv_fs_type(29); ++} ++impl uv_fs_type { ++ pub const UV_FS_LCHOWN: uv_fs_type = uv_fs_type(30); ++} ++impl uv_fs_type { ++ pub const UV_FS_OPENDIR: uv_fs_type = uv_fs_type(31); ++} ++impl uv_fs_type { ++ pub const UV_FS_READDIR: uv_fs_type = uv_fs_type(32); ++} ++impl uv_fs_type { ++ pub const UV_FS_CLOSEDIR: uv_fs_type = uv_fs_type(33); ++} ++impl uv_fs_type { ++ pub const UV_FS_STATFS: uv_fs_type = uv_fs_type(34); ++} ++impl uv_fs_type { ++ pub const UV_FS_MKSTEMP: uv_fs_type = uv_fs_type(35); ++} ++impl uv_fs_type { ++ pub const UV_FS_LUTIME: uv_fs_type = uv_fs_type(36); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_fs_type(pub ::std::os::raw::c_int); ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_dir_s { ++ pub dirents: *mut uv_dirent_t, ++ pub nentries: usize, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++ pub dir: *mut DIR, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_dir_s"][::std::mem::size_of::() - 56usize]; ++ ["Alignment of uv_dir_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_dir_s::dirents"] ++ [::std::mem::offset_of!(uv_dir_s, dirents) - 0usize]; ++ ["Offset of field: uv_dir_s::nentries"] ++ [::std::mem::offset_of!(uv_dir_s, nentries) - 8usize]; ++ ["Offset of field: uv_dir_s::reserved"] ++ [::std::mem::offset_of!(uv_dir_s, reserved) - 16usize]; ++ ["Offset of field: uv_dir_s::dir"] ++ [::std::mem::offset_of!(uv_dir_s, dir) - 48usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_fs_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub fs_type: uv_fs_type, ++ pub loop_: *mut uv_loop_t, ++ pub cb: uv_fs_cb, ++ pub result: isize, ++ pub ptr: *mut ::std::os::raw::c_void, ++ pub path: *const ::std::os::raw::c_char, ++ pub statbuf: uv_stat_t, ++ pub new_path: *const ::std::os::raw::c_char, ++ pub file: uv_file, ++ pub flags: ::std::os::raw::c_int, ++ pub mode: mode_t, ++ pub nbufs: ::std::os::raw::c_uint, ++ pub bufs: *mut uv_buf_t, ++ pub off: off_t, ++ pub uid: uv_uid_t, ++ pub gid: uv_gid_t, ++ pub atime: f64, ++ pub mtime: f64, ++ pub work_req: uv__work, ++ pub bufsml: [uv_buf_t; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_fs_s"][::std::mem::size_of::() - 440usize]; ++ ["Alignment of uv_fs_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_fs_s::data"] ++ [::std::mem::offset_of!(uv_fs_s, data) - 0usize]; ++ ["Offset of field: uv_fs_s::type_"] ++ [::std::mem::offset_of!(uv_fs_s, type_) - 8usize]; ++ ["Offset of field: uv_fs_s::reserved"] ++ [::std::mem::offset_of!(uv_fs_s, reserved) - 16usize]; ++ ["Offset of field: uv_fs_s::fs_type"] ++ [::std::mem::offset_of!(uv_fs_s, fs_type) - 64usize]; ++ ["Offset of field: uv_fs_s::loop_"] ++ [::std::mem::offset_of!(uv_fs_s, loop_) - 72usize]; ++ ["Offset of field: uv_fs_s::cb"] ++ [::std::mem::offset_of!(uv_fs_s, cb) - 80usize]; ++ ["Offset of field: uv_fs_s::result"] ++ [::std::mem::offset_of!(uv_fs_s, result) - 88usize]; ++ ["Offset of field: uv_fs_s::ptr"] ++ [::std::mem::offset_of!(uv_fs_s, ptr) - 96usize]; ++ ["Offset of field: uv_fs_s::path"] ++ [::std::mem::offset_of!(uv_fs_s, path) - 104usize]; ++ ["Offset of field: uv_fs_s::statbuf"] ++ [::std::mem::offset_of!(uv_fs_s, statbuf) - 112usize]; ++ ["Offset of field: uv_fs_s::new_path"] ++ [::std::mem::offset_of!(uv_fs_s, new_path) - 272usize]; ++ ["Offset of field: uv_fs_s::file"] ++ [::std::mem::offset_of!(uv_fs_s, file) - 280usize]; ++ ["Offset of field: uv_fs_s::flags"] ++ [::std::mem::offset_of!(uv_fs_s, flags) - 284usize]; ++ ["Offset of field: uv_fs_s::mode"] ++ [::std::mem::offset_of!(uv_fs_s, mode) - 288usize]; ++ ["Offset of field: uv_fs_s::nbufs"] ++ [::std::mem::offset_of!(uv_fs_s, nbufs) - 292usize]; ++ ["Offset of field: uv_fs_s::bufs"] ++ [::std::mem::offset_of!(uv_fs_s, bufs) - 296usize]; ++ ["Offset of field: uv_fs_s::off"] ++ [::std::mem::offset_of!(uv_fs_s, off) - 304usize]; ++ ["Offset of field: uv_fs_s::uid"] ++ [::std::mem::offset_of!(uv_fs_s, uid) - 312usize]; ++ ["Offset of field: uv_fs_s::gid"] ++ [::std::mem::offset_of!(uv_fs_s, gid) - 316usize]; ++ ["Offset of field: uv_fs_s::atime"] ++ [::std::mem::offset_of!(uv_fs_s, atime) - 320usize]; ++ ["Offset of field: uv_fs_s::mtime"] ++ [::std::mem::offset_of!(uv_fs_s, mtime) - 328usize]; ++ ["Offset of field: uv_fs_s::work_req"] ++ [::std::mem::offset_of!(uv_fs_s, work_req) - 336usize]; ++ ["Offset of field: uv_fs_s::bufsml"] ++ [::std::mem::offset_of!(uv_fs_s, bufsml) - 376usize]; ++}; ++impl uv_fs_event { ++ pub const UV_RENAME: uv_fs_event = uv_fs_event(1); ++} ++impl uv_fs_event { ++ pub const UV_CHANGE: uv_fs_event = uv_fs_event(2); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_fs_event(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_fs_event_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_fs_event_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub path: *mut ::std::os::raw::c_char, ++ pub cb: uv_fs_event_cb, ++ pub event_watcher: uv__io_t, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_fs_event_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_fs_event_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_fs_event_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_fs_event_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_fs_event_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_fs_event_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_fs_event_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_fs_event_s"][::std::mem::size_of::() - 176usize]; ++ ["Alignment of uv_fs_event_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_fs_event_s::data"] ++ [::std::mem::offset_of!(uv_fs_event_s, data) - 0usize]; ++ ["Offset of field: uv_fs_event_s::loop_"] ++ [::std::mem::offset_of!(uv_fs_event_s, loop_) - 8usize]; ++ ["Offset of field: uv_fs_event_s::type_"] ++ [::std::mem::offset_of!(uv_fs_event_s, type_) - 16usize]; ++ ["Offset of field: uv_fs_event_s::close_cb"] ++ [::std::mem::offset_of!(uv_fs_event_s, close_cb) - 24usize]; ++ ["Offset of field: uv_fs_event_s::handle_queue"] ++ [::std::mem::offset_of!(uv_fs_event_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_fs_event_s::u"] ++ [::std::mem::offset_of!(uv_fs_event_s, u) - 48usize]; ++ ["Offset of field: uv_fs_event_s::next_closing"] ++ [::std::mem::offset_of!(uv_fs_event_s, next_closing) - 80usize]; ++ ["Offset of field: uv_fs_event_s::flags"] ++ [::std::mem::offset_of!(uv_fs_event_s, flags) - 88usize]; ++ ["Offset of field: uv_fs_event_s::path"] ++ [::std::mem::offset_of!(uv_fs_event_s, path) - 96usize]; ++ ["Offset of field: uv_fs_event_s::cb"] ++ [::std::mem::offset_of!(uv_fs_event_s, cb) - 104usize]; ++ ["Offset of field: uv_fs_event_s::event_watcher"] ++ [::std::mem::offset_of!(uv_fs_event_s, event_watcher) - 112usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_fs_poll_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_fs_poll_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub poll_ctx: *mut ::std::os::raw::c_void, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_fs_poll_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_fs_poll_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_fs_poll_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_fs_poll_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_fs_poll_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_fs_poll_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_fs_poll_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_fs_poll_s"][::std::mem::size_of::() - 104usize]; ++ ["Alignment of uv_fs_poll_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_fs_poll_s::data"] ++ [::std::mem::offset_of!(uv_fs_poll_s, data) - 0usize]; ++ ["Offset of field: uv_fs_poll_s::loop_"] ++ [::std::mem::offset_of!(uv_fs_poll_s, loop_) - 8usize]; ++ ["Offset of field: uv_fs_poll_s::type_"] ++ [::std::mem::offset_of!(uv_fs_poll_s, type_) - 16usize]; ++ ["Offset of field: uv_fs_poll_s::close_cb"] ++ [::std::mem::offset_of!(uv_fs_poll_s, close_cb) - 24usize]; ++ ["Offset of field: uv_fs_poll_s::handle_queue"] ++ [::std::mem::offset_of!(uv_fs_poll_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_fs_poll_s::u"] ++ [::std::mem::offset_of!(uv_fs_poll_s, u) - 48usize]; ++ ["Offset of field: uv_fs_poll_s::next_closing"] ++ [::std::mem::offset_of!(uv_fs_poll_s, next_closing) - 80usize]; ++ ["Offset of field: uv_fs_poll_s::flags"] ++ [::std::mem::offset_of!(uv_fs_poll_s, flags) - 88usize]; ++ ["Offset of field: uv_fs_poll_s::poll_ctx"] ++ [::std::mem::offset_of!(uv_fs_poll_s, poll_ctx) - 96usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_signal_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_signal_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub signal_cb: uv_signal_cb, ++ pub signum: ::std::os::raw::c_int, ++ pub tree_entry: uv_signal_s__bindgen_ty_2, ++ pub caught_signals: ::std::os::raw::c_uint, ++ pub dispatched_signals: ::std::os::raw::c_uint, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_signal_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_signal_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_signal_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_signal_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_signal_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_signal_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_signal_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_signal_s__bindgen_ty_2 { ++ pub rbe_left: *mut uv_signal_s, ++ pub rbe_right: *mut uv_signal_s, ++ pub rbe_parent: *mut uv_signal_s, ++ pub rbe_color: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_signal_s__bindgen_ty_2"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_signal_s__bindgen_ty_2"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_signal_s__bindgen_ty_2::rbe_left"] ++ [::std::mem::offset_of!(uv_signal_s__bindgen_ty_2, rbe_left) - 0usize]; ++ ["Offset of field: uv_signal_s__bindgen_ty_2::rbe_right"] ++ [::std::mem::offset_of!(uv_signal_s__bindgen_ty_2, rbe_right) - 8usize]; ++ ["Offset of field: uv_signal_s__bindgen_ty_2::rbe_parent"] ++ [::std::mem::offset_of!(uv_signal_s__bindgen_ty_2, rbe_parent) - 16usize]; ++ ["Offset of field: uv_signal_s__bindgen_ty_2::rbe_color"] ++ [::std::mem::offset_of!(uv_signal_s__bindgen_ty_2, rbe_color) - 24usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_signal_s"][::std::mem::size_of::() - 152usize]; ++ ["Alignment of uv_signal_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_signal_s::data"] ++ [::std::mem::offset_of!(uv_signal_s, data) - 0usize]; ++ ["Offset of field: uv_signal_s::loop_"] ++ [::std::mem::offset_of!(uv_signal_s, loop_) - 8usize]; ++ ["Offset of field: uv_signal_s::type_"] ++ [::std::mem::offset_of!(uv_signal_s, type_) - 16usize]; ++ ["Offset of field: uv_signal_s::close_cb"] ++ [::std::mem::offset_of!(uv_signal_s, close_cb) - 24usize]; ++ ["Offset of field: uv_signal_s::handle_queue"] ++ [::std::mem::offset_of!(uv_signal_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_signal_s::u"] ++ [::std::mem::offset_of!(uv_signal_s, u) - 48usize]; ++ ["Offset of field: uv_signal_s::next_closing"] ++ [::std::mem::offset_of!(uv_signal_s, next_closing) - 80usize]; ++ ["Offset of field: uv_signal_s::flags"] ++ [::std::mem::offset_of!(uv_signal_s, flags) - 88usize]; ++ ["Offset of field: uv_signal_s::signal_cb"] ++ [::std::mem::offset_of!(uv_signal_s, signal_cb) - 96usize]; ++ ["Offset of field: uv_signal_s::signum"] ++ [::std::mem::offset_of!(uv_signal_s, signum) - 104usize]; ++ ["Offset of field: uv_signal_s::tree_entry"] ++ [::std::mem::offset_of!(uv_signal_s, tree_entry) - 112usize]; ++ ["Offset of field: uv_signal_s::caught_signals"] ++ [::std::mem::offset_of!(uv_signal_s, caught_signals) - 144usize]; ++ ["Offset of field: uv_signal_s::dispatched_signals"] ++ [::std::mem::offset_of!(uv_signal_s, dispatched_signals) - 148usize]; ++}; ++impl uv_fs_event_flags { ++ pub const UV_FS_EVENT_WATCH_ENTRY: uv_fs_event_flags = uv_fs_event_flags(1); ++} ++impl uv_fs_event_flags { ++ pub const UV_FS_EVENT_STAT: uv_fs_event_flags = uv_fs_event_flags(2); ++} ++impl uv_fs_event_flags { ++ pub const UV_FS_EVENT_RECURSIVE: uv_fs_event_flags = uv_fs_event_flags(4); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_fs_event_flags(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_random_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub loop_: *mut uv_loop_t, ++ pub status: ::std::os::raw::c_int, ++ pub buf: *mut ::std::os::raw::c_void, ++ pub buflen: usize, ++ pub cb: uv_random_cb, ++ pub work_req: uv__work, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_random_s"][::std::mem::size_of::() - 144usize]; ++ ["Alignment of uv_random_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_random_s::data"] ++ [::std::mem::offset_of!(uv_random_s, data) - 0usize]; ++ ["Offset of field: uv_random_s::type_"] ++ [::std::mem::offset_of!(uv_random_s, type_) - 8usize]; ++ ["Offset of field: uv_random_s::reserved"] ++ [::std::mem::offset_of!(uv_random_s, reserved) - 16usize]; ++ ["Offset of field: uv_random_s::loop_"] ++ [::std::mem::offset_of!(uv_random_s, loop_) - 64usize]; ++ ["Offset of field: uv_random_s::status"] ++ [::std::mem::offset_of!(uv_random_s, status) - 72usize]; ++ ["Offset of field: uv_random_s::buf"] ++ [::std::mem::offset_of!(uv_random_s, buf) - 80usize]; ++ ["Offset of field: uv_random_s::buflen"] ++ [::std::mem::offset_of!(uv_random_s, buflen) - 88usize]; ++ ["Offset of field: uv_random_s::cb"] ++ [::std::mem::offset_of!(uv_random_s, cb) - 96usize]; ++ ["Offset of field: uv_random_s::work_req"] ++ [::std::mem::offset_of!(uv_random_s, work_req) - 104usize]; ++}; ++pub type uv_thread_cb = ++ ::std::option::Option; ++impl uv_thread_create_flags { ++ pub const UV_THREAD_NO_FLAGS: uv_thread_create_flags = ++ uv_thread_create_flags(0); ++} ++impl uv_thread_create_flags { ++ pub const UV_THREAD_HAS_STACK_SIZE: uv_thread_create_flags = ++ uv_thread_create_flags(1); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_thread_create_flags(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_thread_options_s { ++ pub flags: ::std::os::raw::c_uint, ++ pub stack_size: usize, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_thread_options_s"] ++ [::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_thread_options_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_thread_options_s::flags"] ++ [::std::mem::offset_of!(uv_thread_options_s, flags) - 0usize]; ++ ["Offset of field: uv_thread_options_s::stack_size"] ++ [::std::mem::offset_of!(uv_thread_options_s, stack_size) - 8usize]; ++}; ++pub type uv_thread_options_t = uv_thread_options_s; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_any_handle { ++ pub async_: uv_async_t, ++ pub check: uv_check_t, ++ pub fs_event: uv_fs_event_t, ++ pub fs_poll: uv_fs_poll_t, ++ pub handle: uv_handle_t, ++ pub idle: uv_idle_t, ++ pub pipe: uv_pipe_t, ++ pub poll: uv_poll_t, ++ pub prepare: uv_prepare_t, ++ pub process: uv_process_t, ++ pub stream: uv_stream_t, ++ pub tcp: uv_tcp_t, ++ pub timer: uv_timer_t, ++ pub tty: uv_tty_t, ++ pub udp: uv_udp_t, ++ pub signal: uv_signal_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_any_handle"][::std::mem::size_of::() - 304usize]; ++ ["Alignment of uv_any_handle"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_any_handle::async_"] ++ [::std::mem::offset_of!(uv_any_handle, async_) - 0usize]; ++ ["Offset of field: uv_any_handle::check"] ++ [::std::mem::offset_of!(uv_any_handle, check) - 0usize]; ++ ["Offset of field: uv_any_handle::fs_event"] ++ [::std::mem::offset_of!(uv_any_handle, fs_event) - 0usize]; ++ ["Offset of field: uv_any_handle::fs_poll"] ++ [::std::mem::offset_of!(uv_any_handle, fs_poll) - 0usize]; ++ ["Offset of field: uv_any_handle::handle"] ++ [::std::mem::offset_of!(uv_any_handle, handle) - 0usize]; ++ ["Offset of field: uv_any_handle::idle"] ++ [::std::mem::offset_of!(uv_any_handle, idle) - 0usize]; ++ ["Offset of field: uv_any_handle::pipe"] ++ [::std::mem::offset_of!(uv_any_handle, pipe) - 0usize]; ++ ["Offset of field: uv_any_handle::poll"] ++ [::std::mem::offset_of!(uv_any_handle, poll) - 0usize]; ++ ["Offset of field: uv_any_handle::prepare"] ++ [::std::mem::offset_of!(uv_any_handle, prepare) - 0usize]; ++ ["Offset of field: uv_any_handle::process"] ++ [::std::mem::offset_of!(uv_any_handle, process) - 0usize]; ++ ["Offset of field: uv_any_handle::stream"] ++ [::std::mem::offset_of!(uv_any_handle, stream) - 0usize]; ++ ["Offset of field: uv_any_handle::tcp"] ++ [::std::mem::offset_of!(uv_any_handle, tcp) - 0usize]; ++ ["Offset of field: uv_any_handle::timer"] ++ [::std::mem::offset_of!(uv_any_handle, timer) - 0usize]; ++ ["Offset of field: uv_any_handle::tty"] ++ [::std::mem::offset_of!(uv_any_handle, tty) - 0usize]; ++ ["Offset of field: uv_any_handle::udp"] ++ [::std::mem::offset_of!(uv_any_handle, udp) - 0usize]; ++ ["Offset of field: uv_any_handle::signal"] ++ [::std::mem::offset_of!(uv_any_handle, signal) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_any_req { ++ pub req: uv_req_t, ++ pub connect: uv_connect_t, ++ pub write: uv_write_t, ++ pub shutdown: uv_shutdown_t, ++ pub udp_send: uv_udp_send_t, ++ pub fs: uv_fs_t, ++ pub work: uv_work_t, ++ pub getaddrinfo: uv_getaddrinfo_t, ++ pub getnameinfo: uv_getnameinfo_t, ++ pub random: uv_random_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_any_req"][::std::mem::size_of::() - 1320usize]; ++ ["Alignment of uv_any_req"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_any_req::req"] ++ [::std::mem::offset_of!(uv_any_req, req) - 0usize]; ++ ["Offset of field: uv_any_req::connect"] ++ [::std::mem::offset_of!(uv_any_req, connect) - 0usize]; ++ ["Offset of field: uv_any_req::write"] ++ [::std::mem::offset_of!(uv_any_req, write) - 0usize]; ++ ["Offset of field: uv_any_req::shutdown"] ++ [::std::mem::offset_of!(uv_any_req, shutdown) - 0usize]; ++ ["Offset of field: uv_any_req::udp_send"] ++ [::std::mem::offset_of!(uv_any_req, udp_send) - 0usize]; ++ ["Offset of field: uv_any_req::fs"] ++ [::std::mem::offset_of!(uv_any_req, fs) - 0usize]; ++ ["Offset of field: uv_any_req::work"] ++ [::std::mem::offset_of!(uv_any_req, work) - 0usize]; ++ ["Offset of field: uv_any_req::getaddrinfo"] ++ [::std::mem::offset_of!(uv_any_req, getaddrinfo) - 0usize]; ++ ["Offset of field: uv_any_req::getnameinfo"] ++ [::std::mem::offset_of!(uv_any_req, getnameinfo) - 0usize]; ++ ["Offset of field: uv_any_req::random"] ++ [::std::mem::offset_of!(uv_any_req, random) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_loop_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub active_handles: ::std::os::raw::c_uint, ++ pub handle_queue: uv__queue, ++ pub active_reqs: uv_loop_s__bindgen_ty_1, ++ pub internal_fields: *mut ::std::os::raw::c_void, ++ pub stop_flag: ::std::os::raw::c_uint, ++ pub flags: ::std::os::raw::c_ulong, ++ pub backend_fd: ::std::os::raw::c_int, ++ pub pending_queue: uv__queue, ++ pub watcher_queue: uv__queue, ++ pub watchers: *mut *mut uv__io_t, ++ pub nwatchers: ::std::os::raw::c_uint, ++ pub nfds: ::std::os::raw::c_uint, ++ pub wq: uv__queue, ++ pub wq_mutex: uv_mutex_t, ++ pub wq_async: uv_async_t, ++ pub cloexec_lock: uv_rwlock_t, ++ pub closing_handles: *mut uv_handle_t, ++ pub process_handles: uv__queue, ++ pub prepare_handles: uv__queue, ++ pub check_handles: uv__queue, ++ pub idle_handles: uv__queue, ++ pub async_handles: uv__queue, ++ pub async_unused: ::std::option::Option, ++ pub async_io_watcher: uv__io_t, ++ pub async_wfd: ::std::os::raw::c_int, ++ pub timer_heap: uv_loop_s__bindgen_ty_2, ++ pub timer_counter: u64, ++ pub time: u64, ++ pub signal_pipefd: [::std::os::raw::c_int; 2usize], ++ pub signal_io_watcher: uv__io_t, ++ pub child_watcher: uv_signal_t, ++ pub emfile_fd: ::std::os::raw::c_int, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_loop_s__bindgen_ty_1 { ++ pub unused: *mut ::std::os::raw::c_void, ++ pub count: ::std::os::raw::c_uint, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_loop_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 8usize]; ++ ["Alignment of uv_loop_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_loop_s__bindgen_ty_1::unused"] ++ [::std::mem::offset_of!(uv_loop_s__bindgen_ty_1, unused) - 0usize]; ++ ["Offset of field: uv_loop_s__bindgen_ty_1::count"] ++ [::std::mem::offset_of!(uv_loop_s__bindgen_ty_1, count) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_loop_s__bindgen_ty_2 { ++ pub min: *mut ::std::os::raw::c_void, ++ pub nelts: ::std::os::raw::c_uint, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_loop_s__bindgen_ty_2"] ++ [::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_loop_s__bindgen_ty_2"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_loop_s__bindgen_ty_2::min"] ++ [::std::mem::offset_of!(uv_loop_s__bindgen_ty_2, min) - 0usize]; ++ ["Offset of field: uv_loop_s__bindgen_ty_2::nelts"] ++ [::std::mem::offset_of!(uv_loop_s__bindgen_ty_2, nelts) - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_loop_s"][::std::mem::size_of::() - 712usize]; ++ ["Alignment of uv_loop_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_loop_s::data"] ++ [::std::mem::offset_of!(uv_loop_s, data) - 0usize]; ++ ["Offset of field: uv_loop_s::active_handles"] ++ [::std::mem::offset_of!(uv_loop_s, active_handles) - 8usize]; ++ ["Offset of field: uv_loop_s::handle_queue"] ++ [::std::mem::offset_of!(uv_loop_s, handle_queue) - 16usize]; ++ ["Offset of field: uv_loop_s::active_reqs"] ++ [::std::mem::offset_of!(uv_loop_s, active_reqs) - 32usize]; ++ ["Offset of field: uv_loop_s::internal_fields"] ++ [::std::mem::offset_of!(uv_loop_s, internal_fields) - 40usize]; ++ ["Offset of field: uv_loop_s::stop_flag"] ++ [::std::mem::offset_of!(uv_loop_s, stop_flag) - 48usize]; ++ ["Offset of field: uv_loop_s::flags"] ++ [::std::mem::offset_of!(uv_loop_s, flags) - 56usize]; ++ ["Offset of field: uv_loop_s::backend_fd"] ++ [::std::mem::offset_of!(uv_loop_s, backend_fd) - 64usize]; ++ ["Offset of field: uv_loop_s::pending_queue"] ++ [::std::mem::offset_of!(uv_loop_s, pending_queue) - 72usize]; ++ ["Offset of field: uv_loop_s::watcher_queue"] ++ [::std::mem::offset_of!(uv_loop_s, watcher_queue) - 88usize]; ++ ["Offset of field: uv_loop_s::watchers"] ++ [::std::mem::offset_of!(uv_loop_s, watchers) - 104usize]; ++ ["Offset of field: uv_loop_s::nwatchers"] ++ [::std::mem::offset_of!(uv_loop_s, nwatchers) - 112usize]; ++ ["Offset of field: uv_loop_s::nfds"] ++ [::std::mem::offset_of!(uv_loop_s, nfds) - 116usize]; ++ ["Offset of field: uv_loop_s::wq"] ++ [::std::mem::offset_of!(uv_loop_s, wq) - 120usize]; ++ ["Offset of field: uv_loop_s::wq_mutex"] ++ [::std::mem::offset_of!(uv_loop_s, wq_mutex) - 136usize]; ++ ["Offset of field: uv_loop_s::wq_async"] ++ [::std::mem::offset_of!(uv_loop_s, wq_async) - 144usize]; ++ ["Offset of field: uv_loop_s::cloexec_lock"] ++ [::std::mem::offset_of!(uv_loop_s, cloexec_lock) - 272usize]; ++ ["Offset of field: uv_loop_s::closing_handles"] ++ [::std::mem::offset_of!(uv_loop_s, closing_handles) - 280usize]; ++ ["Offset of field: uv_loop_s::process_handles"] ++ [::std::mem::offset_of!(uv_loop_s, process_handles) - 288usize]; ++ ["Offset of field: uv_loop_s::prepare_handles"] ++ [::std::mem::offset_of!(uv_loop_s, prepare_handles) - 304usize]; ++ ["Offset of field: uv_loop_s::check_handles"] ++ [::std::mem::offset_of!(uv_loop_s, check_handles) - 320usize]; ++ ["Offset of field: uv_loop_s::idle_handles"] ++ [::std::mem::offset_of!(uv_loop_s, idle_handles) - 336usize]; ++ ["Offset of field: uv_loop_s::async_handles"] ++ [::std::mem::offset_of!(uv_loop_s, async_handles) - 352usize]; ++ ["Offset of field: uv_loop_s::async_unused"] ++ [::std::mem::offset_of!(uv_loop_s, async_unused) - 368usize]; ++ ["Offset of field: uv_loop_s::async_io_watcher"] ++ [::std::mem::offset_of!(uv_loop_s, async_io_watcher) - 376usize]; ++ ["Offset of field: uv_loop_s::async_wfd"] ++ [::std::mem::offset_of!(uv_loop_s, async_wfd) - 440usize]; ++ ["Offset of field: uv_loop_s::timer_heap"] ++ [::std::mem::offset_of!(uv_loop_s, timer_heap) - 448usize]; ++ ["Offset of field: uv_loop_s::timer_counter"] ++ [::std::mem::offset_of!(uv_loop_s, timer_counter) - 464usize]; ++ ["Offset of field: uv_loop_s::time"] ++ [::std::mem::offset_of!(uv_loop_s, time) - 472usize]; ++ ["Offset of field: uv_loop_s::signal_pipefd"] ++ [::std::mem::offset_of!(uv_loop_s, signal_pipefd) - 480usize]; ++ ["Offset of field: uv_loop_s::signal_io_watcher"] ++ [::std::mem::offset_of!(uv_loop_s, signal_io_watcher) - 488usize]; ++ ["Offset of field: uv_loop_s::child_watcher"] ++ [::std::mem::offset_of!(uv_loop_s, child_watcher) - 552usize]; ++ ["Offset of field: uv_loop_s::emfile_fd"] ++ [::std::mem::offset_of!(uv_loop_s, emfile_fd) - 704usize]; ++}; + + +--- cargo-crates/libuv-sys-lite-1.48.3/src/bindings_freebsd_aarch64.rs.orig 2026-04-07 10:57:30 UTC ++++ cargo-crates/libuv-sys-lite-1.48.3/src/bindings_freebsd_aarch64.rs +@@ -0,0 +1,3505 @@ ++/* automatically generated by rust-bindgen 0.70.1 */ ++ ++pub const UV__EOF: i32 = -4095; ++pub const UV__UNKNOWN: i32 = -4094; ++pub const UV__EAI_ADDRFAMILY: i32 = -3000; ++pub const UV__EAI_AGAIN: i32 = -3001; ++pub const UV__EAI_BADFLAGS: i32 = -3002; ++pub const UV__EAI_CANCELED: i32 = -3003; ++pub const UV__EAI_FAIL: i32 = -3004; ++pub const UV__EAI_FAMILY: i32 = -3005; ++pub const UV__EAI_MEMORY: i32 = -3006; ++pub const UV__EAI_NODATA: i32 = -3007; ++pub const UV__EAI_NONAME: i32 = -3008; ++pub const UV__EAI_OVERFLOW: i32 = -3009; ++pub const UV__EAI_SERVICE: i32 = -3010; ++pub const UV__EAI_SOCKTYPE: i32 = -3011; ++pub const UV__EAI_BADHINTS: i32 = -3013; ++pub const UV__EAI_PROTOCOL: i32 = -3014; ++pub const UV__ECHARSET: i32 = -4080; ++pub const UV__ENONET: i32 = -4056; ++pub const UV__EREMOTEIO: i32 = -4030; ++pub const UV__ENODATA: i32 = -9919; ++pub const UV__EUNATCH: i32 = -4023; ++pub const UV_VERSION_MAJOR: u32 = 1; ++pub const UV_VERSION_MINOR: u32 = 48; ++pub const UV_VERSION_PATCH: u32 = 0; ++pub const UV_VERSION_IS_RELEASE: u32 = 1; ++pub const UV_VERSION_SUFFIX: &[u8; 1] = b"\0"; ++pub const UV_VERSION_HEX: u32 = 77824; ++pub const UV_HAVE_KQUEUE: u32 = 1; ++pub const UV__DT_FILE: u32 = 8; ++pub const UV__DT_DIR: u32 = 4; ++pub const UV__DT_LINK: u32 = 10; ++pub const UV__DT_FIFO: u32 = 1; ++pub const UV__DT_SOCKET: u32 = 12; ++pub const UV__DT_CHAR: u32 = 2; ++pub const UV__DT_BLOCK: u32 = 6; ++pub const UV_FS_O_APPEND: u32 = 8; ++pub const UV_FS_O_CREAT: u32 = 512; ++pub const UV_FS_O_DIRECT: u32 = 65536; ++pub const UV_FS_O_DIRECTORY: u32 = 131072; ++pub const UV_FS_O_DSYNC: u32 = 16777216; ++pub const UV_FS_O_EXCL: u32 = 2048; ++pub const UV_FS_O_EXLOCK: u32 = 32; ++pub const UV_FS_O_NOATIME: u32 = 0; ++pub const UV_FS_O_NOCTTY: u32 = 32768; ++pub const UV_FS_O_NOFOLLOW: u32 = 256; ++pub const UV_FS_O_NONBLOCK: u32 = 4; ++pub const UV_FS_O_RDONLY: u32 = 0; ++pub const UV_FS_O_RDWR: u32 = 2; ++pub const UV_FS_O_SYMLINK: u32 = 0; ++pub const UV_FS_O_SYNC: u32 = 128; ++pub const UV_FS_O_TRUNC: u32 = 1024; ++pub const UV_FS_O_WRONLY: u32 = 1; ++pub const UV_FS_O_FILEMAP: u32 = 0; ++pub const UV_FS_O_RANDOM: u32 = 0; ++pub const UV_FS_O_SHORT_LIVED: u32 = 0; ++pub const UV_FS_O_SEQUENTIAL: u32 = 0; ++pub const UV_FS_O_TEMPORARY: u32 = 0; ++pub const UV_PRIORITY_LOW: u32 = 19; ++pub const UV_PRIORITY_BELOW_NORMAL: u32 = 10; ++pub const UV_PRIORITY_NORMAL: u32 = 0; ++pub const UV_PRIORITY_ABOVE_NORMAL: i32 = -7; ++pub const UV_PRIORITY_HIGH: i32 = -14; ++pub const UV_PRIORITY_HIGHEST: i32 = -20; ++pub const UV_MAXHOSTNAMESIZE: u32 = 257; ++pub const UV_FS_COPYFILE_EXCL: u32 = 1; ++pub const UV_FS_COPYFILE_FICLONE: u32 = 2; ++pub const UV_FS_COPYFILE_FICLONE_FORCE: u32 = 4; ++pub const UV_FS_SYMLINK_DIR: u32 = 1; ++pub const UV_FS_SYMLINK_JUNCTION: u32 = 2; ++pub const UV_IF_NAMESIZE: u32 = 17; ++pub type __uint8_t = ::std::os::raw::c_uchar; ++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_long; ++pub type __uint64_t = ::std::os::raw::c_ulong; ++pub type __gid_t = __uint32_t; ++pub type __ino_t = __uint64_t; ++pub type __mode_t = __uint16_t; ++pub type __off_t = __int64_t; ++pub type __pid_t = __int32_t; ++pub type __sa_family_t = __uint8_t; ++pub type __socklen_t = __uint32_t; ++pub type __uid_t = __uint32_t; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union __mbstate_t { ++ pub __mbstate8: [::std::os::raw::c_char; 128usize], ++ pub _mbstateL: __int64_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __mbstate_t"][::std::mem::size_of::<__mbstate_t>() - 128usize]; ++ ["Alignment of __mbstate_t"][::std::mem::align_of::<__mbstate_t>() - 8usize]; ++ ["Offset of field: __mbstate_t::__mbstate8"] ++ [::std::mem::offset_of!(__mbstate_t, __mbstate8) - 0usize]; ++ ["Offset of field: __mbstate_t::_mbstateL"] ++ [::std::mem::offset_of!(__mbstate_t, _mbstateL) - 0usize]; ++}; ++pub type fpos_t = __off_t; ++pub type off_t = __off_t; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __sbuf { ++ pub _base: *mut ::std::os::raw::c_uchar, ++ pub _size: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __sbuf"][::std::mem::size_of::<__sbuf>() - 16usize]; ++ ["Alignment of __sbuf"][::std::mem::align_of::<__sbuf>() - 8usize]; ++ ["Offset of field: __sbuf::_base"][::std::mem::offset_of!(__sbuf, _base) - 0usize]; ++ ["Offset of field: __sbuf::_size"][::std::mem::offset_of!(__sbuf, _size) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct __sFILE { ++ pub _p: *mut ::std::os::raw::c_uchar, ++ pub _r: ::std::os::raw::c_int, ++ pub _w: ::std::os::raw::c_int, ++ pub _flags: ::std::os::raw::c_short, ++ pub _file: ::std::os::raw::c_short, ++ pub _bf: __sbuf, ++ pub _lbfsize: ::std::os::raw::c_int, ++ pub _cookie: *mut ::std::os::raw::c_void, ++ pub _close: ::std::option::Option< ++ unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, ++ >, ++ pub _read: ::std::option::Option< ++ unsafe extern "C" fn( ++ arg1: *mut ::std::os::raw::c_void, ++ arg2: *mut ::std::os::raw::c_char, ++ arg3: ::std::os::raw::c_int, ++ ) -> ::std::os::raw::c_int, ++ >, ++ pub _seek: ::std::option::Option< ++ unsafe extern "C" fn( ++ arg1: *mut ::std::os::raw::c_void, ++ arg2: fpos_t, ++ arg3: ::std::os::raw::c_int, ++ ) -> fpos_t, ++ >, ++ pub _write: ::std::option::Option< ++ unsafe extern "C" fn( ++ arg1: *mut ::std::os::raw::c_void, ++ arg2: *const ::std::os::raw::c_char, ++ arg3: ::std::os::raw::c_int, ++ ) -> ::std::os::raw::c_int, ++ >, ++ pub _ub: __sbuf, ++ pub _up: *mut ::std::os::raw::c_uchar, ++ pub _ur: ::std::os::raw::c_int, ++ pub _ubuf: [::std::os::raw::c_uchar; 3usize], ++ pub _nbuf: [::std::os::raw::c_uchar; 1usize], ++ pub _lb: __sbuf, ++ pub _blksize: ::std::os::raw::c_int, ++ pub _offset: fpos_t, ++ pub _fl_mutex: *mut pthread_mutex, ++ pub _fl_owner: *mut pthread, ++ pub _fl_count: ::std::os::raw::c_int, ++ pub _orientation: ::std::os::raw::c_int, ++ pub _mbstate: __mbstate_t, ++ pub _flags2: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __sFILE"][::std::mem::size_of::<__sFILE>() - 312usize]; ++ ["Alignment of __sFILE"][::std::mem::align_of::<__sFILE>() - 8usize]; ++ ["Offset of field: __sFILE::_p"][::std::mem::offset_of!(__sFILE, _p) - 0usize]; ++ ["Offset of field: __sFILE::_r"][::std::mem::offset_of!(__sFILE, _r) - 8usize]; ++ ["Offset of field: __sFILE::_w"][::std::mem::offset_of!(__sFILE, _w) - 12usize]; ++ ["Offset of field: __sFILE::_flags"][::std::mem::offset_of!(__sFILE, _flags) - 16usize]; ++ ["Offset of field: __sFILE::_file"][::std::mem::offset_of!(__sFILE, _file) - 18usize]; ++ ["Offset of field: __sFILE::_bf"][::std::mem::offset_of!(__sFILE, _bf) - 24usize]; ++ ["Offset of field: __sFILE::_lbfsize"][::std::mem::offset_of!(__sFILE, _lbfsize) - 40usize]; ++ ["Offset of field: __sFILE::_cookie"][::std::mem::offset_of!(__sFILE, _cookie) - 48usize]; ++ ["Offset of field: __sFILE::_close"][::std::mem::offset_of!(__sFILE, _close) - 56usize]; ++ ["Offset of field: __sFILE::_read"][::std::mem::offset_of!(__sFILE, _read) - 64usize]; ++ ["Offset of field: __sFILE::_seek"][::std::mem::offset_of!(__sFILE, _seek) - 72usize]; ++ ["Offset of field: __sFILE::_write"][::std::mem::offset_of!(__sFILE, _write) - 80usize]; ++ ["Offset of field: __sFILE::_ub"][::std::mem::offset_of!(__sFILE, _ub) - 88usize]; ++ ["Offset of field: __sFILE::_up"][::std::mem::offset_of!(__sFILE, _up) - 104usize]; ++ ["Offset of field: __sFILE::_ur"][::std::mem::offset_of!(__sFILE, _ur) - 112usize]; ++ ["Offset of field: __sFILE::_ubuf"][::std::mem::offset_of!(__sFILE, _ubuf) - 116usize]; ++ ["Offset of field: __sFILE::_nbuf"][::std::mem::offset_of!(__sFILE, _nbuf) - 119usize]; ++ ["Offset of field: __sFILE::_lb"][::std::mem::offset_of!(__sFILE, _lb) - 120usize]; ++ ["Offset of field: __sFILE::_blksize"][::std::mem::offset_of!(__sFILE, _blksize) - 136usize]; ++ ["Offset of field: __sFILE::_offset"][::std::mem::offset_of!(__sFILE, _offset) - 144usize]; ++ ["Offset of field: __sFILE::_fl_mutex"][::std::mem::offset_of!(__sFILE, _fl_mutex) - 152usize]; ++ ["Offset of field: __sFILE::_fl_owner"][::std::mem::offset_of!(__sFILE, _fl_owner) - 160usize]; ++ ["Offset of field: __sFILE::_fl_count"][::std::mem::offset_of!(__sFILE, _fl_count) - 168usize]; ++ ["Offset of field: __sFILE::_orientation"] ++ [::std::mem::offset_of!(__sFILE, _orientation) - 172usize]; ++ ["Offset of field: __sFILE::_mbstate"][::std::mem::offset_of!(__sFILE, _mbstate) - 176usize]; ++ ["Offset of field: __sFILE::_flags2"][::std::mem::offset_of!(__sFILE, _flags2) - 304usize]; ++}; ++pub type FILE = __sFILE; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv__queue { ++ pub next: *mut uv__queue, ++ pub prev: *mut uv__queue, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv__queue"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv__queue"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv__queue::next"][::std::mem::offset_of!(uv__queue, next) - 0usize]; ++ ["Offset of field: uv__queue::prev"][::std::mem::offset_of!(uv__queue, prev) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread { ++ _unused: [u8; 0], ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_cond { ++ _unused: [u8; 0], ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_mutex { ++ _unused: [u8; 0], ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_rwlock { ++ _unused: [u8; 0], ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_barrier { ++ _unused: [u8; 0], ++} ++pub type pthread_t = *mut pthread; ++pub type pthread_mutex_t = *mut pthread_mutex; ++pub type pthread_cond_t = *mut pthread_cond; ++pub type pthread_key_t = ::std::os::raw::c_int; ++pub type pthread_once_t = pthread_once; ++pub type pthread_rwlock_t = *mut pthread_rwlock; ++pub type pthread_barrier_t = *mut pthread_barrier; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_once { ++ pub state: ::std::os::raw::c_int, ++ pub mutex: pthread_mutex_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_once"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of pthread_once"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_once::state"][::std::mem::offset_of!(pthread_once, state) - 0usize]; ++ ["Offset of field: pthread_once::mutex"][::std::mem::offset_of!(pthread_once, mutex) - 8usize]; ++}; ++pub type gid_t = __gid_t; ++pub type in_addr_t = __uint32_t; ++pub type in_port_t = __uint16_t; ++pub type ino_t = __ino_t; ++pub type mode_t = __mode_t; ++pub type pid_t = __pid_t; ++pub type uid_t = __uid_t; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct dirent { ++ pub d_fileno: ino_t, ++ pub d_off: off_t, ++ pub d_reclen: __uint16_t, ++ pub d_type: __uint8_t, ++ pub d_pad0: __uint8_t, ++ pub d_namlen: __uint16_t, ++ pub d_pad1: __uint16_t, ++ pub d_name: [::std::os::raw::c_char; 256usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of dirent"][::std::mem::size_of::() - 280usize]; ++ ["Alignment of dirent"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: dirent::d_fileno"][::std::mem::offset_of!(dirent, d_fileno) - 0usize]; ++ ["Offset of field: dirent::d_off"][::std::mem::offset_of!(dirent, d_off) - 8usize]; ++ ["Offset of field: dirent::d_reclen"][::std::mem::offset_of!(dirent, d_reclen) - 16usize]; ++ ["Offset of field: dirent::d_type"][::std::mem::offset_of!(dirent, d_type) - 18usize]; ++ ["Offset of field: dirent::d_pad0"][::std::mem::offset_of!(dirent, d_pad0) - 19usize]; ++ ["Offset of field: dirent::d_namlen"][::std::mem::offset_of!(dirent, d_namlen) - 20usize]; ++ ["Offset of field: dirent::d_pad1"][::std::mem::offset_of!(dirent, d_pad1) - 22usize]; ++ ["Offset of field: dirent::d_name"][::std::mem::offset_of!(dirent, d_name) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct _dirdesc { ++ _unused: [u8; 0], ++} ++pub type DIR = _dirdesc; ++pub type sa_family_t = __sa_family_t; ++pub type socklen_t = __socklen_t; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct sockaddr { ++ pub sa_len: ::std::os::raw::c_uchar, ++ pub sa_family: sa_family_t, ++ pub sa_data: [::std::os::raw::c_char; 14usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sockaddr"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of sockaddr"][::std::mem::align_of::() - 1usize]; ++ ["Offset of field: sockaddr::sa_len"][::std::mem::offset_of!(sockaddr, sa_len) - 0usize]; ++ ["Offset of field: sockaddr::sa_family"][::std::mem::offset_of!(sockaddr, sa_family) - 1usize]; ++ ["Offset of field: sockaddr::sa_data"][::std::mem::offset_of!(sockaddr, sa_data) - 2usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct sockaddr_storage { ++ pub ss_len: ::std::os::raw::c_uchar, ++ pub ss_family: sa_family_t, ++ pub __ss_pad1: [::std::os::raw::c_char; 6usize], ++ pub __ss_align: __int64_t, ++ pub __ss_pad2: [::std::os::raw::c_char; 112usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sockaddr_storage"][::std::mem::size_of::() - 128usize]; ++ ["Alignment of sockaddr_storage"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: sockaddr_storage::ss_len"] ++ [::std::mem::offset_of!(sockaddr_storage, ss_len) - 0usize]; ++ ["Offset of field: sockaddr_storage::ss_family"] ++ [::std::mem::offset_of!(sockaddr_storage, ss_family) - 1usize]; ++ ["Offset of field: sockaddr_storage::__ss_pad1"] ++ [::std::mem::offset_of!(sockaddr_storage, __ss_pad1) - 2usize]; ++ ["Offset of field: sockaddr_storage::__ss_align"] ++ [::std::mem::offset_of!(sockaddr_storage, __ss_align) - 8usize]; ++ ["Offset of field: sockaddr_storage::__ss_pad2"] ++ [::std::mem::offset_of!(sockaddr_storage, __ss_pad2) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct in_addr { ++ pub s_addr: in_addr_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of in_addr"][::std::mem::size_of::() - 4usize]; ++ ["Alignment of in_addr"][::std::mem::align_of::() - 4usize]; ++ ["Offset of field: in_addr::s_addr"][::std::mem::offset_of!(in_addr, s_addr) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct sockaddr_in { ++ pub sin_len: u8, ++ pub sin_family: sa_family_t, ++ pub sin_port: in_port_t, ++ pub sin_addr: in_addr, ++ pub sin_zero: [::std::os::raw::c_char; 8usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sockaddr_in"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of sockaddr_in"][::std::mem::align_of::() - 4usize]; ++ ["Offset of field: sockaddr_in::sin_len"] ++ [::std::mem::offset_of!(sockaddr_in, sin_len) - 0usize]; ++ ["Offset of field: sockaddr_in::sin_family"] ++ [::std::mem::offset_of!(sockaddr_in, sin_family) - 1usize]; ++ ["Offset of field: sockaddr_in::sin_port"] ++ [::std::mem::offset_of!(sockaddr_in, sin_port) - 2usize]; ++ ["Offset of field: sockaddr_in::sin_addr"] ++ [::std::mem::offset_of!(sockaddr_in, sin_addr) - 4usize]; ++ ["Offset of field: sockaddr_in::sin_zero"] ++ [::std::mem::offset_of!(sockaddr_in, sin_zero) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct in6_addr { ++ pub __u6_addr: in6_addr__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union in6_addr__bindgen_ty_1 { ++ pub __u6_addr8: [u8; 16usize], ++ pub __u6_addr16: [u16; 8usize], ++ pub __u6_addr32: [u32; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of in6_addr__bindgen_ty_1"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of in6_addr__bindgen_ty_1"] ++ [::std::mem::align_of::() - 4usize]; ++ ["Offset of field: in6_addr__bindgen_ty_1::__u6_addr8"] ++ [::std::mem::offset_of!(in6_addr__bindgen_ty_1, __u6_addr8) - 0usize]; ++ ["Offset of field: in6_addr__bindgen_ty_1::__u6_addr16"] ++ [::std::mem::offset_of!(in6_addr__bindgen_ty_1, __u6_addr16) - 0usize]; ++ ["Offset of field: in6_addr__bindgen_ty_1::__u6_addr32"] ++ [::std::mem::offset_of!(in6_addr__bindgen_ty_1, __u6_addr32) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of in6_addr"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of in6_addr"][::std::mem::align_of::() - 4usize]; ++ ["Offset of field: in6_addr::__u6_addr"][::std::mem::offset_of!(in6_addr, __u6_addr) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct sockaddr_in6 { ++ pub sin6_len: u8, ++ pub sin6_family: sa_family_t, ++ pub sin6_port: in_port_t, ++ pub sin6_flowinfo: u32, ++ pub sin6_addr: in6_addr, ++ pub sin6_scope_id: u32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sockaddr_in6"][::std::mem::size_of::() - 28usize]; ++ ["Alignment of sockaddr_in6"][::std::mem::align_of::() - 4usize]; ++ ["Offset of field: sockaddr_in6::sin6_len"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_len) - 0usize]; ++ ["Offset of field: sockaddr_in6::sin6_family"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_family) - 1usize]; ++ ["Offset of field: sockaddr_in6::sin6_port"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_port) - 2usize]; ++ ["Offset of field: sockaddr_in6::sin6_flowinfo"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_flowinfo) - 4usize]; ++ ["Offset of field: sockaddr_in6::sin6_addr"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_addr) - 8usize]; ++ ["Offset of field: sockaddr_in6::sin6_scope_id"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_scope_id) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct addrinfo { ++ pub ai_flags: ::std::os::raw::c_int, ++ pub ai_family: ::std::os::raw::c_int, ++ pub ai_socktype: ::std::os::raw::c_int, ++ pub ai_protocol: ::std::os::raw::c_int, ++ pub ai_addrlen: socklen_t, ++ pub ai_canonname: *mut ::std::os::raw::c_char, ++ pub ai_addr: *mut sockaddr, ++ pub ai_next: *mut addrinfo, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of addrinfo"][::std::mem::size_of::() - 48usize]; ++ ["Alignment of addrinfo"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: addrinfo::ai_flags"][::std::mem::offset_of!(addrinfo, ai_flags) - 0usize]; ++ ["Offset of field: addrinfo::ai_family"][::std::mem::offset_of!(addrinfo, ai_family) - 4usize]; ++ ["Offset of field: addrinfo::ai_socktype"] ++ [::std::mem::offset_of!(addrinfo, ai_socktype) - 8usize]; ++ ["Offset of field: addrinfo::ai_protocol"] ++ [::std::mem::offset_of!(addrinfo, ai_protocol) - 12usize]; ++ ["Offset of field: addrinfo::ai_addrlen"] ++ [::std::mem::offset_of!(addrinfo, ai_addrlen) - 16usize]; ++ ["Offset of field: addrinfo::ai_canonname"] ++ [::std::mem::offset_of!(addrinfo, ai_canonname) - 24usize]; ++ ["Offset of field: addrinfo::ai_addr"][::std::mem::offset_of!(addrinfo, ai_addr) - 32usize]; ++ ["Offset of field: addrinfo::ai_next"][::std::mem::offset_of!(addrinfo, ai_next) - 40usize]; ++}; ++pub type tcflag_t = ::std::os::raw::c_uint; ++pub type cc_t = ::std::os::raw::c_uchar; ++pub type speed_t = ::std::os::raw::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct termios { ++ pub c_iflag: tcflag_t, ++ pub c_oflag: tcflag_t, ++ pub c_cflag: tcflag_t, ++ pub c_lflag: tcflag_t, ++ pub c_cc: [cc_t; 20usize], ++ pub c_ispeed: speed_t, ++ pub c_ospeed: speed_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of termios"][::std::mem::size_of::() - 44usize]; ++ ["Alignment of termios"][::std::mem::align_of::() - 4usize]; ++ ["Offset of field: termios::c_iflag"][::std::mem::offset_of!(termios, c_iflag) - 0usize]; ++ ["Offset of field: termios::c_oflag"][::std::mem::offset_of!(termios, c_oflag) - 4usize]; ++ ["Offset of field: termios::c_cflag"][::std::mem::offset_of!(termios, c_cflag) - 8usize]; ++ ["Offset of field: termios::c_lflag"][::std::mem::offset_of!(termios, c_lflag) - 12usize]; ++ ["Offset of field: termios::c_cc"][::std::mem::offset_of!(termios, c_cc) - 16usize]; ++ ["Offset of field: termios::c_ispeed"][::std::mem::offset_of!(termios, c_ispeed) - 36usize]; ++ ["Offset of field: termios::c_ospeed"][::std::mem::offset_of!(termios, c_ospeed) - 40usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct _usem2 { ++ pub _count: __uint32_t, ++ pub _flags: __uint32_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of _usem2"][::std::mem::size_of::<_usem2>() - 8usize]; ++ ["Alignment of _usem2"][::std::mem::align_of::<_usem2>() - 4usize]; ++ ["Offset of field: _usem2::_count"][::std::mem::offset_of!(_usem2, _count) - 0usize]; ++ ["Offset of field: _usem2::_flags"][::std::mem::offset_of!(_usem2, _flags) - 4usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct _sem { ++ pub _magic: __uint32_t, ++ pub _kern: _usem2, ++ pub _padding: __uint32_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of _sem"][::std::mem::size_of::<_sem>() - 16usize]; ++ ["Alignment of _sem"][::std::mem::align_of::<_sem>() - 4usize]; ++ ["Offset of field: _sem::_magic"][::std::mem::offset_of!(_sem, _magic) - 0usize]; ++ ["Offset of field: _sem::_kern"][::std::mem::offset_of!(_sem, _kern) - 4usize]; ++ ["Offset of field: _sem::_padding"][::std::mem::offset_of!(_sem, _padding) - 12usize]; ++}; ++pub type sem_t = _sem; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv__work { ++ pub work: ::std::option::Option, ++ pub done: ::std::option::Option< ++ unsafe extern "C" fn(w: *mut uv__work, status: ::std::os::raw::c_int), ++ >, ++ pub loop_: *mut uv_loop_s, ++ pub wq: uv__queue, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv__work"][::std::mem::size_of::() - 40usize]; ++ ["Alignment of uv__work"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv__work::work"][::std::mem::offset_of!(uv__work, work) - 0usize]; ++ ["Offset of field: uv__work::done"][::std::mem::offset_of!(uv__work, done) - 8usize]; ++ ["Offset of field: uv__work::loop_"][::std::mem::offset_of!(uv__work, loop_) - 16usize]; ++ ["Offset of field: uv__work::wq"][::std::mem::offset_of!(uv__work, wq) - 24usize]; ++}; ++pub type uv__io_cb = ::std::option::Option< ++ unsafe extern "C" fn(loop_: *mut uv_loop_s, w: *mut uv__io_s, events: ::std::os::raw::c_uint), ++>; ++pub type uv__io_t = uv__io_s; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv__io_s { ++ pub cb: uv__io_cb, ++ pub pending_queue: uv__queue, ++ pub watcher_queue: uv__queue, ++ pub pevents: ::std::os::raw::c_uint, ++ pub events: ::std::os::raw::c_uint, ++ pub fd: ::std::os::raw::c_int, ++ pub rcount: ::std::os::raw::c_int, ++ pub wcount: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv__io_s"][::std::mem::size_of::() - 64usize]; ++ ["Alignment of uv__io_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv__io_s::cb"][::std::mem::offset_of!(uv__io_s, cb) - 0usize]; ++ ["Offset of field: uv__io_s::pending_queue"] ++ [::std::mem::offset_of!(uv__io_s, pending_queue) - 8usize]; ++ ["Offset of field: uv__io_s::watcher_queue"] ++ [::std::mem::offset_of!(uv__io_s, watcher_queue) - 24usize]; ++ ["Offset of field: uv__io_s::pevents"][::std::mem::offset_of!(uv__io_s, pevents) - 40usize]; ++ ["Offset of field: uv__io_s::events"][::std::mem::offset_of!(uv__io_s, events) - 44usize]; ++ ["Offset of field: uv__io_s::fd"][::std::mem::offset_of!(uv__io_s, fd) - 48usize]; ++ ["Offset of field: uv__io_s::rcount"][::std::mem::offset_of!(uv__io_s, rcount) - 52usize]; ++ ["Offset of field: uv__io_s::wcount"][::std::mem::offset_of!(uv__io_s, wcount) - 56usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_buf_t { ++ pub base: *mut ::std::os::raw::c_char, ++ pub len: usize, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_buf_t"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_buf_t"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_buf_t::base"][::std::mem::offset_of!(uv_buf_t, base) - 0usize]; ++ ["Offset of field: uv_buf_t::len"][::std::mem::offset_of!(uv_buf_t, len) - 8usize]; ++}; ++pub type uv_file = ::std::os::raw::c_int; ++pub type uv_os_sock_t = ::std::os::raw::c_int; ++pub type uv_os_fd_t = ::std::os::raw::c_int; ++pub type uv_pid_t = pid_t; ++pub type uv_once_t = pthread_once_t; ++pub type uv_thread_t = pthread_t; ++pub type uv_mutex_t = pthread_mutex_t; ++pub type uv_rwlock_t = pthread_rwlock_t; ++pub type uv_sem_t = sem_t; ++pub type uv_cond_t = pthread_cond_t; ++pub type uv_key_t = pthread_key_t; ++pub type uv_barrier_t = pthread_barrier_t; ++pub type uv_gid_t = gid_t; ++pub type uv_uid_t = uid_t; ++pub type uv__dirent_t = dirent; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_lib_t { ++ pub handle: *mut ::std::os::raw::c_void, ++ pub errmsg: *mut ::std::os::raw::c_char, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_lib_t"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_lib_t"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_lib_t::handle"][::std::mem::offset_of!(uv_lib_t, handle) - 0usize]; ++ ["Offset of field: uv_lib_t::errmsg"][::std::mem::offset_of!(uv_lib_t, errmsg) - 8usize]; ++}; ++impl uv_errno_t { ++ pub const UV_E2BIG: uv_errno_t = uv_errno_t(-7); ++} ++impl uv_errno_t { ++ pub const UV_EACCES: uv_errno_t = uv_errno_t(-13); ++} ++impl uv_errno_t { ++ pub const UV_EADDRINUSE: uv_errno_t = uv_errno_t(-48); ++} ++impl uv_errno_t { ++ pub const UV_EADDRNOTAVAIL: uv_errno_t = uv_errno_t(-49); ++} ++impl uv_errno_t { ++ pub const UV_EAFNOSUPPORT: uv_errno_t = uv_errno_t(-47); ++} ++impl uv_errno_t { ++ pub const UV_EAGAIN: uv_errno_t = uv_errno_t(-35); ++} ++impl uv_errno_t { ++ pub const UV_EAI_ADDRFAMILY: uv_errno_t = uv_errno_t(-3000); ++} ++impl uv_errno_t { ++ pub const UV_EAI_AGAIN: uv_errno_t = uv_errno_t(-3001); ++} ++impl uv_errno_t { ++ pub const UV_EAI_BADFLAGS: uv_errno_t = uv_errno_t(-3002); ++} ++impl uv_errno_t { ++ pub const UV_EAI_BADHINTS: uv_errno_t = uv_errno_t(-3013); ++} ++impl uv_errno_t { ++ pub const UV_EAI_CANCELED: uv_errno_t = uv_errno_t(-3003); ++} ++impl uv_errno_t { ++ pub const UV_EAI_FAIL: uv_errno_t = uv_errno_t(-3004); ++} ++impl uv_errno_t { ++ pub const UV_EAI_FAMILY: uv_errno_t = uv_errno_t(-3005); ++} ++impl uv_errno_t { ++ pub const UV_EAI_MEMORY: uv_errno_t = uv_errno_t(-3006); ++} ++impl uv_errno_t { ++ pub const UV_EAI_NODATA: uv_errno_t = uv_errno_t(-3007); ++} ++impl uv_errno_t { ++ pub const UV_EAI_NONAME: uv_errno_t = uv_errno_t(-3008); ++} ++impl uv_errno_t { ++ pub const UV_EAI_OVERFLOW: uv_errno_t = uv_errno_t(-3009); ++} ++impl uv_errno_t { ++ pub const UV_EAI_PROTOCOL: uv_errno_t = uv_errno_t(-3014); ++} ++impl uv_errno_t { ++ pub const UV_EAI_SERVICE: uv_errno_t = uv_errno_t(-3010); ++} ++impl uv_errno_t { ++ pub const UV_EAI_SOCKTYPE: uv_errno_t = uv_errno_t(-3011); ++} ++impl uv_errno_t { ++ pub const UV_EALREADY: uv_errno_t = uv_errno_t(-37); ++} ++impl uv_errno_t { ++ pub const UV_EBADF: uv_errno_t = uv_errno_t(-9); ++} ++impl uv_errno_t { ++ pub const UV_EBUSY: uv_errno_t = uv_errno_t(-16); ++} ++impl uv_errno_t { ++ pub const UV_ECANCELED: uv_errno_t = uv_errno_t(-85); ++} ++impl uv_errno_t { ++ pub const UV_ECHARSET: uv_errno_t = uv_errno_t(-4080); ++} ++impl uv_errno_t { ++ pub const UV_ECONNABORTED: uv_errno_t = uv_errno_t(-53); ++} ++impl uv_errno_t { ++ pub const UV_ECONNREFUSED: uv_errno_t = uv_errno_t(-61); ++} ++impl uv_errno_t { ++ pub const UV_ECONNRESET: uv_errno_t = uv_errno_t(-54); ++} ++impl uv_errno_t { ++ pub const UV_EDESTADDRREQ: uv_errno_t = uv_errno_t(-39); ++} ++impl uv_errno_t { ++ pub const UV_EEXIST: uv_errno_t = uv_errno_t(-17); ++} ++impl uv_errno_t { ++ pub const UV_EFAULT: uv_errno_t = uv_errno_t(-14); ++} ++impl uv_errno_t { ++ pub const UV_EFBIG: uv_errno_t = uv_errno_t(-27); ++} ++impl uv_errno_t { ++ pub const UV_EHOSTUNREACH: uv_errno_t = uv_errno_t(-65); ++} ++impl uv_errno_t { ++ pub const UV_EINTR: uv_errno_t = uv_errno_t(-4); ++} ++impl uv_errno_t { ++ pub const UV_EINVAL: uv_errno_t = uv_errno_t(-22); ++} ++impl uv_errno_t { ++ pub const UV_EIO: uv_errno_t = uv_errno_t(-5); ++} ++impl uv_errno_t { ++ pub const UV_EISCONN: uv_errno_t = uv_errno_t(-56); ++} ++impl uv_errno_t { ++ pub const UV_EISDIR: uv_errno_t = uv_errno_t(-21); ++} ++impl uv_errno_t { ++ pub const UV_ELOOP: uv_errno_t = uv_errno_t(-62); ++} ++impl uv_errno_t { ++ pub const UV_EMFILE: uv_errno_t = uv_errno_t(-24); ++} ++impl uv_errno_t { ++ pub const UV_EMSGSIZE: uv_errno_t = uv_errno_t(-40); ++} ++impl uv_errno_t { ++ pub const UV_ENAMETOOLONG: uv_errno_t = uv_errno_t(-63); ++} ++impl uv_errno_t { ++ pub const UV_ENETDOWN: uv_errno_t = uv_errno_t(-50); ++} ++impl uv_errno_t { ++ pub const UV_ENETUNREACH: uv_errno_t = uv_errno_t(-51); ++} ++impl uv_errno_t { ++ pub const UV_ENFILE: uv_errno_t = uv_errno_t(-23); ++} ++impl uv_errno_t { ++ pub const UV_ENOBUFS: uv_errno_t = uv_errno_t(-55); ++} ++impl uv_errno_t { ++ pub const UV_ENODEV: uv_errno_t = uv_errno_t(-19); ++} ++impl uv_errno_t { ++ pub const UV_ENOENT: uv_errno_t = uv_errno_t(-2); ++} ++impl uv_errno_t { ++ pub const UV_ENOMEM: uv_errno_t = uv_errno_t(-12); ++} ++impl uv_errno_t { ++ pub const UV_ENONET: uv_errno_t = uv_errno_t(-4056); ++} ++impl uv_errno_t { ++ pub const UV_ENOPROTOOPT: uv_errno_t = uv_errno_t(-42); ++} ++impl uv_errno_t { ++ pub const UV_ENOSPC: uv_errno_t = uv_errno_t(-28); ++} ++impl uv_errno_t { ++ pub const UV_ENOSYS: uv_errno_t = uv_errno_t(-78); ++} ++impl uv_errno_t { ++ pub const UV_ENOTCONN: uv_errno_t = uv_errno_t(-57); ++} ++impl uv_errno_t { ++ pub const UV_ENOTDIR: uv_errno_t = uv_errno_t(-20); ++} ++impl uv_errno_t { ++ pub const UV_ENOTEMPTY: uv_errno_t = uv_errno_t(-66); ++} ++impl uv_errno_t { ++ pub const UV_ENOTSOCK: uv_errno_t = uv_errno_t(-38); ++} ++impl uv_errno_t { ++ pub const UV_ENOTSUP: uv_errno_t = uv_errno_t(-45); ++} ++impl uv_errno_t { ++ pub const UV_EOVERFLOW: uv_errno_t = uv_errno_t(-84); ++} ++impl uv_errno_t { ++ pub const UV_EPERM: uv_errno_t = uv_errno_t(-1); ++} ++impl uv_errno_t { ++ pub const UV_EPIPE: uv_errno_t = uv_errno_t(-32); ++} ++impl uv_errno_t { ++ pub const UV_EPROTO: uv_errno_t = uv_errno_t(-92); ++} ++impl uv_errno_t { ++ pub const UV_EPROTONOSUPPORT: uv_errno_t = uv_errno_t(-43); ++} ++impl uv_errno_t { ++ pub const UV_EPROTOTYPE: uv_errno_t = uv_errno_t(-41); ++} ++impl uv_errno_t { ++ pub const UV_ERANGE: uv_errno_t = uv_errno_t(-34); ++} ++impl uv_errno_t { ++ pub const UV_EROFS: uv_errno_t = uv_errno_t(-30); ++} ++impl uv_errno_t { ++ pub const UV_ESHUTDOWN: uv_errno_t = uv_errno_t(-58); ++} ++impl uv_errno_t { ++ pub const UV_ESPIPE: uv_errno_t = uv_errno_t(-29); ++} ++impl uv_errno_t { ++ pub const UV_ESRCH: uv_errno_t = uv_errno_t(-3); ++} ++impl uv_errno_t { ++ pub const UV_ETIMEDOUT: uv_errno_t = uv_errno_t(-60); ++} ++impl uv_errno_t { ++ pub const UV_ETXTBSY: uv_errno_t = uv_errno_t(-26); ++} ++impl uv_errno_t { ++ pub const UV_EXDEV: uv_errno_t = uv_errno_t(-18); ++} ++impl uv_errno_t { ++ pub const UV_UNKNOWN: uv_errno_t = uv_errno_t(-4094); ++} ++impl uv_errno_t { ++ pub const UV_EOF: uv_errno_t = uv_errno_t(-4095); ++} ++impl uv_errno_t { ++ pub const UV_ENXIO: uv_errno_t = uv_errno_t(-6); ++} ++impl uv_errno_t { ++ pub const UV_EMLINK: uv_errno_t = uv_errno_t(-31); ++} ++impl uv_errno_t { ++ pub const UV_EHOSTDOWN: uv_errno_t = uv_errno_t(-64); ++} ++impl uv_errno_t { ++ pub const UV_EREMOTEIO: uv_errno_t = uv_errno_t(-4030); ++} ++impl uv_errno_t { ++ pub const UV_ENOTTY: uv_errno_t = uv_errno_t(-25); ++} ++impl uv_errno_t { ++ pub const UV_EFTYPE: uv_errno_t = uv_errno_t(-79); ++} ++impl uv_errno_t { ++ pub const UV_EILSEQ: uv_errno_t = uv_errno_t(-86); ++} ++impl uv_errno_t { ++ pub const UV_ESOCKTNOSUPPORT: uv_errno_t = uv_errno_t(-44); ++} ++impl uv_errno_t { ++ pub const UV_ENODATA: uv_errno_t = uv_errno_t(-9919); ++} ++impl uv_errno_t { ++ pub const UV_EUNATCH: uv_errno_t = uv_errno_t(-4023); ++} ++impl uv_errno_t { ++ pub const UV_ERRNO_MAX: uv_errno_t = uv_errno_t(-4096); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_errno_t(pub ::std::os::raw::c_int); ++impl uv_handle_type { ++ pub const UV_UNKNOWN_HANDLE: uv_handle_type = uv_handle_type(0); ++} ++impl uv_handle_type { ++ pub const UV_ASYNC: uv_handle_type = uv_handle_type(1); ++} ++impl uv_handle_type { ++ pub const UV_CHECK: uv_handle_type = uv_handle_type(2); ++} ++impl uv_handle_type { ++ pub const UV_FS_EVENT: uv_handle_type = uv_handle_type(3); ++} ++impl uv_handle_type { ++ pub const UV_FS_POLL: uv_handle_type = uv_handle_type(4); ++} ++impl uv_handle_type { ++ pub const UV_HANDLE: uv_handle_type = uv_handle_type(5); ++} ++impl uv_handle_type { ++ pub const UV_IDLE: uv_handle_type = uv_handle_type(6); ++} ++impl uv_handle_type { ++ pub const UV_NAMED_PIPE: uv_handle_type = uv_handle_type(7); ++} ++impl uv_handle_type { ++ pub const UV_POLL: uv_handle_type = uv_handle_type(8); ++} ++impl uv_handle_type { ++ pub const UV_PREPARE: uv_handle_type = uv_handle_type(9); ++} ++impl uv_handle_type { ++ pub const UV_PROCESS: uv_handle_type = uv_handle_type(10); ++} ++impl uv_handle_type { ++ pub const UV_STREAM: uv_handle_type = uv_handle_type(11); ++} ++impl uv_handle_type { ++ pub const UV_TCP: uv_handle_type = uv_handle_type(12); ++} ++impl uv_handle_type { ++ pub const UV_TIMER: uv_handle_type = uv_handle_type(13); ++} ++impl uv_handle_type { ++ pub const UV_TTY: uv_handle_type = uv_handle_type(14); ++} ++impl uv_handle_type { ++ pub const UV_UDP: uv_handle_type = uv_handle_type(15); ++} ++impl uv_handle_type { ++ pub const UV_SIGNAL: uv_handle_type = uv_handle_type(16); ++} ++impl uv_handle_type { ++ pub const UV_FILE: uv_handle_type = uv_handle_type(17); ++} ++impl uv_handle_type { ++ pub const UV_HANDLE_TYPE_MAX: uv_handle_type = uv_handle_type(18); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_handle_type(pub ::std::os::raw::c_uint); ++impl uv_req_type { ++ pub const UV_UNKNOWN_REQ: uv_req_type = uv_req_type(0); ++} ++impl uv_req_type { ++ pub const UV_REQ: uv_req_type = uv_req_type(1); ++} ++impl uv_req_type { ++ pub const UV_CONNECT: uv_req_type = uv_req_type(2); ++} ++impl uv_req_type { ++ pub const UV_WRITE: uv_req_type = uv_req_type(3); ++} ++impl uv_req_type { ++ pub const UV_SHUTDOWN: uv_req_type = uv_req_type(4); ++} ++impl uv_req_type { ++ pub const UV_UDP_SEND: uv_req_type = uv_req_type(5); ++} ++impl uv_req_type { ++ pub const UV_FS: uv_req_type = uv_req_type(6); ++} ++impl uv_req_type { ++ pub const UV_WORK: uv_req_type = uv_req_type(7); ++} ++impl uv_req_type { ++ pub const UV_GETADDRINFO: uv_req_type = uv_req_type(8); ++} ++impl uv_req_type { ++ pub const UV_GETNAMEINFO: uv_req_type = uv_req_type(9); ++} ++impl uv_req_type { ++ pub const UV_RANDOM: uv_req_type = uv_req_type(10); ++} ++impl uv_req_type { ++ pub const UV_REQ_TYPE_MAX: uv_req_type = uv_req_type(11); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_req_type(pub ::std::os::raw::c_uint); ++pub type uv_loop_t = uv_loop_s; ++pub type uv_handle_t = uv_handle_s; ++pub type uv_dir_t = uv_dir_s; ++pub type uv_stream_t = uv_stream_s; ++pub type uv_tcp_t = uv_tcp_s; ++pub type uv_udp_t = uv_udp_s; ++pub type uv_pipe_t = uv_pipe_s; ++pub type uv_tty_t = uv_tty_s; ++pub type uv_poll_t = uv_poll_s; ++pub type uv_timer_t = uv_timer_s; ++pub type uv_prepare_t = uv_prepare_s; ++pub type uv_check_t = uv_check_s; ++pub type uv_idle_t = uv_idle_s; ++pub type uv_async_t = uv_async_s; ++pub type uv_process_t = uv_process_s; ++pub type uv_fs_event_t = uv_fs_event_s; ++pub type uv_fs_poll_t = uv_fs_poll_s; ++pub type uv_signal_t = uv_signal_s; ++pub type uv_req_t = uv_req_s; ++pub type uv_getaddrinfo_t = uv_getaddrinfo_s; ++pub type uv_getnameinfo_t = uv_getnameinfo_s; ++pub type uv_shutdown_t = uv_shutdown_s; ++pub type uv_write_t = uv_write_s; ++pub type uv_connect_t = uv_connect_s; ++pub type uv_udp_send_t = uv_udp_send_s; ++pub type uv_fs_t = uv_fs_s; ++pub type uv_work_t = uv_work_s; ++pub type uv_random_t = uv_random_s; ++pub type uv_env_item_t = uv_env_item_s; ++pub type uv_cpu_info_t = uv_cpu_info_s; ++pub type uv_interface_address_t = uv_interface_address_s; ++pub type uv_dirent_t = uv_dirent_s; ++pub type uv_passwd_t = uv_passwd_s; ++pub type uv_group_t = uv_group_s; ++pub type uv_utsname_t = uv_utsname_s; ++pub type uv_statfs_t = uv_statfs_s; ++pub type uv_metrics_t = uv_metrics_s; ++impl uv_loop_option { ++ pub const UV_LOOP_BLOCK_SIGNAL: uv_loop_option = uv_loop_option(0); ++} ++impl uv_loop_option { ++ pub const UV_METRICS_IDLE_TIME: uv_loop_option = uv_loop_option(1); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_loop_option(pub ::std::os::raw::c_uint); ++impl uv_run_mode { ++ pub const UV_RUN_DEFAULT: uv_run_mode = uv_run_mode(0); ++} ++impl uv_run_mode { ++ pub const UV_RUN_ONCE: uv_run_mode = uv_run_mode(1); ++} ++impl uv_run_mode { ++ pub const UV_RUN_NOWAIT: uv_run_mode = uv_run_mode(2); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_run_mode(pub ::std::os::raw::c_uint); ++pub type uv_malloc_func = ++ ::std::option::Option *mut ::std::os::raw::c_void>; ++pub type uv_realloc_func = ::std::option::Option< ++ unsafe extern "C" fn( ++ ptr: *mut ::std::os::raw::c_void, ++ size: usize, ++ ) -> *mut ::std::os::raw::c_void, ++>; ++pub type uv_calloc_func = ::std::option::Option< ++ unsafe extern "C" fn(count: usize, size: usize) -> *mut ::std::os::raw::c_void, ++>; ++pub type uv_free_func = ++ ::std::option::Option; ++pub type uv_alloc_cb = ::std::option::Option< ++ unsafe extern "C" fn(handle: *mut uv_handle_t, suggested_size: usize, buf: *mut uv_buf_t), ++>; ++pub type uv_read_cb = ::std::option::Option< ++ unsafe extern "C" fn(stream: *mut uv_stream_t, nread: isize, buf: *const uv_buf_t), ++>; ++pub type uv_write_cb = ::std::option::Option< ++ unsafe extern "C" fn(req: *mut uv_write_t, status: ::std::os::raw::c_int), ++>; ++pub type uv_connect_cb = ::std::option::Option< ++ unsafe extern "C" fn(req: *mut uv_connect_t, status: ::std::os::raw::c_int), ++>; ++pub type uv_shutdown_cb = ::std::option::Option< ++ unsafe extern "C" fn(req: *mut uv_shutdown_t, status: ::std::os::raw::c_int), ++>; ++pub type uv_connection_cb = ::std::option::Option< ++ unsafe extern "C" fn(server: *mut uv_stream_t, status: ::std::os::raw::c_int), ++>; ++pub type uv_close_cb = ::std::option::Option; ++pub type uv_poll_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ handle: *mut uv_poll_t, ++ status: ::std::os::raw::c_int, ++ events: ::std::os::raw::c_int, ++ ), ++>; ++pub type uv_timer_cb = ::std::option::Option; ++pub type uv_async_cb = ::std::option::Option; ++pub type uv_prepare_cb = ::std::option::Option; ++pub type uv_check_cb = ::std::option::Option; ++pub type uv_idle_cb = ::std::option::Option; ++pub type uv_exit_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ arg1: *mut uv_process_t, ++ exit_status: i64, ++ term_signal: ::std::os::raw::c_int, ++ ), ++>; ++pub type uv_walk_cb = ::std::option::Option< ++ unsafe extern "C" fn(handle: *mut uv_handle_t, arg: *mut ::std::os::raw::c_void), ++>; ++pub type uv_fs_cb = ::std::option::Option; ++pub type uv_work_cb = ::std::option::Option; ++pub type uv_after_work_cb = ++ ::std::option::Option; ++pub type uv_getaddrinfo_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ req: *mut uv_getaddrinfo_t, ++ status: ::std::os::raw::c_int, ++ res: *mut addrinfo, ++ ), ++>; ++pub type uv_getnameinfo_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ req: *mut uv_getnameinfo_t, ++ status: ::std::os::raw::c_int, ++ hostname: *const ::std::os::raw::c_char, ++ service: *const ::std::os::raw::c_char, ++ ), ++>; ++pub type uv_random_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ req: *mut uv_random_t, ++ status: ::std::os::raw::c_int, ++ buf: *mut ::std::os::raw::c_void, ++ buflen: usize, ++ ), ++>; ++impl uv_clock_id { ++ pub const UV_CLOCK_MONOTONIC: uv_clock_id = uv_clock_id(0); ++} ++impl uv_clock_id { ++ pub const UV_CLOCK_REALTIME: uv_clock_id = uv_clock_id(1); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_clock_id(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_timespec_t { ++ pub tv_sec: ::std::os::raw::c_long, ++ pub tv_nsec: ::std::os::raw::c_long, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_timespec_t"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_timespec_t"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_timespec_t::tv_sec"] ++ [::std::mem::offset_of!(uv_timespec_t, tv_sec) - 0usize]; ++ ["Offset of field: uv_timespec_t::tv_nsec"] ++ [::std::mem::offset_of!(uv_timespec_t, tv_nsec) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_timespec64_t { ++ pub tv_sec: i64, ++ pub tv_nsec: i32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_timespec64_t"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_timespec64_t"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_timespec64_t::tv_sec"] ++ [::std::mem::offset_of!(uv_timespec64_t, tv_sec) - 0usize]; ++ ["Offset of field: uv_timespec64_t::tv_nsec"] ++ [::std::mem::offset_of!(uv_timespec64_t, tv_nsec) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_timeval_t { ++ pub tv_sec: ::std::os::raw::c_long, ++ pub tv_usec: ::std::os::raw::c_long, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_timeval_t"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_timeval_t"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_timeval_t::tv_sec"] ++ [::std::mem::offset_of!(uv_timeval_t, tv_sec) - 0usize]; ++ ["Offset of field: uv_timeval_t::tv_usec"] ++ [::std::mem::offset_of!(uv_timeval_t, tv_usec) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_timeval64_t { ++ pub tv_sec: i64, ++ pub tv_usec: i32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_timeval64_t"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_timeval64_t"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_timeval64_t::tv_sec"] ++ [::std::mem::offset_of!(uv_timeval64_t, tv_sec) - 0usize]; ++ ["Offset of field: uv_timeval64_t::tv_usec"] ++ [::std::mem::offset_of!(uv_timeval64_t, tv_usec) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_stat_t { ++ pub st_dev: u64, ++ pub st_mode: u64, ++ pub st_nlink: u64, ++ pub st_uid: u64, ++ pub st_gid: u64, ++ pub st_rdev: u64, ++ pub st_ino: u64, ++ pub st_size: u64, ++ pub st_blksize: u64, ++ pub st_blocks: u64, ++ pub st_flags: u64, ++ pub st_gen: u64, ++ pub st_atim: uv_timespec_t, ++ pub st_mtim: uv_timespec_t, ++ pub st_ctim: uv_timespec_t, ++ pub st_birthtim: uv_timespec_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_stat_t"][::std::mem::size_of::() - 160usize]; ++ ["Alignment of uv_stat_t"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_stat_t::st_dev"][::std::mem::offset_of!(uv_stat_t, st_dev) - 0usize]; ++ ["Offset of field: uv_stat_t::st_mode"][::std::mem::offset_of!(uv_stat_t, st_mode) - 8usize]; ++ ["Offset of field: uv_stat_t::st_nlink"][::std::mem::offset_of!(uv_stat_t, st_nlink) - 16usize]; ++ ["Offset of field: uv_stat_t::st_uid"][::std::mem::offset_of!(uv_stat_t, st_uid) - 24usize]; ++ ["Offset of field: uv_stat_t::st_gid"][::std::mem::offset_of!(uv_stat_t, st_gid) - 32usize]; ++ ["Offset of field: uv_stat_t::st_rdev"][::std::mem::offset_of!(uv_stat_t, st_rdev) - 40usize]; ++ ["Offset of field: uv_stat_t::st_ino"][::std::mem::offset_of!(uv_stat_t, st_ino) - 48usize]; ++ ["Offset of field: uv_stat_t::st_size"][::std::mem::offset_of!(uv_stat_t, st_size) - 56usize]; ++ ["Offset of field: uv_stat_t::st_blksize"] ++ [::std::mem::offset_of!(uv_stat_t, st_blksize) - 64usize]; ++ ["Offset of field: uv_stat_t::st_blocks"] ++ [::std::mem::offset_of!(uv_stat_t, st_blocks) - 72usize]; ++ ["Offset of field: uv_stat_t::st_flags"][::std::mem::offset_of!(uv_stat_t, st_flags) - 80usize]; ++ ["Offset of field: uv_stat_t::st_gen"][::std::mem::offset_of!(uv_stat_t, st_gen) - 88usize]; ++ ["Offset of field: uv_stat_t::st_atim"][::std::mem::offset_of!(uv_stat_t, st_atim) - 96usize]; ++ ["Offset of field: uv_stat_t::st_mtim"][::std::mem::offset_of!(uv_stat_t, st_mtim) - 112usize]; ++ ["Offset of field: uv_stat_t::st_ctim"][::std::mem::offset_of!(uv_stat_t, st_ctim) - 128usize]; ++ ["Offset of field: uv_stat_t::st_birthtim"] ++ [::std::mem::offset_of!(uv_stat_t, st_birthtim) - 144usize]; ++}; ++pub type uv_fs_event_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ handle: *mut uv_fs_event_t, ++ filename: *const ::std::os::raw::c_char, ++ events: ::std::os::raw::c_int, ++ status: ::std::os::raw::c_int, ++ ), ++>; ++pub type uv_fs_poll_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ handle: *mut uv_fs_poll_t, ++ status: ::std::os::raw::c_int, ++ prev: *const uv_stat_t, ++ curr: *const uv_stat_t, ++ ), ++>; ++pub type uv_signal_cb = ::std::option::Option< ++ unsafe extern "C" fn(handle: *mut uv_signal_t, signum: ::std::os::raw::c_int), ++>; ++impl uv_membership { ++ pub const UV_LEAVE_GROUP: uv_membership = uv_membership(0); ++} ++impl uv_membership { ++ pub const UV_JOIN_GROUP: uv_membership = uv_membership(1); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_membership(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_req_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_req_s"][::std::mem::size_of::() - 64usize]; ++ ["Alignment of uv_req_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_req_s::data"][::std::mem::offset_of!(uv_req_s, data) - 0usize]; ++ ["Offset of field: uv_req_s::type_"][::std::mem::offset_of!(uv_req_s, type_) - 8usize]; ++ ["Offset of field: uv_req_s::reserved"][::std::mem::offset_of!(uv_req_s, reserved) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_shutdown_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub handle: *mut uv_stream_t, ++ pub cb: uv_shutdown_cb, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_shutdown_s"][::std::mem::size_of::() - 80usize]; ++ ["Alignment of uv_shutdown_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_shutdown_s::data"][::std::mem::offset_of!(uv_shutdown_s, data) - 0usize]; ++ ["Offset of field: uv_shutdown_s::type_"] ++ [::std::mem::offset_of!(uv_shutdown_s, type_) - 8usize]; ++ ["Offset of field: uv_shutdown_s::reserved"] ++ [::std::mem::offset_of!(uv_shutdown_s, reserved) - 16usize]; ++ ["Offset of field: uv_shutdown_s::handle"] ++ [::std::mem::offset_of!(uv_shutdown_s, handle) - 64usize]; ++ ["Offset of field: uv_shutdown_s::cb"][::std::mem::offset_of!(uv_shutdown_s, cb) - 72usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_handle_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_handle_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_handle_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_handle_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_handle_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_handle_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_handle_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_handle_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_handle_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_handle_s"][::std::mem::size_of::() - 96usize]; ++ ["Alignment of uv_handle_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_handle_s::data"][::std::mem::offset_of!(uv_handle_s, data) - 0usize]; ++ ["Offset of field: uv_handle_s::loop_"][::std::mem::offset_of!(uv_handle_s, loop_) - 8usize]; ++ ["Offset of field: uv_handle_s::type_"][::std::mem::offset_of!(uv_handle_s, type_) - 16usize]; ++ ["Offset of field: uv_handle_s::close_cb"] ++ [::std::mem::offset_of!(uv_handle_s, close_cb) - 24usize]; ++ ["Offset of field: uv_handle_s::handle_queue"] ++ [::std::mem::offset_of!(uv_handle_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_handle_s::u"][::std::mem::offset_of!(uv_handle_s, u) - 48usize]; ++ ["Offset of field: uv_handle_s::next_closing"] ++ [::std::mem::offset_of!(uv_handle_s, next_closing) - 80usize]; ++ ["Offset of field: uv_handle_s::flags"][::std::mem::offset_of!(uv_handle_s, flags) - 88usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_stream_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_stream_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub write_queue_size: usize, ++ pub alloc_cb: uv_alloc_cb, ++ pub read_cb: uv_read_cb, ++ pub connect_req: *mut uv_connect_t, ++ pub shutdown_req: *mut uv_shutdown_t, ++ pub io_watcher: uv__io_t, ++ pub write_queue: uv__queue, ++ pub write_completed_queue: uv__queue, ++ pub connection_cb: uv_connection_cb, ++ pub delayed_error: ::std::os::raw::c_int, ++ pub accepted_fd: ::std::os::raw::c_int, ++ pub queued_fds: *mut ::std::os::raw::c_void, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_stream_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_stream_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_stream_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_stream_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_stream_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_stream_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_stream_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_stream_s"][::std::mem::size_of::() - 256usize]; ++ ["Alignment of uv_stream_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_stream_s::data"][::std::mem::offset_of!(uv_stream_s, data) - 0usize]; ++ ["Offset of field: uv_stream_s::loop_"][::std::mem::offset_of!(uv_stream_s, loop_) - 8usize]; ++ ["Offset of field: uv_stream_s::type_"][::std::mem::offset_of!(uv_stream_s, type_) - 16usize]; ++ ["Offset of field: uv_stream_s::close_cb"] ++ [::std::mem::offset_of!(uv_stream_s, close_cb) - 24usize]; ++ ["Offset of field: uv_stream_s::handle_queue"] ++ [::std::mem::offset_of!(uv_stream_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_stream_s::u"][::std::mem::offset_of!(uv_stream_s, u) - 48usize]; ++ ["Offset of field: uv_stream_s::next_closing"] ++ [::std::mem::offset_of!(uv_stream_s, next_closing) - 80usize]; ++ ["Offset of field: uv_stream_s::flags"][::std::mem::offset_of!(uv_stream_s, flags) - 88usize]; ++ ["Offset of field: uv_stream_s::write_queue_size"] ++ [::std::mem::offset_of!(uv_stream_s, write_queue_size) - 96usize]; ++ ["Offset of field: uv_stream_s::alloc_cb"] ++ [::std::mem::offset_of!(uv_stream_s, alloc_cb) - 104usize]; ++ ["Offset of field: uv_stream_s::read_cb"] ++ [::std::mem::offset_of!(uv_stream_s, read_cb) - 112usize]; ++ ["Offset of field: uv_stream_s::connect_req"] ++ [::std::mem::offset_of!(uv_stream_s, connect_req) - 120usize]; ++ ["Offset of field: uv_stream_s::shutdown_req"] ++ [::std::mem::offset_of!(uv_stream_s, shutdown_req) - 128usize]; ++ ["Offset of field: uv_stream_s::io_watcher"] ++ [::std::mem::offset_of!(uv_stream_s, io_watcher) - 136usize]; ++ ["Offset of field: uv_stream_s::write_queue"] ++ [::std::mem::offset_of!(uv_stream_s, write_queue) - 200usize]; ++ ["Offset of field: uv_stream_s::write_completed_queue"] ++ [::std::mem::offset_of!(uv_stream_s, write_completed_queue) - 216usize]; ++ ["Offset of field: uv_stream_s::connection_cb"] ++ [::std::mem::offset_of!(uv_stream_s, connection_cb) - 232usize]; ++ ["Offset of field: uv_stream_s::delayed_error"] ++ [::std::mem::offset_of!(uv_stream_s, delayed_error) - 240usize]; ++ ["Offset of field: uv_stream_s::accepted_fd"] ++ [::std::mem::offset_of!(uv_stream_s, accepted_fd) - 244usize]; ++ ["Offset of field: uv_stream_s::queued_fds"] ++ [::std::mem::offset_of!(uv_stream_s, queued_fds) - 248usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_write_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub cb: uv_write_cb, ++ pub send_handle: *mut uv_stream_t, ++ pub handle: *mut uv_stream_t, ++ pub queue: uv__queue, ++ pub write_index: ::std::os::raw::c_uint, ++ pub bufs: *mut uv_buf_t, ++ pub nbufs: ::std::os::raw::c_uint, ++ pub error: ::std::os::raw::c_int, ++ pub bufsml: [uv_buf_t; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_write_s"][::std::mem::size_of::() - 192usize]; ++ ["Alignment of uv_write_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_write_s::data"][::std::mem::offset_of!(uv_write_s, data) - 0usize]; ++ ["Offset of field: uv_write_s::type_"][::std::mem::offset_of!(uv_write_s, type_) - 8usize]; ++ ["Offset of field: uv_write_s::reserved"] ++ [::std::mem::offset_of!(uv_write_s, reserved) - 16usize]; ++ ["Offset of field: uv_write_s::cb"][::std::mem::offset_of!(uv_write_s, cb) - 64usize]; ++ ["Offset of field: uv_write_s::send_handle"] ++ [::std::mem::offset_of!(uv_write_s, send_handle) - 72usize]; ++ ["Offset of field: uv_write_s::handle"][::std::mem::offset_of!(uv_write_s, handle) - 80usize]; ++ ["Offset of field: uv_write_s::queue"][::std::mem::offset_of!(uv_write_s, queue) - 88usize]; ++ ["Offset of field: uv_write_s::write_index"] ++ [::std::mem::offset_of!(uv_write_s, write_index) - 104usize]; ++ ["Offset of field: uv_write_s::bufs"][::std::mem::offset_of!(uv_write_s, bufs) - 112usize]; ++ ["Offset of field: uv_write_s::nbufs"][::std::mem::offset_of!(uv_write_s, nbufs) - 120usize]; ++ ["Offset of field: uv_write_s::error"][::std::mem::offset_of!(uv_write_s, error) - 124usize]; ++ ["Offset of field: uv_write_s::bufsml"][::std::mem::offset_of!(uv_write_s, bufsml) - 128usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_tcp_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_tcp_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub write_queue_size: usize, ++ pub alloc_cb: uv_alloc_cb, ++ pub read_cb: uv_read_cb, ++ pub connect_req: *mut uv_connect_t, ++ pub shutdown_req: *mut uv_shutdown_t, ++ pub io_watcher: uv__io_t, ++ pub write_queue: uv__queue, ++ pub write_completed_queue: uv__queue, ++ pub connection_cb: uv_connection_cb, ++ pub delayed_error: ::std::os::raw::c_int, ++ pub accepted_fd: ::std::os::raw::c_int, ++ pub queued_fds: *mut ::std::os::raw::c_void, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_tcp_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_tcp_s__bindgen_ty_1"][::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_tcp_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_tcp_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_tcp_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_tcp_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_tcp_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_tcp_s"][::std::mem::size_of::() - 256usize]; ++ ["Alignment of uv_tcp_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_tcp_s::data"][::std::mem::offset_of!(uv_tcp_s, data) - 0usize]; ++ ["Offset of field: uv_tcp_s::loop_"][::std::mem::offset_of!(uv_tcp_s, loop_) - 8usize]; ++ ["Offset of field: uv_tcp_s::type_"][::std::mem::offset_of!(uv_tcp_s, type_) - 16usize]; ++ ["Offset of field: uv_tcp_s::close_cb"][::std::mem::offset_of!(uv_tcp_s, close_cb) - 24usize]; ++ ["Offset of field: uv_tcp_s::handle_queue"] ++ [::std::mem::offset_of!(uv_tcp_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_tcp_s::u"][::std::mem::offset_of!(uv_tcp_s, u) - 48usize]; ++ ["Offset of field: uv_tcp_s::next_closing"] ++ [::std::mem::offset_of!(uv_tcp_s, next_closing) - 80usize]; ++ ["Offset of field: uv_tcp_s::flags"][::std::mem::offset_of!(uv_tcp_s, flags) - 88usize]; ++ ["Offset of field: uv_tcp_s::write_queue_size"] ++ [::std::mem::offset_of!(uv_tcp_s, write_queue_size) - 96usize]; ++ ["Offset of field: uv_tcp_s::alloc_cb"][::std::mem::offset_of!(uv_tcp_s, alloc_cb) - 104usize]; ++ ["Offset of field: uv_tcp_s::read_cb"][::std::mem::offset_of!(uv_tcp_s, read_cb) - 112usize]; ++ ["Offset of field: uv_tcp_s::connect_req"] ++ [::std::mem::offset_of!(uv_tcp_s, connect_req) - 120usize]; ++ ["Offset of field: uv_tcp_s::shutdown_req"] ++ [::std::mem::offset_of!(uv_tcp_s, shutdown_req) - 128usize]; ++ ["Offset of field: uv_tcp_s::io_watcher"] ++ [::std::mem::offset_of!(uv_tcp_s, io_watcher) - 136usize]; ++ ["Offset of field: uv_tcp_s::write_queue"] ++ [::std::mem::offset_of!(uv_tcp_s, write_queue) - 200usize]; ++ ["Offset of field: uv_tcp_s::write_completed_queue"] ++ [::std::mem::offset_of!(uv_tcp_s, write_completed_queue) - 216usize]; ++ ["Offset of field: uv_tcp_s::connection_cb"] ++ [::std::mem::offset_of!(uv_tcp_s, connection_cb) - 232usize]; ++ ["Offset of field: uv_tcp_s::delayed_error"] ++ [::std::mem::offset_of!(uv_tcp_s, delayed_error) - 240usize]; ++ ["Offset of field: uv_tcp_s::accepted_fd"] ++ [::std::mem::offset_of!(uv_tcp_s, accepted_fd) - 244usize]; ++ ["Offset of field: uv_tcp_s::queued_fds"] ++ [::std::mem::offset_of!(uv_tcp_s, queued_fds) - 248usize]; ++}; ++impl uv_tcp_flags { ++ pub const UV_TCP_IPV6ONLY: uv_tcp_flags = uv_tcp_flags(1); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_tcp_flags(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_connect_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub cb: uv_connect_cb, ++ pub handle: *mut uv_stream_t, ++ pub queue: uv__queue, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_connect_s"][::std::mem::size_of::() - 96usize]; ++ ["Alignment of uv_connect_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_connect_s::data"][::std::mem::offset_of!(uv_connect_s, data) - 0usize]; ++ ["Offset of field: uv_connect_s::type_"][::std::mem::offset_of!(uv_connect_s, type_) - 8usize]; ++ ["Offset of field: uv_connect_s::reserved"] ++ [::std::mem::offset_of!(uv_connect_s, reserved) - 16usize]; ++ ["Offset of field: uv_connect_s::cb"][::std::mem::offset_of!(uv_connect_s, cb) - 64usize]; ++ ["Offset of field: uv_connect_s::handle"] ++ [::std::mem::offset_of!(uv_connect_s, handle) - 72usize]; ++ ["Offset of field: uv_connect_s::queue"][::std::mem::offset_of!(uv_connect_s, queue) - 80usize]; ++}; ++impl uv_udp_flags { ++ pub const UV_UDP_IPV6ONLY: uv_udp_flags = uv_udp_flags(1); ++} ++impl uv_udp_flags { ++ pub const UV_UDP_PARTIAL: uv_udp_flags = uv_udp_flags(2); ++} ++impl uv_udp_flags { ++ pub const UV_UDP_REUSEADDR: uv_udp_flags = uv_udp_flags(4); ++} ++impl uv_udp_flags { ++ pub const UV_UDP_MMSG_CHUNK: uv_udp_flags = uv_udp_flags(8); ++} ++impl uv_udp_flags { ++ pub const UV_UDP_MMSG_FREE: uv_udp_flags = uv_udp_flags(16); ++} ++impl uv_udp_flags { ++ pub const UV_UDP_LINUX_RECVERR: uv_udp_flags = uv_udp_flags(32); ++} ++impl uv_udp_flags { ++ pub const UV_UDP_RECVMMSG: uv_udp_flags = uv_udp_flags(256); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_udp_flags(pub ::std::os::raw::c_uint); ++pub type uv_udp_send_cb = ::std::option::Option< ++ unsafe extern "C" fn(req: *mut uv_udp_send_t, status: ::std::os::raw::c_int), ++>; ++pub type uv_udp_recv_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ handle: *mut uv_udp_t, ++ nread: isize, ++ buf: *const uv_buf_t, ++ addr: *const sockaddr, ++ flags: ::std::os::raw::c_uint, ++ ), ++>; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_udp_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_udp_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub send_queue_size: usize, ++ pub send_queue_count: usize, ++ pub alloc_cb: uv_alloc_cb, ++ pub recv_cb: uv_udp_recv_cb, ++ pub io_watcher: uv__io_t, ++ pub write_queue: uv__queue, ++ pub write_completed_queue: uv__queue, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_udp_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_udp_s__bindgen_ty_1"][::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_udp_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_udp_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_udp_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_udp_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_udp_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_udp_s"][::std::mem::size_of::() - 224usize]; ++ ["Alignment of uv_udp_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_udp_s::data"][::std::mem::offset_of!(uv_udp_s, data) - 0usize]; ++ ["Offset of field: uv_udp_s::loop_"][::std::mem::offset_of!(uv_udp_s, loop_) - 8usize]; ++ ["Offset of field: uv_udp_s::type_"][::std::mem::offset_of!(uv_udp_s, type_) - 16usize]; ++ ["Offset of field: uv_udp_s::close_cb"][::std::mem::offset_of!(uv_udp_s, close_cb) - 24usize]; ++ ["Offset of field: uv_udp_s::handle_queue"] ++ [::std::mem::offset_of!(uv_udp_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_udp_s::u"][::std::mem::offset_of!(uv_udp_s, u) - 48usize]; ++ ["Offset of field: uv_udp_s::next_closing"] ++ [::std::mem::offset_of!(uv_udp_s, next_closing) - 80usize]; ++ ["Offset of field: uv_udp_s::flags"][::std::mem::offset_of!(uv_udp_s, flags) - 88usize]; ++ ["Offset of field: uv_udp_s::send_queue_size"] ++ [::std::mem::offset_of!(uv_udp_s, send_queue_size) - 96usize]; ++ ["Offset of field: uv_udp_s::send_queue_count"] ++ [::std::mem::offset_of!(uv_udp_s, send_queue_count) - 104usize]; ++ ["Offset of field: uv_udp_s::alloc_cb"][::std::mem::offset_of!(uv_udp_s, alloc_cb) - 112usize]; ++ ["Offset of field: uv_udp_s::recv_cb"][::std::mem::offset_of!(uv_udp_s, recv_cb) - 120usize]; ++ ["Offset of field: uv_udp_s::io_watcher"] ++ [::std::mem::offset_of!(uv_udp_s, io_watcher) - 128usize]; ++ ["Offset of field: uv_udp_s::write_queue"] ++ [::std::mem::offset_of!(uv_udp_s, write_queue) - 192usize]; ++ ["Offset of field: uv_udp_s::write_completed_queue"] ++ [::std::mem::offset_of!(uv_udp_s, write_completed_queue) - 208usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_udp_send_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub handle: *mut uv_udp_t, ++ pub cb: uv_udp_send_cb, ++ pub queue: uv__queue, ++ pub addr: sockaddr_storage, ++ pub nbufs: ::std::os::raw::c_uint, ++ pub bufs: *mut uv_buf_t, ++ pub status: isize, ++ pub send_cb: uv_udp_send_cb, ++ pub bufsml: [uv_buf_t; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_udp_send_s"][::std::mem::size_of::() - 320usize]; ++ ["Alignment of uv_udp_send_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_udp_send_s::data"][::std::mem::offset_of!(uv_udp_send_s, data) - 0usize]; ++ ["Offset of field: uv_udp_send_s::type_"] ++ [::std::mem::offset_of!(uv_udp_send_s, type_) - 8usize]; ++ ["Offset of field: uv_udp_send_s::reserved"] ++ [::std::mem::offset_of!(uv_udp_send_s, reserved) - 16usize]; ++ ["Offset of field: uv_udp_send_s::handle"] ++ [::std::mem::offset_of!(uv_udp_send_s, handle) - 64usize]; ++ ["Offset of field: uv_udp_send_s::cb"][::std::mem::offset_of!(uv_udp_send_s, cb) - 72usize]; ++ ["Offset of field: uv_udp_send_s::queue"] ++ [::std::mem::offset_of!(uv_udp_send_s, queue) - 80usize]; ++ ["Offset of field: uv_udp_send_s::addr"][::std::mem::offset_of!(uv_udp_send_s, addr) - 96usize]; ++ ["Offset of field: uv_udp_send_s::nbufs"] ++ [::std::mem::offset_of!(uv_udp_send_s, nbufs) - 224usize]; ++ ["Offset of field: uv_udp_send_s::bufs"] ++ [::std::mem::offset_of!(uv_udp_send_s, bufs) - 232usize]; ++ ["Offset of field: uv_udp_send_s::status"] ++ [::std::mem::offset_of!(uv_udp_send_s, status) - 240usize]; ++ ["Offset of field: uv_udp_send_s::send_cb"] ++ [::std::mem::offset_of!(uv_udp_send_s, send_cb) - 248usize]; ++ ["Offset of field: uv_udp_send_s::bufsml"] ++ [::std::mem::offset_of!(uv_udp_send_s, bufsml) - 256usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_tty_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_tty_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub write_queue_size: usize, ++ pub alloc_cb: uv_alloc_cb, ++ pub read_cb: uv_read_cb, ++ pub connect_req: *mut uv_connect_t, ++ pub shutdown_req: *mut uv_shutdown_t, ++ pub io_watcher: uv__io_t, ++ pub write_queue: uv__queue, ++ pub write_completed_queue: uv__queue, ++ pub connection_cb: uv_connection_cb, ++ pub delayed_error: ::std::os::raw::c_int, ++ pub accepted_fd: ::std::os::raw::c_int, ++ pub queued_fds: *mut ::std::os::raw::c_void, ++ pub orig_termios: termios, ++ pub mode: ::std::os::raw::c_int, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_tty_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_tty_s__bindgen_ty_1"][::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_tty_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_tty_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_tty_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_tty_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_tty_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_tty_s"][::std::mem::size_of::() - 304usize]; ++ ["Alignment of uv_tty_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_tty_s::data"][::std::mem::offset_of!(uv_tty_s, data) - 0usize]; ++ ["Offset of field: uv_tty_s::loop_"][::std::mem::offset_of!(uv_tty_s, loop_) - 8usize]; ++ ["Offset of field: uv_tty_s::type_"][::std::mem::offset_of!(uv_tty_s, type_) - 16usize]; ++ ["Offset of field: uv_tty_s::close_cb"][::std::mem::offset_of!(uv_tty_s, close_cb) - 24usize]; ++ ["Offset of field: uv_tty_s::handle_queue"] ++ [::std::mem::offset_of!(uv_tty_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_tty_s::u"][::std::mem::offset_of!(uv_tty_s, u) - 48usize]; ++ ["Offset of field: uv_tty_s::next_closing"] ++ [::std::mem::offset_of!(uv_tty_s, next_closing) - 80usize]; ++ ["Offset of field: uv_tty_s::flags"][::std::mem::offset_of!(uv_tty_s, flags) - 88usize]; ++ ["Offset of field: uv_tty_s::write_queue_size"] ++ [::std::mem::offset_of!(uv_tty_s, write_queue_size) - 96usize]; ++ ["Offset of field: uv_tty_s::alloc_cb"][::std::mem::offset_of!(uv_tty_s, alloc_cb) - 104usize]; ++ ["Offset of field: uv_tty_s::read_cb"][::std::mem::offset_of!(uv_tty_s, read_cb) - 112usize]; ++ ["Offset of field: uv_tty_s::connect_req"] ++ [::std::mem::offset_of!(uv_tty_s, connect_req) - 120usize]; ++ ["Offset of field: uv_tty_s::shutdown_req"] ++ [::std::mem::offset_of!(uv_tty_s, shutdown_req) - 128usize]; ++ ["Offset of field: uv_tty_s::io_watcher"] ++ [::std::mem::offset_of!(uv_tty_s, io_watcher) - 136usize]; ++ ["Offset of field: uv_tty_s::write_queue"] ++ [::std::mem::offset_of!(uv_tty_s, write_queue) - 200usize]; ++ ["Offset of field: uv_tty_s::write_completed_queue"] ++ [::std::mem::offset_of!(uv_tty_s, write_completed_queue) - 216usize]; ++ ["Offset of field: uv_tty_s::connection_cb"] ++ [::std::mem::offset_of!(uv_tty_s, connection_cb) - 232usize]; ++ ["Offset of field: uv_tty_s::delayed_error"] ++ [::std::mem::offset_of!(uv_tty_s, delayed_error) - 240usize]; ++ ["Offset of field: uv_tty_s::accepted_fd"] ++ [::std::mem::offset_of!(uv_tty_s, accepted_fd) - 244usize]; ++ ["Offset of field: uv_tty_s::queued_fds"] ++ [::std::mem::offset_of!(uv_tty_s, queued_fds) - 248usize]; ++ ["Offset of field: uv_tty_s::orig_termios"] ++ [::std::mem::offset_of!(uv_tty_s, orig_termios) - 256usize]; ++ ["Offset of field: uv_tty_s::mode"][::std::mem::offset_of!(uv_tty_s, mode) - 300usize]; ++}; ++impl uv_tty_mode_t { ++ pub const UV_TTY_MODE_NORMAL: uv_tty_mode_t = uv_tty_mode_t(0); ++} ++impl uv_tty_mode_t { ++ pub const UV_TTY_MODE_RAW: uv_tty_mode_t = uv_tty_mode_t(1); ++} ++impl uv_tty_mode_t { ++ pub const UV_TTY_MODE_IO: uv_tty_mode_t = uv_tty_mode_t(2); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_tty_mode_t(pub ::std::os::raw::c_uint); ++impl uv_tty_vtermstate_t { ++ pub const UV_TTY_SUPPORTED: uv_tty_vtermstate_t = uv_tty_vtermstate_t(0); ++} ++impl uv_tty_vtermstate_t { ++ pub const UV_TTY_UNSUPPORTED: uv_tty_vtermstate_t = uv_tty_vtermstate_t(1); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_tty_vtermstate_t(pub ::std::os::raw::c_uint); ++pub const UV_PIPE_NO_TRUNCATE: _bindgen_ty_1 = _bindgen_ty_1(1); ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct _bindgen_ty_1(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_pipe_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_pipe_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub write_queue_size: usize, ++ pub alloc_cb: uv_alloc_cb, ++ pub read_cb: uv_read_cb, ++ pub connect_req: *mut uv_connect_t, ++ pub shutdown_req: *mut uv_shutdown_t, ++ pub io_watcher: uv__io_t, ++ pub write_queue: uv__queue, ++ pub write_completed_queue: uv__queue, ++ pub connection_cb: uv_connection_cb, ++ pub delayed_error: ::std::os::raw::c_int, ++ pub accepted_fd: ::std::os::raw::c_int, ++ pub queued_fds: *mut ::std::os::raw::c_void, ++ pub ipc: ::std::os::raw::c_int, ++ pub pipe_fname: *const ::std::os::raw::c_char, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_pipe_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_pipe_s__bindgen_ty_1"][::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_pipe_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_pipe_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_pipe_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_pipe_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_pipe_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_pipe_s"][::std::mem::size_of::() - 272usize]; ++ ["Alignment of uv_pipe_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_pipe_s::data"][::std::mem::offset_of!(uv_pipe_s, data) - 0usize]; ++ ["Offset of field: uv_pipe_s::loop_"][::std::mem::offset_of!(uv_pipe_s, loop_) - 8usize]; ++ ["Offset of field: uv_pipe_s::type_"][::std::mem::offset_of!(uv_pipe_s, type_) - 16usize]; ++ ["Offset of field: uv_pipe_s::close_cb"][::std::mem::offset_of!(uv_pipe_s, close_cb) - 24usize]; ++ ["Offset of field: uv_pipe_s::handle_queue"] ++ [::std::mem::offset_of!(uv_pipe_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_pipe_s::u"][::std::mem::offset_of!(uv_pipe_s, u) - 48usize]; ++ ["Offset of field: uv_pipe_s::next_closing"] ++ [::std::mem::offset_of!(uv_pipe_s, next_closing) - 80usize]; ++ ["Offset of field: uv_pipe_s::flags"][::std::mem::offset_of!(uv_pipe_s, flags) - 88usize]; ++ ["Offset of field: uv_pipe_s::write_queue_size"] ++ [::std::mem::offset_of!(uv_pipe_s, write_queue_size) - 96usize]; ++ ["Offset of field: uv_pipe_s::alloc_cb"] ++ [::std::mem::offset_of!(uv_pipe_s, alloc_cb) - 104usize]; ++ ["Offset of field: uv_pipe_s::read_cb"][::std::mem::offset_of!(uv_pipe_s, read_cb) - 112usize]; ++ ["Offset of field: uv_pipe_s::connect_req"] ++ [::std::mem::offset_of!(uv_pipe_s, connect_req) - 120usize]; ++ ["Offset of field: uv_pipe_s::shutdown_req"] ++ [::std::mem::offset_of!(uv_pipe_s, shutdown_req) - 128usize]; ++ ["Offset of field: uv_pipe_s::io_watcher"] ++ [::std::mem::offset_of!(uv_pipe_s, io_watcher) - 136usize]; ++ ["Offset of field: uv_pipe_s::write_queue"] ++ [::std::mem::offset_of!(uv_pipe_s, write_queue) - 200usize]; ++ ["Offset of field: uv_pipe_s::write_completed_queue"] ++ [::std::mem::offset_of!(uv_pipe_s, write_completed_queue) - 216usize]; ++ ["Offset of field: uv_pipe_s::connection_cb"] ++ [::std::mem::offset_of!(uv_pipe_s, connection_cb) - 232usize]; ++ ["Offset of field: uv_pipe_s::delayed_error"] ++ [::std::mem::offset_of!(uv_pipe_s, delayed_error) - 240usize]; ++ ["Offset of field: uv_pipe_s::accepted_fd"] ++ [::std::mem::offset_of!(uv_pipe_s, accepted_fd) - 244usize]; ++ ["Offset of field: uv_pipe_s::queued_fds"] ++ [::std::mem::offset_of!(uv_pipe_s, queued_fds) - 248usize]; ++ ["Offset of field: uv_pipe_s::ipc"][::std::mem::offset_of!(uv_pipe_s, ipc) - 256usize]; ++ ["Offset of field: uv_pipe_s::pipe_fname"] ++ [::std::mem::offset_of!(uv_pipe_s, pipe_fname) - 264usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_poll_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_poll_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub poll_cb: uv_poll_cb, ++ pub io_watcher: uv__io_t, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_poll_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_poll_s__bindgen_ty_1"][::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_poll_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_poll_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_poll_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_poll_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_poll_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_poll_s"][::std::mem::size_of::() - 168usize]; ++ ["Alignment of uv_poll_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_poll_s::data"][::std::mem::offset_of!(uv_poll_s, data) - 0usize]; ++ ["Offset of field: uv_poll_s::loop_"][::std::mem::offset_of!(uv_poll_s, loop_) - 8usize]; ++ ["Offset of field: uv_poll_s::type_"][::std::mem::offset_of!(uv_poll_s, type_) - 16usize]; ++ ["Offset of field: uv_poll_s::close_cb"][::std::mem::offset_of!(uv_poll_s, close_cb) - 24usize]; ++ ["Offset of field: uv_poll_s::handle_queue"] ++ [::std::mem::offset_of!(uv_poll_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_poll_s::u"][::std::mem::offset_of!(uv_poll_s, u) - 48usize]; ++ ["Offset of field: uv_poll_s::next_closing"] ++ [::std::mem::offset_of!(uv_poll_s, next_closing) - 80usize]; ++ ["Offset of field: uv_poll_s::flags"][::std::mem::offset_of!(uv_poll_s, flags) - 88usize]; ++ ["Offset of field: uv_poll_s::poll_cb"][::std::mem::offset_of!(uv_poll_s, poll_cb) - 96usize]; ++ ["Offset of field: uv_poll_s::io_watcher"] ++ [::std::mem::offset_of!(uv_poll_s, io_watcher) - 104usize]; ++}; ++impl uv_poll_event { ++ pub const UV_READABLE: uv_poll_event = uv_poll_event(1); ++} ++impl uv_poll_event { ++ pub const UV_WRITABLE: uv_poll_event = uv_poll_event(2); ++} ++impl uv_poll_event { ++ pub const UV_DISCONNECT: uv_poll_event = uv_poll_event(4); ++} ++impl uv_poll_event { ++ pub const UV_PRIORITIZED: uv_poll_event = uv_poll_event(8); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_poll_event(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_prepare_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_prepare_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub prepare_cb: uv_prepare_cb, ++ pub queue: uv__queue, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_prepare_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_prepare_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_prepare_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_prepare_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_prepare_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_prepare_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_prepare_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_prepare_s"][::std::mem::size_of::() - 120usize]; ++ ["Alignment of uv_prepare_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_prepare_s::data"][::std::mem::offset_of!(uv_prepare_s, data) - 0usize]; ++ ["Offset of field: uv_prepare_s::loop_"][::std::mem::offset_of!(uv_prepare_s, loop_) - 8usize]; ++ ["Offset of field: uv_prepare_s::type_"][::std::mem::offset_of!(uv_prepare_s, type_) - 16usize]; ++ ["Offset of field: uv_prepare_s::close_cb"] ++ [::std::mem::offset_of!(uv_prepare_s, close_cb) - 24usize]; ++ ["Offset of field: uv_prepare_s::handle_queue"] ++ [::std::mem::offset_of!(uv_prepare_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_prepare_s::u"][::std::mem::offset_of!(uv_prepare_s, u) - 48usize]; ++ ["Offset of field: uv_prepare_s::next_closing"] ++ [::std::mem::offset_of!(uv_prepare_s, next_closing) - 80usize]; ++ ["Offset of field: uv_prepare_s::flags"][::std::mem::offset_of!(uv_prepare_s, flags) - 88usize]; ++ ["Offset of field: uv_prepare_s::prepare_cb"] ++ [::std::mem::offset_of!(uv_prepare_s, prepare_cb) - 96usize]; ++ ["Offset of field: uv_prepare_s::queue"] ++ [::std::mem::offset_of!(uv_prepare_s, queue) - 104usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_check_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_check_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub check_cb: uv_check_cb, ++ pub queue: uv__queue, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_check_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_check_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_check_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_check_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_check_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_check_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_check_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_check_s"][::std::mem::size_of::() - 120usize]; ++ ["Alignment of uv_check_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_check_s::data"][::std::mem::offset_of!(uv_check_s, data) - 0usize]; ++ ["Offset of field: uv_check_s::loop_"][::std::mem::offset_of!(uv_check_s, loop_) - 8usize]; ++ ["Offset of field: uv_check_s::type_"][::std::mem::offset_of!(uv_check_s, type_) - 16usize]; ++ ["Offset of field: uv_check_s::close_cb"] ++ [::std::mem::offset_of!(uv_check_s, close_cb) - 24usize]; ++ ["Offset of field: uv_check_s::handle_queue"] ++ [::std::mem::offset_of!(uv_check_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_check_s::u"][::std::mem::offset_of!(uv_check_s, u) - 48usize]; ++ ["Offset of field: uv_check_s::next_closing"] ++ [::std::mem::offset_of!(uv_check_s, next_closing) - 80usize]; ++ ["Offset of field: uv_check_s::flags"][::std::mem::offset_of!(uv_check_s, flags) - 88usize]; ++ ["Offset of field: uv_check_s::check_cb"] ++ [::std::mem::offset_of!(uv_check_s, check_cb) - 96usize]; ++ ["Offset of field: uv_check_s::queue"][::std::mem::offset_of!(uv_check_s, queue) - 104usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_idle_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_idle_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub idle_cb: uv_idle_cb, ++ pub queue: uv__queue, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_idle_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_idle_s__bindgen_ty_1"][::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_idle_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_idle_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_idle_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_idle_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_idle_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_idle_s"][::std::mem::size_of::() - 120usize]; ++ ["Alignment of uv_idle_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_idle_s::data"][::std::mem::offset_of!(uv_idle_s, data) - 0usize]; ++ ["Offset of field: uv_idle_s::loop_"][::std::mem::offset_of!(uv_idle_s, loop_) - 8usize]; ++ ["Offset of field: uv_idle_s::type_"][::std::mem::offset_of!(uv_idle_s, type_) - 16usize]; ++ ["Offset of field: uv_idle_s::close_cb"][::std::mem::offset_of!(uv_idle_s, close_cb) - 24usize]; ++ ["Offset of field: uv_idle_s::handle_queue"] ++ [::std::mem::offset_of!(uv_idle_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_idle_s::u"][::std::mem::offset_of!(uv_idle_s, u) - 48usize]; ++ ["Offset of field: uv_idle_s::next_closing"] ++ [::std::mem::offset_of!(uv_idle_s, next_closing) - 80usize]; ++ ["Offset of field: uv_idle_s::flags"][::std::mem::offset_of!(uv_idle_s, flags) - 88usize]; ++ ["Offset of field: uv_idle_s::idle_cb"][::std::mem::offset_of!(uv_idle_s, idle_cb) - 96usize]; ++ ["Offset of field: uv_idle_s::queue"][::std::mem::offset_of!(uv_idle_s, queue) - 104usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_async_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_async_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub async_cb: uv_async_cb, ++ pub queue: uv__queue, ++ pub pending: ::std::os::raw::c_int, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_async_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_async_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_async_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_async_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_async_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_async_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_async_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_async_s"][::std::mem::size_of::() - 128usize]; ++ ["Alignment of uv_async_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_async_s::data"][::std::mem::offset_of!(uv_async_s, data) - 0usize]; ++ ["Offset of field: uv_async_s::loop_"][::std::mem::offset_of!(uv_async_s, loop_) - 8usize]; ++ ["Offset of field: uv_async_s::type_"][::std::mem::offset_of!(uv_async_s, type_) - 16usize]; ++ ["Offset of field: uv_async_s::close_cb"] ++ [::std::mem::offset_of!(uv_async_s, close_cb) - 24usize]; ++ ["Offset of field: uv_async_s::handle_queue"] ++ [::std::mem::offset_of!(uv_async_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_async_s::u"][::std::mem::offset_of!(uv_async_s, u) - 48usize]; ++ ["Offset of field: uv_async_s::next_closing"] ++ [::std::mem::offset_of!(uv_async_s, next_closing) - 80usize]; ++ ["Offset of field: uv_async_s::flags"][::std::mem::offset_of!(uv_async_s, flags) - 88usize]; ++ ["Offset of field: uv_async_s::async_cb"] ++ [::std::mem::offset_of!(uv_async_s, async_cb) - 96usize]; ++ ["Offset of field: uv_async_s::queue"][::std::mem::offset_of!(uv_async_s, queue) - 104usize]; ++ ["Offset of field: uv_async_s::pending"] ++ [::std::mem::offset_of!(uv_async_s, pending) - 120usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_timer_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_timer_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub timer_cb: uv_timer_cb, ++ pub node: uv_timer_s__bindgen_ty_2, ++ pub timeout: u64, ++ pub repeat: u64, ++ pub start_id: u64, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_timer_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_timer_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_timer_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_timer_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_timer_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_timer_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_timer_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_timer_s__bindgen_ty_2 { ++ pub heap: [*mut ::std::os::raw::c_void; 3usize], ++ pub queue: uv__queue, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_timer_s__bindgen_ty_2"] ++ [::std::mem::size_of::() - 24usize]; ++ ["Alignment of uv_timer_s__bindgen_ty_2"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_timer_s__bindgen_ty_2::heap"] ++ [::std::mem::offset_of!(uv_timer_s__bindgen_ty_2, heap) - 0usize]; ++ ["Offset of field: uv_timer_s__bindgen_ty_2::queue"] ++ [::std::mem::offset_of!(uv_timer_s__bindgen_ty_2, queue) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_timer_s"][::std::mem::size_of::() - 152usize]; ++ ["Alignment of uv_timer_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_timer_s::data"][::std::mem::offset_of!(uv_timer_s, data) - 0usize]; ++ ["Offset of field: uv_timer_s::loop_"][::std::mem::offset_of!(uv_timer_s, loop_) - 8usize]; ++ ["Offset of field: uv_timer_s::type_"][::std::mem::offset_of!(uv_timer_s, type_) - 16usize]; ++ ["Offset of field: uv_timer_s::close_cb"] ++ [::std::mem::offset_of!(uv_timer_s, close_cb) - 24usize]; ++ ["Offset of field: uv_timer_s::handle_queue"] ++ [::std::mem::offset_of!(uv_timer_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_timer_s::u"][::std::mem::offset_of!(uv_timer_s, u) - 48usize]; ++ ["Offset of field: uv_timer_s::next_closing"] ++ [::std::mem::offset_of!(uv_timer_s, next_closing) - 80usize]; ++ ["Offset of field: uv_timer_s::flags"][::std::mem::offset_of!(uv_timer_s, flags) - 88usize]; ++ ["Offset of field: uv_timer_s::timer_cb"] ++ [::std::mem::offset_of!(uv_timer_s, timer_cb) - 96usize]; ++ ["Offset of field: uv_timer_s::node"][::std::mem::offset_of!(uv_timer_s, node) - 104usize]; ++ ["Offset of field: uv_timer_s::timeout"] ++ [::std::mem::offset_of!(uv_timer_s, timeout) - 128usize]; ++ ["Offset of field: uv_timer_s::repeat"][::std::mem::offset_of!(uv_timer_s, repeat) - 136usize]; ++ ["Offset of field: uv_timer_s::start_id"] ++ [::std::mem::offset_of!(uv_timer_s, start_id) - 144usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_getaddrinfo_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub loop_: *mut uv_loop_t, ++ pub work_req: uv__work, ++ pub cb: uv_getaddrinfo_cb, ++ pub hints: *mut addrinfo, ++ pub hostname: *mut ::std::os::raw::c_char, ++ pub service: *mut ::std::os::raw::c_char, ++ pub addrinfo: *mut addrinfo, ++ pub retcode: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_getaddrinfo_s"][::std::mem::size_of::() - 160usize]; ++ ["Alignment of uv_getaddrinfo_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_getaddrinfo_s::data"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, data) - 0usize]; ++ ["Offset of field: uv_getaddrinfo_s::type_"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, type_) - 8usize]; ++ ["Offset of field: uv_getaddrinfo_s::reserved"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, reserved) - 16usize]; ++ ["Offset of field: uv_getaddrinfo_s::loop_"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, loop_) - 64usize]; ++ ["Offset of field: uv_getaddrinfo_s::work_req"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, work_req) - 72usize]; ++ ["Offset of field: uv_getaddrinfo_s::cb"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, cb) - 112usize]; ++ ["Offset of field: uv_getaddrinfo_s::hints"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, hints) - 120usize]; ++ ["Offset of field: uv_getaddrinfo_s::hostname"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, hostname) - 128usize]; ++ ["Offset of field: uv_getaddrinfo_s::service"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, service) - 136usize]; ++ ["Offset of field: uv_getaddrinfo_s::addrinfo"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, addrinfo) - 144usize]; ++ ["Offset of field: uv_getaddrinfo_s::retcode"] ++ [::std::mem::offset_of!(uv_getaddrinfo_s, retcode) - 152usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_getnameinfo_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub loop_: *mut uv_loop_t, ++ pub work_req: uv__work, ++ pub getnameinfo_cb: uv_getnameinfo_cb, ++ pub storage: sockaddr_storage, ++ pub flags: ::std::os::raw::c_int, ++ pub host: [::std::os::raw::c_char; 1025usize], ++ pub service: [::std::os::raw::c_char; 32usize], ++ pub retcode: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_getnameinfo_s"][::std::mem::size_of::() - 1320usize]; ++ ["Alignment of uv_getnameinfo_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_getnameinfo_s::data"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, data) - 0usize]; ++ ["Offset of field: uv_getnameinfo_s::type_"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, type_) - 8usize]; ++ ["Offset of field: uv_getnameinfo_s::reserved"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, reserved) - 16usize]; ++ ["Offset of field: uv_getnameinfo_s::loop_"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, loop_) - 64usize]; ++ ["Offset of field: uv_getnameinfo_s::work_req"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, work_req) - 72usize]; ++ ["Offset of field: uv_getnameinfo_s::getnameinfo_cb"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, getnameinfo_cb) - 112usize]; ++ ["Offset of field: uv_getnameinfo_s::storage"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, storage) - 120usize]; ++ ["Offset of field: uv_getnameinfo_s::flags"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, flags) - 248usize]; ++ ["Offset of field: uv_getnameinfo_s::host"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, host) - 252usize]; ++ ["Offset of field: uv_getnameinfo_s::service"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, service) - 1277usize]; ++ ["Offset of field: uv_getnameinfo_s::retcode"] ++ [::std::mem::offset_of!(uv_getnameinfo_s, retcode) - 1312usize]; ++}; ++impl uv_stdio_flags { ++ pub const UV_IGNORE: uv_stdio_flags = uv_stdio_flags(0); ++} ++impl uv_stdio_flags { ++ pub const UV_CREATE_PIPE: uv_stdio_flags = uv_stdio_flags(1); ++} ++impl uv_stdio_flags { ++ pub const UV_INHERIT_FD: uv_stdio_flags = uv_stdio_flags(2); ++} ++impl uv_stdio_flags { ++ pub const UV_INHERIT_STREAM: uv_stdio_flags = uv_stdio_flags(4); ++} ++impl uv_stdio_flags { ++ pub const UV_READABLE_PIPE: uv_stdio_flags = uv_stdio_flags(16); ++} ++impl uv_stdio_flags { ++ pub const UV_WRITABLE_PIPE: uv_stdio_flags = uv_stdio_flags(32); ++} ++impl uv_stdio_flags { ++ pub const UV_NONBLOCK_PIPE: uv_stdio_flags = uv_stdio_flags(64); ++} ++impl uv_stdio_flags { ++ pub const UV_OVERLAPPED_PIPE: uv_stdio_flags = uv_stdio_flags(64); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_stdio_flags(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_stdio_container_s { ++ pub flags: uv_stdio_flags, ++ pub data: uv_stdio_container_s__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_stdio_container_s__bindgen_ty_1 { ++ pub stream: *mut uv_stream_t, ++ pub fd: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_stdio_container_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 8usize]; ++ ["Alignment of uv_stdio_container_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_stdio_container_s__bindgen_ty_1::stream"] ++ [::std::mem::offset_of!(uv_stdio_container_s__bindgen_ty_1, stream) - 0usize]; ++ ["Offset of field: uv_stdio_container_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_stdio_container_s__bindgen_ty_1, fd) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_stdio_container_s"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_stdio_container_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_stdio_container_s::flags"] ++ [::std::mem::offset_of!(uv_stdio_container_s, flags) - 0usize]; ++ ["Offset of field: uv_stdio_container_s::data"] ++ [::std::mem::offset_of!(uv_stdio_container_s, data) - 8usize]; ++}; ++pub type uv_stdio_container_t = uv_stdio_container_s; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_process_options_s { ++ pub exit_cb: uv_exit_cb, ++ pub file: *const ::std::os::raw::c_char, ++ pub args: *mut *mut ::std::os::raw::c_char, ++ pub env: *mut *mut ::std::os::raw::c_char, ++ pub cwd: *const ::std::os::raw::c_char, ++ pub flags: ::std::os::raw::c_uint, ++ pub stdio_count: ::std::os::raw::c_int, ++ pub stdio: *mut uv_stdio_container_t, ++ pub uid: uv_uid_t, ++ pub gid: uv_gid_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_process_options_s"][::std::mem::size_of::() - 64usize]; ++ ["Alignment of uv_process_options_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_process_options_s::exit_cb"] ++ [::std::mem::offset_of!(uv_process_options_s, exit_cb) - 0usize]; ++ ["Offset of field: uv_process_options_s::file"] ++ [::std::mem::offset_of!(uv_process_options_s, file) - 8usize]; ++ ["Offset of field: uv_process_options_s::args"] ++ [::std::mem::offset_of!(uv_process_options_s, args) - 16usize]; ++ ["Offset of field: uv_process_options_s::env"] ++ [::std::mem::offset_of!(uv_process_options_s, env) - 24usize]; ++ ["Offset of field: uv_process_options_s::cwd"] ++ [::std::mem::offset_of!(uv_process_options_s, cwd) - 32usize]; ++ ["Offset of field: uv_process_options_s::flags"] ++ [::std::mem::offset_of!(uv_process_options_s, flags) - 40usize]; ++ ["Offset of field: uv_process_options_s::stdio_count"] ++ [::std::mem::offset_of!(uv_process_options_s, stdio_count) - 44usize]; ++ ["Offset of field: uv_process_options_s::stdio"] ++ [::std::mem::offset_of!(uv_process_options_s, stdio) - 48usize]; ++ ["Offset of field: uv_process_options_s::uid"] ++ [::std::mem::offset_of!(uv_process_options_s, uid) - 56usize]; ++ ["Offset of field: uv_process_options_s::gid"] ++ [::std::mem::offset_of!(uv_process_options_s, gid) - 60usize]; ++}; ++pub type uv_process_options_t = uv_process_options_s; ++impl uv_process_flags { ++ pub const UV_PROCESS_SETUID: uv_process_flags = uv_process_flags(1); ++} ++impl uv_process_flags { ++ pub const UV_PROCESS_SETGID: uv_process_flags = uv_process_flags(2); ++} ++impl uv_process_flags { ++ pub const UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS: uv_process_flags = uv_process_flags(4); ++} ++impl uv_process_flags { ++ pub const UV_PROCESS_DETACHED: uv_process_flags = uv_process_flags(8); ++} ++impl uv_process_flags { ++ pub const UV_PROCESS_WINDOWS_HIDE: uv_process_flags = uv_process_flags(16); ++} ++impl uv_process_flags { ++ pub const UV_PROCESS_WINDOWS_HIDE_CONSOLE: uv_process_flags = uv_process_flags(32); ++} ++impl uv_process_flags { ++ pub const UV_PROCESS_WINDOWS_HIDE_GUI: uv_process_flags = uv_process_flags(64); ++} ++impl uv_process_flags { ++ pub const UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME: uv_process_flags = uv_process_flags(128); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_process_flags(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_process_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_process_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub exit_cb: uv_exit_cb, ++ pub pid: ::std::os::raw::c_int, ++ pub queue: uv__queue, ++ pub status: ::std::os::raw::c_int, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_process_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_process_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_process_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_process_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_process_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_process_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_process_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_process_s"][::std::mem::size_of::() - 136usize]; ++ ["Alignment of uv_process_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_process_s::data"][::std::mem::offset_of!(uv_process_s, data) - 0usize]; ++ ["Offset of field: uv_process_s::loop_"][::std::mem::offset_of!(uv_process_s, loop_) - 8usize]; ++ ["Offset of field: uv_process_s::type_"][::std::mem::offset_of!(uv_process_s, type_) - 16usize]; ++ ["Offset of field: uv_process_s::close_cb"] ++ [::std::mem::offset_of!(uv_process_s, close_cb) - 24usize]; ++ ["Offset of field: uv_process_s::handle_queue"] ++ [::std::mem::offset_of!(uv_process_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_process_s::u"][::std::mem::offset_of!(uv_process_s, u) - 48usize]; ++ ["Offset of field: uv_process_s::next_closing"] ++ [::std::mem::offset_of!(uv_process_s, next_closing) - 80usize]; ++ ["Offset of field: uv_process_s::flags"][::std::mem::offset_of!(uv_process_s, flags) - 88usize]; ++ ["Offset of field: uv_process_s::exit_cb"] ++ [::std::mem::offset_of!(uv_process_s, exit_cb) - 96usize]; ++ ["Offset of field: uv_process_s::pid"][::std::mem::offset_of!(uv_process_s, pid) - 104usize]; ++ ["Offset of field: uv_process_s::queue"] ++ [::std::mem::offset_of!(uv_process_s, queue) - 112usize]; ++ ["Offset of field: uv_process_s::status"] ++ [::std::mem::offset_of!(uv_process_s, status) - 128usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_work_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub loop_: *mut uv_loop_t, ++ pub work_cb: uv_work_cb, ++ pub after_work_cb: uv_after_work_cb, ++ pub work_req: uv__work, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_work_s"][::std::mem::size_of::() - 128usize]; ++ ["Alignment of uv_work_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_work_s::data"][::std::mem::offset_of!(uv_work_s, data) - 0usize]; ++ ["Offset of field: uv_work_s::type_"][::std::mem::offset_of!(uv_work_s, type_) - 8usize]; ++ ["Offset of field: uv_work_s::reserved"][::std::mem::offset_of!(uv_work_s, reserved) - 16usize]; ++ ["Offset of field: uv_work_s::loop_"][::std::mem::offset_of!(uv_work_s, loop_) - 64usize]; ++ ["Offset of field: uv_work_s::work_cb"][::std::mem::offset_of!(uv_work_s, work_cb) - 72usize]; ++ ["Offset of field: uv_work_s::after_work_cb"] ++ [::std::mem::offset_of!(uv_work_s, after_work_cb) - 80usize]; ++ ["Offset of field: uv_work_s::work_req"][::std::mem::offset_of!(uv_work_s, work_req) - 88usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_cpu_times_s { ++ pub user: u64, ++ pub nice: u64, ++ pub sys: u64, ++ pub idle: u64, ++ pub irq: u64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_cpu_times_s"][::std::mem::size_of::() - 40usize]; ++ ["Alignment of uv_cpu_times_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_cpu_times_s::user"] ++ [::std::mem::offset_of!(uv_cpu_times_s, user) - 0usize]; ++ ["Offset of field: uv_cpu_times_s::nice"] ++ [::std::mem::offset_of!(uv_cpu_times_s, nice) - 8usize]; ++ ["Offset of field: uv_cpu_times_s::sys"][::std::mem::offset_of!(uv_cpu_times_s, sys) - 16usize]; ++ ["Offset of field: uv_cpu_times_s::idle"] ++ [::std::mem::offset_of!(uv_cpu_times_s, idle) - 24usize]; ++ ["Offset of field: uv_cpu_times_s::irq"][::std::mem::offset_of!(uv_cpu_times_s, irq) - 32usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_cpu_info_s { ++ pub model: *mut ::std::os::raw::c_char, ++ pub speed: ::std::os::raw::c_int, ++ pub cpu_times: uv_cpu_times_s, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_cpu_info_s"][::std::mem::size_of::() - 56usize]; ++ ["Alignment of uv_cpu_info_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_cpu_info_s::model"] ++ [::std::mem::offset_of!(uv_cpu_info_s, model) - 0usize]; ++ ["Offset of field: uv_cpu_info_s::speed"] ++ [::std::mem::offset_of!(uv_cpu_info_s, speed) - 8usize]; ++ ["Offset of field: uv_cpu_info_s::cpu_times"] ++ [::std::mem::offset_of!(uv_cpu_info_s, cpu_times) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_interface_address_s { ++ pub name: *mut ::std::os::raw::c_char, ++ pub phys_addr: [::std::os::raw::c_char; 6usize], ++ pub is_internal: ::std::os::raw::c_int, ++ pub address: uv_interface_address_s__bindgen_ty_1, ++ pub netmask: uv_interface_address_s__bindgen_ty_2, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_interface_address_s__bindgen_ty_1 { ++ pub address4: sockaddr_in, ++ pub address6: sockaddr_in6, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_interface_address_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 28usize]; ++ ["Alignment of uv_interface_address_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 4usize]; ++ ["Offset of field: uv_interface_address_s__bindgen_ty_1::address4"] ++ [::std::mem::offset_of!(uv_interface_address_s__bindgen_ty_1, address4) - 0usize]; ++ ["Offset of field: uv_interface_address_s__bindgen_ty_1::address6"] ++ [::std::mem::offset_of!(uv_interface_address_s__bindgen_ty_1, address6) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_interface_address_s__bindgen_ty_2 { ++ pub netmask4: sockaddr_in, ++ pub netmask6: sockaddr_in6, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_interface_address_s__bindgen_ty_2"] ++ [::std::mem::size_of::() - 28usize]; ++ ["Alignment of uv_interface_address_s__bindgen_ty_2"] ++ [::std::mem::align_of::() - 4usize]; ++ ["Offset of field: uv_interface_address_s__bindgen_ty_2::netmask4"] ++ [::std::mem::offset_of!(uv_interface_address_s__bindgen_ty_2, netmask4) - 0usize]; ++ ["Offset of field: uv_interface_address_s__bindgen_ty_2::netmask6"] ++ [::std::mem::offset_of!(uv_interface_address_s__bindgen_ty_2, netmask6) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_interface_address_s"][::std::mem::size_of::() - 80usize]; ++ ["Alignment of uv_interface_address_s"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_interface_address_s::name"] ++ [::std::mem::offset_of!(uv_interface_address_s, name) - 0usize]; ++ ["Offset of field: uv_interface_address_s::phys_addr"] ++ [::std::mem::offset_of!(uv_interface_address_s, phys_addr) - 8usize]; ++ ["Offset of field: uv_interface_address_s::is_internal"] ++ [::std::mem::offset_of!(uv_interface_address_s, is_internal) - 16usize]; ++ ["Offset of field: uv_interface_address_s::address"] ++ [::std::mem::offset_of!(uv_interface_address_s, address) - 20usize]; ++ ["Offset of field: uv_interface_address_s::netmask"] ++ [::std::mem::offset_of!(uv_interface_address_s, netmask) - 48usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_passwd_s { ++ pub username: *mut ::std::os::raw::c_char, ++ pub uid: ::std::os::raw::c_ulong, ++ pub gid: ::std::os::raw::c_ulong, ++ pub shell: *mut ::std::os::raw::c_char, ++ pub homedir: *mut ::std::os::raw::c_char, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_passwd_s"][::std::mem::size_of::() - 40usize]; ++ ["Alignment of uv_passwd_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_passwd_s::username"] ++ [::std::mem::offset_of!(uv_passwd_s, username) - 0usize]; ++ ["Offset of field: uv_passwd_s::uid"][::std::mem::offset_of!(uv_passwd_s, uid) - 8usize]; ++ ["Offset of field: uv_passwd_s::gid"][::std::mem::offset_of!(uv_passwd_s, gid) - 16usize]; ++ ["Offset of field: uv_passwd_s::shell"][::std::mem::offset_of!(uv_passwd_s, shell) - 24usize]; ++ ["Offset of field: uv_passwd_s::homedir"] ++ [::std::mem::offset_of!(uv_passwd_s, homedir) - 32usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_group_s { ++ pub groupname: *mut ::std::os::raw::c_char, ++ pub gid: ::std::os::raw::c_ulong, ++ pub members: *mut *mut ::std::os::raw::c_char, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_group_s"][::std::mem::size_of::() - 24usize]; ++ ["Alignment of uv_group_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_group_s::groupname"] ++ [::std::mem::offset_of!(uv_group_s, groupname) - 0usize]; ++ ["Offset of field: uv_group_s::gid"][::std::mem::offset_of!(uv_group_s, gid) - 8usize]; ++ ["Offset of field: uv_group_s::members"][::std::mem::offset_of!(uv_group_s, members) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_utsname_s { ++ pub sysname: [::std::os::raw::c_char; 256usize], ++ pub release: [::std::os::raw::c_char; 256usize], ++ pub version: [::std::os::raw::c_char; 256usize], ++ pub machine: [::std::os::raw::c_char; 256usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_utsname_s"][::std::mem::size_of::() - 1024usize]; ++ ["Alignment of uv_utsname_s"][::std::mem::align_of::() - 1usize]; ++ ["Offset of field: uv_utsname_s::sysname"] ++ [::std::mem::offset_of!(uv_utsname_s, sysname) - 0usize]; ++ ["Offset of field: uv_utsname_s::release"] ++ [::std::mem::offset_of!(uv_utsname_s, release) - 256usize]; ++ ["Offset of field: uv_utsname_s::version"] ++ [::std::mem::offset_of!(uv_utsname_s, version) - 512usize]; ++ ["Offset of field: uv_utsname_s::machine"] ++ [::std::mem::offset_of!(uv_utsname_s, machine) - 768usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_statfs_s { ++ pub f_type: u64, ++ pub f_bsize: u64, ++ pub f_blocks: u64, ++ pub f_bfree: u64, ++ pub f_bavail: u64, ++ pub f_files: u64, ++ pub f_ffree: u64, ++ pub f_spare: [u64; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_statfs_s"][::std::mem::size_of::() - 88usize]; ++ ["Alignment of uv_statfs_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_statfs_s::f_type"][::std::mem::offset_of!(uv_statfs_s, f_type) - 0usize]; ++ ["Offset of field: uv_statfs_s::f_bsize"] ++ [::std::mem::offset_of!(uv_statfs_s, f_bsize) - 8usize]; ++ ["Offset of field: uv_statfs_s::f_blocks"] ++ [::std::mem::offset_of!(uv_statfs_s, f_blocks) - 16usize]; ++ ["Offset of field: uv_statfs_s::f_bfree"] ++ [::std::mem::offset_of!(uv_statfs_s, f_bfree) - 24usize]; ++ ["Offset of field: uv_statfs_s::f_bavail"] ++ [::std::mem::offset_of!(uv_statfs_s, f_bavail) - 32usize]; ++ ["Offset of field: uv_statfs_s::f_files"] ++ [::std::mem::offset_of!(uv_statfs_s, f_files) - 40usize]; ++ ["Offset of field: uv_statfs_s::f_ffree"] ++ [::std::mem::offset_of!(uv_statfs_s, f_ffree) - 48usize]; ++ ["Offset of field: uv_statfs_s::f_spare"] ++ [::std::mem::offset_of!(uv_statfs_s, f_spare) - 56usize]; ++}; ++impl uv_dirent_type_t { ++ pub const UV_DIRENT_UNKNOWN: uv_dirent_type_t = uv_dirent_type_t(0); ++} ++impl uv_dirent_type_t { ++ pub const UV_DIRENT_FILE: uv_dirent_type_t = uv_dirent_type_t(1); ++} ++impl uv_dirent_type_t { ++ pub const UV_DIRENT_DIR: uv_dirent_type_t = uv_dirent_type_t(2); ++} ++impl uv_dirent_type_t { ++ pub const UV_DIRENT_LINK: uv_dirent_type_t = uv_dirent_type_t(3); ++} ++impl uv_dirent_type_t { ++ pub const UV_DIRENT_FIFO: uv_dirent_type_t = uv_dirent_type_t(4); ++} ++impl uv_dirent_type_t { ++ pub const UV_DIRENT_SOCKET: uv_dirent_type_t = uv_dirent_type_t(5); ++} ++impl uv_dirent_type_t { ++ pub const UV_DIRENT_CHAR: uv_dirent_type_t = uv_dirent_type_t(6); ++} ++impl uv_dirent_type_t { ++ pub const UV_DIRENT_BLOCK: uv_dirent_type_t = uv_dirent_type_t(7); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_dirent_type_t(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_dirent_s { ++ pub name: *const ::std::os::raw::c_char, ++ pub type_: uv_dirent_type_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_dirent_s"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_dirent_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_dirent_s::name"][::std::mem::offset_of!(uv_dirent_s, name) - 0usize]; ++ ["Offset of field: uv_dirent_s::type_"][::std::mem::offset_of!(uv_dirent_s, type_) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_rusage_t { ++ pub ru_utime: uv_timeval_t, ++ pub ru_stime: uv_timeval_t, ++ pub ru_maxrss: u64, ++ pub ru_ixrss: u64, ++ pub ru_idrss: u64, ++ pub ru_isrss: u64, ++ pub ru_minflt: u64, ++ pub ru_majflt: u64, ++ pub ru_nswap: u64, ++ pub ru_inblock: u64, ++ pub ru_oublock: u64, ++ pub ru_msgsnd: u64, ++ pub ru_msgrcv: u64, ++ pub ru_nsignals: u64, ++ pub ru_nvcsw: u64, ++ pub ru_nivcsw: u64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_rusage_t"][::std::mem::size_of::() - 144usize]; ++ ["Alignment of uv_rusage_t"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_rusage_t::ru_utime"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_utime) - 0usize]; ++ ["Offset of field: uv_rusage_t::ru_stime"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_stime) - 16usize]; ++ ["Offset of field: uv_rusage_t::ru_maxrss"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_maxrss) - 32usize]; ++ ["Offset of field: uv_rusage_t::ru_ixrss"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_ixrss) - 40usize]; ++ ["Offset of field: uv_rusage_t::ru_idrss"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_idrss) - 48usize]; ++ ["Offset of field: uv_rusage_t::ru_isrss"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_isrss) - 56usize]; ++ ["Offset of field: uv_rusage_t::ru_minflt"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_minflt) - 64usize]; ++ ["Offset of field: uv_rusage_t::ru_majflt"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_majflt) - 72usize]; ++ ["Offset of field: uv_rusage_t::ru_nswap"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_nswap) - 80usize]; ++ ["Offset of field: uv_rusage_t::ru_inblock"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_inblock) - 88usize]; ++ ["Offset of field: uv_rusage_t::ru_oublock"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_oublock) - 96usize]; ++ ["Offset of field: uv_rusage_t::ru_msgsnd"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_msgsnd) - 104usize]; ++ ["Offset of field: uv_rusage_t::ru_msgrcv"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_msgrcv) - 112usize]; ++ ["Offset of field: uv_rusage_t::ru_nsignals"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_nsignals) - 120usize]; ++ ["Offset of field: uv_rusage_t::ru_nvcsw"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_nvcsw) - 128usize]; ++ ["Offset of field: uv_rusage_t::ru_nivcsw"] ++ [::std::mem::offset_of!(uv_rusage_t, ru_nivcsw) - 136usize]; ++}; ++pub const UV_THREAD_PRIORITY_HIGHEST: _bindgen_ty_2 = _bindgen_ty_2(2); ++pub const UV_THREAD_PRIORITY_ABOVE_NORMAL: _bindgen_ty_2 = _bindgen_ty_2(1); ++pub const UV_THREAD_PRIORITY_NORMAL: _bindgen_ty_2 = _bindgen_ty_2(0); ++pub const UV_THREAD_PRIORITY_BELOW_NORMAL: _bindgen_ty_2 = _bindgen_ty_2(-1); ++pub const UV_THREAD_PRIORITY_LOWEST: _bindgen_ty_2 = _bindgen_ty_2(-2); ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct _bindgen_ty_2(pub ::std::os::raw::c_int); ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_env_item_s { ++ pub name: *mut ::std::os::raw::c_char, ++ pub value: *mut ::std::os::raw::c_char, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_env_item_s"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_env_item_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_env_item_s::name"][::std::mem::offset_of!(uv_env_item_s, name) - 0usize]; ++ ["Offset of field: uv_env_item_s::value"] ++ [::std::mem::offset_of!(uv_env_item_s, value) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_metrics_s { ++ pub loop_count: u64, ++ pub events: u64, ++ pub events_waiting: u64, ++ pub reserved: [*mut u64; 13usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_metrics_s"][::std::mem::size_of::() - 128usize]; ++ ["Alignment of uv_metrics_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_metrics_s::loop_count"] ++ [::std::mem::offset_of!(uv_metrics_s, loop_count) - 0usize]; ++ ["Offset of field: uv_metrics_s::events"] ++ [::std::mem::offset_of!(uv_metrics_s, events) - 8usize]; ++ ["Offset of field: uv_metrics_s::events_waiting"] ++ [::std::mem::offset_of!(uv_metrics_s, events_waiting) - 16usize]; ++ ["Offset of field: uv_metrics_s::reserved"] ++ [::std::mem::offset_of!(uv_metrics_s, reserved) - 24usize]; ++}; ++impl uv_fs_type { ++ pub const UV_FS_UNKNOWN: uv_fs_type = uv_fs_type(-1); ++} ++impl uv_fs_type { ++ pub const UV_FS_CUSTOM: uv_fs_type = uv_fs_type(0); ++} ++impl uv_fs_type { ++ pub const UV_FS_OPEN: uv_fs_type = uv_fs_type(1); ++} ++impl uv_fs_type { ++ pub const UV_FS_CLOSE: uv_fs_type = uv_fs_type(2); ++} ++impl uv_fs_type { ++ pub const UV_FS_READ: uv_fs_type = uv_fs_type(3); ++} ++impl uv_fs_type { ++ pub const UV_FS_WRITE: uv_fs_type = uv_fs_type(4); ++} ++impl uv_fs_type { ++ pub const UV_FS_SENDFILE: uv_fs_type = uv_fs_type(5); ++} ++impl uv_fs_type { ++ pub const UV_FS_STAT: uv_fs_type = uv_fs_type(6); ++} ++impl uv_fs_type { ++ pub const UV_FS_LSTAT: uv_fs_type = uv_fs_type(7); ++} ++impl uv_fs_type { ++ pub const UV_FS_FSTAT: uv_fs_type = uv_fs_type(8); ++} ++impl uv_fs_type { ++ pub const UV_FS_FTRUNCATE: uv_fs_type = uv_fs_type(9); ++} ++impl uv_fs_type { ++ pub const UV_FS_UTIME: uv_fs_type = uv_fs_type(10); ++} ++impl uv_fs_type { ++ pub const UV_FS_FUTIME: uv_fs_type = uv_fs_type(11); ++} ++impl uv_fs_type { ++ pub const UV_FS_ACCESS: uv_fs_type = uv_fs_type(12); ++} ++impl uv_fs_type { ++ pub const UV_FS_CHMOD: uv_fs_type = uv_fs_type(13); ++} ++impl uv_fs_type { ++ pub const UV_FS_FCHMOD: uv_fs_type = uv_fs_type(14); ++} ++impl uv_fs_type { ++ pub const UV_FS_FSYNC: uv_fs_type = uv_fs_type(15); ++} ++impl uv_fs_type { ++ pub const UV_FS_FDATASYNC: uv_fs_type = uv_fs_type(16); ++} ++impl uv_fs_type { ++ pub const UV_FS_UNLINK: uv_fs_type = uv_fs_type(17); ++} ++impl uv_fs_type { ++ pub const UV_FS_RMDIR: uv_fs_type = uv_fs_type(18); ++} ++impl uv_fs_type { ++ pub const UV_FS_MKDIR: uv_fs_type = uv_fs_type(19); ++} ++impl uv_fs_type { ++ pub const UV_FS_MKDTEMP: uv_fs_type = uv_fs_type(20); ++} ++impl uv_fs_type { ++ pub const UV_FS_RENAME: uv_fs_type = uv_fs_type(21); ++} ++impl uv_fs_type { ++ pub const UV_FS_SCANDIR: uv_fs_type = uv_fs_type(22); ++} ++impl uv_fs_type { ++ pub const UV_FS_LINK: uv_fs_type = uv_fs_type(23); ++} ++impl uv_fs_type { ++ pub const UV_FS_SYMLINK: uv_fs_type = uv_fs_type(24); ++} ++impl uv_fs_type { ++ pub const UV_FS_READLINK: uv_fs_type = uv_fs_type(25); ++} ++impl uv_fs_type { ++ pub const UV_FS_CHOWN: uv_fs_type = uv_fs_type(26); ++} ++impl uv_fs_type { ++ pub const UV_FS_FCHOWN: uv_fs_type = uv_fs_type(27); ++} ++impl uv_fs_type { ++ pub const UV_FS_REALPATH: uv_fs_type = uv_fs_type(28); ++} ++impl uv_fs_type { ++ pub const UV_FS_COPYFILE: uv_fs_type = uv_fs_type(29); ++} ++impl uv_fs_type { ++ pub const UV_FS_LCHOWN: uv_fs_type = uv_fs_type(30); ++} ++impl uv_fs_type { ++ pub const UV_FS_OPENDIR: uv_fs_type = uv_fs_type(31); ++} ++impl uv_fs_type { ++ pub const UV_FS_READDIR: uv_fs_type = uv_fs_type(32); ++} ++impl uv_fs_type { ++ pub const UV_FS_CLOSEDIR: uv_fs_type = uv_fs_type(33); ++} ++impl uv_fs_type { ++ pub const UV_FS_STATFS: uv_fs_type = uv_fs_type(34); ++} ++impl uv_fs_type { ++ pub const UV_FS_MKSTEMP: uv_fs_type = uv_fs_type(35); ++} ++impl uv_fs_type { ++ pub const UV_FS_LUTIME: uv_fs_type = uv_fs_type(36); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_fs_type(pub ::std::os::raw::c_int); ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_dir_s { ++ pub dirents: *mut uv_dirent_t, ++ pub nentries: usize, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++ pub dir: *mut DIR, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_dir_s"][::std::mem::size_of::() - 56usize]; ++ ["Alignment of uv_dir_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_dir_s::dirents"][::std::mem::offset_of!(uv_dir_s, dirents) - 0usize]; ++ ["Offset of field: uv_dir_s::nentries"][::std::mem::offset_of!(uv_dir_s, nentries) - 8usize]; ++ ["Offset of field: uv_dir_s::reserved"][::std::mem::offset_of!(uv_dir_s, reserved) - 16usize]; ++ ["Offset of field: uv_dir_s::dir"][::std::mem::offset_of!(uv_dir_s, dir) - 48usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_fs_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub fs_type: uv_fs_type, ++ pub loop_: *mut uv_loop_t, ++ pub cb: uv_fs_cb, ++ pub result: isize, ++ pub ptr: *mut ::std::os::raw::c_void, ++ pub path: *const ::std::os::raw::c_char, ++ pub statbuf: uv_stat_t, ++ pub new_path: *const ::std::os::raw::c_char, ++ pub file: uv_file, ++ pub flags: ::std::os::raw::c_int, ++ pub mode: mode_t, ++ pub nbufs: ::std::os::raw::c_uint, ++ pub bufs: *mut uv_buf_t, ++ pub off: off_t, ++ pub uid: uv_uid_t, ++ pub gid: uv_gid_t, ++ pub atime: f64, ++ pub mtime: f64, ++ pub work_req: uv__work, ++ pub bufsml: [uv_buf_t; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_fs_s"][::std::mem::size_of::() - 440usize]; ++ ["Alignment of uv_fs_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_fs_s::data"][::std::mem::offset_of!(uv_fs_s, data) - 0usize]; ++ ["Offset of field: uv_fs_s::type_"][::std::mem::offset_of!(uv_fs_s, type_) - 8usize]; ++ ["Offset of field: uv_fs_s::reserved"][::std::mem::offset_of!(uv_fs_s, reserved) - 16usize]; ++ ["Offset of field: uv_fs_s::fs_type"][::std::mem::offset_of!(uv_fs_s, fs_type) - 64usize]; ++ ["Offset of field: uv_fs_s::loop_"][::std::mem::offset_of!(uv_fs_s, loop_) - 72usize]; ++ ["Offset of field: uv_fs_s::cb"][::std::mem::offset_of!(uv_fs_s, cb) - 80usize]; ++ ["Offset of field: uv_fs_s::result"][::std::mem::offset_of!(uv_fs_s, result) - 88usize]; ++ ["Offset of field: uv_fs_s::ptr"][::std::mem::offset_of!(uv_fs_s, ptr) - 96usize]; ++ ["Offset of field: uv_fs_s::path"][::std::mem::offset_of!(uv_fs_s, path) - 104usize]; ++ ["Offset of field: uv_fs_s::statbuf"][::std::mem::offset_of!(uv_fs_s, statbuf) - 112usize]; ++ ["Offset of field: uv_fs_s::new_path"][::std::mem::offset_of!(uv_fs_s, new_path) - 272usize]; ++ ["Offset of field: uv_fs_s::file"][::std::mem::offset_of!(uv_fs_s, file) - 280usize]; ++ ["Offset of field: uv_fs_s::flags"][::std::mem::offset_of!(uv_fs_s, flags) - 284usize]; ++ ["Offset of field: uv_fs_s::mode"][::std::mem::offset_of!(uv_fs_s, mode) - 288usize]; ++ ["Offset of field: uv_fs_s::nbufs"][::std::mem::offset_of!(uv_fs_s, nbufs) - 292usize]; ++ ["Offset of field: uv_fs_s::bufs"][::std::mem::offset_of!(uv_fs_s, bufs) - 296usize]; ++ ["Offset of field: uv_fs_s::off"][::std::mem::offset_of!(uv_fs_s, off) - 304usize]; ++ ["Offset of field: uv_fs_s::uid"][::std::mem::offset_of!(uv_fs_s, uid) - 312usize]; ++ ["Offset of field: uv_fs_s::gid"][::std::mem::offset_of!(uv_fs_s, gid) - 316usize]; ++ ["Offset of field: uv_fs_s::atime"][::std::mem::offset_of!(uv_fs_s, atime) - 320usize]; ++ ["Offset of field: uv_fs_s::mtime"][::std::mem::offset_of!(uv_fs_s, mtime) - 328usize]; ++ ["Offset of field: uv_fs_s::work_req"][::std::mem::offset_of!(uv_fs_s, work_req) - 336usize]; ++ ["Offset of field: uv_fs_s::bufsml"][::std::mem::offset_of!(uv_fs_s, bufsml) - 376usize]; ++}; ++impl uv_fs_event { ++ pub const UV_RENAME: uv_fs_event = uv_fs_event(1); ++} ++impl uv_fs_event { ++ pub const UV_CHANGE: uv_fs_event = uv_fs_event(2); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_fs_event(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_fs_event_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_fs_event_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub path: *mut ::std::os::raw::c_char, ++ pub cb: uv_fs_event_cb, ++ pub event_watcher: uv__io_t, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_fs_event_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_fs_event_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_fs_event_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_fs_event_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_fs_event_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_fs_event_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_fs_event_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_fs_event_s"][::std::mem::size_of::() - 176usize]; ++ ["Alignment of uv_fs_event_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_fs_event_s::data"][::std::mem::offset_of!(uv_fs_event_s, data) - 0usize]; ++ ["Offset of field: uv_fs_event_s::loop_"] ++ [::std::mem::offset_of!(uv_fs_event_s, loop_) - 8usize]; ++ ["Offset of field: uv_fs_event_s::type_"] ++ [::std::mem::offset_of!(uv_fs_event_s, type_) - 16usize]; ++ ["Offset of field: uv_fs_event_s::close_cb"] ++ [::std::mem::offset_of!(uv_fs_event_s, close_cb) - 24usize]; ++ ["Offset of field: uv_fs_event_s::handle_queue"] ++ [::std::mem::offset_of!(uv_fs_event_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_fs_event_s::u"][::std::mem::offset_of!(uv_fs_event_s, u) - 48usize]; ++ ["Offset of field: uv_fs_event_s::next_closing"] ++ [::std::mem::offset_of!(uv_fs_event_s, next_closing) - 80usize]; ++ ["Offset of field: uv_fs_event_s::flags"] ++ [::std::mem::offset_of!(uv_fs_event_s, flags) - 88usize]; ++ ["Offset of field: uv_fs_event_s::path"][::std::mem::offset_of!(uv_fs_event_s, path) - 96usize]; ++ ["Offset of field: uv_fs_event_s::cb"][::std::mem::offset_of!(uv_fs_event_s, cb) - 104usize]; ++ ["Offset of field: uv_fs_event_s::event_watcher"] ++ [::std::mem::offset_of!(uv_fs_event_s, event_watcher) - 112usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_fs_poll_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_fs_poll_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub poll_ctx: *mut ::std::os::raw::c_void, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_fs_poll_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_fs_poll_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_fs_poll_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_fs_poll_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_fs_poll_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_fs_poll_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_fs_poll_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_fs_poll_s"][::std::mem::size_of::() - 104usize]; ++ ["Alignment of uv_fs_poll_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_fs_poll_s::data"][::std::mem::offset_of!(uv_fs_poll_s, data) - 0usize]; ++ ["Offset of field: uv_fs_poll_s::loop_"][::std::mem::offset_of!(uv_fs_poll_s, loop_) - 8usize]; ++ ["Offset of field: uv_fs_poll_s::type_"][::std::mem::offset_of!(uv_fs_poll_s, type_) - 16usize]; ++ ["Offset of field: uv_fs_poll_s::close_cb"] ++ [::std::mem::offset_of!(uv_fs_poll_s, close_cb) - 24usize]; ++ ["Offset of field: uv_fs_poll_s::handle_queue"] ++ [::std::mem::offset_of!(uv_fs_poll_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_fs_poll_s::u"][::std::mem::offset_of!(uv_fs_poll_s, u) - 48usize]; ++ ["Offset of field: uv_fs_poll_s::next_closing"] ++ [::std::mem::offset_of!(uv_fs_poll_s, next_closing) - 80usize]; ++ ["Offset of field: uv_fs_poll_s::flags"][::std::mem::offset_of!(uv_fs_poll_s, flags) - 88usize]; ++ ["Offset of field: uv_fs_poll_s::poll_ctx"] ++ [::std::mem::offset_of!(uv_fs_poll_s, poll_ctx) - 96usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_signal_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub loop_: *mut uv_loop_t, ++ pub type_: uv_handle_type, ++ pub close_cb: uv_close_cb, ++ pub handle_queue: uv__queue, ++ pub u: uv_signal_s__bindgen_ty_1, ++ pub next_closing: *mut uv_handle_t, ++ pub flags: ::std::os::raw::c_uint, ++ pub signal_cb: uv_signal_cb, ++ pub signum: ::std::os::raw::c_int, ++ pub tree_entry: uv_signal_s__bindgen_ty_2, ++ pub caught_signals: ::std::os::raw::c_uint, ++ pub dispatched_signals: ::std::os::raw::c_uint, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_signal_s__bindgen_ty_1 { ++ pub fd: ::std::os::raw::c_int, ++ pub reserved: [*mut ::std::os::raw::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_signal_s__bindgen_ty_1"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_signal_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_signal_s__bindgen_ty_1::fd"] ++ [::std::mem::offset_of!(uv_signal_s__bindgen_ty_1, fd) - 0usize]; ++ ["Offset of field: uv_signal_s__bindgen_ty_1::reserved"] ++ [::std::mem::offset_of!(uv_signal_s__bindgen_ty_1, reserved) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_signal_s__bindgen_ty_2 { ++ pub rbe_left: *mut uv_signal_s, ++ pub rbe_right: *mut uv_signal_s, ++ pub rbe_parent: *mut uv_signal_s, ++ pub rbe_color: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_signal_s__bindgen_ty_2"] ++ [::std::mem::size_of::() - 32usize]; ++ ["Alignment of uv_signal_s__bindgen_ty_2"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_signal_s__bindgen_ty_2::rbe_left"] ++ [::std::mem::offset_of!(uv_signal_s__bindgen_ty_2, rbe_left) - 0usize]; ++ ["Offset of field: uv_signal_s__bindgen_ty_2::rbe_right"] ++ [::std::mem::offset_of!(uv_signal_s__bindgen_ty_2, rbe_right) - 8usize]; ++ ["Offset of field: uv_signal_s__bindgen_ty_2::rbe_parent"] ++ [::std::mem::offset_of!(uv_signal_s__bindgen_ty_2, rbe_parent) - 16usize]; ++ ["Offset of field: uv_signal_s__bindgen_ty_2::rbe_color"] ++ [::std::mem::offset_of!(uv_signal_s__bindgen_ty_2, rbe_color) - 24usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_signal_s"][::std::mem::size_of::() - 152usize]; ++ ["Alignment of uv_signal_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_signal_s::data"][::std::mem::offset_of!(uv_signal_s, data) - 0usize]; ++ ["Offset of field: uv_signal_s::loop_"][::std::mem::offset_of!(uv_signal_s, loop_) - 8usize]; ++ ["Offset of field: uv_signal_s::type_"][::std::mem::offset_of!(uv_signal_s, type_) - 16usize]; ++ ["Offset of field: uv_signal_s::close_cb"] ++ [::std::mem::offset_of!(uv_signal_s, close_cb) - 24usize]; ++ ["Offset of field: uv_signal_s::handle_queue"] ++ [::std::mem::offset_of!(uv_signal_s, handle_queue) - 32usize]; ++ ["Offset of field: uv_signal_s::u"][::std::mem::offset_of!(uv_signal_s, u) - 48usize]; ++ ["Offset of field: uv_signal_s::next_closing"] ++ [::std::mem::offset_of!(uv_signal_s, next_closing) - 80usize]; ++ ["Offset of field: uv_signal_s::flags"][::std::mem::offset_of!(uv_signal_s, flags) - 88usize]; ++ ["Offset of field: uv_signal_s::signal_cb"] ++ [::std::mem::offset_of!(uv_signal_s, signal_cb) - 96usize]; ++ ["Offset of field: uv_signal_s::signum"] ++ [::std::mem::offset_of!(uv_signal_s, signum) - 104usize]; ++ ["Offset of field: uv_signal_s::tree_entry"] ++ [::std::mem::offset_of!(uv_signal_s, tree_entry) - 112usize]; ++ ["Offset of field: uv_signal_s::caught_signals"] ++ [::std::mem::offset_of!(uv_signal_s, caught_signals) - 144usize]; ++ ["Offset of field: uv_signal_s::dispatched_signals"] ++ [::std::mem::offset_of!(uv_signal_s, dispatched_signals) - 148usize]; ++}; ++impl uv_fs_event_flags { ++ pub const UV_FS_EVENT_WATCH_ENTRY: uv_fs_event_flags = uv_fs_event_flags(1); ++} ++impl uv_fs_event_flags { ++ pub const UV_FS_EVENT_STAT: uv_fs_event_flags = uv_fs_event_flags(2); ++} ++impl uv_fs_event_flags { ++ pub const UV_FS_EVENT_RECURSIVE: uv_fs_event_flags = uv_fs_event_flags(4); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_fs_event_flags(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_random_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub type_: uv_req_type, ++ pub reserved: [*mut ::std::os::raw::c_void; 6usize], ++ pub loop_: *mut uv_loop_t, ++ pub status: ::std::os::raw::c_int, ++ pub buf: *mut ::std::os::raw::c_void, ++ pub buflen: usize, ++ pub cb: uv_random_cb, ++ pub work_req: uv__work, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_random_s"][::std::mem::size_of::() - 144usize]; ++ ["Alignment of uv_random_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_random_s::data"][::std::mem::offset_of!(uv_random_s, data) - 0usize]; ++ ["Offset of field: uv_random_s::type_"][::std::mem::offset_of!(uv_random_s, type_) - 8usize]; ++ ["Offset of field: uv_random_s::reserved"] ++ [::std::mem::offset_of!(uv_random_s, reserved) - 16usize]; ++ ["Offset of field: uv_random_s::loop_"][::std::mem::offset_of!(uv_random_s, loop_) - 64usize]; ++ ["Offset of field: uv_random_s::status"][::std::mem::offset_of!(uv_random_s, status) - 72usize]; ++ ["Offset of field: uv_random_s::buf"][::std::mem::offset_of!(uv_random_s, buf) - 80usize]; ++ ["Offset of field: uv_random_s::buflen"][::std::mem::offset_of!(uv_random_s, buflen) - 88usize]; ++ ["Offset of field: uv_random_s::cb"][::std::mem::offset_of!(uv_random_s, cb) - 96usize]; ++ ["Offset of field: uv_random_s::work_req"] ++ [::std::mem::offset_of!(uv_random_s, work_req) - 104usize]; ++}; ++pub type uv_thread_cb = ++ ::std::option::Option; ++impl uv_thread_create_flags { ++ pub const UV_THREAD_NO_FLAGS: uv_thread_create_flags = uv_thread_create_flags(0); ++} ++impl uv_thread_create_flags { ++ pub const UV_THREAD_HAS_STACK_SIZE: uv_thread_create_flags = uv_thread_create_flags(1); ++} ++#[repr(transparent)] ++#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] ++pub struct uv_thread_create_flags(pub ::std::os::raw::c_uint); ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_thread_options_s { ++ pub flags: ::std::os::raw::c_uint, ++ pub stack_size: usize, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_thread_options_s"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_thread_options_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_thread_options_s::flags"] ++ [::std::mem::offset_of!(uv_thread_options_s, flags) - 0usize]; ++ ["Offset of field: uv_thread_options_s::stack_size"] ++ [::std::mem::offset_of!(uv_thread_options_s, stack_size) - 8usize]; ++}; ++pub type uv_thread_options_t = uv_thread_options_s; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_any_handle { ++ pub async_: uv_async_t, ++ pub check: uv_check_t, ++ pub fs_event: uv_fs_event_t, ++ pub fs_poll: uv_fs_poll_t, ++ pub handle: uv_handle_t, ++ pub idle: uv_idle_t, ++ pub pipe: uv_pipe_t, ++ pub poll: uv_poll_t, ++ pub prepare: uv_prepare_t, ++ pub process: uv_process_t, ++ pub stream: uv_stream_t, ++ pub tcp: uv_tcp_t, ++ pub timer: uv_timer_t, ++ pub tty: uv_tty_t, ++ pub udp: uv_udp_t, ++ pub signal: uv_signal_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_any_handle"][::std::mem::size_of::() - 304usize]; ++ ["Alignment of uv_any_handle"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_any_handle::async_"] ++ [::std::mem::offset_of!(uv_any_handle, async_) - 0usize]; ++ ["Offset of field: uv_any_handle::check"] ++ [::std::mem::offset_of!(uv_any_handle, check) - 0usize]; ++ ["Offset of field: uv_any_handle::fs_event"] ++ [::std::mem::offset_of!(uv_any_handle, fs_event) - 0usize]; ++ ["Offset of field: uv_any_handle::fs_poll"] ++ [::std::mem::offset_of!(uv_any_handle, fs_poll) - 0usize]; ++ ["Offset of field: uv_any_handle::handle"] ++ [::std::mem::offset_of!(uv_any_handle, handle) - 0usize]; ++ ["Offset of field: uv_any_handle::idle"][::std::mem::offset_of!(uv_any_handle, idle) - 0usize]; ++ ["Offset of field: uv_any_handle::pipe"][::std::mem::offset_of!(uv_any_handle, pipe) - 0usize]; ++ ["Offset of field: uv_any_handle::poll"][::std::mem::offset_of!(uv_any_handle, poll) - 0usize]; ++ ["Offset of field: uv_any_handle::prepare"] ++ [::std::mem::offset_of!(uv_any_handle, prepare) - 0usize]; ++ ["Offset of field: uv_any_handle::process"] ++ [::std::mem::offset_of!(uv_any_handle, process) - 0usize]; ++ ["Offset of field: uv_any_handle::stream"] ++ [::std::mem::offset_of!(uv_any_handle, stream) - 0usize]; ++ ["Offset of field: uv_any_handle::tcp"][::std::mem::offset_of!(uv_any_handle, tcp) - 0usize]; ++ ["Offset of field: uv_any_handle::timer"] ++ [::std::mem::offset_of!(uv_any_handle, timer) - 0usize]; ++ ["Offset of field: uv_any_handle::tty"][::std::mem::offset_of!(uv_any_handle, tty) - 0usize]; ++ ["Offset of field: uv_any_handle::udp"][::std::mem::offset_of!(uv_any_handle, udp) - 0usize]; ++ ["Offset of field: uv_any_handle::signal"] ++ [::std::mem::offset_of!(uv_any_handle, signal) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_any_req { ++ pub req: uv_req_t, ++ pub connect: uv_connect_t, ++ pub write: uv_write_t, ++ pub shutdown: uv_shutdown_t, ++ pub udp_send: uv_udp_send_t, ++ pub fs: uv_fs_t, ++ pub work: uv_work_t, ++ pub getaddrinfo: uv_getaddrinfo_t, ++ pub getnameinfo: uv_getnameinfo_t, ++ pub random: uv_random_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_any_req"][::std::mem::size_of::() - 1320usize]; ++ ["Alignment of uv_any_req"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_any_req::req"][::std::mem::offset_of!(uv_any_req, req) - 0usize]; ++ ["Offset of field: uv_any_req::connect"][::std::mem::offset_of!(uv_any_req, connect) - 0usize]; ++ ["Offset of field: uv_any_req::write"][::std::mem::offset_of!(uv_any_req, write) - 0usize]; ++ ["Offset of field: uv_any_req::shutdown"] ++ [::std::mem::offset_of!(uv_any_req, shutdown) - 0usize]; ++ ["Offset of field: uv_any_req::udp_send"] ++ [::std::mem::offset_of!(uv_any_req, udp_send) - 0usize]; ++ ["Offset of field: uv_any_req::fs"][::std::mem::offset_of!(uv_any_req, fs) - 0usize]; ++ ["Offset of field: uv_any_req::work"][::std::mem::offset_of!(uv_any_req, work) - 0usize]; ++ ["Offset of field: uv_any_req::getaddrinfo"] ++ [::std::mem::offset_of!(uv_any_req, getaddrinfo) - 0usize]; ++ ["Offset of field: uv_any_req::getnameinfo"] ++ [::std::mem::offset_of!(uv_any_req, getnameinfo) - 0usize]; ++ ["Offset of field: uv_any_req::random"][::std::mem::offset_of!(uv_any_req, random) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct uv_loop_s { ++ pub data: *mut ::std::os::raw::c_void, ++ pub active_handles: ::std::os::raw::c_uint, ++ pub handle_queue: uv__queue, ++ pub active_reqs: uv_loop_s__bindgen_ty_1, ++ pub internal_fields: *mut ::std::os::raw::c_void, ++ pub stop_flag: ::std::os::raw::c_uint, ++ pub flags: ::std::os::raw::c_ulong, ++ pub backend_fd: ::std::os::raw::c_int, ++ pub pending_queue: uv__queue, ++ pub watcher_queue: uv__queue, ++ pub watchers: *mut *mut uv__io_t, ++ pub nwatchers: ::std::os::raw::c_uint, ++ pub nfds: ::std::os::raw::c_uint, ++ pub wq: uv__queue, ++ pub wq_mutex: uv_mutex_t, ++ pub wq_async: uv_async_t, ++ pub cloexec_lock: uv_rwlock_t, ++ pub closing_handles: *mut uv_handle_t, ++ pub process_handles: uv__queue, ++ pub prepare_handles: uv__queue, ++ pub check_handles: uv__queue, ++ pub idle_handles: uv__queue, ++ pub async_handles: uv__queue, ++ pub async_unused: ::std::option::Option, ++ pub async_io_watcher: uv__io_t, ++ pub async_wfd: ::std::os::raw::c_int, ++ pub timer_heap: uv_loop_s__bindgen_ty_2, ++ pub timer_counter: u64, ++ pub time: u64, ++ pub signal_pipefd: [::std::os::raw::c_int; 2usize], ++ pub signal_io_watcher: uv__io_t, ++ pub child_watcher: uv_signal_t, ++ pub emfile_fd: ::std::os::raw::c_int, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union uv_loop_s__bindgen_ty_1 { ++ pub unused: *mut ::std::os::raw::c_void, ++ pub count: ::std::os::raw::c_uint, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_loop_s__bindgen_ty_1"][::std::mem::size_of::() - 8usize]; ++ ["Alignment of uv_loop_s__bindgen_ty_1"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_loop_s__bindgen_ty_1::unused"] ++ [::std::mem::offset_of!(uv_loop_s__bindgen_ty_1, unused) - 0usize]; ++ ["Offset of field: uv_loop_s__bindgen_ty_1::count"] ++ [::std::mem::offset_of!(uv_loop_s__bindgen_ty_1, count) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_loop_s__bindgen_ty_2 { ++ pub min: *mut ::std::os::raw::c_void, ++ pub nelts: ::std::os::raw::c_uint, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_loop_s__bindgen_ty_2"][::std::mem::size_of::() - 16usize]; ++ ["Alignment of uv_loop_s__bindgen_ty_2"] ++ [::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_loop_s__bindgen_ty_2::min"] ++ [::std::mem::offset_of!(uv_loop_s__bindgen_ty_2, min) - 0usize]; ++ ["Offset of field: uv_loop_s__bindgen_ty_2::nelts"] ++ [::std::mem::offset_of!(uv_loop_s__bindgen_ty_2, nelts) - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_loop_s"][::std::mem::size_of::() - 712usize]; ++ ["Alignment of uv_loop_s"][::std::mem::align_of::() - 8usize]; ++ ["Offset of field: uv_loop_s::data"][::std::mem::offset_of!(uv_loop_s, data) - 0usize]; ++ ["Offset of field: uv_loop_s::active_handles"] ++ [::std::mem::offset_of!(uv_loop_s, active_handles) - 8usize]; ++ ["Offset of field: uv_loop_s::handle_queue"] ++ [::std::mem::offset_of!(uv_loop_s, handle_queue) - 16usize]; ++ ["Offset of field: uv_loop_s::active_reqs"] ++ [::std::mem::offset_of!(uv_loop_s, active_reqs) - 32usize]; ++ ["Offset of field: uv_loop_s::internal_fields"] ++ [::std::mem::offset_of!(uv_loop_s, internal_fields) - 40usize]; ++ ["Offset of field: uv_loop_s::stop_flag"] ++ [::std::mem::offset_of!(uv_loop_s, stop_flag) - 48usize]; ++ ["Offset of field: uv_loop_s::flags"][::std::mem::offset_of!(uv_loop_s, flags) - 56usize]; ++ ["Offset of field: uv_loop_s::backend_fd"] ++ [::std::mem::offset_of!(uv_loop_s, backend_fd) - 64usize]; ++ ["Offset of field: uv_loop_s::pending_queue"] ++ [::std::mem::offset_of!(uv_loop_s, pending_queue) - 72usize]; ++ ["Offset of field: uv_loop_s::watcher_queue"] ++ [::std::mem::offset_of!(uv_loop_s, watcher_queue) - 88usize]; ++ ["Offset of field: uv_loop_s::watchers"] ++ [::std::mem::offset_of!(uv_loop_s, watchers) - 104usize]; ++ ["Offset of field: uv_loop_s::nwatchers"] ++ [::std::mem::offset_of!(uv_loop_s, nwatchers) - 112usize]; ++ ["Offset of field: uv_loop_s::nfds"][::std::mem::offset_of!(uv_loop_s, nfds) - 116usize]; ++ ["Offset of field: uv_loop_s::wq"][::std::mem::offset_of!(uv_loop_s, wq) - 120usize]; ++ ["Offset of field: uv_loop_s::wq_mutex"] ++ [::std::mem::offset_of!(uv_loop_s, wq_mutex) - 136usize]; ++ ["Offset of field: uv_loop_s::wq_async"] ++ [::std::mem::offset_of!(uv_loop_s, wq_async) - 144usize]; ++ ["Offset of field: uv_loop_s::cloexec_lock"] ++ [::std::mem::offset_of!(uv_loop_s, cloexec_lock) - 272usize]; ++ ["Offset of field: uv_loop_s::closing_handles"] ++ [::std::mem::offset_of!(uv_loop_s, closing_handles) - 280usize]; ++ ["Offset of field: uv_loop_s::process_handles"] ++ [::std::mem::offset_of!(uv_loop_s, process_handles) - 288usize]; ++ ["Offset of field: uv_loop_s::prepare_handles"] ++ [::std::mem::offset_of!(uv_loop_s, prepare_handles) - 304usize]; ++ ["Offset of field: uv_loop_s::check_handles"] ++ [::std::mem::offset_of!(uv_loop_s, check_handles) - 320usize]; ++ ["Offset of field: uv_loop_s::idle_handles"] ++ [::std::mem::offset_of!(uv_loop_s, idle_handles) - 336usize]; ++ ["Offset of field: uv_loop_s::async_handles"] ++ [::std::mem::offset_of!(uv_loop_s, async_handles) - 352usize]; ++ ["Offset of field: uv_loop_s::async_unused"] ++ [::std::mem::offset_of!(uv_loop_s, async_unused) - 368usize]; ++ ["Offset of field: uv_loop_s::async_io_watcher"] ++ [::std::mem::offset_of!(uv_loop_s, async_io_watcher) - 376usize]; ++ ["Offset of field: uv_loop_s::async_wfd"] ++ [::std::mem::offset_of!(uv_loop_s, async_wfd) - 440usize]; ++ ["Offset of field: uv_loop_s::timer_heap"] ++ [::std::mem::offset_of!(uv_loop_s, timer_heap) - 448usize]; ++ ["Offset of field: uv_loop_s::timer_counter"] ++ [::std::mem::offset_of!(uv_loop_s, timer_counter) - 464usize]; ++ ["Offset of field: uv_loop_s::time"][::std::mem::offset_of!(uv_loop_s, time) - 472usize]; ++ ["Offset of field: uv_loop_s::signal_pipefd"] ++ [::std::mem::offset_of!(uv_loop_s, signal_pipefd) - 480usize]; ++ ["Offset of field: uv_loop_s::signal_io_watcher"] ++ [::std::mem::offset_of!(uv_loop_s, signal_io_watcher) - 488usize]; ++ ["Offset of field: uv_loop_s::child_watcher"] ++ [::std::mem::offset_of!(uv_loop_s, child_watcher) - 552usize]; ++ ["Offset of field: uv_loop_s::emfile_fd"] ++ [::std::mem::offset_of!(uv_loop_s, emfile_fd) - 704usize]; ++};