@types/node 14.10.0 → 14.10.1

node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for Node.js (http://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Thu, 10 Sep 2020 17:17:10 GMT
+ * Last updated: Fri, 11 Sep 2020 16:36:27 GMT
  * Dependencies: none
  * Global values: `Buffer`, `__dirname`, `__filename`, `clearImmediate`, `clearInterval`, `clearTimeout`, `console`, `exports`, `global`, `module`, `process`, `queueMicrotask`, `require`, `setImmediate`, `setInterval`, `setTimeout`, `Symbol`
 

node/assert.d.ts

@@ -1,4 +1,5 @@
 declare module "assert" {
+    /** An alias of `assert.ok()`. */
     function assert(value: any, message?: string | Error): asserts value;
     namespace assert {
         class AssertionError implements Error {
@@ -11,11 +12,37 @@ declare module "assert" {
             code: 'ERR_ASSERTION';
 
             constructor(options?: {
-                message?: string; actual?: any; expected?: any;
-                operator?: string; stackStartFn?: Function
+                /** If provided, the error message is set to this value. */
+                message?: string;
+                /** The `actual` property on the error instance. */
+                actual?: any;
+                /** The `expected` property on the error instance. */
+                expected?: any;
+                /** The `operator` property on the error instance. */
+                operator?: string;
+                /** If provided, the generated stack trace omits frames before this function. */
+                stackStartFn?: Function
             });
         }
 
+        class CallTracker {
+            calls(exact?: number): () => void;
+            calls<Func extends (...args: any[]) => any>(fn?: Func, exact?: number): Func;
+            report(): CallTrackerReportInformation[];
+            verify(): void;
+        }
+        export interface CallTrackerReportInformation {
+            message: string;
+            /** The actual number of times the function was called. */
+            actual: number;
+            /** The number of times the function was expected to be called. */
+            expected: number;
+            /** The name of the function that is wrapped. */
+            operator: string;
+            /** A stack trace of the function. */
+            stack: object;
+        }
+
         type AssertPredicate = RegExp | (new() => object) | ((thrown: any) => boolean) | object | Error;
 
         function fail(message?: string | Error): never;

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "14.10.0",
+    "version": "14.10.1",
     "description": "TypeScript definitions for Node.js",
     "license": "MIT",
     "contributors": [
@@ -246,6 +246,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "1f84a9f206134885334a6e49e5126f4c6c26bf59a9d8d74d48900d8f383df7fb",
+    "typesPublisherContentHash": "b022f3ba74691f5df061333d238cc0b27b5f5a9bd8dadfeb49c0c8cfb41527a6",
     "typeScriptVersion": "3.1"
 }

node/ts3.1/async_hooks.d.ts

@@ -115,6 +115,19 @@ declare module "async_hooks" {
          */
         constructor(type: string, triggerAsyncId?: number|AsyncResourceOptions);
 
+        /**
+         * Binds the given function to the current execution context.
+         * @param fn The function to bind to the current execution context.
+         * @param type An optional name to associate with the underlying `AsyncResource`.
+         */
+        static bind<Func extends (...args: any[]) => any>(fn: Func, type?: string): Func & { asyncResource: AsyncResource };
+
+        /**
+         * Binds the given function to execute to this `AsyncResource`'s scope.
+         * @param fn The function to bind to the current `AsyncResource`.
+         */
+        bind<Func extends (...args: any[]) => any>(fn: Func): Func & { asyncResource: AsyncResource };
+
         /**
          * Call the provided function with the provided arguments in the
          * execution context of the async resource. This will establish the

node/ts3.1/crypto.d.ts

@@ -408,6 +408,7 @@ declare module "crypto" {
     function privateEncrypt(private_key: RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
     function getCiphers(): string[];
     function getCurves(): string[];
+    function getFips(): 1 | 0;
     function getHashes(): string[];
     class ECDH {
         private constructor();

node/ts3.1/globals.d.ts

@@ -576,7 +576,8 @@ declare namespace NodeJS {
         id: string;
         filename: string;
         loaded: boolean;
-        parent: Module | null;
+        /** @deprecated since 14.6.0 Please use `require.main` and `module.children` instead. */
+        parent: Module | null | undefined;
         children: Module[];
         /**
          * @since 11.14.0

node/ts3.1/perf_hooks.d.ts

@@ -48,74 +48,43 @@ declare module 'perf_hooks' {
         readonly bootstrapComplete: number;
 
         /**
-         * The high resolution millisecond timestamp at which cluster processing ended.
+         * The high resolution millisecond timestamp at which the Node.js process completed bootstrapping.
+         * If bootstrapping has not yet finished, the property has the value of -1.
          */
-        readonly clusterSetupEnd: number;
+        readonly environment: number;
 
         /**
-         * The high resolution millisecond timestamp at which cluster processing started.
+         * The high resolution millisecond timestamp at which the Node.js environment was initialized.
          */
-        readonly clusterSetupStart: number;
+        readonly idleTime: number;
 
         /**
-         * The high resolution millisecond timestamp at which the Node.js event loop exited.
+         * The high resolution millisecond timestamp of the amount of time the event loop has been idle
+         *  within the event loop's event provider (e.g. `epoll_wait`). This does not take CPU usage
+         * into consideration. If the event loop has not yet started (e.g., in the first tick of the main script),
+         *  the property has the value of 0.
          */
         readonly loopExit: number;
 
         /**
          * The high resolution millisecond timestamp at which the Node.js event loop started.
+         * If the event loop has not yet started (e.g., in the first tick of the main script), the property has the value of -1.
          */
         readonly loopStart: number;
 
-        /**
-         * The high resolution millisecond timestamp at which main module load ended.
-         */
-        readonly moduleLoadEnd: number;
-
-        /**
-         * The high resolution millisecond timestamp at which main module load started.
-         */
-        readonly moduleLoadStart: number;
-
-        /**
-         * The high resolution millisecond timestamp at which the Node.js process was initialized.
-         */
-        readonly nodeStart: number;
-
-        /**
-         * The high resolution millisecond timestamp at which preload module load ended.
-         */
-        readonly preloadModuleLoadEnd: number;
-
-        /**
-         * The high resolution millisecond timestamp at which preload module load started.
-         */
-        readonly preloadModuleLoadStart: number;
-
-        /**
-         * The high resolution millisecond timestamp at which third_party_main processing ended.
-         */
-        readonly thirdPartyMainEnd: number;
-
-        /**
-         * The high resolution millisecond timestamp at which third_party_main processing started.
-         */
-        readonly thirdPartyMainStart: number;
-
         /**
          * The high resolution millisecond timestamp at which the V8 platform was initialized.
          */
         readonly v8Start: number;
     }
 
-    interface Performance {
-        /**
-         * If name is not provided, removes all PerformanceFunction objects from the Performance Timeline.
-         * If name is provided, removes entries with name.
-         * @param name
-         */
-        clearFunctions(name?: string): void;
+    interface EventLoopUtilization {
+        idle: number;
+        active: number;
+        utilization: number;
+    }
 
+    interface Performance {
         /**
          * If name is not provided, removes all PerformanceMark objects from the Performance Timeline.
          * If name is provided, removes only the named mark.
@@ -123,35 +92,6 @@ declare module 'perf_hooks' {
          */
         clearMarks(name?: string): void;
 
-        /**
-         * If name is not provided, removes all PerformanceMeasure objects from the Performance Timeline.
-         * If name is provided, removes only objects whose performanceEntry.name matches name.
-         */
-        clearMeasures(name?: string): void;
-
-        /**
-         * Returns a list of all PerformanceEntry objects in chronological order with respect to performanceEntry.startTime.
-         * @return list of all PerformanceEntry objects
-         */
-        getEntries(): PerformanceEntry[];
-
-        /**
-         * Returns a list of all PerformanceEntry objects in chronological order with respect to performanceEntry.startTime
-         * whose performanceEntry.name is equal to name, and optionally, whose performanceEntry.entryType is equal to type.
-         * @param name
-         * @param type
-         * @return list of all PerformanceEntry objects
-         */
-        getEntriesByName(name: string, type?: EntryType): PerformanceEntry[];
-
-        /**
-         * Returns a list of all PerformanceEntry objects in chronological order with respect to performanceEntry.startTime
-         * whose performanceEntry.entryType is equal to type.
-         * @param type
-         * @return list of all PerformanceEntry objects
-         */
-        getEntriesByType(type: EntryType): PerformanceEntry[];
-
         /**
          * Creates a new PerformanceMark entry in the Performance Timeline.
          * A PerformanceMark is a subclass of PerformanceEntry whose performanceEntry.entryType is always 'mark',
@@ -199,6 +139,16 @@ declare module 'perf_hooks' {
          * @param fn
          */
         timerify<T extends (...optionalParams: any[]) => any>(fn: T): T;
+
+        /**
+         * eventLoopUtilization is similar to CPU utilization except that it is calculated using high precision wall-clock time.
+         * It represents the percentage of time the event loop has spent outside the event loop's event provider (e.g. epoll_wait).
+         * No other CPU idle time is taken into consideration.
+         *
+         * @param util1 The result of a previous call to eventLoopUtilization()
+         * @param util2 The result of a previous call to eventLoopUtilization() prior to util1
+         */
+        eventLoopUtilization(util1?: EventLoopUtilization, util2?: EventLoopUtilization): EventLoopUtilization;
     }
 
     interface PerformanceObserverEntryList {

node/ts3.1/process.d.ts

@@ -245,6 +245,8 @@ declare module "process" {
                 title: string;
                 arch: string;
                 platform: Platform;
+                /** @deprecated since v14.0.0 - use `require.main` instead. */
+                mainModule?: Module;
                 memoryUsage(): MemoryUsage;
                 cpuUsage(previousValue?: CpuUsage): CpuUsage;
                 nextTick(callback: Function, ...args: any[]): void;
@@ -259,6 +261,12 @@ declare module "process" {
                     tls_ocsp: boolean;
                     tls: boolean;
                 };
+                /**
+                 * @deprecated since v14.0.0 - Calling process.umask() with no argument causes
+                 * the process-wide umask to be written twice. This introduces a race condition between threads,
+                 * and is a potential security vulnerability. There is no safe, cross-platform alternative API.
+                 */
+                umask(): number;
                 /**
                  * Can only be set if not in worker thread.
                  */