1pub const NAPI_VERSION: u32 = 8;
4pub const true_: u32 = 1;
5pub const false_: u32 = 0;
6pub const __bool_true_false_are_defined: u32 = 1;
7pub const NAPI_VERSION_EXPERIMENTAL: u32 = 2147483647;
8pub const __WORDSIZE: u32 = 64;
9pub const __DARWIN_ONLY_64_BIT_INO_T: u32 = 1;
10pub const __DARWIN_ONLY_UNIX_CONFORMANCE: u32 = 1;
11pub const __DARWIN_ONLY_VERS_1050: u32 = 1;
12pub const __DARWIN_UNIX03: u32 = 1;
13pub const __DARWIN_64_BIT_INO_T: u32 = 1;
14pub const __DARWIN_VERS_1050: u32 = 1;
15pub const __DARWIN_NON_CANCELABLE: u32 = 0;
16pub const __DARWIN_SUF_EXTSN: &[u8; 14] = b"$DARWIN_EXTSN\0";
17pub const __DARWIN_C_ANSI: u32 = 4096;
18pub const __DARWIN_C_FULL: u32 = 900000;
19pub const __DARWIN_C_LEVEL: u32 = 900000;
20pub const __STDC_WANT_LIB_EXT1__: u32 = 1;
21pub const __DARWIN_NO_LONG_LONG: u32 = 0;
22pub const _DARWIN_FEATURE_64_BIT_INODE: u32 = 1;
23pub const _DARWIN_FEATURE_ONLY_64_BIT_INODE: u32 = 1;
24pub const _DARWIN_FEATURE_ONLY_VERS_1050: u32 = 1;
25pub const _DARWIN_FEATURE_ONLY_UNIX_CONFORMANCE: u32 = 1;
26pub const _DARWIN_FEATURE_UNIX_CONFORMANCE: u32 = 3;
27pub const __has_ptrcheck: u32 = 0;
28pub const __PTHREAD_SIZE__: u32 = 8176;
29pub const __PTHREAD_ATTR_SIZE__: u32 = 56;
30pub const __PTHREAD_MUTEXATTR_SIZE__: u32 = 8;
31pub const __PTHREAD_MUTEX_SIZE__: u32 = 56;
32pub const __PTHREAD_CONDATTR_SIZE__: u32 = 8;
33pub const __PTHREAD_COND_SIZE__: u32 = 40;
34pub const __PTHREAD_ONCE_SIZE__: u32 = 8;
35pub const __PTHREAD_RWLOCK_SIZE__: u32 = 192;
36pub const __PTHREAD_RWLOCKATTR_SIZE__: u32 = 16;
37pub const INT8_MAX: u32 = 127;
38pub const INT16_MAX: u32 = 32767;
39pub const INT32_MAX: u32 = 2147483647;
40pub const INT64_MAX: u64 = 9223372036854775807;
41pub const INT8_MIN: i32 = -128;
42pub const INT16_MIN: i32 = -32768;
43pub const INT32_MIN: i32 = -2147483648;
44pub const INT64_MIN: i64 = -9223372036854775808;
45pub const UINT8_MAX: u32 = 255;
46pub const UINT16_MAX: u32 = 65535;
47pub const UINT32_MAX: u32 = 4294967295;
48pub const UINT64_MAX: i32 = -1;
49pub const INT_LEAST8_MIN: i32 = -128;
50pub const INT_LEAST16_MIN: i32 = -32768;
51pub const INT_LEAST32_MIN: i32 = -2147483648;
52pub const INT_LEAST64_MIN: i64 = -9223372036854775808;
53pub const INT_LEAST8_MAX: u32 = 127;
54pub const INT_LEAST16_MAX: u32 = 32767;
55pub const INT_LEAST32_MAX: u32 = 2147483647;
56pub const INT_LEAST64_MAX: u64 = 9223372036854775807;
57pub const UINT_LEAST8_MAX: u32 = 255;
58pub const UINT_LEAST16_MAX: u32 = 65535;
59pub const UINT_LEAST32_MAX: u32 = 4294967295;
60pub const UINT_LEAST64_MAX: i32 = -1;
61pub const INT_FAST8_MIN: i32 = -128;
62pub const INT_FAST16_MIN: i32 = -32768;
63pub const INT_FAST32_MIN: i32 = -2147483648;
64pub const INT_FAST64_MIN: i64 = -9223372036854775808;
65pub const INT_FAST8_MAX: u32 = 127;
66pub const INT_FAST16_MAX: u32 = 32767;
67pub const INT_FAST32_MAX: u32 = 2147483647;
68pub const INT_FAST64_MAX: u64 = 9223372036854775807;
69pub const UINT_FAST8_MAX: u32 = 255;
70pub const UINT_FAST16_MAX: u32 = 65535;
71pub const UINT_FAST32_MAX: u32 = 4294967295;
72pub const UINT_FAST64_MAX: i32 = -1;
73pub const INTPTR_MAX: u64 = 9223372036854775807;
74pub const INTPTR_MIN: i64 = -9223372036854775808;
75pub const UINTPTR_MAX: i32 = -1;
76pub const SIZE_MAX: i32 = -1;
77pub const RSIZE_MAX: i32 = -1;
78pub const WINT_MIN: i32 = -2147483648;
79pub const WINT_MAX: u32 = 2147483647;
80pub const SIG_ATOMIC_MIN: i32 = -2147483648;
81pub const SIG_ATOMIC_MAX: u32 = 2147483647;
82pub const NAPI_AUTO_LENGTH: i32 = -1;
83pub const NAPI_MODULE_VERSION: u32 = 1;
84pub type wchar_t = ::std::os::raw::c_int;
85pub type max_align_t = f64;
86pub type int_least8_t = i8;
87pub type int_least16_t = i16;
88pub type int_least32_t = i32;
89pub type int_least64_t = i64;
90pub type uint_least8_t = u8;
91pub type uint_least16_t = u16;
92pub type uint_least32_t = u32;
93pub type uint_least64_t = u64;
94pub type int_fast8_t = i8;
95pub type int_fast16_t = i16;
96pub type int_fast32_t = i32;
97pub type int_fast64_t = i64;
98pub type uint_fast8_t = u8;
99pub type uint_fast16_t = u16;
100pub type uint_fast32_t = u32;
101pub type uint_fast64_t = u64;
102pub type __int8_t = ::std::os::raw::c_schar;
103pub type __uint8_t = ::std::os::raw::c_uchar;
104pub type __int16_t = ::std::os::raw::c_short;
105pub type __uint16_t = ::std::os::raw::c_ushort;
106pub type __int32_t = ::std::os::raw::c_int;
107pub type __uint32_t = ::std::os::raw::c_uint;
108pub type __int64_t = ::std::os::raw::c_longlong;
109pub type __uint64_t = ::std::os::raw::c_ulonglong;
110pub type __darwin_intptr_t = ::std::os::raw::c_long;
111pub type __darwin_natural_t = ::std::os::raw::c_uint;
112pub type __darwin_ct_rune_t = ::std::os::raw::c_int;
113#[repr(C)]
114#[derive(Copy, Clone)]
115pub union __mbstate_t {
116 pub __mbstate8: [::std::os::raw::c_char; 128usize],
117 pub _mbstateL: ::std::os::raw::c_longlong,
118}
119#[test]
120fn bindgen_test_layout___mbstate_t() {
121 const UNINIT: ::std::mem::MaybeUninit<__mbstate_t> = ::std::mem::MaybeUninit::uninit();
122 let ptr = UNINIT.as_ptr();
123 assert_eq!(
124 ::std::mem::size_of::<__mbstate_t>(),
125 128usize,
126 concat!("Size of: ", stringify!(__mbstate_t))
127 );
128 assert_eq!(
129 ::std::mem::align_of::<__mbstate_t>(),
130 8usize,
131 concat!("Alignment of ", stringify!(__mbstate_t))
132 );
133 assert_eq!(
134 unsafe { ::std::ptr::addr_of!((*ptr).__mbstate8) as usize - ptr as usize },
135 0usize,
136 concat!(
137 "Offset of field: ",
138 stringify!(__mbstate_t),
139 "::",
140 stringify!(__mbstate8)
141 )
142 );
143 assert_eq!(
144 unsafe { ::std::ptr::addr_of!((*ptr)._mbstateL) as usize - ptr as usize },
145 0usize,
146 concat!(
147 "Offset of field: ",
148 stringify!(__mbstate_t),
149 "::",
150 stringify!(_mbstateL)
151 )
152 );
153}
154pub type __darwin_mbstate_t = __mbstate_t;
155pub type __darwin_ptrdiff_t = ::std::os::raw::c_long;
156pub type __darwin_size_t = ::std::os::raw::c_ulong;
157pub type __darwin_va_list = __builtin_va_list;
158pub type __darwin_wchar_t = ::std::os::raw::c_int;
159pub type __darwin_rune_t = __darwin_wchar_t;
160pub type __darwin_wint_t = ::std::os::raw::c_int;
161pub type __darwin_clock_t = ::std::os::raw::c_ulong;
162pub type __darwin_socklen_t = __uint32_t;
163pub type __darwin_ssize_t = ::std::os::raw::c_long;
164pub type __darwin_time_t = ::std::os::raw::c_long;
165pub type __darwin_blkcnt_t = __int64_t;
166pub type __darwin_blksize_t = __int32_t;
167pub type __darwin_dev_t = __int32_t;
168pub type __darwin_fsblkcnt_t = ::std::os::raw::c_uint;
169pub type __darwin_fsfilcnt_t = ::std::os::raw::c_uint;
170pub type __darwin_gid_t = __uint32_t;
171pub type __darwin_id_t = __uint32_t;
172pub type __darwin_ino64_t = __uint64_t;
173pub type __darwin_ino_t = __darwin_ino64_t;
174pub type __darwin_mach_port_name_t = __darwin_natural_t;
175pub type __darwin_mach_port_t = __darwin_mach_port_name_t;
176pub type __darwin_mode_t = __uint16_t;
177pub type __darwin_off_t = __int64_t;
178pub type __darwin_pid_t = __int32_t;
179pub type __darwin_sigset_t = __uint32_t;
180pub type __darwin_suseconds_t = __int32_t;
181pub type __darwin_uid_t = __uint32_t;
182pub type __darwin_useconds_t = __uint32_t;
183pub type __darwin_uuid_t = [::std::os::raw::c_uchar; 16usize];
184pub type __darwin_uuid_string_t = [::std::os::raw::c_char; 37usize];
185#[repr(C)]
186#[derive(Debug, Copy, Clone)]
187pub struct __darwin_pthread_handler_rec {
188 pub __routine: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
189 pub __arg: *mut ::std::os::raw::c_void,
190 pub __next: *mut __darwin_pthread_handler_rec,
191}
192#[test]
193fn bindgen_test_layout___darwin_pthread_handler_rec() {
194 const UNINIT: ::std::mem::MaybeUninit<__darwin_pthread_handler_rec> =
195 ::std::mem::MaybeUninit::uninit();
196 let ptr = UNINIT.as_ptr();
197 assert_eq!(
198 ::std::mem::size_of::<__darwin_pthread_handler_rec>(),
199 24usize,
200 concat!("Size of: ", stringify!(__darwin_pthread_handler_rec))
201 );
202 assert_eq!(
203 ::std::mem::align_of::<__darwin_pthread_handler_rec>(),
204 8usize,
205 concat!("Alignment of ", stringify!(__darwin_pthread_handler_rec))
206 );
207 assert_eq!(
208 unsafe { ::std::ptr::addr_of!((*ptr).__routine) as usize - ptr as usize },
209 0usize,
210 concat!(
211 "Offset of field: ",
212 stringify!(__darwin_pthread_handler_rec),
213 "::",
214 stringify!(__routine)
215 )
216 );
217 assert_eq!(
218 unsafe { ::std::ptr::addr_of!((*ptr).__arg) as usize - ptr as usize },
219 8usize,
220 concat!(
221 "Offset of field: ",
222 stringify!(__darwin_pthread_handler_rec),
223 "::",
224 stringify!(__arg)
225 )
226 );
227 assert_eq!(
228 unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
229 16usize,
230 concat!(
231 "Offset of field: ",
232 stringify!(__darwin_pthread_handler_rec),
233 "::",
234 stringify!(__next)
235 )
236 );
237}
238#[repr(C)]
239#[derive(Debug, Copy, Clone)]
240pub struct _opaque_pthread_attr_t {
241 pub __sig: ::std::os::raw::c_long,
242 pub __opaque: [::std::os::raw::c_char; 56usize],
243}
244#[test]
245fn bindgen_test_layout__opaque_pthread_attr_t() {
246 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_attr_t> =
247 ::std::mem::MaybeUninit::uninit();
248 let ptr = UNINIT.as_ptr();
249 assert_eq!(
250 ::std::mem::size_of::<_opaque_pthread_attr_t>(),
251 64usize,
252 concat!("Size of: ", stringify!(_opaque_pthread_attr_t))
253 );
254 assert_eq!(
255 ::std::mem::align_of::<_opaque_pthread_attr_t>(),
256 8usize,
257 concat!("Alignment of ", stringify!(_opaque_pthread_attr_t))
258 );
259 assert_eq!(
260 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
261 0usize,
262 concat!(
263 "Offset of field: ",
264 stringify!(_opaque_pthread_attr_t),
265 "::",
266 stringify!(__sig)
267 )
268 );
269 assert_eq!(
270 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
271 8usize,
272 concat!(
273 "Offset of field: ",
274 stringify!(_opaque_pthread_attr_t),
275 "::",
276 stringify!(__opaque)
277 )
278 );
279}
280#[repr(C)]
281#[derive(Debug, Copy, Clone)]
282pub struct _opaque_pthread_cond_t {
283 pub __sig: ::std::os::raw::c_long,
284 pub __opaque: [::std::os::raw::c_char; 40usize],
285}
286#[test]
287fn bindgen_test_layout__opaque_pthread_cond_t() {
288 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_cond_t> =
289 ::std::mem::MaybeUninit::uninit();
290 let ptr = UNINIT.as_ptr();
291 assert_eq!(
292 ::std::mem::size_of::<_opaque_pthread_cond_t>(),
293 48usize,
294 concat!("Size of: ", stringify!(_opaque_pthread_cond_t))
295 );
296 assert_eq!(
297 ::std::mem::align_of::<_opaque_pthread_cond_t>(),
298 8usize,
299 concat!("Alignment of ", stringify!(_opaque_pthread_cond_t))
300 );
301 assert_eq!(
302 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
303 0usize,
304 concat!(
305 "Offset of field: ",
306 stringify!(_opaque_pthread_cond_t),
307 "::",
308 stringify!(__sig)
309 )
310 );
311 assert_eq!(
312 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
313 8usize,
314 concat!(
315 "Offset of field: ",
316 stringify!(_opaque_pthread_cond_t),
317 "::",
318 stringify!(__opaque)
319 )
320 );
321}
322#[repr(C)]
323#[derive(Debug, Copy, Clone)]
324pub struct _opaque_pthread_condattr_t {
325 pub __sig: ::std::os::raw::c_long,
326 pub __opaque: [::std::os::raw::c_char; 8usize],
327}
328#[test]
329fn bindgen_test_layout__opaque_pthread_condattr_t() {
330 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_condattr_t> =
331 ::std::mem::MaybeUninit::uninit();
332 let ptr = UNINIT.as_ptr();
333 assert_eq!(
334 ::std::mem::size_of::<_opaque_pthread_condattr_t>(),
335 16usize,
336 concat!("Size of: ", stringify!(_opaque_pthread_condattr_t))
337 );
338 assert_eq!(
339 ::std::mem::align_of::<_opaque_pthread_condattr_t>(),
340 8usize,
341 concat!("Alignment of ", stringify!(_opaque_pthread_condattr_t))
342 );
343 assert_eq!(
344 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
345 0usize,
346 concat!(
347 "Offset of field: ",
348 stringify!(_opaque_pthread_condattr_t),
349 "::",
350 stringify!(__sig)
351 )
352 );
353 assert_eq!(
354 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
355 8usize,
356 concat!(
357 "Offset of field: ",
358 stringify!(_opaque_pthread_condattr_t),
359 "::",
360 stringify!(__opaque)
361 )
362 );
363}
364#[repr(C)]
365#[derive(Debug, Copy, Clone)]
366pub struct _opaque_pthread_mutex_t {
367 pub __sig: ::std::os::raw::c_long,
368 pub __opaque: [::std::os::raw::c_char; 56usize],
369}
370#[test]
371fn bindgen_test_layout__opaque_pthread_mutex_t() {
372 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_mutex_t> =
373 ::std::mem::MaybeUninit::uninit();
374 let ptr = UNINIT.as_ptr();
375 assert_eq!(
376 ::std::mem::size_of::<_opaque_pthread_mutex_t>(),
377 64usize,
378 concat!("Size of: ", stringify!(_opaque_pthread_mutex_t))
379 );
380 assert_eq!(
381 ::std::mem::align_of::<_opaque_pthread_mutex_t>(),
382 8usize,
383 concat!("Alignment of ", stringify!(_opaque_pthread_mutex_t))
384 );
385 assert_eq!(
386 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
387 0usize,
388 concat!(
389 "Offset of field: ",
390 stringify!(_opaque_pthread_mutex_t),
391 "::",
392 stringify!(__sig)
393 )
394 );
395 assert_eq!(
396 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
397 8usize,
398 concat!(
399 "Offset of field: ",
400 stringify!(_opaque_pthread_mutex_t),
401 "::",
402 stringify!(__opaque)
403 )
404 );
405}
406#[repr(C)]
407#[derive(Debug, Copy, Clone)]
408pub struct _opaque_pthread_mutexattr_t {
409 pub __sig: ::std::os::raw::c_long,
410 pub __opaque: [::std::os::raw::c_char; 8usize],
411}
412#[test]
413fn bindgen_test_layout__opaque_pthread_mutexattr_t() {
414 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_mutexattr_t> =
415 ::std::mem::MaybeUninit::uninit();
416 let ptr = UNINIT.as_ptr();
417 assert_eq!(
418 ::std::mem::size_of::<_opaque_pthread_mutexattr_t>(),
419 16usize,
420 concat!("Size of: ", stringify!(_opaque_pthread_mutexattr_t))
421 );
422 assert_eq!(
423 ::std::mem::align_of::<_opaque_pthread_mutexattr_t>(),
424 8usize,
425 concat!("Alignment of ", stringify!(_opaque_pthread_mutexattr_t))
426 );
427 assert_eq!(
428 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
429 0usize,
430 concat!(
431 "Offset of field: ",
432 stringify!(_opaque_pthread_mutexattr_t),
433 "::",
434 stringify!(__sig)
435 )
436 );
437 assert_eq!(
438 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
439 8usize,
440 concat!(
441 "Offset of field: ",
442 stringify!(_opaque_pthread_mutexattr_t),
443 "::",
444 stringify!(__opaque)
445 )
446 );
447}
448#[repr(C)]
449#[derive(Debug, Copy, Clone)]
450pub struct _opaque_pthread_once_t {
451 pub __sig: ::std::os::raw::c_long,
452 pub __opaque: [::std::os::raw::c_char; 8usize],
453}
454#[test]
455fn bindgen_test_layout__opaque_pthread_once_t() {
456 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_once_t> =
457 ::std::mem::MaybeUninit::uninit();
458 let ptr = UNINIT.as_ptr();
459 assert_eq!(
460 ::std::mem::size_of::<_opaque_pthread_once_t>(),
461 16usize,
462 concat!("Size of: ", stringify!(_opaque_pthread_once_t))
463 );
464 assert_eq!(
465 ::std::mem::align_of::<_opaque_pthread_once_t>(),
466 8usize,
467 concat!("Alignment of ", stringify!(_opaque_pthread_once_t))
468 );
469 assert_eq!(
470 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
471 0usize,
472 concat!(
473 "Offset of field: ",
474 stringify!(_opaque_pthread_once_t),
475 "::",
476 stringify!(__sig)
477 )
478 );
479 assert_eq!(
480 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
481 8usize,
482 concat!(
483 "Offset of field: ",
484 stringify!(_opaque_pthread_once_t),
485 "::",
486 stringify!(__opaque)
487 )
488 );
489}
490#[repr(C)]
491#[derive(Debug, Copy, Clone)]
492pub struct _opaque_pthread_rwlock_t {
493 pub __sig: ::std::os::raw::c_long,
494 pub __opaque: [::std::os::raw::c_char; 192usize],
495}
496#[test]
497fn bindgen_test_layout__opaque_pthread_rwlock_t() {
498 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_rwlock_t> =
499 ::std::mem::MaybeUninit::uninit();
500 let ptr = UNINIT.as_ptr();
501 assert_eq!(
502 ::std::mem::size_of::<_opaque_pthread_rwlock_t>(),
503 200usize,
504 concat!("Size of: ", stringify!(_opaque_pthread_rwlock_t))
505 );
506 assert_eq!(
507 ::std::mem::align_of::<_opaque_pthread_rwlock_t>(),
508 8usize,
509 concat!("Alignment of ", stringify!(_opaque_pthread_rwlock_t))
510 );
511 assert_eq!(
512 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
513 0usize,
514 concat!(
515 "Offset of field: ",
516 stringify!(_opaque_pthread_rwlock_t),
517 "::",
518 stringify!(__sig)
519 )
520 );
521 assert_eq!(
522 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
523 8usize,
524 concat!(
525 "Offset of field: ",
526 stringify!(_opaque_pthread_rwlock_t),
527 "::",
528 stringify!(__opaque)
529 )
530 );
531}
532#[repr(C)]
533#[derive(Debug, Copy, Clone)]
534pub struct _opaque_pthread_rwlockattr_t {
535 pub __sig: ::std::os::raw::c_long,
536 pub __opaque: [::std::os::raw::c_char; 16usize],
537}
538#[test]
539fn bindgen_test_layout__opaque_pthread_rwlockattr_t() {
540 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_rwlockattr_t> =
541 ::std::mem::MaybeUninit::uninit();
542 let ptr = UNINIT.as_ptr();
543 assert_eq!(
544 ::std::mem::size_of::<_opaque_pthread_rwlockattr_t>(),
545 24usize,
546 concat!("Size of: ", stringify!(_opaque_pthread_rwlockattr_t))
547 );
548 assert_eq!(
549 ::std::mem::align_of::<_opaque_pthread_rwlockattr_t>(),
550 8usize,
551 concat!("Alignment of ", stringify!(_opaque_pthread_rwlockattr_t))
552 );
553 assert_eq!(
554 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
555 0usize,
556 concat!(
557 "Offset of field: ",
558 stringify!(_opaque_pthread_rwlockattr_t),
559 "::",
560 stringify!(__sig)
561 )
562 );
563 assert_eq!(
564 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
565 8usize,
566 concat!(
567 "Offset of field: ",
568 stringify!(_opaque_pthread_rwlockattr_t),
569 "::",
570 stringify!(__opaque)
571 )
572 );
573}
574#[repr(C)]
575#[derive(Debug, Copy, Clone)]
576pub struct _opaque_pthread_t {
577 pub __sig: ::std::os::raw::c_long,
578 pub __cleanup_stack: *mut __darwin_pthread_handler_rec,
579 pub __opaque: [::std::os::raw::c_char; 8176usize],
580}
581#[test]
582fn bindgen_test_layout__opaque_pthread_t() {
583 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_t> = ::std::mem::MaybeUninit::uninit();
584 let ptr = UNINIT.as_ptr();
585 assert_eq!(
586 ::std::mem::size_of::<_opaque_pthread_t>(),
587 8192usize,
588 concat!("Size of: ", stringify!(_opaque_pthread_t))
589 );
590 assert_eq!(
591 ::std::mem::align_of::<_opaque_pthread_t>(),
592 8usize,
593 concat!("Alignment of ", stringify!(_opaque_pthread_t))
594 );
595 assert_eq!(
596 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
597 0usize,
598 concat!(
599 "Offset of field: ",
600 stringify!(_opaque_pthread_t),
601 "::",
602 stringify!(__sig)
603 )
604 );
605 assert_eq!(
606 unsafe { ::std::ptr::addr_of!((*ptr).__cleanup_stack) as usize - ptr as usize },
607 8usize,
608 concat!(
609 "Offset of field: ",
610 stringify!(_opaque_pthread_t),
611 "::",
612 stringify!(__cleanup_stack)
613 )
614 );
615 assert_eq!(
616 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
617 16usize,
618 concat!(
619 "Offset of field: ",
620 stringify!(_opaque_pthread_t),
621 "::",
622 stringify!(__opaque)
623 )
624 );
625}
626pub type __darwin_pthread_attr_t = _opaque_pthread_attr_t;
627pub type __darwin_pthread_cond_t = _opaque_pthread_cond_t;
628pub type __darwin_pthread_condattr_t = _opaque_pthread_condattr_t;
629pub type __darwin_pthread_key_t = ::std::os::raw::c_ulong;
630pub type __darwin_pthread_mutex_t = _opaque_pthread_mutex_t;
631pub type __darwin_pthread_mutexattr_t = _opaque_pthread_mutexattr_t;
632pub type __darwin_pthread_once_t = _opaque_pthread_once_t;
633pub type __darwin_pthread_rwlock_t = _opaque_pthread_rwlock_t;
634pub type __darwin_pthread_rwlockattr_t = _opaque_pthread_rwlockattr_t;
635pub type __darwin_pthread_t = *mut _opaque_pthread_t;
636pub type u_int8_t = ::std::os::raw::c_uchar;
637pub type u_int16_t = ::std::os::raw::c_ushort;
638pub type u_int32_t = ::std::os::raw::c_uint;
639pub type u_int64_t = ::std::os::raw::c_ulonglong;
640pub type register_t = i64;
641pub type user_addr_t = u_int64_t;
642pub type user_size_t = u_int64_t;
643pub type user_ssize_t = i64;
644pub type user_long_t = i64;
645pub type user_ulong_t = u_int64_t;
646pub type user_time_t = i64;
647pub type user_off_t = i64;
648pub type syscall_arg_t = u_int64_t;
649pub type intmax_t = ::std::os::raw::c_long;
650pub type uintmax_t = ::std::os::raw::c_ulong;
651pub type char16_t = u16;
652#[repr(C)]
653#[derive(Debug, Copy, Clone)]
654pub struct napi_env__ {
655 _unused: [u8; 0],
656}
657pub type napi_env = *mut napi_env__;
658#[repr(C)]
659#[derive(Debug, Copy, Clone)]
660pub struct napi_value__ {
661 _unused: [u8; 0],
662}
663pub type napi_value = *mut napi_value__;
664#[repr(C)]
665#[derive(Debug, Copy, Clone)]
666pub struct napi_ref__ {
667 _unused: [u8; 0],
668}
669pub type napi_ref = *mut napi_ref__;
670#[repr(C)]
671#[derive(Debug, Copy, Clone)]
672pub struct napi_handle_scope__ {
673 _unused: [u8; 0],
674}
675pub type napi_handle_scope = *mut napi_handle_scope__;
676#[repr(C)]
677#[derive(Debug, Copy, Clone)]
678pub struct napi_escapable_handle_scope__ {
679 _unused: [u8; 0],
680}
681pub type napi_escapable_handle_scope = *mut napi_escapable_handle_scope__;
682#[repr(C)]
683#[derive(Debug, Copy, Clone)]
684pub struct napi_callback_info__ {
685 _unused: [u8; 0],
686}
687pub type napi_callback_info = *mut napi_callback_info__;
688#[repr(C)]
689#[derive(Debug, Copy, Clone)]
690pub struct napi_deferred__ {
691 _unused: [u8; 0],
692}
693pub type napi_deferred = *mut napi_deferred__;
694pub const napi_property_attributes_napi_default: napi_property_attributes = 0;
695pub const napi_property_attributes_napi_writable: napi_property_attributes = 1;
696pub const napi_property_attributes_napi_enumerable: napi_property_attributes = 2;
697pub const napi_property_attributes_napi_configurable: napi_property_attributes = 4;
698pub const napi_property_attributes_napi_static: napi_property_attributes = 1024;
699pub const napi_property_attributes_napi_default_method: napi_property_attributes = 5;
700pub const napi_property_attributes_napi_default_jsproperty: napi_property_attributes = 7;
701pub type napi_property_attributes = ::std::os::raw::c_uint;
702pub const napi_valuetype_napi_undefined: napi_valuetype = 0;
703pub const napi_valuetype_napi_null: napi_valuetype = 1;
704pub const napi_valuetype_napi_boolean: napi_valuetype = 2;
705pub const napi_valuetype_napi_number: napi_valuetype = 3;
706pub const napi_valuetype_napi_string: napi_valuetype = 4;
707pub const napi_valuetype_napi_symbol: napi_valuetype = 5;
708pub const napi_valuetype_napi_object: napi_valuetype = 6;
709pub const napi_valuetype_napi_function: napi_valuetype = 7;
710pub const napi_valuetype_napi_external: napi_valuetype = 8;
711pub const napi_valuetype_napi_bigint: napi_valuetype = 9;
712pub type napi_valuetype = ::std::os::raw::c_uint;
713pub const napi_typedarray_type_napi_int8_array: napi_typedarray_type = 0;
714pub const napi_typedarray_type_napi_uint8_array: napi_typedarray_type = 1;
715pub const napi_typedarray_type_napi_uint8_clamped_array: napi_typedarray_type = 2;
716pub const napi_typedarray_type_napi_int16_array: napi_typedarray_type = 3;
717pub const napi_typedarray_type_napi_uint16_array: napi_typedarray_type = 4;
718pub const napi_typedarray_type_napi_int32_array: napi_typedarray_type = 5;
719pub const napi_typedarray_type_napi_uint32_array: napi_typedarray_type = 6;
720pub const napi_typedarray_type_napi_float32_array: napi_typedarray_type = 7;
721pub const napi_typedarray_type_napi_float64_array: napi_typedarray_type = 8;
722pub const napi_typedarray_type_napi_bigint64_array: napi_typedarray_type = 9;
723pub const napi_typedarray_type_napi_biguint64_array: napi_typedarray_type = 10;
724pub type napi_typedarray_type = ::std::os::raw::c_uint;
725pub const napi_status_napi_ok: napi_status = 0;
726pub const napi_status_napi_invalid_arg: napi_status = 1;
727pub const napi_status_napi_object_expected: napi_status = 2;
728pub const napi_status_napi_string_expected: napi_status = 3;
729pub const napi_status_napi_name_expected: napi_status = 4;
730pub const napi_status_napi_function_expected: napi_status = 5;
731pub const napi_status_napi_number_expected: napi_status = 6;
732pub const napi_status_napi_boolean_expected: napi_status = 7;
733pub const napi_status_napi_array_expected: napi_status = 8;
734pub const napi_status_napi_generic_failure: napi_status = 9;
735pub const napi_status_napi_pending_exception: napi_status = 10;
736pub const napi_status_napi_cancelled: napi_status = 11;
737pub const napi_status_napi_escape_called_twice: napi_status = 12;
738pub const napi_status_napi_handle_scope_mismatch: napi_status = 13;
739pub const napi_status_napi_callback_scope_mismatch: napi_status = 14;
740pub const napi_status_napi_queue_full: napi_status = 15;
741pub const napi_status_napi_closing: napi_status = 16;
742pub const napi_status_napi_bigint_expected: napi_status = 17;
743pub const napi_status_napi_date_expected: napi_status = 18;
744pub const napi_status_napi_arraybuffer_expected: napi_status = 19;
745pub const napi_status_napi_detachable_arraybuffer_expected: napi_status = 20;
746pub const napi_status_napi_would_deadlock: napi_status = 21;
747pub const napi_status_napi_no_external_buffers_allowed: napi_status = 22;
748pub const napi_status_napi_cannot_run_js: napi_status = 23;
749pub type napi_status = ::std::os::raw::c_uint;
750pub type napi_callback = ::std::option::Option<
751 unsafe extern "C" fn(env: napi_env, info: napi_callback_info) -> napi_value,
752>;
753pub type napi_finalize = ::std::option::Option<
754 unsafe extern "C" fn(
755 env: napi_env,
756 finalize_data: *mut ::std::os::raw::c_void,
757 finalize_hint: *mut ::std::os::raw::c_void,
758 ),
759>;
760#[repr(C)]
761#[derive(Debug, Copy, Clone)]
762pub struct napi_property_descriptor {
763 pub utf8name: *const ::std::os::raw::c_char,
764 pub name: napi_value,
765 pub method: napi_callback,
766 pub getter: napi_callback,
767 pub setter: napi_callback,
768 pub value: napi_value,
769 pub attributes: napi_property_attributes,
770 pub data: *mut ::std::os::raw::c_void,
771}
772#[test]
773fn bindgen_test_layout_napi_property_descriptor() {
774 const UNINIT: ::std::mem::MaybeUninit<napi_property_descriptor> =
775 ::std::mem::MaybeUninit::uninit();
776 let ptr = UNINIT.as_ptr();
777 assert_eq!(
778 ::std::mem::size_of::<napi_property_descriptor>(),
779 64usize,
780 concat!("Size of: ", stringify!(napi_property_descriptor))
781 );
782 assert_eq!(
783 ::std::mem::align_of::<napi_property_descriptor>(),
784 8usize,
785 concat!("Alignment of ", stringify!(napi_property_descriptor))
786 );
787 assert_eq!(
788 unsafe { ::std::ptr::addr_of!((*ptr).utf8name) as usize - ptr as usize },
789 0usize,
790 concat!(
791 "Offset of field: ",
792 stringify!(napi_property_descriptor),
793 "::",
794 stringify!(utf8name)
795 )
796 );
797 assert_eq!(
798 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
799 8usize,
800 concat!(
801 "Offset of field: ",
802 stringify!(napi_property_descriptor),
803 "::",
804 stringify!(name)
805 )
806 );
807 assert_eq!(
808 unsafe { ::std::ptr::addr_of!((*ptr).method) as usize - ptr as usize },
809 16usize,
810 concat!(
811 "Offset of field: ",
812 stringify!(napi_property_descriptor),
813 "::",
814 stringify!(method)
815 )
816 );
817 assert_eq!(
818 unsafe { ::std::ptr::addr_of!((*ptr).getter) as usize - ptr as usize },
819 24usize,
820 concat!(
821 "Offset of field: ",
822 stringify!(napi_property_descriptor),
823 "::",
824 stringify!(getter)
825 )
826 );
827 assert_eq!(
828 unsafe { ::std::ptr::addr_of!((*ptr).setter) as usize - ptr as usize },
829 32usize,
830 concat!(
831 "Offset of field: ",
832 stringify!(napi_property_descriptor),
833 "::",
834 stringify!(setter)
835 )
836 );
837 assert_eq!(
838 unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
839 40usize,
840 concat!(
841 "Offset of field: ",
842 stringify!(napi_property_descriptor),
843 "::",
844 stringify!(value)
845 )
846 );
847 assert_eq!(
848 unsafe { ::std::ptr::addr_of!((*ptr).attributes) as usize - ptr as usize },
849 48usize,
850 concat!(
851 "Offset of field: ",
852 stringify!(napi_property_descriptor),
853 "::",
854 stringify!(attributes)
855 )
856 );
857 assert_eq!(
858 unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
859 56usize,
860 concat!(
861 "Offset of field: ",
862 stringify!(napi_property_descriptor),
863 "::",
864 stringify!(data)
865 )
866 );
867}
868#[repr(C)]
869#[derive(Debug, Copy, Clone)]
870pub struct napi_extended_error_info {
871 pub error_message: *const ::std::os::raw::c_char,
872 pub engine_reserved: *mut ::std::os::raw::c_void,
873 pub engine_error_code: u32,
874 pub error_code: napi_status,
875}
876#[test]
877fn bindgen_test_layout_napi_extended_error_info() {
878 const UNINIT: ::std::mem::MaybeUninit<napi_extended_error_info> =
879 ::std::mem::MaybeUninit::uninit();
880 let ptr = UNINIT.as_ptr();
881 assert_eq!(
882 ::std::mem::size_of::<napi_extended_error_info>(),
883 24usize,
884 concat!("Size of: ", stringify!(napi_extended_error_info))
885 );
886 assert_eq!(
887 ::std::mem::align_of::<napi_extended_error_info>(),
888 8usize,
889 concat!("Alignment of ", stringify!(napi_extended_error_info))
890 );
891 assert_eq!(
892 unsafe { ::std::ptr::addr_of!((*ptr).error_message) as usize - ptr as usize },
893 0usize,
894 concat!(
895 "Offset of field: ",
896 stringify!(napi_extended_error_info),
897 "::",
898 stringify!(error_message)
899 )
900 );
901 assert_eq!(
902 unsafe { ::std::ptr::addr_of!((*ptr).engine_reserved) as usize - ptr as usize },
903 8usize,
904 concat!(
905 "Offset of field: ",
906 stringify!(napi_extended_error_info),
907 "::",
908 stringify!(engine_reserved)
909 )
910 );
911 assert_eq!(
912 unsafe { ::std::ptr::addr_of!((*ptr).engine_error_code) as usize - ptr as usize },
913 16usize,
914 concat!(
915 "Offset of field: ",
916 stringify!(napi_extended_error_info),
917 "::",
918 stringify!(engine_error_code)
919 )
920 );
921 assert_eq!(
922 unsafe { ::std::ptr::addr_of!((*ptr).error_code) as usize - ptr as usize },
923 20usize,
924 concat!(
925 "Offset of field: ",
926 stringify!(napi_extended_error_info),
927 "::",
928 stringify!(error_code)
929 )
930 );
931}
932pub const napi_key_collection_mode_napi_key_include_prototypes: napi_key_collection_mode = 0;
933pub const napi_key_collection_mode_napi_key_own_only: napi_key_collection_mode = 1;
934pub type napi_key_collection_mode = ::std::os::raw::c_uint;
935pub const napi_key_filter_napi_key_all_properties: napi_key_filter = 0;
936pub const napi_key_filter_napi_key_writable: napi_key_filter = 1;
937pub const napi_key_filter_napi_key_enumerable: napi_key_filter = 2;
938pub const napi_key_filter_napi_key_configurable: napi_key_filter = 4;
939pub const napi_key_filter_napi_key_skip_strings: napi_key_filter = 8;
940pub const napi_key_filter_napi_key_skip_symbols: napi_key_filter = 16;
941pub type napi_key_filter = ::std::os::raw::c_uint;
942pub const napi_key_conversion_napi_key_keep_numbers: napi_key_conversion = 0;
943pub const napi_key_conversion_napi_key_numbers_to_strings: napi_key_conversion = 1;
944pub type napi_key_conversion = ::std::os::raw::c_uint;
945#[repr(C)]
946#[derive(Debug, Copy, Clone)]
947pub struct napi_type_tag {
948 pub lower: u64,
949 pub upper: u64,
950}
951#[test]
952fn bindgen_test_layout_napi_type_tag() {
953 const UNINIT: ::std::mem::MaybeUninit<napi_type_tag> = ::std::mem::MaybeUninit::uninit();
954 let ptr = UNINIT.as_ptr();
955 assert_eq!(
956 ::std::mem::size_of::<napi_type_tag>(),
957 16usize,
958 concat!("Size of: ", stringify!(napi_type_tag))
959 );
960 assert_eq!(
961 ::std::mem::align_of::<napi_type_tag>(),
962 8usize,
963 concat!("Alignment of ", stringify!(napi_type_tag))
964 );
965 assert_eq!(
966 unsafe { ::std::ptr::addr_of!((*ptr).lower) as usize - ptr as usize },
967 0usize,
968 concat!(
969 "Offset of field: ",
970 stringify!(napi_type_tag),
971 "::",
972 stringify!(lower)
973 )
974 );
975 assert_eq!(
976 unsafe { ::std::ptr::addr_of!((*ptr).upper) as usize - ptr as usize },
977 8usize,
978 concat!(
979 "Offset of field: ",
980 stringify!(napi_type_tag),
981 "::",
982 stringify!(upper)
983 )
984 );
985}
986extern "C" {
987 pub fn napi_get_last_error_info(
988 env: napi_env,
989 result: *mut *const napi_extended_error_info,
990 ) -> napi_status;
991}
992extern "C" {
993 pub fn napi_get_undefined(env: napi_env, result: *mut napi_value) -> napi_status;
994}
995extern "C" {
996 pub fn napi_get_null(env: napi_env, result: *mut napi_value) -> napi_status;
997}
998extern "C" {
999 pub fn napi_get_global(env: napi_env, result: *mut napi_value) -> napi_status;
1000}
1001extern "C" {
1002 pub fn napi_get_boolean(env: napi_env, value: bool, result: *mut napi_value) -> napi_status;
1003}
1004extern "C" {
1005 pub fn napi_create_object(env: napi_env, result: *mut napi_value) -> napi_status;
1006}
1007extern "C" {
1008 pub fn napi_create_array(env: napi_env, result: *mut napi_value) -> napi_status;
1009}
1010extern "C" {
1011 pub fn napi_create_array_with_length(
1012 env: napi_env,
1013 length: usize,
1014 result: *mut napi_value,
1015 ) -> napi_status;
1016}
1017extern "C" {
1018 pub fn napi_create_double(env: napi_env, value: f64, result: *mut napi_value) -> napi_status;
1019}
1020extern "C" {
1021 pub fn napi_create_int32(env: napi_env, value: i32, result: *mut napi_value) -> napi_status;
1022}
1023extern "C" {
1024 pub fn napi_create_uint32(env: napi_env, value: u32, result: *mut napi_value) -> napi_status;
1025}
1026extern "C" {
1027 pub fn napi_create_int64(env: napi_env, value: i64, result: *mut napi_value) -> napi_status;
1028}
1029extern "C" {
1030 pub fn napi_create_string_latin1(
1031 env: napi_env,
1032 str_: *const ::std::os::raw::c_char,
1033 length: usize,
1034 result: *mut napi_value,
1035 ) -> napi_status;
1036}
1037extern "C" {
1038 pub fn napi_create_string_utf8(
1039 env: napi_env,
1040 str_: *const ::std::os::raw::c_char,
1041 length: usize,
1042 result: *mut napi_value,
1043 ) -> napi_status;
1044}
1045extern "C" {
1046 pub fn napi_create_string_utf16(
1047 env: napi_env,
1048 str_: *const char16_t,
1049 length: usize,
1050 result: *mut napi_value,
1051 ) -> napi_status;
1052}
1053extern "C" {
1054 pub fn napi_create_symbol(
1055 env: napi_env,
1056 description: napi_value,
1057 result: *mut napi_value,
1058 ) -> napi_status;
1059}
1060extern "C" {
1061 pub fn napi_create_function(
1062 env: napi_env,
1063 utf8name: *const ::std::os::raw::c_char,
1064 length: usize,
1065 cb: napi_callback,
1066 data: *mut ::std::os::raw::c_void,
1067 result: *mut napi_value,
1068 ) -> napi_status;
1069}
1070extern "C" {
1071 pub fn napi_create_error(
1072 env: napi_env,
1073 code: napi_value,
1074 msg: napi_value,
1075 result: *mut napi_value,
1076 ) -> napi_status;
1077}
1078extern "C" {
1079 pub fn napi_create_type_error(
1080 env: napi_env,
1081 code: napi_value,
1082 msg: napi_value,
1083 result: *mut napi_value,
1084 ) -> napi_status;
1085}
1086extern "C" {
1087 pub fn napi_create_range_error(
1088 env: napi_env,
1089 code: napi_value,
1090 msg: napi_value,
1091 result: *mut napi_value,
1092 ) -> napi_status;
1093}
1094extern "C" {
1095 pub fn napi_typeof(
1096 env: napi_env,
1097 value: napi_value,
1098 result: *mut napi_valuetype,
1099 ) -> napi_status;
1100}
1101extern "C" {
1102 pub fn napi_get_value_double(env: napi_env, value: napi_value, result: *mut f64)
1103 -> napi_status;
1104}
1105extern "C" {
1106 pub fn napi_get_value_int32(env: napi_env, value: napi_value, result: *mut i32) -> napi_status;
1107}
1108extern "C" {
1109 pub fn napi_get_value_uint32(env: napi_env, value: napi_value, result: *mut u32)
1110 -> napi_status;
1111}
1112extern "C" {
1113 pub fn napi_get_value_int64(env: napi_env, value: napi_value, result: *mut i64) -> napi_status;
1114}
1115extern "C" {
1116 pub fn napi_get_value_bool(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
1117}
1118extern "C" {
1119 pub fn napi_get_value_string_latin1(
1120 env: napi_env,
1121 value: napi_value,
1122 buf: *mut ::std::os::raw::c_char,
1123 bufsize: usize,
1124 result: *mut usize,
1125 ) -> napi_status;
1126}
1127extern "C" {
1128 pub fn napi_get_value_string_utf8(
1129 env: napi_env,
1130 value: napi_value,
1131 buf: *mut ::std::os::raw::c_char,
1132 bufsize: usize,
1133 result: *mut usize,
1134 ) -> napi_status;
1135}
1136extern "C" {
1137 pub fn napi_get_value_string_utf16(
1138 env: napi_env,
1139 value: napi_value,
1140 buf: *mut char16_t,
1141 bufsize: usize,
1142 result: *mut usize,
1143 ) -> napi_status;
1144}
1145extern "C" {
1146 pub fn napi_coerce_to_bool(
1147 env: napi_env,
1148 value: napi_value,
1149 result: *mut napi_value,
1150 ) -> napi_status;
1151}
1152extern "C" {
1153 pub fn napi_coerce_to_number(
1154 env: napi_env,
1155 value: napi_value,
1156 result: *mut napi_value,
1157 ) -> napi_status;
1158}
1159extern "C" {
1160 pub fn napi_coerce_to_object(
1161 env: napi_env,
1162 value: napi_value,
1163 result: *mut napi_value,
1164 ) -> napi_status;
1165}
1166extern "C" {
1167 pub fn napi_coerce_to_string(
1168 env: napi_env,
1169 value: napi_value,
1170 result: *mut napi_value,
1171 ) -> napi_status;
1172}
1173extern "C" {
1174 pub fn napi_get_prototype(
1175 env: napi_env,
1176 object: napi_value,
1177 result: *mut napi_value,
1178 ) -> napi_status;
1179}
1180extern "C" {
1181 pub fn napi_get_property_names(
1182 env: napi_env,
1183 object: napi_value,
1184 result: *mut napi_value,
1185 ) -> napi_status;
1186}
1187extern "C" {
1188 pub fn napi_set_property(
1189 env: napi_env,
1190 object: napi_value,
1191 key: napi_value,
1192 value: napi_value,
1193 ) -> napi_status;
1194}
1195extern "C" {
1196 pub fn napi_has_property(
1197 env: napi_env,
1198 object: napi_value,
1199 key: napi_value,
1200 result: *mut bool,
1201 ) -> napi_status;
1202}
1203extern "C" {
1204 pub fn napi_get_property(
1205 env: napi_env,
1206 object: napi_value,
1207 key: napi_value,
1208 result: *mut napi_value,
1209 ) -> napi_status;
1210}
1211extern "C" {
1212 pub fn napi_delete_property(
1213 env: napi_env,
1214 object: napi_value,
1215 key: napi_value,
1216 result: *mut bool,
1217 ) -> napi_status;
1218}
1219extern "C" {
1220 pub fn napi_has_own_property(
1221 env: napi_env,
1222 object: napi_value,
1223 key: napi_value,
1224 result: *mut bool,
1225 ) -> napi_status;
1226}
1227extern "C" {
1228 pub fn napi_set_named_property(
1229 env: napi_env,
1230 object: napi_value,
1231 utf8name: *const ::std::os::raw::c_char,
1232 value: napi_value,
1233 ) -> napi_status;
1234}
1235extern "C" {
1236 pub fn napi_has_named_property(
1237 env: napi_env,
1238 object: napi_value,
1239 utf8name: *const ::std::os::raw::c_char,
1240 result: *mut bool,
1241 ) -> napi_status;
1242}
1243extern "C" {
1244 pub fn napi_get_named_property(
1245 env: napi_env,
1246 object: napi_value,
1247 utf8name: *const ::std::os::raw::c_char,
1248 result: *mut napi_value,
1249 ) -> napi_status;
1250}
1251extern "C" {
1252 pub fn napi_set_element(
1253 env: napi_env,
1254 object: napi_value,
1255 index: u32,
1256 value: napi_value,
1257 ) -> napi_status;
1258}
1259extern "C" {
1260 pub fn napi_has_element(
1261 env: napi_env,
1262 object: napi_value,
1263 index: u32,
1264 result: *mut bool,
1265 ) -> napi_status;
1266}
1267extern "C" {
1268 pub fn napi_get_element(
1269 env: napi_env,
1270 object: napi_value,
1271 index: u32,
1272 result: *mut napi_value,
1273 ) -> napi_status;
1274}
1275extern "C" {
1276 pub fn napi_delete_element(
1277 env: napi_env,
1278 object: napi_value,
1279 index: u32,
1280 result: *mut bool,
1281 ) -> napi_status;
1282}
1283extern "C" {
1284 pub fn napi_define_properties(
1285 env: napi_env,
1286 object: napi_value,
1287 property_count: usize,
1288 properties: *const napi_property_descriptor,
1289 ) -> napi_status;
1290}
1291extern "C" {
1292 pub fn napi_is_array(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
1293}
1294extern "C" {
1295 pub fn napi_get_array_length(env: napi_env, value: napi_value, result: *mut u32)
1296 -> napi_status;
1297}
1298extern "C" {
1299 pub fn napi_strict_equals(
1300 env: napi_env,
1301 lhs: napi_value,
1302 rhs: napi_value,
1303 result: *mut bool,
1304 ) -> napi_status;
1305}
1306extern "C" {
1307 pub fn napi_call_function(
1308 env: napi_env,
1309 recv: napi_value,
1310 func: napi_value,
1311 argc: usize,
1312 argv: *const napi_value,
1313 result: *mut napi_value,
1314 ) -> napi_status;
1315}
1316extern "C" {
1317 pub fn napi_new_instance(
1318 env: napi_env,
1319 constructor: napi_value,
1320 argc: usize,
1321 argv: *const napi_value,
1322 result: *mut napi_value,
1323 ) -> napi_status;
1324}
1325extern "C" {
1326 pub fn napi_instanceof(
1327 env: napi_env,
1328 object: napi_value,
1329 constructor: napi_value,
1330 result: *mut bool,
1331 ) -> napi_status;
1332}
1333extern "C" {
1334 pub fn napi_get_cb_info(
1335 env: napi_env,
1336 cbinfo: napi_callback_info,
1337 argc: *mut usize,
1338 argv: *mut napi_value,
1339 this_arg: *mut napi_value,
1340 data: *mut *mut ::std::os::raw::c_void,
1341 ) -> napi_status;
1342}
1343extern "C" {
1344 pub fn napi_get_new_target(
1345 env: napi_env,
1346 cbinfo: napi_callback_info,
1347 result: *mut napi_value,
1348 ) -> napi_status;
1349}
1350extern "C" {
1351 pub fn napi_define_class(
1352 env: napi_env,
1353 utf8name: *const ::std::os::raw::c_char,
1354 length: usize,
1355 constructor: napi_callback,
1356 data: *mut ::std::os::raw::c_void,
1357 property_count: usize,
1358 properties: *const napi_property_descriptor,
1359 result: *mut napi_value,
1360 ) -> napi_status;
1361}
1362extern "C" {
1363 pub fn napi_wrap(
1364 env: napi_env,
1365 js_object: napi_value,
1366 native_object: *mut ::std::os::raw::c_void,
1367 finalize_cb: napi_finalize,
1368 finalize_hint: *mut ::std::os::raw::c_void,
1369 result: *mut napi_ref,
1370 ) -> napi_status;
1371}
1372extern "C" {
1373 pub fn napi_unwrap(
1374 env: napi_env,
1375 js_object: napi_value,
1376 result: *mut *mut ::std::os::raw::c_void,
1377 ) -> napi_status;
1378}
1379extern "C" {
1380 pub fn napi_remove_wrap(
1381 env: napi_env,
1382 js_object: napi_value,
1383 result: *mut *mut ::std::os::raw::c_void,
1384 ) -> napi_status;
1385}
1386extern "C" {
1387 pub fn napi_create_external(
1388 env: napi_env,
1389 data: *mut ::std::os::raw::c_void,
1390 finalize_cb: napi_finalize,
1391 finalize_hint: *mut ::std::os::raw::c_void,
1392 result: *mut napi_value,
1393 ) -> napi_status;
1394}
1395extern "C" {
1396 pub fn napi_get_value_external(
1397 env: napi_env,
1398 value: napi_value,
1399 result: *mut *mut ::std::os::raw::c_void,
1400 ) -> napi_status;
1401}
1402extern "C" {
1403 pub fn napi_create_reference(
1404 env: napi_env,
1405 value: napi_value,
1406 initial_refcount: u32,
1407 result: *mut napi_ref,
1408 ) -> napi_status;
1409}
1410extern "C" {
1411 pub fn napi_delete_reference(env: napi_env, ref_: napi_ref) -> napi_status;
1412}
1413extern "C" {
1414 pub fn napi_reference_ref(env: napi_env, ref_: napi_ref, result: *mut u32) -> napi_status;
1415}
1416extern "C" {
1417 pub fn napi_reference_unref(env: napi_env, ref_: napi_ref, result: *mut u32) -> napi_status;
1418}
1419extern "C" {
1420 pub fn napi_get_reference_value(
1421 env: napi_env,
1422 ref_: napi_ref,
1423 result: *mut napi_value,
1424 ) -> napi_status;
1425}
1426extern "C" {
1427 pub fn napi_open_handle_scope(env: napi_env, result: *mut napi_handle_scope) -> napi_status;
1428}
1429extern "C" {
1430 pub fn napi_close_handle_scope(env: napi_env, scope: napi_handle_scope) -> napi_status;
1431}
1432extern "C" {
1433 pub fn napi_open_escapable_handle_scope(
1434 env: napi_env,
1435 result: *mut napi_escapable_handle_scope,
1436 ) -> napi_status;
1437}
1438extern "C" {
1439 pub fn napi_close_escapable_handle_scope(
1440 env: napi_env,
1441 scope: napi_escapable_handle_scope,
1442 ) -> napi_status;
1443}
1444extern "C" {
1445 pub fn napi_escape_handle(
1446 env: napi_env,
1447 scope: napi_escapable_handle_scope,
1448 escapee: napi_value,
1449 result: *mut napi_value,
1450 ) -> napi_status;
1451}
1452extern "C" {
1453 pub fn napi_throw(env: napi_env, error: napi_value) -> napi_status;
1454}
1455extern "C" {
1456 pub fn napi_throw_error(
1457 env: napi_env,
1458 code: *const ::std::os::raw::c_char,
1459 msg: *const ::std::os::raw::c_char,
1460 ) -> napi_status;
1461}
1462extern "C" {
1463 pub fn napi_throw_type_error(
1464 env: napi_env,
1465 code: *const ::std::os::raw::c_char,
1466 msg: *const ::std::os::raw::c_char,
1467 ) -> napi_status;
1468}
1469extern "C" {
1470 pub fn napi_throw_range_error(
1471 env: napi_env,
1472 code: *const ::std::os::raw::c_char,
1473 msg: *const ::std::os::raw::c_char,
1474 ) -> napi_status;
1475}
1476extern "C" {
1477 pub fn napi_is_error(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
1478}
1479extern "C" {
1480 pub fn napi_is_exception_pending(env: napi_env, result: *mut bool) -> napi_status;
1481}
1482extern "C" {
1483 pub fn napi_get_and_clear_last_exception(env: napi_env, result: *mut napi_value)
1484 -> napi_status;
1485}
1486extern "C" {
1487 pub fn napi_is_arraybuffer(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
1488}
1489extern "C" {
1490 pub fn napi_create_arraybuffer(
1491 env: napi_env,
1492 byte_length: usize,
1493 data: *mut *mut ::std::os::raw::c_void,
1494 result: *mut napi_value,
1495 ) -> napi_status;
1496}
1497extern "C" {
1498 pub fn napi_create_external_arraybuffer(
1499 env: napi_env,
1500 external_data: *mut ::std::os::raw::c_void,
1501 byte_length: usize,
1502 finalize_cb: napi_finalize,
1503 finalize_hint: *mut ::std::os::raw::c_void,
1504 result: *mut napi_value,
1505 ) -> napi_status;
1506}
1507extern "C" {
1508 pub fn napi_get_arraybuffer_info(
1509 env: napi_env,
1510 arraybuffer: napi_value,
1511 data: *mut *mut ::std::os::raw::c_void,
1512 byte_length: *mut usize,
1513 ) -> napi_status;
1514}
1515extern "C" {
1516 pub fn napi_is_typedarray(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
1517}
1518extern "C" {
1519 pub fn napi_create_typedarray(
1520 env: napi_env,
1521 type_: napi_typedarray_type,
1522 length: usize,
1523 arraybuffer: napi_value,
1524 byte_offset: usize,
1525 result: *mut napi_value,
1526 ) -> napi_status;
1527}
1528extern "C" {
1529 pub fn napi_get_typedarray_info(
1530 env: napi_env,
1531 typedarray: napi_value,
1532 type_: *mut napi_typedarray_type,
1533 length: *mut usize,
1534 data: *mut *mut ::std::os::raw::c_void,
1535 arraybuffer: *mut napi_value,
1536 byte_offset: *mut usize,
1537 ) -> napi_status;
1538}
1539extern "C" {
1540 pub fn napi_create_dataview(
1541 env: napi_env,
1542 length: usize,
1543 arraybuffer: napi_value,
1544 byte_offset: usize,
1545 result: *mut napi_value,
1546 ) -> napi_status;
1547}
1548extern "C" {
1549 pub fn napi_is_dataview(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
1550}
1551extern "C" {
1552 pub fn napi_get_dataview_info(
1553 env: napi_env,
1554 dataview: napi_value,
1555 bytelength: *mut usize,
1556 data: *mut *mut ::std::os::raw::c_void,
1557 arraybuffer: *mut napi_value,
1558 byte_offset: *mut usize,
1559 ) -> napi_status;
1560}
1561extern "C" {
1562 pub fn napi_get_version(env: napi_env, result: *mut u32) -> napi_status;
1563}
1564extern "C" {
1565 pub fn napi_create_promise(
1566 env: napi_env,
1567 deferred: *mut napi_deferred,
1568 promise: *mut napi_value,
1569 ) -> napi_status;
1570}
1571extern "C" {
1572 pub fn napi_resolve_deferred(
1573 env: napi_env,
1574 deferred: napi_deferred,
1575 resolution: napi_value,
1576 ) -> napi_status;
1577}
1578extern "C" {
1579 pub fn napi_reject_deferred(
1580 env: napi_env,
1581 deferred: napi_deferred,
1582 rejection: napi_value,
1583 ) -> napi_status;
1584}
1585extern "C" {
1586 pub fn napi_is_promise(env: napi_env, value: napi_value, is_promise: *mut bool) -> napi_status;
1587}
1588extern "C" {
1589 pub fn napi_run_script(
1590 env: napi_env,
1591 script: napi_value,
1592 result: *mut napi_value,
1593 ) -> napi_status;
1594}
1595extern "C" {
1596 pub fn napi_adjust_external_memory(
1597 env: napi_env,
1598 change_in_bytes: i64,
1599 adjusted_value: *mut i64,
1600 ) -> napi_status;
1601}
1602extern "C" {
1603 pub fn napi_create_date(env: napi_env, time: f64, result: *mut napi_value) -> napi_status;
1604}
1605extern "C" {
1606 pub fn napi_is_date(env: napi_env, value: napi_value, is_date: *mut bool) -> napi_status;
1607}
1608extern "C" {
1609 pub fn napi_get_date_value(env: napi_env, value: napi_value, result: *mut f64) -> napi_status;
1610}
1611extern "C" {
1612 pub fn napi_add_finalizer(
1613 env: napi_env,
1614 js_object: napi_value,
1615 finalize_data: *mut ::std::os::raw::c_void,
1616 finalize_cb: napi_finalize,
1617 finalize_hint: *mut ::std::os::raw::c_void,
1618 result: *mut napi_ref,
1619 ) -> napi_status;
1620}
1621extern "C" {
1622 pub fn napi_create_bigint_int64(
1623 env: napi_env,
1624 value: i64,
1625 result: *mut napi_value,
1626 ) -> napi_status;
1627}
1628extern "C" {
1629 pub fn napi_create_bigint_uint64(
1630 env: napi_env,
1631 value: u64,
1632 result: *mut napi_value,
1633 ) -> napi_status;
1634}
1635extern "C" {
1636 pub fn napi_create_bigint_words(
1637 env: napi_env,
1638 sign_bit: ::std::os::raw::c_int,
1639 word_count: usize,
1640 words: *const u64,
1641 result: *mut napi_value,
1642 ) -> napi_status;
1643}
1644extern "C" {
1645 pub fn napi_get_value_bigint_int64(
1646 env: napi_env,
1647 value: napi_value,
1648 result: *mut i64,
1649 lossless: *mut bool,
1650 ) -> napi_status;
1651}
1652extern "C" {
1653 pub fn napi_get_value_bigint_uint64(
1654 env: napi_env,
1655 value: napi_value,
1656 result: *mut u64,
1657 lossless: *mut bool,
1658 ) -> napi_status;
1659}
1660extern "C" {
1661 pub fn napi_get_value_bigint_words(
1662 env: napi_env,
1663 value: napi_value,
1664 sign_bit: *mut ::std::os::raw::c_int,
1665 word_count: *mut usize,
1666 words: *mut u64,
1667 ) -> napi_status;
1668}
1669extern "C" {
1670 pub fn napi_get_all_property_names(
1671 env: napi_env,
1672 object: napi_value,
1673 key_mode: napi_key_collection_mode,
1674 key_filter: napi_key_filter,
1675 key_conversion: napi_key_conversion,
1676 result: *mut napi_value,
1677 ) -> napi_status;
1678}
1679extern "C" {
1680 pub fn napi_set_instance_data(
1681 env: napi_env,
1682 data: *mut ::std::os::raw::c_void,
1683 finalize_cb: napi_finalize,
1684 finalize_hint: *mut ::std::os::raw::c_void,
1685 ) -> napi_status;
1686}
1687extern "C" {
1688 pub fn napi_get_instance_data(
1689 env: napi_env,
1690 data: *mut *mut ::std::os::raw::c_void,
1691 ) -> napi_status;
1692}
1693extern "C" {
1694 pub fn napi_detach_arraybuffer(env: napi_env, arraybuffer: napi_value) -> napi_status;
1695}
1696extern "C" {
1697 pub fn napi_is_detached_arraybuffer(
1698 env: napi_env,
1699 value: napi_value,
1700 result: *mut bool,
1701 ) -> napi_status;
1702}
1703extern "C" {
1704 pub fn napi_type_tag_object(
1705 env: napi_env,
1706 value: napi_value,
1707 type_tag: *const napi_type_tag,
1708 ) -> napi_status;
1709}
1710extern "C" {
1711 pub fn napi_check_object_type_tag(
1712 env: napi_env,
1713 value: napi_value,
1714 type_tag: *const napi_type_tag,
1715 result: *mut bool,
1716 ) -> napi_status;
1717}
1718extern "C" {
1719 pub fn napi_object_freeze(env: napi_env, object: napi_value) -> napi_status;
1720}
1721extern "C" {
1722 pub fn napi_object_seal(env: napi_env, object: napi_value) -> napi_status;
1723}
1724#[repr(C)]
1725#[derive(Debug, Copy, Clone)]
1726pub struct napi_callback_scope__ {
1727 _unused: [u8; 0],
1728}
1729pub type napi_callback_scope = *mut napi_callback_scope__;
1730#[repr(C)]
1731#[derive(Debug, Copy, Clone)]
1732pub struct napi_async_context__ {
1733 _unused: [u8; 0],
1734}
1735pub type napi_async_context = *mut napi_async_context__;
1736#[repr(C)]
1737#[derive(Debug, Copy, Clone)]
1738pub struct napi_async_work__ {
1739 _unused: [u8; 0],
1740}
1741pub type napi_async_work = *mut napi_async_work__;
1742pub type napi_cleanup_hook =
1743 ::std::option::Option<unsafe extern "C" fn(arg: *mut ::std::os::raw::c_void)>;
1744#[repr(C)]
1745#[derive(Debug, Copy, Clone)]
1746pub struct napi_threadsafe_function__ {
1747 _unused: [u8; 0],
1748}
1749pub type napi_threadsafe_function = *mut napi_threadsafe_function__;
1750pub const napi_threadsafe_function_release_mode_napi_tsfn_release:
1751 napi_threadsafe_function_release_mode = 0;
1752pub const napi_threadsafe_function_release_mode_napi_tsfn_abort:
1753 napi_threadsafe_function_release_mode = 1;
1754pub type napi_threadsafe_function_release_mode = ::std::os::raw::c_uint;
1755pub const napi_threadsafe_function_call_mode_napi_tsfn_nonblocking:
1756 napi_threadsafe_function_call_mode = 0;
1757pub const napi_threadsafe_function_call_mode_napi_tsfn_blocking:
1758 napi_threadsafe_function_call_mode = 1;
1759pub type napi_threadsafe_function_call_mode = ::std::os::raw::c_uint;
1760pub type napi_async_execute_callback =
1761 ::std::option::Option<unsafe extern "C" fn(env: napi_env, data: *mut ::std::os::raw::c_void)>;
1762pub type napi_async_complete_callback = ::std::option::Option<
1763 unsafe extern "C" fn(env: napi_env, status: napi_status, data: *mut ::std::os::raw::c_void),
1764>;
1765pub type napi_threadsafe_function_call_js = ::std::option::Option<
1766 unsafe extern "C" fn(
1767 env: napi_env,
1768 js_callback: napi_value,
1769 context: *mut ::std::os::raw::c_void,
1770 data: *mut ::std::os::raw::c_void,
1771 ),
1772>;
1773#[repr(C)]
1774#[derive(Debug, Copy, Clone)]
1775pub struct napi_node_version {
1776 pub major: u32,
1777 pub minor: u32,
1778 pub patch: u32,
1779 pub release: *const ::std::os::raw::c_char,
1780}
1781#[test]
1782fn bindgen_test_layout_napi_node_version() {
1783 const UNINIT: ::std::mem::MaybeUninit<napi_node_version> = ::std::mem::MaybeUninit::uninit();
1784 let ptr = UNINIT.as_ptr();
1785 assert_eq!(
1786 ::std::mem::size_of::<napi_node_version>(),
1787 24usize,
1788 concat!("Size of: ", stringify!(napi_node_version))
1789 );
1790 assert_eq!(
1791 ::std::mem::align_of::<napi_node_version>(),
1792 8usize,
1793 concat!("Alignment of ", stringify!(napi_node_version))
1794 );
1795 assert_eq!(
1796 unsafe { ::std::ptr::addr_of!((*ptr).major) as usize - ptr as usize },
1797 0usize,
1798 concat!(
1799 "Offset of field: ",
1800 stringify!(napi_node_version),
1801 "::",
1802 stringify!(major)
1803 )
1804 );
1805 assert_eq!(
1806 unsafe { ::std::ptr::addr_of!((*ptr).minor) as usize - ptr as usize },
1807 4usize,
1808 concat!(
1809 "Offset of field: ",
1810 stringify!(napi_node_version),
1811 "::",
1812 stringify!(minor)
1813 )
1814 );
1815 assert_eq!(
1816 unsafe { ::std::ptr::addr_of!((*ptr).patch) as usize - ptr as usize },
1817 8usize,
1818 concat!(
1819 "Offset of field: ",
1820 stringify!(napi_node_version),
1821 "::",
1822 stringify!(patch)
1823 )
1824 );
1825 assert_eq!(
1826 unsafe { ::std::ptr::addr_of!((*ptr).release) as usize - ptr as usize },
1827 16usize,
1828 concat!(
1829 "Offset of field: ",
1830 stringify!(napi_node_version),
1831 "::",
1832 stringify!(release)
1833 )
1834 );
1835}
1836#[repr(C)]
1837#[derive(Debug, Copy, Clone)]
1838pub struct napi_async_cleanup_hook_handle__ {
1839 _unused: [u8; 0],
1840}
1841pub type napi_async_cleanup_hook_handle = *mut napi_async_cleanup_hook_handle__;
1842pub type napi_async_cleanup_hook = ::std::option::Option<
1843 unsafe extern "C" fn(handle: napi_async_cleanup_hook_handle, data: *mut ::std::os::raw::c_void),
1844>;
1845#[repr(C)]
1846#[derive(Debug, Copy, Clone)]
1847pub struct uv_loop_s {
1848 _unused: [u8; 0],
1849}
1850pub type napi_addon_register_func =
1851 ::std::option::Option<unsafe extern "C" fn(env: napi_env, exports: napi_value) -> napi_value>;
1852pub type node_api_addon_get_api_version_func = ::std::option::Option<unsafe extern "C" fn() -> i32>;
1853#[repr(C)]
1854#[derive(Debug, Copy, Clone)]
1855pub struct napi_module {
1856 pub nm_version: ::std::os::raw::c_int,
1857 pub nm_flags: ::std::os::raw::c_uint,
1858 pub nm_filename: *const ::std::os::raw::c_char,
1859 pub nm_register_func: napi_addon_register_func,
1860 pub nm_modname: *const ::std::os::raw::c_char,
1861 pub nm_priv: *mut ::std::os::raw::c_void,
1862 pub reserved: [*mut ::std::os::raw::c_void; 4usize],
1863}
1864#[test]
1865fn bindgen_test_layout_napi_module() {
1866 const UNINIT: ::std::mem::MaybeUninit<napi_module> = ::std::mem::MaybeUninit::uninit();
1867 let ptr = UNINIT.as_ptr();
1868 assert_eq!(
1869 ::std::mem::size_of::<napi_module>(),
1870 72usize,
1871 concat!("Size of: ", stringify!(napi_module))
1872 );
1873 assert_eq!(
1874 ::std::mem::align_of::<napi_module>(),
1875 8usize,
1876 concat!("Alignment of ", stringify!(napi_module))
1877 );
1878 assert_eq!(
1879 unsafe { ::std::ptr::addr_of!((*ptr).nm_version) as usize - ptr as usize },
1880 0usize,
1881 concat!(
1882 "Offset of field: ",
1883 stringify!(napi_module),
1884 "::",
1885 stringify!(nm_version)
1886 )
1887 );
1888 assert_eq!(
1889 unsafe { ::std::ptr::addr_of!((*ptr).nm_flags) as usize - ptr as usize },
1890 4usize,
1891 concat!(
1892 "Offset of field: ",
1893 stringify!(napi_module),
1894 "::",
1895 stringify!(nm_flags)
1896 )
1897 );
1898 assert_eq!(
1899 unsafe { ::std::ptr::addr_of!((*ptr).nm_filename) as usize - ptr as usize },
1900 8usize,
1901 concat!(
1902 "Offset of field: ",
1903 stringify!(napi_module),
1904 "::",
1905 stringify!(nm_filename)
1906 )
1907 );
1908 assert_eq!(
1909 unsafe { ::std::ptr::addr_of!((*ptr).nm_register_func) as usize - ptr as usize },
1910 16usize,
1911 concat!(
1912 "Offset of field: ",
1913 stringify!(napi_module),
1914 "::",
1915 stringify!(nm_register_func)
1916 )
1917 );
1918 assert_eq!(
1919 unsafe { ::std::ptr::addr_of!((*ptr).nm_modname) as usize - ptr as usize },
1920 24usize,
1921 concat!(
1922 "Offset of field: ",
1923 stringify!(napi_module),
1924 "::",
1925 stringify!(nm_modname)
1926 )
1927 );
1928 assert_eq!(
1929 unsafe { ::std::ptr::addr_of!((*ptr).nm_priv) as usize - ptr as usize },
1930 32usize,
1931 concat!(
1932 "Offset of field: ",
1933 stringify!(napi_module),
1934 "::",
1935 stringify!(nm_priv)
1936 )
1937 );
1938 assert_eq!(
1939 unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
1940 40usize,
1941 concat!(
1942 "Offset of field: ",
1943 stringify!(napi_module),
1944 "::",
1945 stringify!(reserved)
1946 )
1947 );
1948}
1949extern "C" {
1950 pub fn napi_module_register(mod_: *mut napi_module);
1951}
1952extern "C" {
1953 pub fn napi_fatal_error(
1954 location: *const ::std::os::raw::c_char,
1955 location_len: usize,
1956 message: *const ::std::os::raw::c_char,
1957 message_len: usize,
1958 ) -> !;
1959}
1960extern "C" {
1961 pub fn napi_async_init(
1962 env: napi_env,
1963 async_resource: napi_value,
1964 async_resource_name: napi_value,
1965 result: *mut napi_async_context,
1966 ) -> napi_status;
1967}
1968extern "C" {
1969 pub fn napi_async_destroy(env: napi_env, async_context: napi_async_context) -> napi_status;
1970}
1971extern "C" {
1972 pub fn napi_make_callback(
1973 env: napi_env,
1974 async_context: napi_async_context,
1975 recv: napi_value,
1976 func: napi_value,
1977 argc: usize,
1978 argv: *const napi_value,
1979 result: *mut napi_value,
1980 ) -> napi_status;
1981}
1982extern "C" {
1983 pub fn napi_create_buffer(
1984 env: napi_env,
1985 length: usize,
1986 data: *mut *mut ::std::os::raw::c_void,
1987 result: *mut napi_value,
1988 ) -> napi_status;
1989}
1990extern "C" {
1991 pub fn napi_create_external_buffer(
1992 env: napi_env,
1993 length: usize,
1994 data: *mut ::std::os::raw::c_void,
1995 finalize_cb: napi_finalize,
1996 finalize_hint: *mut ::std::os::raw::c_void,
1997 result: *mut napi_value,
1998 ) -> napi_status;
1999}
2000extern "C" {
2001 pub fn napi_create_buffer_copy(
2002 env: napi_env,
2003 length: usize,
2004 data: *const ::std::os::raw::c_void,
2005 result_data: *mut *mut ::std::os::raw::c_void,
2006 result: *mut napi_value,
2007 ) -> napi_status;
2008}
2009extern "C" {
2010 pub fn napi_is_buffer(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
2011}
2012extern "C" {
2013 pub fn napi_get_buffer_info(
2014 env: napi_env,
2015 value: napi_value,
2016 data: *mut *mut ::std::os::raw::c_void,
2017 length: *mut usize,
2018 ) -> napi_status;
2019}
2020extern "C" {
2021 pub fn napi_create_async_work(
2022 env: napi_env,
2023 async_resource: napi_value,
2024 async_resource_name: napi_value,
2025 execute: napi_async_execute_callback,
2026 complete: napi_async_complete_callback,
2027 data: *mut ::std::os::raw::c_void,
2028 result: *mut napi_async_work,
2029 ) -> napi_status;
2030}
2031extern "C" {
2032 pub fn napi_delete_async_work(env: napi_env, work: napi_async_work) -> napi_status;
2033}
2034extern "C" {
2035 pub fn napi_queue_async_work(env: napi_env, work: napi_async_work) -> napi_status;
2036}
2037extern "C" {
2038 pub fn napi_cancel_async_work(env: napi_env, work: napi_async_work) -> napi_status;
2039}
2040extern "C" {
2041 pub fn napi_get_node_version(
2042 env: napi_env,
2043 version: *mut *const napi_node_version,
2044 ) -> napi_status;
2045}
2046extern "C" {
2047 pub fn napi_get_uv_event_loop(env: napi_env, loop_: *mut *mut uv_loop_s) -> napi_status;
2048}
2049extern "C" {
2050 pub fn napi_fatal_exception(env: napi_env, err: napi_value) -> napi_status;
2051}
2052extern "C" {
2053 pub fn napi_add_env_cleanup_hook(
2054 env: napi_env,
2055 fun: napi_cleanup_hook,
2056 arg: *mut ::std::os::raw::c_void,
2057 ) -> napi_status;
2058}
2059extern "C" {
2060 pub fn napi_remove_env_cleanup_hook(
2061 env: napi_env,
2062 fun: napi_cleanup_hook,
2063 arg: *mut ::std::os::raw::c_void,
2064 ) -> napi_status;
2065}
2066extern "C" {
2067 pub fn napi_open_callback_scope(
2068 env: napi_env,
2069 resource_object: napi_value,
2070 context: napi_async_context,
2071 result: *mut napi_callback_scope,
2072 ) -> napi_status;
2073}
2074extern "C" {
2075 pub fn napi_close_callback_scope(env: napi_env, scope: napi_callback_scope) -> napi_status;
2076}
2077extern "C" {
2078 pub fn napi_create_threadsafe_function(
2079 env: napi_env,
2080 func: napi_value,
2081 async_resource: napi_value,
2082 async_resource_name: napi_value,
2083 max_queue_size: usize,
2084 initial_thread_count: usize,
2085 thread_finalize_data: *mut ::std::os::raw::c_void,
2086 thread_finalize_cb: napi_finalize,
2087 context: *mut ::std::os::raw::c_void,
2088 call_js_cb: napi_threadsafe_function_call_js,
2089 result: *mut napi_threadsafe_function,
2090 ) -> napi_status;
2091}
2092extern "C" {
2093 pub fn napi_get_threadsafe_function_context(
2094 func: napi_threadsafe_function,
2095 result: *mut *mut ::std::os::raw::c_void,
2096 ) -> napi_status;
2097}
2098extern "C" {
2099 pub fn napi_call_threadsafe_function(
2100 func: napi_threadsafe_function,
2101 data: *mut ::std::os::raw::c_void,
2102 is_blocking: napi_threadsafe_function_call_mode,
2103 ) -> napi_status;
2104}
2105extern "C" {
2106 pub fn napi_acquire_threadsafe_function(func: napi_threadsafe_function) -> napi_status;
2107}
2108extern "C" {
2109 pub fn napi_release_threadsafe_function(
2110 func: napi_threadsafe_function,
2111 mode: napi_threadsafe_function_release_mode,
2112 ) -> napi_status;
2113}
2114extern "C" {
2115 pub fn napi_unref_threadsafe_function(
2116 env: napi_env,
2117 func: napi_threadsafe_function,
2118 ) -> napi_status;
2119}
2120extern "C" {
2121 pub fn napi_ref_threadsafe_function(
2122 env: napi_env,
2123 func: napi_threadsafe_function,
2124 ) -> napi_status;
2125}
2126extern "C" {
2127 pub fn napi_add_async_cleanup_hook(
2128 env: napi_env,
2129 hook: napi_async_cleanup_hook,
2130 arg: *mut ::std::os::raw::c_void,
2131 remove_handle: *mut napi_async_cleanup_hook_handle,
2132 ) -> napi_status;
2133}
2134extern "C" {
2135 pub fn napi_remove_async_cleanup_hook(
2136 remove_handle: napi_async_cleanup_hook_handle,
2137 ) -> napi_status;
2138}
2139pub type __builtin_va_list = *mut ::std::os::raw::c_char;