@types/node 14.18.6 → 15.0.0

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

@@ -1,8 +1,26 @@
+declare module 'node:timers' {
+    export * from 'timers';
+}
+
 declare module 'timers' {
+    interface TimerOptions {
+        /**
+         * Set to `false` to indicate that the scheduled `Timeout`
+         * should not require the Node.js event loop to remain active.
+         * @default true
+         */
+        ref?: boolean;
+
+        /**
+         * An optional `AbortSignal` that can be used to cancel the scheduled `Timeout`.
+         */
+        signal?: AbortSignal;
+    }
+
     function setTimeout(callback: (...args: any[]) => void, ms?: number, ...args: any[]): NodeJS.Timeout;
     namespace setTimeout {
         function __promisify__(ms: number): Promise<void>;
-        function __promisify__<T>(ms: number, value: T): Promise<T>;
+        function __promisify__<T>(ms: number, value: T, options?: TimerOptions): Promise<T>;
     }
     function clearTimeout(timeoutId: NodeJS.Timeout): void;
     function setInterval(callback: (...args: any[]) => void, ms?: number, ...args: any[]): NodeJS.Timeout;
@@ -10,10 +28,7 @@ declare module 'timers' {
     function setImmediate(callback: (...args: any[]) => void, ...args: any[]): NodeJS.Immediate;
     namespace setImmediate {
         function __promisify__(): Promise<void>;
-        function __promisify__<T>(value: T): Promise<T>;
+        function __promisify__<T>(value: T, options?: TimerOptions): Promise<T>;
     }
     function clearImmediate(immediateId: NodeJS.Immediate): void;
 }
-declare module 'node:timers' {
-    export * from 'timers';
-}

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

@@ -1,6 +1,9 @@
+declare module 'node:tls' {
+    export * from 'tls';
+}
+
 declare module 'tls' {
-    import * as net from 'net';
-    import * as stream from 'stream';
+    import * as net from 'node:net';
 
     const CLIENT_RENEG_LIMIT: number;
     const CLIENT_RENEG_WINDOW: number;
@@ -76,7 +79,7 @@ declare module 'tls' {
         /**
          * The name property is available only when type is 'ECDH'.
          */
-        name?: string | undefined;
+        name?: string;
         /**
          * The size of parameter of an ephemeral key exchange.
          */
@@ -91,7 +94,7 @@ declare module 'tls' {
         /**
          * Optional passphrase.
          */
-        passphrase?: string | undefined;
+        passphrase?: string;
     }
 
     interface PxfObject {
@@ -102,7 +105,7 @@ declare module 'tls' {
         /**
          * Optional passphrase.
          */
-        passphrase?: string | undefined;
+        passphrase?: string;
     }
 
     interface TLSSocketOptions extends SecureContextOptions, CommonConnectionOptions {
@@ -110,22 +113,22 @@ declare module 'tls' {
          * If true the TLS socket will be instantiated in server-mode.
          * Defaults to false.
          */
-        isServer?: boolean | undefined;
+        isServer?: boolean;
         /**
          * An optional net.Server instance.
          */
-        server?: net.Server | undefined;
+        server?: net.Server;
 
         /**
          * An optional Buffer instance containing a TLS session.
          */
-        session?: Buffer | undefined;
+        session?: Buffer;
         /**
          * If true, specifies that the OCSP status request extension will be
          * added to the client hello and an 'OCSPResponse' event will be
          * emitted on the socket before establishing a secure communication
          */
-        requestOCSP?: boolean | undefined;
+        requestOCSP?: boolean;
     }
 
     class TLSSocket extends net.Socket {
@@ -151,10 +154,9 @@ declare module 'tls' {
 
         /**
          * String containing the selected ALPN protocol.
-         * Before a handshake has completed, this value is always null.
-         * When a handshake is completed but not ALPN protocol was selected, tlsSocket.alpnProtocol equals false.
+         * When ALPN has no selected protocol, tlsSocket.alpnProtocol equals false.
          */
-        alpnProtocol: string | false | null;
+        alpnProtocol?: string;
 
         /**
          * Returns an object representing the local certificate. The returned
@@ -266,7 +268,7 @@ declare module 'tls' {
          * is successfully completed.
          * @return `undefined` when socket is destroy, `false` if negotiaion can't be initiated.
          */
-        renegotiate(options: { rejectUnauthorized?: boolean | undefined, requestCert?: boolean | undefined }, callback: (err: Error | null) => void): undefined | boolean;
+        renegotiate(options: { rejectUnauthorized?: boolean, requestCert?: boolean }, callback: (err: Error | null) => void): undefined | boolean;
         /**
          * Set maximum TLS fragment size (default and maximum value is: 16384, minimum is: 512).
          * Smaller fragment size decreases buffering latency on the client: large fragments are buffered by
@@ -346,25 +348,25 @@ declare module 'tls' {
         /**
          * An optional TLS context object from tls.createSecureContext()
          */
-        secureContext?: SecureContext | undefined;
+        secureContext?: SecureContext;
 
         /**
          * When enabled, TLS packet trace information is written to `stderr`. This can be
          * used to debug TLS connection problems.
          * @default false
          */
-        enableTrace?: boolean | undefined;
+        enableTrace?: boolean;
         /**
          * If true the server will request a certificate from clients that
          * connect and attempt to verify that certificate. Defaults to
          * false.
          */
-        requestCert?: boolean | undefined;
+        requestCert?: boolean;
         /**
          * An array of strings or a Buffer naming possible ALPN protocols.
          * (Protocols should be ordered by their priority.)
          */
-        ALPNProtocols?: string[] | Uint8Array[] | Uint8Array | undefined;
+        ALPNProtocols?: string[] | Uint8Array[] | Uint8Array;
         /**
          * SNICallback(servername, cb) <Function> A function that will be
          * called if the client supports SNI TLS extension. Two arguments
@@ -374,14 +376,14 @@ declare module 'tls' {
          * SecureContext.) If SNICallback wasn't provided the default callback
          * with high-level API will be used (see below).
          */
-        SNICallback?: ((servername: string, cb: (err: Error | null, ctx: SecureContext) => void) => void) | undefined;
+        SNICallback?: (servername: string, cb: (err: Error | null, ctx: SecureContext) => void) => void;
         /**
          * If true the server will reject any connection which is not
          * authorized with the list of supplied CAs. This option only has an
          * effect if requestCert is true.
          * @default true
          */
-        rejectUnauthorized?: boolean | undefined;
+        rejectUnauthorized?: boolean;
     }
 
     interface TlsOptions extends SecureContextOptions, CommonConnectionOptions, net.ServerOpts {
@@ -391,17 +393,17 @@ declare module 'tls' {
          * the tls.Server object whenever a handshake times out. Default:
          * 120000 (120 seconds).
          */
-        handshakeTimeout?: number | undefined;
+        handshakeTimeout?: number;
         /**
          * The number of seconds after which a TLS session created by the
          * server will no longer be resumable. See Session Resumption for more
          * information. Default: 300.
          */
-        sessionTimeout?: number | undefined;
+        sessionTimeout?: number;
         /**
          * 48-bytes of cryptographically strong pseudo-random data.
          */
-        ticketKeys?: Buffer | undefined;
+        ticketKeys?: Buffer;
 
         /**
          *
@@ -430,7 +432,7 @@ declare module 'tls' {
          * in TLS 1.3. Upon failing to set pskIdentityHint `tlsClientError` will be
          * emitted with `ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED` code.
          */
-        pskIdentityHint?: string | undefined;
+        pskIdentityHint?: string;
     }
 
     interface PSKCallbackNegotation {
@@ -439,16 +441,16 @@ declare module 'tls' {
     }
 
     interface ConnectionOptions extends SecureContextOptions, CommonConnectionOptions {
-        host?: string | undefined;
-        port?: number | undefined;
-        path?: string | undefined; // Creates unix socket connection to path. If this option is specified, `host` and `port` are ignored.
-        socket?: stream.Duplex | undefined; // Establish secure connection on a given socket rather than creating a new socket
-        checkServerIdentity?: typeof checkServerIdentity | undefined;
-        servername?: string | undefined; // SNI TLS Extension
-        session?: Buffer | undefined;
-        minDHSize?: number | undefined;
-        lookup?: net.LookupFunction | undefined;
-        timeout?: number | undefined;
+        host?: string;
+        port?: number;
+        path?: string; // Creates unix socket connection to path. If this option is specified, `host` and `port` are ignored.
+        socket?: net.Socket; // Establish secure connection on a given socket rather than creating a new socket
+        checkServerIdentity?: typeof checkServerIdentity;
+        servername?: string; // SNI TLS Extension
+        session?: Buffer;
+        minDHSize?: number;
+        lookup?: net.LookupFunction;
+        timeout?: number;
         /**
          * When negotiating TLS-PSK (pre-shared keys), this function is called
          * with optional identity `hint` provided by the server or `null`
@@ -568,7 +570,7 @@ declare module 'tls' {
          * the well-known CAs curated by Mozilla. Mozilla's CAs are completely
          * replaced when CAs are explicitly specified using this option.
          */
-        ca?: string | Buffer | Array<string | Buffer> | undefined;
+        ca?: string | Buffer | Array<string | Buffer>;
         /**
          *  Cert chains in PEM format. One cert chain should be provided per
          *  private key. Each cert chain should consist of the PEM formatted
@@ -580,29 +582,29 @@ declare module 'tls' {
          *  intermediate certificates are not provided, the peer will not be
          *  able to validate the certificate, and the handshake will fail.
          */
-        cert?: string | Buffer | Array<string | Buffer> | undefined;
+        cert?: string | Buffer | Array<string | Buffer>;
         /**
          *  Colon-separated list of supported signature algorithms. The list
          *  can contain digest algorithms (SHA256, MD5 etc.), public key
          *  algorithms (RSA-PSS, ECDSA etc.), combination of both (e.g
          *  'RSA+SHA384') or TLS v1.3 scheme names (e.g. rsa_pss_pss_sha512).
          */
-        sigalgs?: string | undefined;
+        sigalgs?: string;
         /**
          * Cipher suite specification, replacing the default. For more
          * information, see modifying the default cipher suite. Permitted
          * ciphers can be obtained via tls.getCiphers(). Cipher names must be
          * uppercased in order for OpenSSL to accept them.
          */
-        ciphers?: string | undefined;
+        ciphers?: string;
         /**
          * Name of an OpenSSL engine which can provide the client certificate.
          */
-        clientCertEngine?: string | undefined;
+        clientCertEngine?: string;
         /**
          * PEM formatted CRLs (Certificate Revocation Lists).
          */
-        crl?: string | Buffer | Array<string | Buffer> | undefined;
+        crl?: string | Buffer | Array<string | Buffer>;
         /**
          * Diffie Hellman parameters, required for Perfect Forward Secrecy. Use
          * openssl dhparam to create the parameters. The key length must be
@@ -611,7 +613,7 @@ declare module 'tls' {
          * stronger security. If omitted or invalid, the parameters are
          * silently discarded and DHE ciphers will not be available.
          */
-        dhparam?: string | Buffer | undefined;
+        dhparam?: string | Buffer;
         /**
          * A string describing a named curve or a colon separated list of curve
          * NIDs or names, for example P-521:P-384:P-256, to use for ECDH key
@@ -621,13 +623,13 @@ declare module 'tls' {
          * name and description of each available elliptic curve. Default:
          * tls.DEFAULT_ECDH_CURVE.
          */
-        ecdhCurve?: string | undefined;
+        ecdhCurve?: string;
         /**
          * Attempt to use the server's cipher suite preferences instead of the
          * client's. When true, causes SSL_OP_CIPHER_SERVER_PREFERENCE to be
          * set in secureOptions
          */
-        honorCipherOrder?: boolean | undefined;
+        honorCipherOrder?: boolean;
         /**
          * Private keys in PEM format. PEM allows the option of private keys
          * being encrypted. Encrypted keys will be decrypted with
@@ -638,18 +640,18 @@ declare module 'tls' {
          * object.passphrase is optional. Encrypted keys will be decrypted with
          * object.passphrase if provided, or options.passphrase if it is not.
          */
-        key?: string | Buffer | Array<Buffer | KeyObject> | undefined;
+        key?: string | Buffer | Array<Buffer | KeyObject>;
         /**
          * Name of an OpenSSL engine to get private key from. Should be used
          * together with privateKeyIdentifier.
          */
-        privateKeyEngine?: string | undefined;
+        privateKeyEngine?: string;
         /**
          * Identifier of a private key managed by an OpenSSL engine. Should be
          * used together with privateKeyEngine. Should not be set together with
          * key, because both options define a private key in different ways.
          */
-        privateKeyIdentifier?: string | undefined;
+        privateKeyIdentifier?: string;
         /**
          * Optionally set the maximum TLS version to allow. One
          * of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the
@@ -658,7 +660,7 @@ declare module 'tls' {
          * `--tls-max-v1.2` sets the default to `'TLSv1.2'`. Using `--tls-max-v1.3` sets the default to
          * `'TLSv1.3'`. If multiple of the options are provided, the highest maximum is used.
          */
-        maxVersion?: SecureVersion | undefined;
+        maxVersion?: SecureVersion;
         /**
          * Optionally set the minimum TLS version to allow. One
          * of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the
@@ -669,11 +671,11 @@ declare module 'tls' {
          * `'TLSv1.1'`. Using `--tls-min-v1.3` sets the default to
          * 'TLSv1.3'. If multiple of the options are provided, the lowest minimum is used.
          */
-        minVersion?: SecureVersion | undefined;
+        minVersion?: SecureVersion;
         /**
          * Shared passphrase used for a single private key and/or a PFX.
          */
-        passphrase?: string | undefined;
+        passphrase?: string;
         /**
          * PFX or PKCS12 encoded private key and certificate chain. pfx is an
          * alternative to providing key and cert individually. PFX is usually
@@ -684,13 +686,13 @@ declare module 'tls' {
          * object.passphrase is optional. Encrypted PFX will be decrypted with
          * object.passphrase if provided, or options.passphrase if it is not.
          */
-        pfx?: string | Buffer | Array<string | Buffer | PxfObject> | undefined;
+        pfx?: string | Buffer | Array<string | Buffer | PxfObject>;
         /**
          * Optionally affect the OpenSSL protocol behavior, which is not
          * usually necessary. This should be used carefully if at all! Value is
          * a numeric bitmask of the SSL_OP_* options from OpenSSL Options
          */
-        secureOptions?: number | undefined; // Value is a numeric bitmask of the `SSL_OP_*` options
+        secureOptions?: number; // Value is a numeric bitmask of the `SSL_OP_*` options
         /**
          * Legacy mechanism to select the TLS protocol version to use, it does
          * not support independent control of the minimum and maximum version,
@@ -702,23 +704,23 @@ declare module 'tls' {
          * TLS versions less than 1.2, but it may be required for
          * interoperability. Default: none, see minVersion.
          */
-        secureProtocol?: string | undefined;
+        secureProtocol?: string;
         /**
          * Opaque identifier used by servers to ensure session state is not
          * shared between applications. Unused by clients.
          */
-        sessionIdContext?: string | undefined;
+        sessionIdContext?: string;
         /**
          * 48-bytes of cryptographically strong pseudo-random data.
          * See Session Resumption for more information.
          */
-        ticketKeys?: Buffer | undefined;
+        ticketKeys?: Buffer;
         /**
          * The number of seconds after which a TLS session created by the
          * server will no longer be resumable. See Session Resumption for more
          * information. Default: 300.
          */
-        sessionTimeout?: number | undefined;
+        sessionTimeout?: number;
     }
 
     interface SecureContext {
@@ -779,6 +781,3 @@ declare module 'tls' {
      */
     const rootCertificates: ReadonlyArray<string>;
 }
-declare module 'node:tls' {
-    export * from 'tls';
-}

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

@@ -1,3 +1,7 @@
+declare module 'node:trace_events' {
+    export * from 'trace_events';
+}
+
 declare module 'trace_events' {
     /**
      * The `Tracing` object is used to enable or disable tracing for sets of
@@ -59,6 +63,3 @@ declare module 'trace_events' {
      */
     function getEnabledCategories(): string | undefined;
 }
-declare module 'node:trace_events' {
-    export * from 'trace_events';
-}

node/ts3.6/assert.d.ts

@@ -0,0 +1,103 @@
+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): void;
+    namespace assert {
+        class AssertionError extends Error {
+            actual: any;
+            expected: any;
+            operator: string;
+            generatedMessage: boolean;
+            code: 'ERR_ASSERTION';
+
+            constructor(options?: {
+                /** 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. */
+                // tslint:disable-next-line:ban-types
+                stackStartFn?: Function;
+            });
+        }
+
+        class CallTracker {
+            calls(exact?: number): () => void;
+            calls<Func extends (...args: any[]) => any>(fn?: Func, exact?: number): Func;
+            report(): CallTrackerReportInformation[];
+            verify(): void;
+        }
+        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;
+        /** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */
+        function fail(
+            actual: any,
+            expected: any,
+            message?: string | Error,
+            operator?: string,
+            // tslint:disable-next-line:ban-types
+            stackStartFn?: Function,
+        ): never;
+        function ok(value: any, message?: string | Error): void;
+        /** @deprecated since v9.9.0 - use strictEqual() instead. */
+        function equal(actual: any, expected: any, message?: string | Error): void;
+        /** @deprecated since v9.9.0 - use notStrictEqual() instead. */
+        function notEqual(actual: any, expected: any, message?: string | Error): void;
+        /** @deprecated since v9.9.0 - use deepStrictEqual() instead. */
+        function deepEqual(actual: any, expected: any, message?: string | Error): void;
+        /** @deprecated since v9.9.0 - use notDeepStrictEqual() instead. */
+        function notDeepEqual(actual: any, expected: any, message?: string | Error): void;
+        function strictEqual(actual: any, expected: any, message?: string | Error): void;
+        function notStrictEqual(actual: any, expected: any, message?: string | Error): void;
+        function deepStrictEqual(actual: any, expected: any, message?: string | Error): void;
+        function notDeepStrictEqual(actual: any, expected: any, message?: string | Error): void;
+
+        function throws(block: () => any, message?: string | Error): void;
+        function throws(block: () => any, error: AssertPredicate, message?: string | Error): void;
+        function doesNotThrow(block: () => any, message?: string | Error): void;
+        function doesNotThrow(block: () => any, error: AssertPredicate, message?: string | Error): void;
+
+        function ifError(value: any): void;
+
+        function rejects(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
+        function rejects(
+            block: (() => Promise<any>) | Promise<any>,
+            error: AssertPredicate,
+            message?: string | Error,
+        ): Promise<void>;
+        function doesNotReject(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
+        function doesNotReject(
+            block: (() => Promise<any>) | Promise<any>,
+            error: AssertPredicate,
+            message?: string | Error,
+        ): Promise<void>;
+
+        function match(value: string, regExp: RegExp, message?: string | Error): void;
+        function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;
+
+        const strict: typeof assert;
+    }
+
+    export = assert;
+}

node/ts3.6/base.d.ts

@@ -0,0 +1,66 @@
+// NOTE: These definitions support NodeJS and TypeScript 3.6 and earlier.
+
+// 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 3.7 and above
+//          - ~/ts3.5/base.d.ts   - Definitions specific to TypeScript 3.6 and earlier
+//          - ~/ts3.5/index.d.ts  - Definitions specific to TypeScript 3.6 and earlier 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="../assert/strict.d.ts" />
+/// <reference path="../globals.d.ts" />
+/// <reference path="../async_hooks.d.ts" />
+/// <reference path="../buffer.d.ts" />
+/// <reference path="../child_process.d.ts" />
+/// <reference path="../cluster.d.ts" />
+/// <reference path="../console.d.ts" />
+/// <reference path="../constants.d.ts" />
+/// <reference path="../crypto.d.ts" />
+/// <reference path="../dgram.d.ts" />
+/// <reference path="../dns.d.ts" />
+/// <reference path="../dns/promises.d.ts" />
+/// <reference path="../dns/promises.d.ts" />
+/// <reference path="../domain.d.ts" />
+/// <reference path="../events.d.ts" />
+/// <reference path="../fs.d.ts" />
+/// <reference path="../fs/promises.d.ts" />
+/// <reference path="../http.d.ts" />
+/// <reference path="../http2.d.ts" />
+/// <reference path="../https.d.ts" />
+/// <reference path="../inspector.d.ts" />
+/// <reference path="../module.d.ts" />
+/// <reference path="../net.d.ts" />
+/// <reference path="../os.d.ts" />
+/// <reference path="../path.d.ts" />
+/// <reference path="../perf_hooks.d.ts" />
+/// <reference path="../process.d.ts" />
+/// <reference path="../punycode.d.ts" />
+/// <reference path="../querystring.d.ts" />
+/// <reference path="../readline.d.ts" />
+/// <reference path="../repl.d.ts" />
+/// <reference path="../stream.d.ts" />
+/// <reference path="../stream/promises.d.ts" />
+/// <reference path="../string_decoder.d.ts" />
+/// <reference path="../timers.d.ts" />
+/// <reference path="../timers/promises.d.ts" />
+/// <reference path="../tls.d.ts" />
+/// <reference path="../trace_events.d.ts" />
+/// <reference path="../tty.d.ts" />
+/// <reference path="../url.d.ts" />
+/// <reference path="../util.d.ts" />
+/// <reference path="../v8.d.ts" />
+/// <reference path="../vm.d.ts" />
+/// <reference path="../worker_threads.d.ts" />
+/// <reference path="../zlib.d.ts" />
+
+// TypeScript 3.5-specific augmentations:
+/// <reference path="../globals.global.d.ts" />
+
+// TypeScript 3.5-specific augmentations:
+/// <reference path="../wasi.d.ts" />

node/ts3.6/index.d.ts

@@ -0,0 +1,7 @@
+// NOTE: These definitions support NodeJS and TypeScript 3.5 - 3.6.
+// This is required to enable typing assert in ts3.7 without causing errors
+// Typically type modifications should be made in base.d.ts instead of here
+
+/// <reference path="base.d.ts" />
+
+/// <reference path="assert.d.ts" />

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

@@ -1,5 +1,9 @@
+declare module 'node:tty' {
+    export * from 'tty';
+}
+
 declare module 'tty' {
-    import * as net from 'net';
+    import * as net from 'node:net';
 
     function isatty(fd: number): boolean;
     class ReadStream extends net.Socket {
@@ -64,6 +68,3 @@ declare module 'tty' {
         isTTY: boolean;
     }
 }
-declare module 'node:tty' {
-    export * from 'tty';
-}

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

@@ -1,19 +1,23 @@
+declare module 'node:url' {
+    export * from 'url';
+}
+
 declare module 'url' {
-    import { ParsedUrlQuery, ParsedUrlQueryInput } from 'querystring';
+    import { ParsedUrlQuery, ParsedUrlQueryInput } from 'node:querystring';
 
     // Input to `url.format`
     interface UrlObject {
-        auth?: string | null | undefined;
-        hash?: string | null | undefined;
-        host?: string | null | undefined;
-        hostname?: string | null | undefined;
-        href?: string | null | undefined;
-        pathname?: string | null | undefined;
-        protocol?: string | null | undefined;
-        search?: string | null | undefined;
-        slashes?: boolean | null | undefined;
-        port?: string | number | null | undefined;
-        query?: string | null | ParsedUrlQueryInput | undefined;
+        auth?: string | null;
+        hash?: string | null;
+        host?: string | null;
+        hostname?: string | null;
+        href?: string | null;
+        pathname?: string | null;
+        protocol?: string | null;
+        search?: string | null;
+        slashes?: boolean | null;
+        port?: string | number | null;
+        query?: string | null | ParsedUrlQueryInput;
     }
 
     // Output of `url.parse`
@@ -73,10 +77,10 @@ declare module 'url' {
     function pathToFileURL(url: string): URL;
 
     interface URLFormatOptions {
-        auth?: boolean | undefined;
-        fragment?: boolean | undefined;
-        search?: boolean | undefined;
-        unicode?: boolean | undefined;
+        auth?: boolean;
+        fragment?: boolean;
+        search?: boolean;
+        unicode?: boolean;
     }
 
     class URL {
@@ -98,7 +102,7 @@ declare module 'url' {
     }
 
     class URLSearchParams implements Iterable<[string, string]> {
-        constructor(init?: URLSearchParams | string | Record<string, string | ReadonlyArray<string>> | Iterable<[string, string]> | ReadonlyArray<[string, string]>);
+        constructor(init?: URLSearchParams | string | NodeJS.Dict<string | ReadonlyArray<string>> | Iterable<[string, string]> | ReadonlyArray<[string, string]>);
         append(name: string, value: string): void;
         delete(name: string): void;
         entries(): IterableIterator<[string, string]>;
@@ -114,6 +118,3 @@ declare module 'url' {
         [Symbol.iterator](): IterableIterator<[string, string]>;
     }
 }
-declare module 'node:url' {
-    export * from 'url';
-}