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