@types/node 12.20.41 → 13.1.2

node v12.20/dgram.d.ts → node/dgram.d.ts

@@ -1,7 +1,7 @@
-declare module 'dgram' {
-    import { AddressInfo } from 'net';
-    import * as dns from 'dns';
-    import EventEmitter = require('events');
+declare module "dgram" {
+    import { AddressInfo } from "net";
+    import * as dns from "dns";
+    import * as events from "events";
 
     interface RemoteInfo {
         address: string;
@@ -11,37 +11,37 @@ declare module 'dgram' {
     }
 
     interface BindOptions {
-        port?: number | undefined;
-        address?: string | undefined;
-        exclusive?: boolean | undefined;
-        fd?: number | undefined;
+        port?: number;
+        address?: string;
+        exclusive?: boolean;
+        fd?: number;
     }
 
     type SocketType = "udp4" | "udp6";
 
     interface SocketOptions {
         type: SocketType;
-        reuseAddr?: boolean | undefined;
+        reuseAddr?: boolean;
         /**
          * @default false
          */
-        ipv6Only?: boolean | undefined;
-        recvBufferSize?: number | undefined;
-        sendBufferSize?: number | undefined;
-        lookup?: ((hostname: string, options: dns.LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void) => void) | undefined;
+        ipv6Only?: boolean;
+        recvBufferSize?: number;
+        sendBufferSize?: number;
+        lookup?: (hostname: string, options: dns.LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void) => void;
     }
 
     function createSocket(type: SocketType, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
     function createSocket(options: SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
 
-    class Socket extends EventEmitter {
+    class Socket extends events.EventEmitter {
         addMembership(multicastAddress: string, multicastInterface?: string): void;
         address(): AddressInfo;
-        bind(port?: number, address?: string, callback?: () => void): this;
-        bind(port?: number, callback?: () => void): this;
-        bind(callback?: () => void): this;
-        bind(options: BindOptions, callback?: () => void): this;
-        close(callback?: () => void): this;
+        bind(port?: number, address?: string, callback?: () => void): void;
+        bind(port?: number, callback?: () => void): void;
+        bind(callback?: () => void): void;
+        bind(options: BindOptions, callback?: () => void): void;
+        close(callback?: () => void): void;
         connect(port: number, address?: string, callback?: () => void): void;
         connect(port: number, callback: () => void): void;
         disconnect(): void;
@@ -50,20 +50,43 @@ declare module 'dgram' {
         getSendBufferSize(): number;
         ref(): this;
         remoteAddress(): AddressInfo;
-        send(msg: string | Uint8Array | ReadonlyArray<any>, port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
-        send(msg: string | Uint8Array | ReadonlyArray<any>, port?: number, callback?: (error: Error | null, bytes: number) => void): void;
-        send(msg: string | Uint8Array | ReadonlyArray<any>, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | Uint8Array | any[], port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | Uint8Array | any[], port?: number, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | Uint8Array | any[], callback?: (error: Error | null, bytes: number) => void): void;
         send(msg: string | Uint8Array, offset: number, length: number, port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
         send(msg: string | Uint8Array, offset: number, length: number, port?: number, callback?: (error: Error | null, bytes: number) => void): void;
         send(msg: string | Uint8Array, offset: number, length: number, callback?: (error: Error | null, bytes: number) => void): void;
         setBroadcast(flag: boolean): void;
         setMulticastInterface(multicastInterface: string): void;
-        setMulticastLoopback(flag: boolean): boolean;
-        setMulticastTTL(ttl: number): number;
+        setMulticastLoopback(flag: boolean): void;
+        setMulticastTTL(ttl: number): void;
         setRecvBufferSize(size: number): void;
         setSendBufferSize(size: number): void;
-        setTTL(ttl: number): number;
+        setTTL(ttl: number): void;
         unref(): this;
+        /**
+         * Tells the kernel to join a source-specific multicast channel at the given
+         * `sourceAddress` and `groupAddress`, using the `multicastInterface` with the
+         * `IP_ADD_SOURCE_MEMBERSHIP` socket option.
+         * If the `multicastInterface` argument
+         * is not specified, the operating system will choose one interface and will add
+         * membership to it.
+         * To add membership to every available interface, call
+         * `socket.addSourceSpecificMembership()` multiple times, once per interface.
+         */
+        addSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;
+
+        /**
+         * Instructs the kernel to leave a source-specific multicast channel at the given
+         * `sourceAddress` and `groupAddress` using the `IP_DROP_SOURCE_MEMBERSHIP`
+         * socket option. This method is automatically called by the kernel when the
+         * socket is closed or the process terminates, so most apps will never have
+         * reason to call this.
+         *
+         * If `multicastInterface` is not specified, the operating system will attempt to
+         * drop membership on all valid interfaces.
+         */
+        dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;
 
         /**
          * events.EventEmitter

node v12.20/dns.d.ts → node/dns.d.ts

@@ -1,17 +1,17 @@
-declare module 'dns' {
+declare module "dns" {
     // Supported getaddrinfo flags.
     const ADDRCONFIG: number;
     const V4MAPPED: number;
 
     interface LookupOptions {
-        family?: number | undefined;
-        hints?: number | undefined;
-        all?: boolean | undefined;
-        verbatim?: boolean | undefined;
+        family?: number;
+        hints?: number;
+        all?: boolean;
+        verbatim?: boolean;
     }
 
     interface LookupOneOptions extends LookupOptions {
-        all?: false | undefined;
+        all?: false;
     }
 
     interface LookupAllOptions extends LookupOptions {
@@ -271,12 +271,7 @@ declare module 'dns' {
     const ADDRGETNETWORKPARAMS: string;
     const CANCELLED: string;
 
-    interface ResolverOptions {
-        timeout?: number | undefined;
-    }
-
     class Resolver {
-        constructor(options?: ResolverOptions);
         getServers: typeof getServers;
         setServers: typeof setServers;
         resolve: typeof resolve;
@@ -351,7 +346,6 @@ declare module 'dns' {
         function setServers(servers: ReadonlyArray<string>): void;
 
         class Resolver {
-            constructor(options?: ResolverOptions);
             getServers: typeof getServers;
             resolve: typeof resolve;
             resolve4: typeof resolve4;

node v12.20/domain.d.ts → node/domain.d.ts

@@ -1,5 +1,5 @@
-declare module 'domain' {
-    import EventEmitter = require('events');
+declare module "domain" {
+    import { EventEmitter } from "events";
 
     class Domain extends EventEmitter implements NodeJS.Domain {
         run<T>(fn: (...args: any[]) => T, ...args: any[]): T;

node/events.d.ts

@@ -0,0 +1,40 @@
+declare module "events" {
+    interface internal extends NodeJS.EventEmitter {}
+    class internal { }
+
+    interface NodeEventTarget {
+        once(event: string | symbol, listener: (...args: any[]) => void): this;
+    }
+
+    interface DOMEventTarget {
+        addEventListener(event: string, listener: (...args: any[]) => void, opts?: { once: boolean }): any;
+    }
+
+    namespace internal {
+        function once(emitter: NodeEventTarget, event: string | symbol): Promise<any[]>;
+        function once(emitter: DOMEventTarget, event: string): Promise<any[]>;
+         class EventEmitter extends internal {
+            /** @deprecated since v4.0.0 */
+            static listenerCount(emitter: EventEmitter, event: string | symbol): number;
+            static defaultMaxListeners: number;
+
+            addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            on(event: string | symbol, listener: (...args: any[]) => void): this;
+            once(event: string | symbol, listener: (...args: any[]) => void): this;
+            prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            off(event: string | symbol, listener: (...args: any[]) => void): this;
+            removeAllListeners(event?: string | symbol): this;
+            setMaxListeners(n: number): this;
+            getMaxListeners(): number;
+            listeners(event: string | symbol): Function[];
+            rawListeners(event: string | symbol): Function[];
+            emit(event: string | symbol, ...args: any[]): boolean;
+            eventNames(): Array<string | symbol>;
+            listenerCount(type: string | symbol): number;
+        }
+    }
+
+    export = internal;
+}