1pub type __uint16_t = ::std::os::raw::c_ushort;
4pub type __int32_t = ::std::os::raw::c_int;
5pub type __uint32_t = ::std::os::raw::c_uint;
6pub type __int64_t = ::std::os::raw::c_long;
7pub type __uint64_t = ::std::os::raw::c_ulong;
8pub type char16_t = u16;
9#[repr(C)]
10#[derive(Debug, Copy, Clone)]
11pub struct napi_env__ {
12 _unused: [u8; 0],
13}
14pub type napi_env = *mut napi_env__;
15#[repr(C)]
16#[derive(Debug, Copy, Clone)]
17pub struct napi_value__ {
18 _unused: [u8; 0],
19}
20pub type napi_value = *mut napi_value__;
21#[repr(C)]
22#[derive(Debug, Copy, Clone)]
23pub struct napi_ref__ {
24 _unused: [u8; 0],
25}
26pub type napi_ref = *mut napi_ref__;
27#[repr(C)]
28#[derive(Debug, Copy, Clone)]
29pub struct napi_handle_scope__ {
30 _unused: [u8; 0],
31}
32pub type napi_handle_scope = *mut napi_handle_scope__;
33#[repr(C)]
34#[derive(Debug, Copy, Clone)]
35pub struct napi_escapable_handle_scope__ {
36 _unused: [u8; 0],
37}
38pub type napi_escapable_handle_scope = *mut napi_escapable_handle_scope__;
39#[repr(C)]
40#[derive(Debug, Copy, Clone)]
41pub struct napi_callback_info__ {
42 _unused: [u8; 0],
43}
44pub type napi_callback_info = *mut napi_callback_info__;
45#[repr(C)]
46#[derive(Debug, Copy, Clone)]
47pub struct napi_deferred__ {
48 _unused: [u8; 0],
49}
50pub type napi_deferred = *mut napi_deferred__;
51#[repr(u32)]
52#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
53pub enum napi_property_attributes {
54 napi_default = 0,
55 napi_writable = 1,
56 napi_enumerable = 2,
57 napi_configurable = 4,
58 napi_static = 1024,
59}
60#[repr(u32)]
61#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
62pub enum napi_valuetype {
63 napi_undefined = 0,
64 napi_null = 1,
65 napi_boolean = 2,
66 napi_number = 3,
67 napi_string = 4,
68 napi_symbol = 5,
69 napi_object = 6,
70 napi_function = 7,
71 napi_external = 8,
72 napi_bigint = 9,
73}
74#[repr(u32)]
75#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
76pub enum napi_typedarray_type {
77 napi_int8_array = 0,
78 napi_uint8_array = 1,
79 napi_uint8_clamped_array = 2,
80 napi_int16_array = 3,
81 napi_uint16_array = 4,
82 napi_int32_array = 5,
83 napi_uint32_array = 6,
84 napi_float32_array = 7,
85 napi_float64_array = 8,
86 napi_bigint64_array = 9,
87 napi_biguint64_array = 10,
88}
89#[repr(u32)]
90#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
91pub enum napi_status {
92 napi_ok = 0,
93 napi_invalid_arg = 1,
94 napi_object_expected = 2,
95 napi_string_expected = 3,
96 napi_name_expected = 4,
97 napi_function_expected = 5,
98 napi_number_expected = 6,
99 napi_boolean_expected = 7,
100 napi_array_expected = 8,
101 napi_generic_failure = 9,
102 napi_pending_exception = 10,
103 napi_cancelled = 11,
104 napi_escape_called_twice = 12,
105 napi_handle_scope_mismatch = 13,
106 napi_callback_scope_mismatch = 14,
107 napi_queue_full = 15,
108 napi_closing = 16,
109 napi_bigint_expected = 17,
110}
111pub type napi_callback = ::std::option::Option<
112 unsafe extern "C" fn(env: napi_env, info: napi_callback_info) -> napi_value,
113>;
114pub type napi_finalize = ::std::option::Option<
115 unsafe extern "C" fn(
116 env: napi_env,
117 finalize_data: *mut ::std::os::raw::c_void,
118 finalize_hint: *mut ::std::os::raw::c_void,
119 ),
120>;
121#[repr(C)]
122#[derive(Debug, Copy, Clone)]
123pub struct napi_property_descriptor {
124 pub utf8name: *const ::std::os::raw::c_char,
125 pub name: napi_value,
126 pub method: napi_callback,
127 pub getter: napi_callback,
128 pub setter: napi_callback,
129 pub value: napi_value,
130 pub attributes: napi_property_attributes,
131 pub data: *mut ::std::os::raw::c_void,
132}
133#[test]
134fn bindgen_test_layout_napi_property_descriptor() {
135 assert_eq!(
136 ::std::mem::size_of::<napi_property_descriptor>(),
137 64usize,
138 concat!("Size of: ", stringify!(napi_property_descriptor))
139 );
140 assert_eq!(
141 ::std::mem::align_of::<napi_property_descriptor>(),
142 8usize,
143 concat!("Alignment of ", stringify!(napi_property_descriptor))
144 );
145 assert_eq!(
146 unsafe {
147 &(*(::std::ptr::null::<napi_property_descriptor>())).utf8name as *const _ as usize
148 },
149 0usize,
150 concat!(
151 "Offset of field: ",
152 stringify!(napi_property_descriptor),
153 "::",
154 stringify!(utf8name)
155 )
156 );
157 assert_eq!(
158 unsafe { &(*(::std::ptr::null::<napi_property_descriptor>())).name as *const _ as usize },
159 8usize,
160 concat!(
161 "Offset of field: ",
162 stringify!(napi_property_descriptor),
163 "::",
164 stringify!(name)
165 )
166 );
167 assert_eq!(
168 unsafe { &(*(::std::ptr::null::<napi_property_descriptor>())).method as *const _ as usize },
169 16usize,
170 concat!(
171 "Offset of field: ",
172 stringify!(napi_property_descriptor),
173 "::",
174 stringify!(method)
175 )
176 );
177 assert_eq!(
178 unsafe { &(*(::std::ptr::null::<napi_property_descriptor>())).getter as *const _ as usize },
179 24usize,
180 concat!(
181 "Offset of field: ",
182 stringify!(napi_property_descriptor),
183 "::",
184 stringify!(getter)
185 )
186 );
187 assert_eq!(
188 unsafe { &(*(::std::ptr::null::<napi_property_descriptor>())).setter as *const _ as usize },
189 32usize,
190 concat!(
191 "Offset of field: ",
192 stringify!(napi_property_descriptor),
193 "::",
194 stringify!(setter)
195 )
196 );
197 assert_eq!(
198 unsafe { &(*(::std::ptr::null::<napi_property_descriptor>())).value as *const _ as usize },
199 40usize,
200 concat!(
201 "Offset of field: ",
202 stringify!(napi_property_descriptor),
203 "::",
204 stringify!(value)
205 )
206 );
207 assert_eq!(
208 unsafe {
209 &(*(::std::ptr::null::<napi_property_descriptor>())).attributes as *const _ as usize
210 },
211 48usize,
212 concat!(
213 "Offset of field: ",
214 stringify!(napi_property_descriptor),
215 "::",
216 stringify!(attributes)
217 )
218 );
219 assert_eq!(
220 unsafe { &(*(::std::ptr::null::<napi_property_descriptor>())).data as *const _ as usize },
221 56usize,
222 concat!(
223 "Offset of field: ",
224 stringify!(napi_property_descriptor),
225 "::",
226 stringify!(data)
227 )
228 );
229}
230#[repr(C)]
231#[derive(Debug, Copy, Clone)]
232pub struct napi_extended_error_info {
233 pub error_message: *const ::std::os::raw::c_char,
234 pub engine_reserved: *mut ::std::os::raw::c_void,
235 pub engine_error_code: u32,
236 pub error_code: napi_status,
237}
238#[test]
239fn bindgen_test_layout_napi_extended_error_info() {
240 assert_eq!(
241 ::std::mem::size_of::<napi_extended_error_info>(),
242 24usize,
243 concat!("Size of: ", stringify!(napi_extended_error_info))
244 );
245 assert_eq!(
246 ::std::mem::align_of::<napi_extended_error_info>(),
247 8usize,
248 concat!("Alignment of ", stringify!(napi_extended_error_info))
249 );
250 assert_eq!(
251 unsafe {
252 &(*(::std::ptr::null::<napi_extended_error_info>())).error_message as *const _ as usize
253 },
254 0usize,
255 concat!(
256 "Offset of field: ",
257 stringify!(napi_extended_error_info),
258 "::",
259 stringify!(error_message)
260 )
261 );
262 assert_eq!(
263 unsafe {
264 &(*(::std::ptr::null::<napi_extended_error_info>())).engine_reserved as *const _
265 as usize
266 },
267 8usize,
268 concat!(
269 "Offset of field: ",
270 stringify!(napi_extended_error_info),
271 "::",
272 stringify!(engine_reserved)
273 )
274 );
275 assert_eq!(
276 unsafe {
277 &(*(::std::ptr::null::<napi_extended_error_info>())).engine_error_code as *const _
278 as usize
279 },
280 16usize,
281 concat!(
282 "Offset of field: ",
283 stringify!(napi_extended_error_info),
284 "::",
285 stringify!(engine_error_code)
286 )
287 );
288 assert_eq!(
289 unsafe {
290 &(*(::std::ptr::null::<napi_extended_error_info>())).error_code as *const _ as usize
291 },
292 20usize,
293 concat!(
294 "Offset of field: ",
295 stringify!(napi_extended_error_info),
296 "::",
297 stringify!(error_code)
298 )
299 );
300}
301extern "C" {
302 pub fn napi_get_last_error_info(
303 env: napi_env,
304 result: *mut *const napi_extended_error_info,
305 ) -> napi_status;
306}
307extern "C" {
308 pub fn napi_get_undefined(env: napi_env, result: *mut napi_value) -> napi_status;
309}
310extern "C" {
311 pub fn napi_get_null(env: napi_env, result: *mut napi_value) -> napi_status;
312}
313extern "C" {
314 pub fn napi_get_global(env: napi_env, result: *mut napi_value) -> napi_status;
315}
316extern "C" {
317 pub fn napi_get_boolean(env: napi_env, value: bool, result: *mut napi_value) -> napi_status;
318}
319extern "C" {
320 pub fn napi_create_object(env: napi_env, result: *mut napi_value) -> napi_status;
321}
322extern "C" {
323 pub fn napi_create_array(env: napi_env, result: *mut napi_value) -> napi_status;
324}
325extern "C" {
326 pub fn napi_create_array_with_length(
327 env: napi_env,
328 length: usize,
329 result: *mut napi_value,
330 ) -> napi_status;
331}
332extern "C" {
333 pub fn napi_create_double(env: napi_env, value: f64, result: *mut napi_value) -> napi_status;
334}
335extern "C" {
336 pub fn napi_create_int32(env: napi_env, value: i32, result: *mut napi_value) -> napi_status;
337}
338extern "C" {
339 pub fn napi_create_uint32(env: napi_env, value: u32, result: *mut napi_value) -> napi_status;
340}
341extern "C" {
342 pub fn napi_create_int64(env: napi_env, value: i64, result: *mut napi_value) -> napi_status;
343}
344extern "C" {
345 pub fn napi_create_string_latin1(
346 env: napi_env,
347 str: *const ::std::os::raw::c_char,
348 length: usize,
349 result: *mut napi_value,
350 ) -> napi_status;
351}
352extern "C" {
353 pub fn napi_create_string_utf8(
354 env: napi_env,
355 str: *const ::std::os::raw::c_char,
356 length: usize,
357 result: *mut napi_value,
358 ) -> napi_status;
359}
360extern "C" {
361 pub fn napi_create_string_utf16(
362 env: napi_env,
363 str: *const char16_t,
364 length: usize,
365 result: *mut napi_value,
366 ) -> napi_status;
367}
368extern "C" {
369 pub fn napi_create_symbol(
370 env: napi_env,
371 description: napi_value,
372 result: *mut napi_value,
373 ) -> napi_status;
374}
375extern "C" {
376 pub fn napi_create_function(
377 env: napi_env,
378 utf8name: *const ::std::os::raw::c_char,
379 length: usize,
380 cb: napi_callback,
381 data: *mut ::std::os::raw::c_void,
382 result: *mut napi_value,
383 ) -> napi_status;
384}
385extern "C" {
386 pub fn napi_create_error(
387 env: napi_env,
388 code: napi_value,
389 msg: napi_value,
390 result: *mut napi_value,
391 ) -> napi_status;
392}
393extern "C" {
394 pub fn napi_create_type_error(
395 env: napi_env,
396 code: napi_value,
397 msg: napi_value,
398 result: *mut napi_value,
399 ) -> napi_status;
400}
401extern "C" {
402 pub fn napi_create_range_error(
403 env: napi_env,
404 code: napi_value,
405 msg: napi_value,
406 result: *mut napi_value,
407 ) -> napi_status;
408}
409extern "C" {
410 pub fn napi_typeof(
411 env: napi_env,
412 value: napi_value,
413 result: *mut napi_valuetype,
414 ) -> napi_status;
415}
416extern "C" {
417 pub fn napi_get_value_double(env: napi_env, value: napi_value, result: *mut f64)
418 -> napi_status;
419}
420extern "C" {
421 pub fn napi_get_value_int32(env: napi_env, value: napi_value, result: *mut i32) -> napi_status;
422}
423extern "C" {
424 pub fn napi_get_value_uint32(env: napi_env, value: napi_value, result: *mut u32)
425 -> napi_status;
426}
427extern "C" {
428 pub fn napi_get_value_int64(env: napi_env, value: napi_value, result: *mut i64) -> napi_status;
429}
430extern "C" {
431 pub fn napi_get_value_bool(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
432}
433extern "C" {
434 pub fn napi_get_value_string_latin1(
435 env: napi_env,
436 value: napi_value,
437 buf: *mut ::std::os::raw::c_char,
438 bufsize: usize,
439 result: *mut usize,
440 ) -> napi_status;
441}
442extern "C" {
443 pub fn napi_get_value_string_utf8(
444 env: napi_env,
445 value: napi_value,
446 buf: *mut ::std::os::raw::c_char,
447 bufsize: usize,
448 result: *mut usize,
449 ) -> napi_status;
450}
451extern "C" {
452 pub fn napi_get_value_string_utf16(
453 env: napi_env,
454 value: napi_value,
455 buf: *mut char16_t,
456 bufsize: usize,
457 result: *mut usize,
458 ) -> napi_status;
459}
460extern "C" {
461 pub fn napi_coerce_to_bool(
462 env: napi_env,
463 value: napi_value,
464 result: *mut napi_value,
465 ) -> napi_status;
466}
467extern "C" {
468 pub fn napi_coerce_to_number(
469 env: napi_env,
470 value: napi_value,
471 result: *mut napi_value,
472 ) -> napi_status;
473}
474extern "C" {
475 pub fn napi_coerce_to_object(
476 env: napi_env,
477 value: napi_value,
478 result: *mut napi_value,
479 ) -> napi_status;
480}
481extern "C" {
482 pub fn napi_coerce_to_string(
483 env: napi_env,
484 value: napi_value,
485 result: *mut napi_value,
486 ) -> napi_status;
487}
488extern "C" {
489 pub fn napi_get_prototype(
490 env: napi_env,
491 object: napi_value,
492 result: *mut napi_value,
493 ) -> napi_status;
494}
495extern "C" {
496 pub fn napi_get_property_names(
497 env: napi_env,
498 object: napi_value,
499 result: *mut napi_value,
500 ) -> napi_status;
501}
502extern "C" {
503 pub fn napi_set_property(
504 env: napi_env,
505 object: napi_value,
506 key: napi_value,
507 value: napi_value,
508 ) -> napi_status;
509}
510extern "C" {
511 pub fn napi_has_property(
512 env: napi_env,
513 object: napi_value,
514 key: napi_value,
515 result: *mut bool,
516 ) -> napi_status;
517}
518extern "C" {
519 pub fn napi_get_property(
520 env: napi_env,
521 object: napi_value,
522 key: napi_value,
523 result: *mut napi_value,
524 ) -> napi_status;
525}
526extern "C" {
527 pub fn napi_delete_property(
528 env: napi_env,
529 object: napi_value,
530 key: napi_value,
531 result: *mut bool,
532 ) -> napi_status;
533}
534extern "C" {
535 pub fn napi_has_own_property(
536 env: napi_env,
537 object: napi_value,
538 key: napi_value,
539 result: *mut bool,
540 ) -> napi_status;
541}
542extern "C" {
543 pub fn napi_set_named_property(
544 env: napi_env,
545 object: napi_value,
546 utf8name: *const ::std::os::raw::c_char,
547 value: napi_value,
548 ) -> napi_status;
549}
550extern "C" {
551 pub fn napi_has_named_property(
552 env: napi_env,
553 object: napi_value,
554 utf8name: *const ::std::os::raw::c_char,
555 result: *mut bool,
556 ) -> napi_status;
557}
558extern "C" {
559 pub fn napi_get_named_property(
560 env: napi_env,
561 object: napi_value,
562 utf8name: *const ::std::os::raw::c_char,
563 result: *mut napi_value,
564 ) -> napi_status;
565}
566extern "C" {
567 pub fn napi_set_element(
568 env: napi_env,
569 object: napi_value,
570 index: u32,
571 value: napi_value,
572 ) -> napi_status;
573}
574extern "C" {
575 pub fn napi_has_element(
576 env: napi_env,
577 object: napi_value,
578 index: u32,
579 result: *mut bool,
580 ) -> napi_status;
581}
582extern "C" {
583 pub fn napi_get_element(
584 env: napi_env,
585 object: napi_value,
586 index: u32,
587 result: *mut napi_value,
588 ) -> napi_status;
589}
590extern "C" {
591 pub fn napi_delete_element(
592 env: napi_env,
593 object: napi_value,
594 index: u32,
595 result: *mut bool,
596 ) -> napi_status;
597}
598extern "C" {
599 pub fn napi_define_properties(
600 env: napi_env,
601 object: napi_value,
602 property_count: usize,
603 properties: *const napi_property_descriptor,
604 ) -> napi_status;
605}
606extern "C" {
607 pub fn napi_is_array(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
608}
609extern "C" {
610 pub fn napi_get_array_length(env: napi_env, value: napi_value, result: *mut u32)
611 -> napi_status;
612}
613extern "C" {
614 pub fn napi_strict_equals(
615 env: napi_env,
616 lhs: napi_value,
617 rhs: napi_value,
618 result: *mut bool,
619 ) -> napi_status;
620}
621extern "C" {
622 pub fn napi_call_function(
623 env: napi_env,
624 recv: napi_value,
625 func: napi_value,
626 argc: usize,
627 argv: *const napi_value,
628 result: *mut napi_value,
629 ) -> napi_status;
630}
631extern "C" {
632 pub fn napi_new_instance(
633 env: napi_env,
634 constructor: napi_value,
635 argc: usize,
636 argv: *const napi_value,
637 result: *mut napi_value,
638 ) -> napi_status;
639}
640extern "C" {
641 pub fn napi_instanceof(
642 env: napi_env,
643 object: napi_value,
644 constructor: napi_value,
645 result: *mut bool,
646 ) -> napi_status;
647}
648extern "C" {
649 pub fn napi_get_cb_info(
650 env: napi_env,
651 cbinfo: napi_callback_info,
652 argc: *mut usize,
653 argv: *mut napi_value,
654 this_arg: *mut napi_value,
655 data: *mut *mut ::std::os::raw::c_void,
656 ) -> napi_status;
657}
658extern "C" {
659 pub fn napi_get_new_target(
660 env: napi_env,
661 cbinfo: napi_callback_info,
662 result: *mut napi_value,
663 ) -> napi_status;
664}
665extern "C" {
666 pub fn napi_define_class(
667 env: napi_env,
668 utf8name: *const ::std::os::raw::c_char,
669 length: usize,
670 constructor: napi_callback,
671 data: *mut ::std::os::raw::c_void,
672 property_count: usize,
673 properties: *const napi_property_descriptor,
674 result: *mut napi_value,
675 ) -> napi_status;
676}
677extern "C" {
678 pub fn napi_wrap(
679 env: napi_env,
680 js_object: napi_value,
681 native_object: *mut ::std::os::raw::c_void,
682 finalize_cb: napi_finalize,
683 finalize_hint: *mut ::std::os::raw::c_void,
684 result: *mut napi_ref,
685 ) -> napi_status;
686}
687extern "C" {
688 pub fn napi_unwrap(
689 env: napi_env,
690 js_object: napi_value,
691 result: *mut *mut ::std::os::raw::c_void,
692 ) -> napi_status;
693}
694extern "C" {
695 pub fn napi_remove_wrap(
696 env: napi_env,
697 js_object: napi_value,
698 result: *mut *mut ::std::os::raw::c_void,
699 ) -> napi_status;
700}
701extern "C" {
702 pub fn napi_create_external(
703 env: napi_env,
704 data: *mut ::std::os::raw::c_void,
705 finalize_cb: napi_finalize,
706 finalize_hint: *mut ::std::os::raw::c_void,
707 result: *mut napi_value,
708 ) -> napi_status;
709}
710extern "C" {
711 pub fn napi_get_value_external(
712 env: napi_env,
713 value: napi_value,
714 result: *mut *mut ::std::os::raw::c_void,
715 ) -> napi_status;
716}
717extern "C" {
718 pub fn napi_create_reference(
719 env: napi_env,
720 value: napi_value,
721 initial_refcount: u32,
722 result: *mut napi_ref,
723 ) -> napi_status;
724}
725extern "C" {
726 pub fn napi_delete_reference(env: napi_env, ref_: napi_ref) -> napi_status;
727}
728extern "C" {
729 pub fn napi_reference_ref(env: napi_env, ref_: napi_ref, result: *mut u32) -> napi_status;
730}
731extern "C" {
732 pub fn napi_reference_unref(env: napi_env, ref_: napi_ref, result: *mut u32) -> napi_status;
733}
734extern "C" {
735 pub fn napi_get_reference_value(
736 env: napi_env,
737 ref_: napi_ref,
738 result: *mut napi_value,
739 ) -> napi_status;
740}
741extern "C" {
742 pub fn napi_open_handle_scope(env: napi_env, result: *mut napi_handle_scope) -> napi_status;
743}
744extern "C" {
745 pub fn napi_close_handle_scope(env: napi_env, scope: napi_handle_scope) -> napi_status;
746}
747extern "C" {
748 pub fn napi_open_escapable_handle_scope(
749 env: napi_env,
750 result: *mut napi_escapable_handle_scope,
751 ) -> napi_status;
752}
753extern "C" {
754 pub fn napi_close_escapable_handle_scope(
755 env: napi_env,
756 scope: napi_escapable_handle_scope,
757 ) -> napi_status;
758}
759extern "C" {
760 pub fn napi_escape_handle(
761 env: napi_env,
762 scope: napi_escapable_handle_scope,
763 escapee: napi_value,
764 result: *mut napi_value,
765 ) -> napi_status;
766}
767extern "C" {
768 pub fn napi_throw(env: napi_env, error: napi_value) -> napi_status;
769}
770extern "C" {
771 pub fn napi_throw_error(
772 env: napi_env,
773 code: *const ::std::os::raw::c_char,
774 msg: *const ::std::os::raw::c_char,
775 ) -> napi_status;
776}
777extern "C" {
778 pub fn napi_throw_type_error(
779 env: napi_env,
780 code: *const ::std::os::raw::c_char,
781 msg: *const ::std::os::raw::c_char,
782 ) -> napi_status;
783}
784extern "C" {
785 pub fn napi_throw_range_error(
786 env: napi_env,
787 code: *const ::std::os::raw::c_char,
788 msg: *const ::std::os::raw::c_char,
789 ) -> napi_status;
790}
791extern "C" {
792 pub fn napi_is_error(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
793}
794extern "C" {
795 pub fn napi_is_exception_pending(env: napi_env, result: *mut bool) -> napi_status;
796}
797extern "C" {
798 pub fn napi_get_and_clear_last_exception(env: napi_env, result: *mut napi_value)
799 -> napi_status;
800}
801extern "C" {
802 pub fn napi_is_arraybuffer(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
803}
804extern "C" {
805 pub fn napi_create_arraybuffer(
806 env: napi_env,
807 byte_length: usize,
808 data: *mut *mut ::std::os::raw::c_void,
809 result: *mut napi_value,
810 ) -> napi_status;
811}
812extern "C" {
813 pub fn napi_create_external_arraybuffer(
814 env: napi_env,
815 external_data: *mut ::std::os::raw::c_void,
816 byte_length: usize,
817 finalize_cb: napi_finalize,
818 finalize_hint: *mut ::std::os::raw::c_void,
819 result: *mut napi_value,
820 ) -> napi_status;
821}
822extern "C" {
823 pub fn napi_get_arraybuffer_info(
824 env: napi_env,
825 arraybuffer: napi_value,
826 data: *mut *mut ::std::os::raw::c_void,
827 byte_length: *mut usize,
828 ) -> napi_status;
829}
830extern "C" {
831 pub fn napi_is_typedarray(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
832}
833extern "C" {
834 pub fn napi_create_typedarray(
835 env: napi_env,
836 type_: napi_typedarray_type,
837 length: usize,
838 arraybuffer: napi_value,
839 byte_offset: usize,
840 result: *mut napi_value,
841 ) -> napi_status;
842}
843extern "C" {
844 pub fn napi_get_typedarray_info(
845 env: napi_env,
846 typedarray: napi_value,
847 type_: *mut napi_typedarray_type,
848 length: *mut usize,
849 data: *mut *mut ::std::os::raw::c_void,
850 arraybuffer: *mut napi_value,
851 byte_offset: *mut usize,
852 ) -> napi_status;
853}
854extern "C" {
855 pub fn napi_create_dataview(
856 env: napi_env,
857 length: usize,
858 arraybuffer: napi_value,
859 byte_offset: usize,
860 result: *mut napi_value,
861 ) -> napi_status;
862}
863extern "C" {
864 pub fn napi_is_dataview(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
865}
866extern "C" {
867 pub fn napi_get_dataview_info(
868 env: napi_env,
869 dataview: napi_value,
870 bytelength: *mut usize,
871 data: *mut *mut ::std::os::raw::c_void,
872 arraybuffer: *mut napi_value,
873 byte_offset: *mut usize,
874 ) -> napi_status;
875}
876extern "C" {
877 pub fn napi_get_version(env: napi_env, result: *mut u32) -> napi_status;
878}
879extern "C" {
880 pub fn napi_create_promise(
881 env: napi_env,
882 deferred: *mut napi_deferred,
883 promise: *mut napi_value,
884 ) -> napi_status;
885}
886extern "C" {
887 pub fn napi_resolve_deferred(
888 env: napi_env,
889 deferred: napi_deferred,
890 resolution: napi_value,
891 ) -> napi_status;
892}
893extern "C" {
894 pub fn napi_reject_deferred(
895 env: napi_env,
896 deferred: napi_deferred,
897 rejection: napi_value,
898 ) -> napi_status;
899}
900extern "C" {
901 pub fn napi_is_promise(
902 env: napi_env,
903 promise: napi_value,
904 is_promise: *mut bool,
905 ) -> napi_status;
906}
907extern "C" {
908 pub fn napi_run_script(
909 env: napi_env,
910 script: napi_value,
911 result: *mut napi_value,
912 ) -> napi_status;
913}
914extern "C" {
915 pub fn napi_adjust_external_memory(
916 env: napi_env,
917 change_in_bytes: i64,
918 adjusted_value: *mut i64,
919 ) -> napi_status;
920}
921extern "C" {
922 pub fn napi_create_bigint_int64(
923 env: napi_env,
924 value: i64,
925 result: *mut napi_value,
926 ) -> napi_status;
927}
928extern "C" {
929 pub fn napi_create_bigint_uint64(
930 env: napi_env,
931 value: u64,
932 result: *mut napi_value,
933 ) -> napi_status;
934}
935extern "C" {
936 pub fn napi_create_bigint_words(
937 env: napi_env,
938 sign_bit: ::std::os::raw::c_int,
939 word_count: usize,
940 words: *const u64,
941 result: *mut napi_value,
942 ) -> napi_status;
943}
944extern "C" {
945 pub fn napi_get_value_bigint_int64(
946 env: napi_env,
947 value: napi_value,
948 result: *mut i64,
949 lossless: *mut bool,
950 ) -> napi_status;
951}
952extern "C" {
953 pub fn napi_get_value_bigint_uint64(
954 env: napi_env,
955 value: napi_value,
956 result: *mut u64,
957 lossless: *mut bool,
958 ) -> napi_status;
959}
960extern "C" {
961 pub fn napi_get_value_bigint_words(
962 env: napi_env,
963 value: napi_value,
964 sign_bit: *mut ::std::os::raw::c_int,
965 word_count: *mut usize,
966 words: *mut u64,
967 ) -> napi_status;
968}
969extern "C" {
970 pub fn napi_add_finalizer(
971 env: napi_env,
972 js_object: napi_value,
973 native_object: *mut ::std::os::raw::c_void,
974 finalize_cb: napi_finalize,
975 finalize_hint: *mut ::std::os::raw::c_void,
976 result: *mut napi_ref,
977 ) -> napi_status;
978}
979#[repr(C)]
980#[derive(Debug, Copy, Clone)]
981pub struct napi_callback_scope__ {
982 _unused: [u8; 0],
983}
984pub type napi_callback_scope = *mut napi_callback_scope__;
985#[repr(C)]
986#[derive(Debug, Copy, Clone)]
987pub struct napi_async_context__ {
988 _unused: [u8; 0],
989}
990pub type napi_async_context = *mut napi_async_context__;
991#[repr(C)]
992#[derive(Debug, Copy, Clone)]
993pub struct napi_async_work__ {
994 _unused: [u8; 0],
995}
996pub type napi_async_work = *mut napi_async_work__;
997#[repr(C)]
998#[derive(Debug, Copy, Clone)]
999pub struct napi_threadsafe_function__ {
1000 _unused: [u8; 0],
1001}
1002pub type napi_threadsafe_function = *mut napi_threadsafe_function__;
1003#[repr(u32)]
1004#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1005pub enum napi_threadsafe_function_release_mode {
1006 napi_tsfn_release = 0,
1007 napi_tsfn_abort = 1,
1008}
1009#[repr(u32)]
1010#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1011pub enum napi_threadsafe_function_call_mode {
1012 napi_tsfn_nonblocking = 0,
1013 napi_tsfn_blocking = 1,
1014}
1015pub type napi_async_execute_callback =
1016 ::std::option::Option<unsafe extern "C" fn(env: napi_env, data: *mut ::std::os::raw::c_void)>;
1017pub type napi_async_complete_callback = ::std::option::Option<
1018 unsafe extern "C" fn(env: napi_env, status: napi_status, data: *mut ::std::os::raw::c_void),
1019>;
1020pub type napi_threadsafe_function_call_js = ::std::option::Option<
1021 unsafe extern "C" fn(
1022 env: napi_env,
1023 js_callback: napi_value,
1024 context: *mut ::std::os::raw::c_void,
1025 data: *mut ::std::os::raw::c_void,
1026 ),
1027>;
1028#[repr(C)]
1029#[derive(Debug, Copy, Clone)]
1030pub struct napi_node_version {
1031 pub major: u32,
1032 pub minor: u32,
1033 pub patch: u32,
1034 pub release: *const ::std::os::raw::c_char,
1035}
1036#[test]
1037fn bindgen_test_layout_napi_node_version() {
1038 assert_eq!(
1039 ::std::mem::size_of::<napi_node_version>(),
1040 24usize,
1041 concat!("Size of: ", stringify!(napi_node_version))
1042 );
1043 assert_eq!(
1044 ::std::mem::align_of::<napi_node_version>(),
1045 8usize,
1046 concat!("Alignment of ", stringify!(napi_node_version))
1047 );
1048 assert_eq!(
1049 unsafe { &(*(::std::ptr::null::<napi_node_version>())).major as *const _ as usize },
1050 0usize,
1051 concat!(
1052 "Offset of field: ",
1053 stringify!(napi_node_version),
1054 "::",
1055 stringify!(major)
1056 )
1057 );
1058 assert_eq!(
1059 unsafe { &(*(::std::ptr::null::<napi_node_version>())).minor as *const _ as usize },
1060 4usize,
1061 concat!(
1062 "Offset of field: ",
1063 stringify!(napi_node_version),
1064 "::",
1065 stringify!(minor)
1066 )
1067 );
1068 assert_eq!(
1069 unsafe { &(*(::std::ptr::null::<napi_node_version>())).patch as *const _ as usize },
1070 8usize,
1071 concat!(
1072 "Offset of field: ",
1073 stringify!(napi_node_version),
1074 "::",
1075 stringify!(patch)
1076 )
1077 );
1078 assert_eq!(
1079 unsafe { &(*(::std::ptr::null::<napi_node_version>())).release as *const _ as usize },
1080 16usize,
1081 concat!(
1082 "Offset of field: ",
1083 stringify!(napi_node_version),
1084 "::",
1085 stringify!(release)
1086 )
1087 );
1088}
1089#[repr(C)]
1090#[derive(Debug, Copy, Clone)]
1091pub struct uv_loop_s {
1092 _unused: [u8; 0],
1093}
1094pub type napi_addon_register_func =
1095 ::std::option::Option<unsafe extern "C" fn(env: napi_env, exports: napi_value) -> napi_value>;
1096#[repr(C)]
1097#[derive(Debug, Copy, Clone)]
1098pub struct napi_module {
1099 pub nm_version: ::std::os::raw::c_int,
1100 pub nm_flags: ::std::os::raw::c_uint,
1101 pub nm_filename: *const ::std::os::raw::c_char,
1102 pub nm_register_func: napi_addon_register_func,
1103 pub nm_modname: *const ::std::os::raw::c_char,
1104 pub nm_priv: *mut ::std::os::raw::c_void,
1105 pub reserved: [*mut ::std::os::raw::c_void; 4usize],
1106}
1107#[test]
1108fn bindgen_test_layout_napi_module() {
1109 assert_eq!(
1110 ::std::mem::size_of::<napi_module>(),
1111 72usize,
1112 concat!("Size of: ", stringify!(napi_module))
1113 );
1114 assert_eq!(
1115 ::std::mem::align_of::<napi_module>(),
1116 8usize,
1117 concat!("Alignment of ", stringify!(napi_module))
1118 );
1119 assert_eq!(
1120 unsafe { &(*(::std::ptr::null::<napi_module>())).nm_version as *const _ as usize },
1121 0usize,
1122 concat!(
1123 "Offset of field: ",
1124 stringify!(napi_module),
1125 "::",
1126 stringify!(nm_version)
1127 )
1128 );
1129 assert_eq!(
1130 unsafe { &(*(::std::ptr::null::<napi_module>())).nm_flags as *const _ as usize },
1131 4usize,
1132 concat!(
1133 "Offset of field: ",
1134 stringify!(napi_module),
1135 "::",
1136 stringify!(nm_flags)
1137 )
1138 );
1139 assert_eq!(
1140 unsafe { &(*(::std::ptr::null::<napi_module>())).nm_filename as *const _ as usize },
1141 8usize,
1142 concat!(
1143 "Offset of field: ",
1144 stringify!(napi_module),
1145 "::",
1146 stringify!(nm_filename)
1147 )
1148 );
1149 assert_eq!(
1150 unsafe { &(*(::std::ptr::null::<napi_module>())).nm_register_func as *const _ as usize },
1151 16usize,
1152 concat!(
1153 "Offset of field: ",
1154 stringify!(napi_module),
1155 "::",
1156 stringify!(nm_register_func)
1157 )
1158 );
1159 assert_eq!(
1160 unsafe { &(*(::std::ptr::null::<napi_module>())).nm_modname as *const _ as usize },
1161 24usize,
1162 concat!(
1163 "Offset of field: ",
1164 stringify!(napi_module),
1165 "::",
1166 stringify!(nm_modname)
1167 )
1168 );
1169 assert_eq!(
1170 unsafe { &(*(::std::ptr::null::<napi_module>())).nm_priv as *const _ as usize },
1171 32usize,
1172 concat!(
1173 "Offset of field: ",
1174 stringify!(napi_module),
1175 "::",
1176 stringify!(nm_priv)
1177 )
1178 );
1179 assert_eq!(
1180 unsafe { &(*(::std::ptr::null::<napi_module>())).reserved as *const _ as usize },
1181 40usize,
1182 concat!(
1183 "Offset of field: ",
1184 stringify!(napi_module),
1185 "::",
1186 stringify!(reserved)
1187 )
1188 );
1189}
1190extern "C" {
1191 pub fn napi_module_register(mod_: *mut napi_module);
1192}
1193extern "C" {
1194 pub fn napi_fatal_error(
1195 location: *const ::std::os::raw::c_char,
1196 location_len: usize,
1197 message: *const ::std::os::raw::c_char,
1198 message_len: usize,
1199 );
1200}
1201extern "C" {
1202 pub fn napi_async_init(
1203 env: napi_env,
1204 async_resource: napi_value,
1205 async_resource_name: napi_value,
1206 result: *mut napi_async_context,
1207 ) -> napi_status;
1208}
1209extern "C" {
1210 pub fn napi_async_destroy(env: napi_env, async_context: napi_async_context) -> napi_status;
1211}
1212extern "C" {
1213 pub fn napi_make_callback(
1214 env: napi_env,
1215 async_context: napi_async_context,
1216 recv: napi_value,
1217 func: napi_value,
1218 argc: usize,
1219 argv: *const napi_value,
1220 result: *mut napi_value,
1221 ) -> napi_status;
1222}
1223extern "C" {
1224 pub fn napi_create_buffer(
1225 env: napi_env,
1226 length: usize,
1227 data: *mut *mut ::std::os::raw::c_void,
1228 result: *mut napi_value,
1229 ) -> napi_status;
1230}
1231extern "C" {
1232 pub fn napi_create_external_buffer(
1233 env: napi_env,
1234 length: usize,
1235 data: *mut ::std::os::raw::c_void,
1236 finalize_cb: napi_finalize,
1237 finalize_hint: *mut ::std::os::raw::c_void,
1238 result: *mut napi_value,
1239 ) -> napi_status;
1240}
1241extern "C" {
1242 pub fn napi_create_buffer_copy(
1243 env: napi_env,
1244 length: usize,
1245 data: *const ::std::os::raw::c_void,
1246 result_data: *mut *mut ::std::os::raw::c_void,
1247 result: *mut napi_value,
1248 ) -> napi_status;
1249}
1250extern "C" {
1251 pub fn napi_is_buffer(env: napi_env, value: napi_value, result: *mut bool) -> napi_status;
1252}
1253extern "C" {
1254 pub fn napi_get_buffer_info(
1255 env: napi_env,
1256 value: napi_value,
1257 data: *mut *mut ::std::os::raw::c_void,
1258 length: *mut usize,
1259 ) -> napi_status;
1260}
1261extern "C" {
1262 pub fn napi_create_async_work(
1263 env: napi_env,
1264 async_resource: napi_value,
1265 async_resource_name: napi_value,
1266 execute: napi_async_execute_callback,
1267 complete: napi_async_complete_callback,
1268 data: *mut ::std::os::raw::c_void,
1269 result: *mut napi_async_work,
1270 ) -> napi_status;
1271}
1272extern "C" {
1273 pub fn napi_delete_async_work(env: napi_env, work: napi_async_work) -> napi_status;
1274}
1275extern "C" {
1276 pub fn napi_queue_async_work(env: napi_env, work: napi_async_work) -> napi_status;
1277}
1278extern "C" {
1279 pub fn napi_cancel_async_work(env: napi_env, work: napi_async_work) -> napi_status;
1280}
1281extern "C" {
1282 pub fn napi_get_node_version(
1283 env: napi_env,
1284 version: *mut *const napi_node_version,
1285 ) -> napi_status;
1286}
1287extern "C" {
1288 pub fn napi_get_uv_event_loop(env: napi_env, loop_: *mut *mut uv_loop_s) -> napi_status;
1289}
1290extern "C" {
1291 pub fn napi_fatal_exception(env: napi_env, err: napi_value) -> napi_status;
1292}
1293extern "C" {
1294 pub fn napi_add_env_cleanup_hook(
1295 env: napi_env,
1296 fun: ::std::option::Option<unsafe extern "C" fn(arg: *mut ::std::os::raw::c_void)>,
1297 arg: *mut ::std::os::raw::c_void,
1298 ) -> napi_status;
1299}
1300extern "C" {
1301 pub fn napi_remove_env_cleanup_hook(
1302 env: napi_env,
1303 fun: ::std::option::Option<unsafe extern "C" fn(arg: *mut ::std::os::raw::c_void)>,
1304 arg: *mut ::std::os::raw::c_void,
1305 ) -> napi_status;
1306}
1307extern "C" {
1308 pub fn napi_open_callback_scope(
1309 env: napi_env,
1310 resource_object: napi_value,
1311 context: napi_async_context,
1312 result: *mut napi_callback_scope,
1313 ) -> napi_status;
1314}
1315extern "C" {
1316 pub fn napi_close_callback_scope(env: napi_env, scope: napi_callback_scope) -> napi_status;
1317}
1318extern "C" {
1319 pub fn napi_create_threadsafe_function(
1320 env: napi_env,
1321 func: napi_value,
1322 async_resource: napi_value,
1323 async_resource_name: napi_value,
1324 max_queue_size: usize,
1325 initial_thread_count: usize,
1326 thread_finalize_data: *mut ::std::os::raw::c_void,
1327 thread_finalize_cb: napi_finalize,
1328 context: *mut ::std::os::raw::c_void,
1329 call_js_cb: napi_threadsafe_function_call_js,
1330 result: *mut napi_threadsafe_function,
1331 ) -> napi_status;
1332}
1333extern "C" {
1334 pub fn napi_get_threadsafe_function_context(
1335 func: napi_threadsafe_function,
1336 result: *mut *mut ::std::os::raw::c_void,
1337 ) -> napi_status;
1338}
1339extern "C" {
1340 pub fn napi_call_threadsafe_function(
1341 func: napi_threadsafe_function,
1342 data: *mut ::std::os::raw::c_void,
1343 is_blocking: napi_threadsafe_function_call_mode,
1344 ) -> napi_status;
1345}
1346extern "C" {
1347 pub fn napi_acquire_threadsafe_function(func: napi_threadsafe_function) -> napi_status;
1348}
1349extern "C" {
1350 pub fn napi_release_threadsafe_function(
1351 func: napi_threadsafe_function,
1352 mode: napi_threadsafe_function_release_mode,
1353 ) -> napi_status;
1354}
1355extern "C" {
1356 pub fn napi_unref_threadsafe_function(
1357 env: napi_env,
1358 func: napi_threadsafe_function,
1359 ) -> napi_status;
1360}
1361extern "C" {
1362 pub fn napi_ref_threadsafe_function(
1363 env: napi_env,
1364 func: napi_threadsafe_function,
1365 ) -> napi_status;
1366}