init project

node_modules/@emnapi/runtime/dist/emnapi.d.ts

@@ -0,0 +1,828 @@
+/// <reference lib="esnext.disposable" />
+
+export declare type Ptr = number | bigint
+
+export declare interface IBuffer extends Uint8Array {
+  toString (encoding?: string, start?: number, end?: number): string
+}
+
+export declare interface BufferCtor {
+  readonly prototype: IBuffer
+  /** @deprecated */
+  new (...args: any[]): IBuffer
+  from: {
+    (buffer: ArrayBufferLike): IBuffer
+    (buffer: ArrayBufferLike, byteOffset: number, length: number): IBuffer
+  }
+  alloc: (size: number) => IBuffer
+  isBuffer: (obj: unknown) => obj is IBuffer
+}
+
+export declare const enum Constant {
+  HOLE,
+  EMPTY,
+  UNDEFINED,
+  NULL,
+  FALSE,
+  TRUE,
+  GLOBAL,
+  EMPTY_STRING,
+}
+
+export declare const enum Version {
+  NODE_API_SUPPORTED_VERSION_MIN = 1,
+  NODE_API_DEFAULT_MODULE_API_VERSION = 8,
+  NODE_API_SUPPORTED_VERSION_MAX = 10,
+  NODE_MODULE_VERSION = 127,
+  NAPI_VERSION_EXPERIMENTAL = 2147483647 // INT_MAX
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export declare type Pointer<T> = number | bigint
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export declare type PointerPointer<T> = number
+export declare type FunctionPointer<T extends (...args: any[]) => any> = Pointer<T>
+export declare type Const<T> = T
+
+export declare type void_p = Pointer<void>
+export declare type void_pp = Pointer<void_p>
+export declare type bool = number
+export declare type char = number
+export declare type char_p = Pointer<char>
+export declare type unsigned_char = number
+export declare type const_char = Const<char>
+export declare type const_char_p = Pointer<const_char>
+export declare type char16_t = number
+export declare type const_char16_t = number
+export declare type char16_t_p = Pointer<char16_t>
+export declare type const_char16_t_p = Pointer<const_char16_t>
+
+export declare type short = number
+export declare type unsigned_short = number
+export declare type int = number
+export declare type unsigned_int = number
+export declare type long = number
+export declare type unsigned_long = number
+export declare type long_long = bigint
+export declare type unsigned_long_long = bigint
+export declare type float = number
+export declare type double = number
+export declare type long_double = number
+export declare type size_t = number
+
+export declare type int8_t = number
+export declare type uint8_t = number
+export declare type int16_t = number
+export declare type uint16_t = number
+export declare type int32_t = number
+export declare type uint32_t = number
+export declare type int64_t = bigint
+export declare type uint64_t = bigint
+export declare type napi_env = Pointer<unknown>
+
+export declare type napi_value = Pointer<unknown>
+export declare type napi_ref = Pointer<unknown>
+export declare type napi_deferred = Pointer<unknown>
+export declare type napi_handle_scope = Pointer<unknown>
+export declare type napi_escapable_handle_scope = Pointer<unknown>
+
+export declare type napi_addon_register_func = FunctionPointer<(env: napi_env, exports: napi_value) => napi_value>
+
+export declare type napi_callback_info = Pointer<unknown>
+export declare type napi_callback = FunctionPointer<(env: napi_env, info: napi_callback_info) => napi_value>
+
+export declare interface napi_extended_error_info {
+  error_message: const_char_p
+  engine_reserved: void_p
+  engine_error_code: uint32_t
+  error_code: napi_status
+}
+
+export declare interface napi_property_descriptor {
+  // One of utf8name or name should be NULL.
+  utf8name: const_char_p
+  name: napi_value
+
+  method: napi_callback
+  getter: napi_callback
+  setter: napi_callback
+  value: napi_value
+  /* napi_property_attributes */
+  attributes: number
+  data: void_p
+}
+
+export declare type napi_finalize = FunctionPointer<(
+  env: napi_env,
+  finalize_data: void_p,
+  finalize_hint: void_p
+) => void>
+
+export declare interface node_module {
+  nm_version: int32_t
+  nm_flags: uint32_t
+  nm_filename: Pointer<const_char>
+  nm_register_func: napi_addon_register_func
+  nm_modname: Pointer<const_char>
+  nm_priv: Pointer<void>
+  reserved: PointerPointer<void>
+}
+
+export declare interface napi_node_version {
+  major: uint32_t
+  minor: uint32_t
+  patch: uint32_t
+  release: const_char_p
+}
+
+export declare interface emnapi_emscripten_version {
+  major: uint32_t
+  minor: uint32_t
+  patch: uint32_t
+}
+
+export declare const enum napi_status {
+  napi_ok,
+  napi_invalid_arg,
+  napi_object_expected,
+  napi_string_expected,
+  napi_name_expected,
+  napi_function_expected,
+  napi_number_expected,
+  napi_boolean_expected,
+  napi_array_expected,
+  napi_generic_failure,
+  napi_pending_exception,
+  napi_cancelled,
+  napi_escape_called_twice,
+  napi_handle_scope_mismatch,
+  napi_callback_scope_mismatch,
+  napi_queue_full,
+  napi_closing,
+  napi_bigint_expected,
+  napi_date_expected,
+  napi_arraybuffer_expected,
+  napi_detachable_arraybuffer_expected,
+  napi_would_deadlock, // unused
+  napi_no_external_buffers_allowed,
+  napi_cannot_run_js
+}
+
+export declare const enum napi_property_attributes {
+  napi_default = 0,
+  napi_writable = 1 << 0,
+  napi_enumerable = 1 << 1,
+  napi_configurable = 1 << 2,
+
+  // Used with napi_define_class to distinguish static properties
+  // from instance properties. Ignored by napi_define_properties.
+  napi_static = 1 << 10,
+
+  /// #ifdef NAPI_EXPERIMENTAL
+  // Default for class methods.
+  napi_default_method = napi_writable | napi_configurable,
+
+  // Default for object properties, like in JS obj[prop].
+  napi_default_jsproperty = napi_writable | napi_enumerable | napi_configurable
+  /// #endif  // NAPI_EXPERIMENTAL
+}
+
+export declare const enum napi_valuetype {
+  napi_undefined,
+  napi_null,
+  napi_boolean,
+  napi_number,
+  napi_string,
+  napi_symbol,
+  napi_object,
+  napi_function,
+  napi_external,
+  napi_bigint
+}
+
+export declare const enum napi_typedarray_type {
+  napi_int8_array,
+  napi_uint8_array,
+  napi_uint8_clamped_array,
+  napi_int16_array,
+  napi_uint16_array,
+  napi_int32_array,
+  napi_uint32_array,
+  napi_float32_array,
+  napi_float64_array,
+  napi_bigint64_array,
+  napi_biguint64_array,
+  napi_float16_array,
+}
+
+export declare const enum napi_key_collection_mode {
+  napi_key_include_prototypes,
+  napi_key_own_only
+}
+
+export declare const enum napi_key_filter {
+  napi_key_all_properties = 0,
+  napi_key_writable = 1,
+  napi_key_enumerable = 1 << 1,
+  napi_key_configurable = 1 << 2,
+  napi_key_skip_strings = 1 << 3,
+  napi_key_skip_symbols = 1 << 4
+}
+
+export declare const enum napi_key_conversion {
+  napi_key_keep_numbers,
+  napi_key_numbers_to_strings
+}
+
+export declare const enum emnapi_memory_view_type {
+  emnapi_int8_array,
+  emnapi_uint8_array,
+  emnapi_uint8_clamped_array,
+  emnapi_int16_array,
+  emnapi_uint16_array,
+  emnapi_int32_array,
+  emnapi_uint32_array,
+  emnapi_float32_array,
+  emnapi_float64_array,
+  emnapi_bigint64_array,
+  emnapi_biguint64_array,
+  emnapi_float16_array,
+  emnapi_data_view = -1,
+  emnapi_buffer = -2
+}
+
+export declare const enum napi_threadsafe_function_call_mode {
+  napi_tsfn_nonblocking,
+  napi_tsfn_blocking
+}
+
+export declare const enum napi_threadsafe_function_release_mode {
+  napi_tsfn_release,
+  napi_tsfn_abort
+}
+export declare class ArrayStore<T extends {
+    id: number | bigint;
+}> extends BaseArrayStore<T> {
+    protected _allocator: IdAllocator;
+    constructor(initialCapacity?: number);
+    insert(value: T): void;
+    alloc<P extends any[]>(factory: (...args: P) => T, ...args: P): T;
+    dealloc(id: number | bigint): void;
+}
+
+export declare class BaseArrayStore<T> extends Disposable_2 implements ObjectAllocator<T> {
+    protected _values: [undefined, ...(T | undefined)[]];
+    constructor(initialCapacity?: number);
+    assign(id: number | bigint, value: T): T;
+    deref<R extends T = T>(id: number | bigint): R | undefined;
+    alloc<P extends any[]>(factory: (...args: P) => T, ...args: P): T;
+    dealloc(id: number | bigint): void;
+    dispose(): void;
+}
+
+export declare type CleanupHookCallbackFunction = number | ((arg: number) => void);
+
+export declare class Context {
+    private _isStopping;
+    private _canCallIntoJs;
+    private _suppressDestroy;
+    private envStore;
+    refStore: Map<number, Reference>;
+    private readonly refCounter?;
+    private readonly cleanupQueue;
+    readonly features: Features;
+    readonly isolate: Isolate;
+    constructor(options?: ContextOptions);
+    getIsolate(): Isolate;
+    suppressDestroy(): void;
+    getRuntimeVersions(): {
+        version: string;
+        NODE_API_SUPPORTED_VERSION_MAX: Version;
+        NAPI_VERSION_EXPERIMENTAL: Version;
+        NODE_API_DEFAULT_MODULE_API_VERSION: Version;
+        NODE_MODULE_VERSION: Version;
+    };
+    createNotSupportWeakRefError(api: string, message: string): NotSupportWeakRefError;
+    createNotSupportBufferError(api: string, message: string): NotSupportBufferError;
+    createReference(envObject: Env, handle_id: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership): Reference;
+    createReferenceWithData(envObject: Env, handle_id: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership, data: void_p): Reference;
+    createReferenceWithFinalizer(envObject: Env, handle_id: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership, finalize_callback?: napi_finalize, finalize_data?: void_p, finalize_hint?: void_p): Reference;
+    createResolver<T>(): Resolver<T>;
+    adjustAmountOfExternalAllocatedMemory(changeInBytes: number | bigint): bigint;
+    createEnv(filename: string, moduleApiVersion: number, bridge: EnvNativeBridge, nodeBinding?: any): Env;
+    createFunction(envObject: Env, napiCallback: (env: napi_env, info: napi_callback_info) => void_p, data: number | bigint, name: string, dynamicExecution: boolean): Function;
+    createTrackedFinalizer(envObject: Env, finalize_callback: napi_finalize, finalize_data: void_p, finalize_hint: void_p): TrackedFinalizer;
+    getCurrentScope(): HandleScope;
+    openScope(envObject: Env): HandleScope;
+    closeScope(envObject: Env, scope?: HandleScope): void;
+    getEnv(env: napi_env): Env | undefined;
+    getRef(ref: napi_ref): Reference | undefined;
+    getHandleScope(scope: napi_handle_scope): HandleScope | undefined;
+    getCallbackInfo(info: napi_callback_info): ICallbackInfo;
+    napiValueFromJsValue(value: unknown): number | bigint;
+    jsValueFromNapiValue<T = any>(napiValue: number | bigint): T | undefined;
+    createExternal(data: number | bigint): External_2;
+    getExternalValue(external: External_2): number | bigint;
+    isExternal(value: unknown): boolean;
+    addCleanupHook(envObject: Env, fn: CleanupHookCallbackFunction, arg: number): void;
+    removeCleanupHook(envObject: Env, fn: CleanupHookCallbackFunction, arg: number): void;
+    runCleanup(): void;
+    increaseWaitingRequestCounter(): void;
+    decreaseWaitingRequestCounter(): void;
+    setCanCallIntoJs(value: boolean): void;
+    setStopping(value: boolean): void;
+    canCallIntoJs(): boolean;
+    getDylinkMetadata(binary: WebAssembly.Module | Uint8Array): DylinkMetadata;
+    destroy(): void;
+}
+
+export declare interface ContextOptions extends IsolateOptions {
+}
+
+export declare class CountIdAllocator extends Disposable_2 implements IdAllocator {
+    next: number;
+    constructor(initialNext?: number);
+    aquire(): number;
+    release(_: number): void;
+    dispose(): void;
+}
+
+export declare class CountIdReuseAllocator extends CountIdAllocator implements IdAllocator {
+    private _freeList;
+    aquire(): number;
+    release(id: number): void;
+    dispose(): void;
+}
+
+export declare function createContext(options?: ContextOptions): Context;
+
+export declare function deletePrivate(obj: any, key: Private): boolean;
+
+declare abstract class Disposable_2 implements globalThis.Disposable {
+    abstract dispose(): void;
+    [Symbol.dispose](): void;
+}
+export { Disposable_2 as Disposable }
+
+export declare interface DylinkMetadata {
+    neededDynlibs: string[];
+    tlsExports: Set<string>;
+    weakImports: Set<string>;
+    runtimePaths: string[];
+    memorySize: number;
+    memoryAlign: number;
+    tableSize: number;
+    tableAlign: number;
+}
+
+export declare class EmnapiError extends Error {
+    constructor(message?: string);
+}
+
+export declare abstract class Env extends Disposable_2 {
+    id: number | bigint;
+    openHandleScopes: number;
+    instanceData: TrackedFinalizer | null;
+    lastException: Persistent<any>;
+    refs: number;
+    reflist: RefTracker;
+    finalizing_reflist: RefTracker;
+    pendingFinalizers: RefTracker[];
+    moduleApiVersion: number;
+    filename: string;
+    nodeBinding?: any;
+    inGcFinalizer: boolean;
+    bridge: EnvNativeBridge;
+    readonly ctx: Context;
+    private store;
+    constructor(ctx: Context, store: ArrayStore<Env>, bridge: EnvNativeBridge);
+    canCallIntoJs(): boolean;
+    terminatedOrTerminating(): boolean;
+    ref(): void;
+    unref(): void;
+    clearLastError(): napi_status;
+    setLastError(error_code: napi_status, engine_error_code?: uint32_t, engine_reserved?: number): napi_status;
+    callIntoModule<T>(fn: (env: Env) => T, handleException?: (envObject: Env, value: any) => void): T;
+    abstract callFinalizer(cb: napi_finalize, data: void_p, hint: void_p): void;
+    invokeFinalizerFromGC(finalizer: RefTracker): void;
+    checkGCAccess(): void;
+    enqueueFinalizer(finalizer: RefTracker): void;
+    dequeueFinalizer(finalizer: RefTracker): void;
+    deleteMe(): void;
+    dispose(): void;
+    private readonly _bindingMap;
+    initObjectBinding<S extends object>(value: S): IReferenceBinding;
+    getObjectBinding<S extends object>(value: S): IReferenceBinding;
+    setInstanceData(data: number, finalize_cb: number, finalize_hint: number): void;
+    getInstanceData(): number | bigint;
+}
+
+export declare interface EnvNativeBridge {
+    address: number;
+    deleteEnv: (ptr: number) => void;
+    setLastError: (env: napi_env, error_code: napi_status, engine_error_code: uint32_t, engine_reserved: number) => void;
+    makeDynCall_vppp: (cb: Ptr) => (a: Ptr, b: Ptr, c: Ptr) => void;
+    makeDynCall_vp: (cb: Ptr) => (a: Ptr) => void;
+    abort: (msg?: string) => never;
+    wasm64?: boolean;
+}
+
+declare interface External_2 extends Record<any, any> {
+}
+
+declare const External_2: {
+    new (value: number | bigint): External_2;
+    prototype: null;
+};
+export { External_2 as External }
+
+export declare interface Features {
+    makeDynamicFunction: ((...args: any[]) => Function) | undefined;
+    getGlobalThis: () => typeof globalThis;
+    setFunctionName: ((fn: Function, name: string) => void) | undefined;
+    Reflect: typeof Reflect | undefined;
+    finalizer: boolean;
+    weakSymbol: boolean;
+    BigInt: typeof BigInt | undefined;
+    MessageChannel: typeof MessageChannel | undefined;
+    Buffer: BufferCtor | undefined;
+    setImmediate: (callback: () => void) => any;
+    withResolvers: <T>(this: PromiseConstructor) => Resolver<T>;
+}
+
+export declare class Finalizer {
+    envObject: Env;
+    private _finalizeCallback;
+    private _finalizeData;
+    private _finalizeHint;
+    private _makeDynCall_vppp;
+    constructor(envObject: Env, _finalizeCallback?: napi_finalize, _finalizeData?: void_p, _finalizeHint?: void_p);
+    copy(): Finalizer;
+    move(target: Finalizer): void;
+    callback(): napi_finalize;
+    data(): void_p;
+    hint(): void_p;
+    resetEnv(): void;
+    resetFinalizer(): void;
+    callFinalizer(): void;
+    dispose(): void;
+}
+
+export declare class FunctionTemplate extends Template {
+    callback: (info: napi_callback_info, v8FunctionCallback: Ptr) => Ptr;
+    v8FunctionCallback: Ptr;
+    data: any;
+    className: string | undefined;
+    signature: Signature | undefined;
+    private _instanceTemplate;
+    private _prototypeTemplate;
+    private _cached;
+    constructor(ctx: Isolate, callback: (info: napi_callback_info, v8FunctionCallback: Ptr) => Ptr, v8FunctionCallback: Ptr, data: any, signature?: Signature);
+    setClassName(name: string): void;
+    instanceTemplate(): ObjectTemplate;
+    prototypeTemplate(): ObjectTemplate;
+    getFunction(): (...args: any[]) => any;
+}
+
+export declare function getDefaultContext(): Context;
+
+export declare function getDylinkMetadata(binary: WebAssembly.Module | Uint8Array): DylinkMetadata;
+
+export declare function getExternalValue(external: External_2): number | bigint;
+
+export declare function getInternalField(instance: object, index: number): any;
+
+export declare function getPrivate(obj: any, key: Private): any;
+
+export declare class HandleScope extends Disposable_2 {
+    handleStore: HandleStore;
+    id: number | bigint;
+    parent: HandleScope | null;
+    child: HandleScope | null;
+    start: number;
+    end: number;
+    private _escapeCalled;
+    callbackInfo: ICallbackInfo;
+    static create(parentScope: HandleScope | null, handleStore: HandleStore, start?: number, end?: number): HandleScope;
+    constructor(parentScope: HandleScope | null, handleStore: HandleStore, start?: number, end?: number);
+    reuse(parentScope: HandleScope): void;
+    add<V>(value: V): number;
+    addExternal(data: number | bigint): number;
+    dispose(): void;
+    escape(handle: number): number;
+    escapeCalled(): boolean;
+}
+
+export declare class HandleStore extends BaseArrayStore<any> {
+    static MIN_ID: 8;
+    private _allocator;
+    private _features;
+    readonly refValues: Map<number, PersistentValueType<any>>;
+    private _erase;
+    private _deref;
+    constructor(features: Features);
+    isOutOfScope(id: number): boolean;
+    deepDeref<R = any>(id: number | bigint): R | undefined;
+    push<S>(value: S): number;
+    erase(start: number, end: number, weak: boolean): void;
+    swap(a: number, b: number): void;
+}
+
+export declare function hasPrivate(obj: any, key: Private): boolean;
+
+export declare interface ICallbackInfo {
+    thiz: any;
+    holder: any;
+    data: void_p;
+    args: ArrayLike<any>;
+    fn: Function;
+}
+
+export declare interface IdAllocator extends Disposable_2 {
+    aquire(): number;
+    release(id: number): void;
+}
+
+export declare interface IReferenceBinding {
+    wrapped: number;
+    tag: Uint32Array | null;
+}
+
+export declare function isExternal(object: unknown): object is External_2;
+
+export declare class Isolate {
+    private _lastException;
+    private _globalThis;
+    private _scopeStore;
+    private _handleStore;
+    private _externalMemory;
+    globalHandleStore: PersistentStore;
+    readonly features: Features;
+    constructor(options?: IsolateOptions);
+    napiValueFromJsValue(value: unknown): number | bigint;
+    jsValueFromNapiValue<T = any>(napiValue: number | bigint): T | undefined;
+    deleteRefSlotValue(id: number | bigint): void;
+    getRefSlotValue(id: number | bigint): PersistentValueType<any>;
+    setRefSlotValue(id: number | bigint, ref: PersistentValueType<any>): void;
+    createReference<T>(...args: [T] | []): Persistent<T>;
+    insertRef<T>(persistent: Persistent<T>): void;
+    getRef<T = any>(ref: napi_ref): Persistent<T> | undefined;
+    removeRef(ref: napi_ref, force?: boolean): void;
+    getTryCatch(address: number | bigint): TryCatch | undefined;
+    pushTryCatch(address: number | bigint): TryCatch;
+    popTryCatch(address: number | bigint): void;
+    setLastException(err: any): void;
+    throwException(err: any): any;
+    hasPendingException(): boolean;
+    getAndClearLastException(): any;
+    adjustAmountOfExternalAllocatedMemory(changeInBytes: number | bigint): bigint;
+    createSignature(template: FunctionTemplate): Signature;
+    createObjectTemplate(constructor: any): ObjectTemplate;
+    setInternalField(obj: any, index: number, value: any): void;
+    getInternalField(obj: any, index: number): any;
+    getInternalFieldCount(obj: any): number;
+    createFunctionTemplate(callback: (info: napi_callback_info, v8FunctionCallback: Ptr) => Ptr, v8FunctionCallback: Ptr, data: any, signature?: Signature): FunctionTemplate;
+    isScopeEmpty(): boolean;
+    getCurrentScope(): HandleScope;
+    openScope(): HandleScope;
+    closeScope(_scope?: HandleScope): void;
+    getHandleScope(scope: napi_handle_scope): HandleScope | undefined;
+    getCallbackInfo(info: napi_callback_info): ICallbackInfo;
+    createExternal(data: number | bigint): External_2;
+    getExternalValue(external: External_2): number | bigint;
+    isExternal(value: unknown): boolean;
+    createResolver<T>(): Resolver<T>;
+    createPrivate(name: string): Private;
+    getOrCreateGlobalPrivate(name: string): Private;
+    setPrivate(obj: any, key: Private, value: any): void;
+    getPrivate(obj: any, key: Private): any;
+    hasPrivate(obj: any, key: Private): boolean;
+    deletePrivate(obj: any, key: Private): boolean;
+}
+
+export declare interface IsolateOptions {
+    features?: Partial<Features>;
+    onExternalMemoryChange?: (current: bigint, old: bigint, delta: bigint) => any;
+}
+
+export declare function isReferenceType(v: any): v is object;
+
+export declare const NAPI_VERSION_EXPERIMENTAL = Version.NAPI_VERSION_EXPERIMENTAL;
+
+export declare const NODE_API_DEFAULT_MODULE_API_VERSION = Version.NODE_API_DEFAULT_MODULE_API_VERSION;
+
+export declare const NODE_API_SUPPORTED_VERSION_MAX = Version.NODE_API_SUPPORTED_VERSION_MAX;
+
+export declare const NODE_API_SUPPORTED_VERSION_MIN = Version.NODE_API_SUPPORTED_VERSION_MIN;
+
+export declare class NodeEnv extends Env {
+    destructing: boolean;
+    finalizationScheduled: boolean;
+    constructor(ctx: Context, store: ArrayStore<Env>, bridge: EnvNativeBridge);
+    deleteMe(): void;
+    canCallIntoJs(): boolean;
+    triggerFatalException(err: any): void;
+    callbackIntoModule<T>(enforceUncaughtExceptionPolicy: boolean, fn: (env: Env) => T): T;
+    callFinalizer(cb: napi_finalize, data: void_p, hint: void_p): void;
+    callFinalizerInternal(forceUncaught: int, cb: napi_finalize, data: void_p, hint: void_p): void;
+    enqueueFinalizer(finalizer: RefTracker): void;
+    drainFinalizerQueue(): void;
+}
+
+export declare class NotSupportBufferError extends EmnapiError {
+    constructor(api: string, message: string);
+}
+
+export declare class NotSupportWeakRefError extends EmnapiError {
+    constructor(api: string, message: string);
+}
+
+export declare interface ObjectAllocator<T> extends Disposable_2 {
+    deref<R extends T = T>(id: number | bigint): R | undefined;
+    alloc<P extends any[]>(factory: (...args: P) => T, ...args: P): T;
+    dealloc(id: number | bigint): void;
+}
+
+export declare class ObjectTemplate extends Template {
+    Ctor: any;
+    internalFieldCount: number;
+    private _accessors;
+    constructor(ctx: Isolate, Ctor?: any);
+    setAccessor(name: string | symbol, getterWrap: (property: Ptr, info: Ptr, getter: Ptr) => Ptr, setterWrap: (property: Ptr, value: Ptr, info: Ptr, setter: Ptr) => Ptr, getter: Ptr, setter: Ptr, data: any, attribute: number, getterSideEffectType: number, setterSideEffectType: number): void;
+    setInternalFieldCount(value: number): void;
+    applyToInstance(instance: any): void;
+    newInstance(_context: any): any;
+}
+
+export declare class Persistent<T> extends Disposable_2 {
+    private _param;
+    private _callback;
+    private _isolate;
+    id: number;
+    private static readonly _registry;
+    constructor(isolate: Isolate, ...args: [T] | []);
+    dispose(): void;
+    copy(): Persistent<T>;
+    move(to: Persistent<T>): void;
+    slot(): number;
+    getSlot(): PersistentValueType<T>;
+    setSlot(ref: PersistentValueType<T>): void;
+    deleteSlot(): void;
+    setWeak<P>(param: P, callback: (param: P) => void): void;
+    clearWeak(): void;
+    reset(): void;
+    resetTo(value: T): void;
+    isEmpty(): boolean;
+    deref(): T | undefined;
+}
+
+export declare class PersistentStore extends ArrayStore<Persistent<any>> {
+    private _recyleList;
+    constructor(initialCapacity?: number);
+    markUnused(id: number | bigint): void;
+    recycle(): void;
+}
+
+export declare type PersistentValueType<T> = StrongRef<T> | WeakRef<T extends object ? T : never> | undefined;
+
+export declare class Private {
+    private _name;
+    constructor(name: string);
+    name(): string;
+    static forApi(name: string): Private;
+}
+
+export declare class Reference extends RefTracker {
+    private static weakCallback;
+    id: number;
+    envObject: Env | undefined;
+    private ctx;
+    private canBeWeak;
+    private _refcount;
+    private _ownership;
+    static create(ctx: Context, envObject: Env, handle_id: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership, _unused1?: void_p, _unused2?: void_p, _unused3?: void_p): Reference;
+    constructor(ctx: Context, envObject: Env, handle_id: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership);
+    getPersistent(): Persistent<any>;
+    ref(): number;
+    unref(): number;
+    deref(): any;
+    get(): napi_value;
+    resetFinalizer(): void;
+    data(): void_p;
+    refcount(): number;
+    ownership(): ReferenceOwnership;
+    protected callUserFinalizer(): void;
+    protected invokeFinalizerFromGC(): void;
+    private _setWeak;
+    setWeakWithData<T>(data: T, callback: (data: T) => void): void;
+    clearWeak(): void;
+    finalize(): void;
+    dispose(): void;
+}
+
+export declare enum ReferenceOwnership {
+    kRuntime = 0,
+    kUserland = 1
+}
+
+export declare class ReferenceWithData extends Reference {
+    private _data;
+    static create(ctx: Context, envObject: Env, value: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership, data: void_p): ReferenceWithData;
+    constructor(ctx: Context, envObject: Env, value: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership, data: void_p);
+    data(): void_p;
+}
+
+export declare class ReferenceWithFinalizer extends Reference {
+    private _finalizer;
+    static create(ctx: Context, envObject: Env, value: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership, finalize_callback: napi_finalize, finalize_data: void_p, finalize_hint: void_p): ReferenceWithFinalizer;
+    constructor(ctx: Context, envObject: Env, value: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership, finalize_callback: napi_finalize, finalize_data: void_p, finalize_hint: void_p);
+    resetFinalizer(): void;
+    data(): void_p;
+    protected callUserFinalizer(): void;
+    protected invokeFinalizerFromGC(): void;
+    dispose(): void;
+}
+
+export declare class RefTracker extends Disposable_2 {
+    dispose(): void;
+    finalize(): void;
+    protected _next: RefTracker | null;
+    protected _prev: RefTracker | null;
+    link(list: RefTracker): void;
+    unlink(): void;
+    static finalizeAll(list: RefTracker): void;
+}
+
+export declare interface Resolver<T> {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+}
+
+export declare interface ReusableStoreValue extends Disposable_2 {
+    reuse(...args: any[]): void;
+}
+
+export declare class ScopeStore extends BaseArrayStore<HandleScope> {
+    private readonly _rootScope;
+    currentScope: HandleScope;
+    constructor();
+    openScope(handleStore: HandleStore): HandleScope;
+    closeScope(): void;
+    isEmpty(): boolean;
+}
+
+export declare function setInternalField(instance: object, index: number, value: any): void;
+
+export declare function setPrivate(obj: any, key: Private, value: any): void;
+
+export declare class Signature {
+    receiver: FunctionTemplate | undefined;
+    constructor(receiver: FunctionTemplate | undefined);
+}
+
+export declare class StrongRef<T> extends Disposable_2 {
+    private _value;
+    constructor(value: T);
+    deref(): T;
+    dispose(): void;
+}
+
+export declare class Template {
+    protected ctx: Isolate;
+    protected _properties: Map<string | symbol, [any, number]>;
+    constructor(ctx: Isolate);
+    set(name: string | symbol, value: any, attr: number): void;
+    protected _addPropertiesToInstance(instance: any): void;
+}
+
+export declare class TrackedFinalizer extends RefTracker {
+    private _finalizer;
+    static create(envObject: Env, finalize_callback: napi_finalize, finalize_data: void_p, finalize_hint: void_p): TrackedFinalizer;
+    private constructor();
+    data(): void_p;
+    dispose(): void;
+    finalize(): void;
+}
+
+export declare class TryCatch {
+    static top: TryCatch | null;
+    private static _map;
+    id: number | bigint;
+    private _exception;
+    private _caught;
+    private _next;
+    constructor(id: number | bigint);
+    static deref(id: number | bigint): TryCatch | undefined;
+    static pop(): void;
+    isEmpty(): boolean;
+    hasCaught(): boolean;
+    exception(): any;
+    rethrow(ctx: Isolate): any;
+    setError(err: any): void;
+    reset(): void;
+    extractException(): any;
+}
+
+export declare const version: string;
+
+export { }