typings: use AsyncWrap for derived types

typings/internalBinding/fs.d.ts

@@ -1,3 +1,4 @@
+import type { AsyncWrap } from './async_wrap';
 import { ConstantsBinding } from './constants';
 
 interface ReadFileContext {
@@ -20,6 +21,8 @@ declare namespace InternalFSBinding {
     context: ReadFileContext;
   }
 
+  interface FSReqCallback<ResultType = unknown> extends AsyncWrap {}
+
   interface FSSyncContext {
     fd?: number;
     path?: string;
@@ -39,12 +42,13 @@ declare namespace InternalFSBinding {
   class FileHandle {
     constructor(fd: number, offset: number, length: number);
     fd: number;
-    getAsyncId(): number;
     close(): Promise<void>;
     onread: () => void;
     stream: Stream;
   }
 
+  interface FileHandle extends AsyncWrap {}
+
   class StatWatcher {
     constructor(useBigint: boolean);
     initialized: boolean;

typings/internalBinding/fs_dir.d.ts

@@ -1,3 +1,4 @@
+import type { AsyncWrap } from './async_wrap';
 import { InternalFSBinding } from './fs';
 
 declare namespace InternalFSDirBinding {
@@ -12,6 +13,8 @@ declare namespace InternalFSDirBinding {
     close(): void;
   }
 
+  interface DirHandle extends AsyncWrap {}
+
   function opendir(path: StringOrBuffer, encoding: string, req: FSReqCallback): DirHandle;
   function opendir(path: StringOrBuffer, encoding: string): DirHandle;
   function opendirSync(path: StringOrBuffer): DirHandle;

typings/internalBinding/heap_utils.d.ts

@@ -1,7 +1,8 @@
+import type { AsyncWrap } from './async_wrap';
 import { owner_symbol } from './symbols';
 
 declare namespace InternalHeapUtilsBinding {
-  interface HeapSnapshotStreamHandle {
+  interface HeapSnapshotStreamHandle extends AsyncWrap {
     [owner_symbol]?: object;
     onread?: (arrayBuffer: ArrayBuffer | undefined) => void;
     readStart(): number;

typings/internalBinding/http_parser.d.ts

@@ -1,3 +1,5 @@
+import type { AsyncWrap } from './async_wrap';
+
 declare namespace InternalHttpParserBinding {
   type Buffer = Uint8Array;
   type Stream = object;
@@ -55,6 +57,8 @@ declare namespace InternalHttpParserBinding {
     unconsume(): void;
     getCurrentBuffer(): Buffer;
   }
+
+  interface HTTPParser extends AsyncWrap {}
 }
 
 export interface HttpParserBinding {

typings/internalBinding/quic.d.ts

@@ -1,3 +1,5 @@
+import type { AsyncWrap } from './async_wrap';
+
 interface QuicCallbacks {
   onEndpointClose: (context: number, status: number) => void;
   onSessionNew: (session: Session) => void;
@@ -53,10 +55,10 @@ interface EndpointOptions {
 interface SessionOptions {}
 interface SocketAddress {}
 
-interface Session {}
-interface Stream {}
+interface Session extends AsyncWrap {}
+interface Stream extends AsyncWrap {}
 
-interface Endpoint {
+interface Endpoint extends AsyncWrap {
   listen(options: SessionOptions): void;
   connect(address: SocketAddress, options: SessionOptions): Session;
   closeGracefully(): void;

typings/internalBinding/stream_pipe.d.ts

@@ -1,3 +1,5 @@
+import type { AsyncWrap } from './async_wrap';
+
 declare namespace InternalStreamPipeBinding {
   class StreamPipe {
     constructor(source: object, sink: object);
@@ -10,6 +12,8 @@ declare namespace InternalStreamPipeBinding {
     isClosed(): boolean;
     pendingWrites(): number;
   }
+
+  interface StreamPipe extends AsyncWrap {}
 }
 
 export interface StreamPipeBinding {

typings/internalBinding/worker.d.ts

@@ -1,3 +1,4 @@
+import type { AsyncWrap } from './async_wrap';
 import { InternalMessagingBinding } from './messaging';
 
 declare namespace InternalWorkerBinding {
@@ -23,6 +24,8 @@ declare namespace InternalWorkerBinding {
     loopIdleTime(): number;
     loopStartTime(): number;
   }
+
+  interface Worker extends AsyncWrap {}
 }
 
 export interface CPUProfileHandle {

typings/internalBinding/zlib.d.ts

@@ -1,3 +1,5 @@
+import type { AsyncWrap } from './async_wrap';
+
 declare namespace InternalZlibBinding {
   class ZlibBase {
     // These attributes are not used by the C++ binding, but declared on JS side.
@@ -15,6 +17,8 @@ declare namespace InternalZlibBinding {
     writeSync(flushFlag: number, input: TypedArray, inputOff: number, inputLen: number, out: TypedArray, outOff: number, outLen: number): void;
   }
 
+  interface ZlibBase extends AsyncWrap {}
+
   class Zlib extends ZlibBase {
     constructor(mode: number)
     init(windowBits: number, level: number, memLevel: number, strategy: number, writeState: Uint32Array, callback: VoidFunction, dictionary: Uint32Array): number;