@types/node 14.18.6 → 15.0.0

node/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/node`
+
+# Summary
+This package contains type definitions for Node.js (http://nodejs.org/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
+
+### Additional Details
+ * Last updated: Mon, 26 Apr 2021 19:31:25 GMT
+ * Dependencies: none
+ * Global values: `AbortController`, `AbortSignal`, `Buffer`, `__dirname`, `__filename`, `clearImmediate`, `clearInterval`, `clearTimeout`, `console`, `exports`, `global`, `module`, `process`, `queueMicrotask`, `require`, `setImmediate`, `setInterval`, `setTimeout`
+
+# Credits
+These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [DefinitelyTyped](https://github.com/DefinitelyTyped), [Alberto Schiabel](https://github.com/jkomyno), [Alvis HT Tang](https://github.com/alvis), [Andrew Makarov](https://github.com/r3nya), [Benjamin Toueg](https://github.com/btoueg), [Bruno Scheufler](https://github.com/brunoscheufler), [Chigozirim C.](https://github.com/smac89), [David Junger](https://github.com/touffy), [Deividas Bakanas](https://github.com/DeividasBakanas), [Eugene Y. Q. Shen](https://github.com/eyqs), [Hannes Magnusson](https://github.com/Hannes-Magnusson-CK), [Hoàng Văn Khải](https://github.com/KSXGitHub), [Huw](https://github.com/hoo29), [Kelvin Jin](https://github.com/kjin), [Klaus Meinhardt](https://github.com/ajafff), [Lishude](https://github.com/islishude), [Mariusz Wiktorczyk](https://github.com/mwiktorczyk), [Mohsen Azimi](https://github.com/mohsen1), [Nicolas Even](https://github.com/n-e), [Nikita Galkin](https://github.com/galkin), [Parambir Singh](https://github.com/parambirs), [Sebastian Silbermann](https://github.com/eps1lon), [Simon Schick](https://github.com/SimonSchick), [Thomas den Hollander](https://github.com/ThomasdenH), [Wilco Bakker](https://github.com/WilcoBakker), [wwwy3y3](https://github.com/wwwy3y3), [Samuel Ainsworth](https://github.com/samuela), [Kyle Uehlein](https://github.com/kuehlein), [Thanik Bhongbhibhat](https://github.com/bhongy), [Marcin Kopacz](https://github.com/chyzwar), [Trivikram Kamat](https://github.com/trivikr), [Minh Son Nguyen](https://github.com/nguymin4), [Junxiao Shi](https://github.com/yoursunny), [Ilia Baryshnikov](https://github.com/qwelias), [ExE Boss](https://github.com/ExE-Boss), [Surasak Chaisurin](https://github.com/Ryan-Willpower), [Piotr Błażejewicz](https://github.com/peterblazejewicz), [Anna Henningsen](https://github.com/addaleax), [Jason Kwok](https://github.com/JasonHK), [Victor Perin](https://github.com/victorperin), and [Yongsheng Zhang](https://github.com/ZYSzys).

node/assert/strict.d.ts

@@ -0,0 +1,4 @@
+declare module 'assert/strict' {
+    import { strict } from 'assert';
+    export = strict;
+}

node v14.18/assert.d.ts → node/assert.d.ts

@@ -1,3 +1,8 @@
+declare module 'node:assert' {
+    import assert = require('assert');
+    export = assert;
+}
+
 declare module 'assert' {
     /** An alias of `assert.ok()`. */
     function assert(value: any, message?: string | Error): asserts value;
@@ -11,16 +16,16 @@ declare module 'assert' {
 
             constructor(options?: {
                 /** If provided, the error message is set to this value. */
-                message?: string | undefined;
+                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 | undefined;
+                operator?: string;
                 /** If provided, the generated stack trace omits frames before this function. */
                 // tslint:disable-next-line:ban-types
-                stackStartFn?: Function | undefined;
+                stackStartFn?: Function;
             });
         }
 
@@ -122,7 +127,3 @@ declare module 'assert' {
 
     export = assert;
 }
-declare module 'node:assert' {
-    import assert = require('assert');
-    export = assert;
-}

node v14.18/async_hooks.d.ts → node/async_hooks.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Async Hooks module: https://nodejs.org/api/async_hooks.html
+ */
+declare module 'node:async_hooks' {
+    export * from 'async_hooks';
+}
+
 /**
  * Async Hooks module: https://nodejs.org/api/async_hooks.html
  */
@@ -85,18 +92,18 @@ declare module 'async_hooks' {
     interface AsyncResourceOptions {
       /**
        * The ID of the execution context that created this async event.
-       * @default executionAsyncId()
+       * Default: `executionAsyncId()`
        */
-      triggerAsyncId?: number | undefined;
+      triggerAsyncId?: number;
 
       /**
        * Disables automatic `emitDestroy` when the object is garbage collected.
        * This usually does not need to be set (even if `emitDestroy` is called
        * manually), unless the resource's `asyncId` is retrieved and the
        * sensitive API's `emitDestroy` is called with it.
-       * @default false
+       * Default: `false`
        */
-      requireManualDestroy?: boolean | undefined;
+      requireManualDestroy?: boolean;
     }
 
     /**
@@ -224,6 +231,3 @@ declare module 'async_hooks' {
         enterWith(store: T): void;
     }
 }
-declare module 'node:async_hooks' {
-    export * from 'async_hooks';
-}

node/base.d.ts

@@ -0,0 +1,19 @@
+// NOTE: These definitions support NodeJS and TypeScript 3.7.
+
+// NOTE: TypeScript version-specific augmentations can be found in the following paths:
+//          - ~/base.d.ts         - Shared definitions common to all TypeScript versions
+//          - ~/index.d.ts        - Definitions specific to TypeScript 2.1
+//          - ~/ts3.7/base.d.ts   - Definitions specific to TypeScript 3.7
+//          - ~/ts3.7/index.d.ts  - Definitions specific to TypeScript 3.7 with assert pulled in
+
+// Reference required types from the default lib:
+/// <reference lib="es2018" />
+/// <reference lib="esnext.asynciterable" />
+/// <reference lib="esnext.intl" />
+/// <reference lib="esnext.bigint" />
+
+// Base definitions for all NodeJS modules that are not specific to any version of TypeScript:
+/// <reference path="ts3.6/base.d.ts" />
+
+// TypeScript 3.7-specific augmentations:
+/// <reference path="assert.d.ts" />

node v14.18/buffer.d.ts → node/buffer.d.ts

@@ -1,3 +1,7 @@
+declare module 'node:buffer' {
+    export * from 'buffer';
+}
+
 declare module 'buffer' {
     export const INSPECT_MAX_BYTES: number;
     export const kMaxLength: number;
@@ -20,6 +24,3 @@ declare module 'buffer' {
 
     export { BuffType as Buffer };
 }
-declare module 'node:buffer' {
-    export * from 'buffer';
-}

node v14.18/child_process.d.ts → node/child_process.d.ts

@@ -1,8 +1,12 @@
+declare module 'node:child_process' {
+    export * from 'child_process';
+}
+
 declare module 'child_process' {
-    import { BaseEncodingOptions } from 'fs';
-    import * as events from 'events';
-    import * as net from 'net';
-    import { Writable, Readable, Stream, Pipe } from 'stream';
+    import { BaseEncodingOptions } from 'node:fs';
+    import * as events from 'node:events';
+    import * as net from 'node:net';
+    import { Writable, Readable, Stream, Pipe } from 'node:stream';
 
     type Serializable = string | object | number | boolean;
     type SendHandle = net.Socket | net.Server;
@@ -11,7 +15,7 @@ declare module 'child_process' {
         stdin: Writable | null;
         stdout: Readable | null;
         stderr: Readable | null;
-        readonly channel?: Pipe | null | undefined;
+        readonly channel?: Pipe | null;
         readonly stdio: [
             Writable | null, // stdin
             Readable | null, // stdout
@@ -119,7 +123,7 @@ declare module 'child_process' {
     }
 
     interface MessageOptions {
-        keepOpen?: boolean | undefined;
+        keepOpen?: boolean;
     }
 
     type StdioOptions = "pipe" | "ignore" | "inherit" | Array<("pipe" | "ipc" | "ignore" | "inherit" | Stream | number | null | undefined)>;
@@ -131,40 +135,40 @@ declare module 'child_process' {
          * Specify the kind of serialization used for sending messages between processes.
          * @default 'json'
          */
-        serialization?: SerializationType | undefined;
+        serialization?: SerializationType;
     }
 
     interface ProcessEnvOptions {
-        uid?: number | undefined;
-        gid?: number | undefined;
-        cwd?: string | undefined;
-        env?: NodeJS.ProcessEnv | undefined;
+        uid?: number;
+        gid?: number;
+        cwd?: string;
+        env?: NodeJS.ProcessEnv;
     }
 
     interface CommonOptions extends ProcessEnvOptions {
         /**
          * @default true
          */
-        windowsHide?: boolean | undefined;
+        windowsHide?: boolean;
         /**
          * @default 0
          */
-        timeout?: number | undefined;
+        timeout?: number;
     }
 
     interface CommonSpawnOptions extends CommonOptions, MessagingOptions {
-        argv0?: string | undefined;
-        stdio?: StdioOptions | undefined;
-        shell?: boolean | string | undefined;
-        windowsVerbatimArguments?: boolean | undefined;
+        argv0?: string;
+        stdio?: StdioOptions;
+        shell?: boolean | string;
+        windowsVerbatimArguments?: boolean;
     }
 
     interface SpawnOptions extends CommonSpawnOptions {
-        detached?: boolean | undefined;
+        detached?: boolean;
     }
 
     interface SpawnOptionsWithoutStdio extends SpawnOptions {
-        stdio?: 'pipe' | Array<null | undefined | 'pipe'> | undefined;
+        stdio?: 'pipe' | Array<null | undefined | 'pipe'>;
     }
 
     type StdioNull = 'inherit' | 'ignore' | Stream;
@@ -263,9 +267,9 @@ declare module 'child_process' {
     function spawn(command: string, args: ReadonlyArray<string>, options: SpawnOptions): ChildProcess;
 
     interface ExecOptions extends CommonOptions {
-        shell?: string | undefined;
-        maxBuffer?: number | undefined;
-        killSignal?: NodeJS.Signals | number | undefined;
+        shell?: string;
+        maxBuffer?: number;
+        killSignal?: NodeJS.Signals | number;
     }
 
     interface ExecOptionsWithStringEncoding extends ExecOptions {
@@ -277,10 +281,10 @@ declare module 'child_process' {
     }
 
     interface ExecException extends Error {
-        cmd?: string | undefined;
-        killed?: boolean | undefined;
-        code?: number | undefined;
-        signal?: NodeJS.Signals | undefined;
+        cmd?: string;
+        killed?: boolean;
+        code?: number;
+        signal?: NodeJS.Signals;
     }
 
     // no `options` definitely means stdout/stderr are `string`.
@@ -324,10 +328,10 @@ declare module 'child_process' {
     }
 
     interface ExecFileOptions extends CommonOptions {
-        maxBuffer?: number | undefined;
-        killSignal?: NodeJS.Signals | number | undefined;
-        windowsVerbatimArguments?: boolean | undefined;
-        shell?: boolean | string | undefined;
+        maxBuffer?: number;
+        killSignal?: NodeJS.Signals | number;
+        windowsVerbatimArguments?: boolean;
+        shell?: boolean | string;
     }
     interface ExecFileOptionsWithStringEncoding extends ExecFileOptions {
         encoding: BufferEncoding;
@@ -428,71 +432,71 @@ declare module 'child_process' {
     }
 
     interface ForkOptions extends ProcessEnvOptions, MessagingOptions {
-        execPath?: string | undefined;
-        execArgv?: string[] | undefined;
-        silent?: boolean | undefined;
-        stdio?: StdioOptions | undefined;
-        detached?: boolean | undefined;
-        windowsVerbatimArguments?: boolean | undefined;
+        execPath?: string;
+        execArgv?: string[];
+        silent?: boolean;
+        stdio?: StdioOptions;
+        detached?: boolean;
+        windowsVerbatimArguments?: boolean;
     }
     function fork(modulePath: string, options?: ForkOptions): ChildProcess;
     function fork(modulePath: string, args?: ReadonlyArray<string>, options?: ForkOptions): ChildProcess;
 
     interface SpawnSyncOptions extends CommonSpawnOptions {
-        input?: string | NodeJS.ArrayBufferView | undefined;
-        killSignal?: NodeJS.Signals | number | undefined;
-        maxBuffer?: number | undefined;
-        encoding?: BufferEncoding | 'buffer' | null | undefined;
+        input?: string | NodeJS.ArrayBufferView;
+        killSignal?: NodeJS.Signals | number;
+        maxBuffer?: number;
+        encoding?: BufferEncoding | 'buffer' | null;
     }
     interface SpawnSyncOptionsWithStringEncoding extends SpawnSyncOptions {
         encoding: BufferEncoding;
     }
     interface SpawnSyncOptionsWithBufferEncoding extends SpawnSyncOptions {
-        encoding?: 'buffer' | null | undefined;
+        encoding?: 'buffer' | null;
     }
     interface SpawnSyncReturns<T> {
         pid: number;
-        output: Array<T | null>;
+        output: string[];
         stdout: T;
         stderr: T;
         status: number | null;
         signal: NodeJS.Signals | null;
-        error?: Error | undefined;
+        error?: Error;
     }
     function spawnSync(command: string): SpawnSyncReturns<Buffer>;
     function spawnSync(command: string, options?: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
     function spawnSync(command: string, options?: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<Buffer>;
-    function spawnSync(command: string, options?: SpawnSyncOptions): SpawnSyncReturns<string | Buffer>;
+    function spawnSync(command: string, options?: SpawnSyncOptions): SpawnSyncReturns<Buffer>;
     function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
     function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<Buffer>;
-    function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptions): SpawnSyncReturns<string | Buffer>;
+    function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptions): SpawnSyncReturns<Buffer>;
 
     interface ExecSyncOptions extends CommonOptions {
-        input?: string | Uint8Array | undefined;
-        stdio?: StdioOptions | undefined;
-        shell?: string | undefined;
-        killSignal?: NodeJS.Signals | number | undefined;
-        maxBuffer?: number | undefined;
-        encoding?: BufferEncoding | 'buffer' | null | undefined;
+        input?: string | Uint8Array;
+        stdio?: StdioOptions;
+        shell?: string;
+        killSignal?: NodeJS.Signals | number;
+        maxBuffer?: number;
+        encoding?: BufferEncoding | 'buffer' | null;
     }
     interface ExecSyncOptionsWithStringEncoding extends ExecSyncOptions {
         encoding: BufferEncoding;
     }
     interface ExecSyncOptionsWithBufferEncoding extends ExecSyncOptions {
-        encoding?: 'buffer' | null | undefined;
+        encoding?: 'buffer' | null;
     }
     function execSync(command: string): Buffer;
-    function execSync(command: string, options: ExecSyncOptionsWithStringEncoding): string;
-    function execSync(command: string, options: ExecSyncOptionsWithBufferEncoding): Buffer;
-    function execSync(command: string, options?: ExecSyncOptions): string | Buffer;
+    function execSync(command: string, options?: ExecSyncOptionsWithStringEncoding): string;
+    function execSync(command: string, options?: ExecSyncOptionsWithBufferEncoding): Buffer;
+    function execSync(command: string, options?: ExecSyncOptions): Buffer;
 
     interface ExecFileSyncOptions extends CommonOptions {
-        input?: string | NodeJS.ArrayBufferView | undefined;
-        stdio?: StdioOptions | undefined;
-        killSignal?: NodeJS.Signals | number | undefined;
-        maxBuffer?: number | undefined;
-        encoding?: BufferEncoding | undefined;
-        shell?: boolean | string | undefined;
+        input?: string | NodeJS.ArrayBufferView;
+        stdio?: StdioOptions;
+        killSignal?: NodeJS.Signals | number;
+        maxBuffer?: number;
+        encoding?: BufferEncoding;
+        shell?: boolean | string;
     }
     interface ExecFileSyncOptionsWithStringEncoding extends ExecFileSyncOptions {
         encoding: BufferEncoding;
@@ -501,14 +505,10 @@ declare module 'child_process' {
         encoding: BufferEncoding; // specify `null`.
     }
     function execFileSync(command: string): Buffer;
-    function execFileSync(command: string, options: ExecFileSyncOptionsWithStringEncoding): string;
-    function execFileSync(command: string, options: ExecFileSyncOptionsWithBufferEncoding): Buffer;
-    function execFileSync(command: string, options?: ExecFileSyncOptions): string | Buffer;
-    function execFileSync(command: string, args: ReadonlyArray<string>): Buffer;
-    function execFileSync(command: string, args: ReadonlyArray<string>, options: ExecFileSyncOptionsWithStringEncoding): string;
-    function execFileSync(command: string, args: ReadonlyArray<string>, options: ExecFileSyncOptionsWithBufferEncoding): Buffer;
-    function execFileSync(command: string, args?: ReadonlyArray<string>, options?: ExecFileSyncOptions): string | Buffer;
-}
-declare module 'node:child_process' {
-    export * from 'child_process';
+    function execFileSync(command: string, options?: ExecFileSyncOptionsWithStringEncoding): string;
+    function execFileSync(command: string, options?: ExecFileSyncOptionsWithBufferEncoding): Buffer;
+    function execFileSync(command: string, options?: ExecFileSyncOptions): Buffer;
+    function execFileSync(command: string, args?: ReadonlyArray<string>, options?: ExecFileSyncOptionsWithStringEncoding): string;
+    function execFileSync(command: string, args?: ReadonlyArray<string>, options?: ExecFileSyncOptionsWithBufferEncoding): Buffer;
+    function execFileSync(command: string, args?: ReadonlyArray<string>, options?: ExecFileSyncOptions): Buffer;
 }

node v14.18/cluster.d.ts → node/cluster.d.ts

@@ -1,18 +1,22 @@
+declare module 'node:cluster' {
+    export * from 'cluster';
+}
+
 declare module 'cluster' {
-    import * as child from 'child_process';
-    import EventEmitter = require('events');
-    import * as net from 'net';
+    import * as child from 'node:child_process';
+    import EventEmitter = require('node:events');
+    import * as net from 'node:net';
 
     // interfaces
     interface ClusterSettings {
-        execArgv?: string[] | undefined; // default: process.execArgv
-        exec?: string | undefined;
-        args?: string[] | undefined;
-        silent?: boolean | undefined;
-        stdio?: any[] | undefined;
-        uid?: number | undefined;
-        gid?: number | undefined;
-        inspectPort?: number | (() => number) | undefined;
+        execArgv?: string[]; // default: process.execArgv
+        exec?: string;
+        args?: string[];
+        silent?: boolean;
+        stdio?: any[];
+        uid?: number;
+        gid?: number;
+        inspectPort?: number | (() => number);
     }
 
     interface Address {
@@ -99,8 +103,8 @@ declare module 'cluster' {
         schedulingPolicy: number;
         settings: ClusterSettings;
         setupMaster(settings?: ClusterSettings): void;
-        worker?: Worker | undefined;
-        workers?: NodeJS.Dict<Worker> | undefined;
+        worker?: Worker;
+        workers?: NodeJS.Dict<Worker>;
 
         readonly SCHED_NONE: number;
         readonly SCHED_RR: number;
@@ -260,6 +264,3 @@ declare module 'cluster' {
 
     function eventNames(): string[];
 }
-declare module 'node:cluster' {
-    export * from 'cluster';
-}

node v14.18/console.d.ts → node/console.d.ts

@@ -1,9 +1,9 @@
-declare module 'console' {
-    import console = require('node:console');
+declare module 'node:console' {
     export = console;
 }
-declare module 'node:console' {
-    import { InspectOptions } from 'util';
+
+declare module 'console' {
+    import { InspectOptions } from 'node:util';
 
     global {
         // This needs to be global to avoid TS2403 in case lib.dom.d.ts is present in the same build
@@ -29,16 +29,16 @@ declare module 'node:console' {
              */
             countReset(label?: string): void;
             /**
-             * The `console.debug()` function is an alias for {@link console.log}.
+             * The `console.debug()` function is an alias for {@link console.log()}.
              */
             debug(message?: any, ...optionalParams: any[]): void;
             /**
-             * Uses {@link util.inspect} on `obj` and prints the resulting string to `stdout`.
+             * Uses {@link util.inspect()} on `obj` and prints the resulting string to `stdout`.
              * This function bypasses any custom `inspect()` function defined on `obj`.
              */
             dir(obj: any, options?: InspectOptions): void;
             /**
-             * This method calls {@link console.log} passing it the arguments received. Please note that this method does not produce any XML formatting
+             * This method calls {@link console.log()} passing it the arguments received. Please note that this method does not produce any XML formatting
              */
             dirxml(...data: any[]): void;
             /**
@@ -51,7 +51,7 @@ declare module 'node:console' {
              */
             group(...label: any[]): void;
             /**
-             * The `console.groupCollapsed()` function is an alias for {@link console.group}.
+             * The `console.groupCollapsed()` function is an alias for {@link console.group()}.
              */
             groupCollapsed(...label: any[]): void;
             /**
@@ -59,7 +59,7 @@ declare module 'node:console' {
              */
             groupEnd(): void;
             /**
-             * The {@link console.info} function is an alias for {@link console.log}.
+             * The {@link console.info()} function is an alias for {@link console.log()}.
              */
             info(message?: any, ...optionalParams: any[]): void;
             /**
@@ -76,19 +76,19 @@ declare module 'node:console' {
              */
             time(label?: string): void;
             /**
-             * Stops a timer that was previously started by calling {@link console.time} and prints the result to `stdout`.
+             * Stops a timer that was previously started by calling {@link console.time()} and prints the result to `stdout`.
              */
             timeEnd(label?: string): void;
             /**
-             * For a timer that was previously started by calling {@link console.time}, prints the elapsed time and other `data` arguments to `stdout`.
+             * For a timer that was previously started by calling {@link console.time()}, prints the elapsed time and other `data` arguments to `stdout`.
              */
             timeLog(label?: string, ...data: any[]): void;
             /**
-             * Prints to `stderr` the string 'Trace :', followed by the {@link util.format} formatted message and stack trace to the current position in the code.
+             * Prints to `stderr` the string 'Trace :', followed by the {@link util.format()} formatted message and stack trace to the current position in the code.
              */
             trace(message?: any, ...optionalParams: any[]): void;
             /**
-             * The {@link console.warn} function is an alias for {@link console.error}.
+             * The {@link console.warn()} function is an alias for {@link console.error()}.
              */
             warn(message?: any, ...optionalParams: any[]): void;
 
@@ -115,15 +115,10 @@ declare module 'node:console' {
         namespace NodeJS {
             interface ConsoleConstructorOptions {
                 stdout: WritableStream;
-                stderr?: WritableStream | undefined;
-                ignoreErrors?: boolean | undefined;
-                colorMode?: boolean | 'auto' | undefined;
-                inspectOptions?: InspectOptions | undefined;
-                /**
-                 * Set group indentation
-                 * @default 2
-                 */
-                 groupIndentation?: number | undefined;
+                stderr?: WritableStream;
+                ignoreErrors?: boolean;
+                colorMode?: boolean | 'auto';
+                inspectOptions?: InspectOptions;
             }
 
             interface ConsoleConstructor {

node v14.18/constants.d.ts → node/constants.d.ts

@@ -1,8 +1,14 @@
+/** @deprecated since v6.3.0 - use constants property exposed by the relevant module instead. */
+declare module 'node:constants' {
+    import exp = require('constants');
+    export = exp;
+}
+
 /** @deprecated since v6.3.0 - use constants property exposed by the relevant module instead. */
 declare module 'constants' {
-    import { constants as osConstants, SignalConstants } from 'os';
-    import { constants as cryptoConstants } from 'crypto';
-    import { constants as fsConstants } from 'fs';
+    import { constants as osConstants, SignalConstants } from 'node:os';
+    import { constants as cryptoConstants } from 'node:crypto';
+    import { constants as fsConstants } from 'node:fs';
 
     const exp: typeof osConstants.errno &
         typeof osConstants.priority &
@@ -11,8 +17,3 @@ declare module 'constants' {
         typeof fsConstants;
     export = exp;
 }
-
-declare module 'node:constants' {
-    import constants = require('constants');
-    export = constants;
-}