@types/node 16.0.0 → 16.3.0

node/repl.d.ts

@@ -8,24 +8,24 @@ declare module 'repl' {
          * The input prompt to display.
          * @default "> "
          */
-        prompt?: string;
+        prompt?: string | undefined;
         /**
          * The `Readable` stream from which REPL input will be read.
          * @default process.stdin
          */
-        input?: NodeJS.ReadableStream;
+        input?: NodeJS.ReadableStream | undefined;
         /**
          * The `Writable` stream to which REPL output will be written.
          * @default process.stdout
          */
-        output?: NodeJS.WritableStream;
+        output?: NodeJS.WritableStream | undefined;
         /**
          * If `true`, specifies that the output should be treated as a TTY terminal, and have
          * ANSI/VT100 escape codes written to it.
          * Default: checking the value of the `isTTY` property on the output stream upon
          * instantiation.
          */
-        terminal?: boolean;
+        terminal?: boolean | undefined;
         /**
          * The function to be used when evaluating each given line of input.
          * Default: an async wrapper for the JavaScript `eval()` function. An `eval` function can
@@ -35,45 +35,45 @@ declare module 'repl' {
          * @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_default_evaluation
          * @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_custom_evaluation_functions
          */
-        eval?: REPLEval;
+        eval?: REPLEval | undefined;
         /**
          * Defines if the repl prints output previews or not.
          * @default `true` Always `false` in case `terminal` is falsy.
          */
-        preview?: boolean;
+        preview?: boolean | undefined;
         /**
          * If `true`, specifies that the default `writer` function should include ANSI color
          * styling to REPL output. If a custom `writer` function is provided then this has no
          * effect.
          * Default: the REPL instance's `terminal` value.
          */
-        useColors?: boolean;
+        useColors?: boolean | undefined;
         /**
          * If `true`, specifies that the default evaluation function will use the JavaScript
          * `global` as the context as opposed to creating a new separate context for the REPL
          * instance. The node CLI REPL sets this value to `true`.
          * Default: `false`.
          */
-        useGlobal?: boolean;
+        useGlobal?: boolean | undefined;
         /**
          * If `true`, specifies that the default writer will not output the return value of a
          * command if it evaluates to `undefined`.
          * Default: `false`.
          */
-        ignoreUndefined?: boolean;
+        ignoreUndefined?: boolean | undefined;
         /**
          * The function to invoke to format the output of each command before writing to `output`.
          * Default: a wrapper for `util.inspect`.
          *
          * @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_customizing_repl_output
          */
-        writer?: REPLWriter;
+        writer?: REPLWriter | undefined;
         /**
          * An optional function used for custom Tab auto completion.
          *
          * @see https://nodejs.org/dist/latest-v11.x/docs/api/readline.html#readline_use_of_the_completer_function
          */
-        completer?: Completer | AsyncCompleter;
+        completer?: Completer | AsyncCompleter | undefined;
         /**
          * A flag that specifies whether the default evaluator executes all JavaScript commands in
          * strict mode or default (sloppy) mode.
@@ -82,13 +82,13 @@ declare module 'repl' {
          * - `repl.REPL_MODE_STRICT` - evaluates expressions in strict mode. This is equivalent to
          *   prefacing every repl statement with `'use strict'`.
          */
-        replMode?: typeof REPL_MODE_SLOPPY | typeof REPL_MODE_STRICT;
+        replMode?: typeof REPL_MODE_SLOPPY | typeof REPL_MODE_STRICT | undefined;
         /**
          * Stop evaluating the current piece of code when `SIGINT` is received, i.e. `Ctrl+C` is
          * pressed. This cannot be used together with a custom `eval` function.
          * Default: `false`.
          */
-        breakEvalOnSigint?: boolean;
+        breakEvalOnSigint?: boolean | undefined;
     }
 
     type REPLEval = (this: REPLServer, evalCmd: string, context: Context, file: string, cb: (err: Error | null, result: any) => void) => void;
@@ -106,7 +106,7 @@ declare module 'repl' {
         /**
          * Help text to be displayed when `.help` is entered.
          */
-        help?: string;
+        help?: string | undefined;
         /**
          * The function to execute, optionally accepting a single string argument.
          */

node/stream.d.ts

@@ -3,7 +3,7 @@ declare module 'stream' {
     import * as streamPromises from "stream/promises";
 
     class internal extends EventEmitter {
-        pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
+        pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean | undefined; }): T;
     }
 
     namespace internal {
@@ -12,16 +12,16 @@ declare module 'stream' {
         }
 
         interface StreamOptions<T extends Stream> extends Abortable {
-            emitClose?: boolean;
-            highWaterMark?: number;
-            objectMode?: boolean;
+            emitClose?: boolean | undefined;
+            highWaterMark?: number | undefined;
+            objectMode?: boolean | undefined;
             construct?(this: T, callback: (error?: Error | null) => void): void;
             destroy?(this: T, error: Error | null, callback: (error: Error | null) => void): void;
-            autoDestroy?: boolean;
+            autoDestroy?: boolean | undefined;
         }
 
         interface ReadableOptions extends StreamOptions<Readable> {
-            encoding?: BufferEncoding;
+            encoding?: BufferEncoding | undefined;
             read?(this: Readable, size: number): void;
         }
 
@@ -132,8 +132,8 @@ declare module 'stream' {
         }
 
         interface WritableOptions extends StreamOptions<Writable> {
-            decodeStrings?: boolean;
-            defaultEncoding?: BufferEncoding;
+            decodeStrings?: boolean | undefined;
+            defaultEncoding?: BufferEncoding | undefined;
             write?(this: Writable, chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
             writev?(this: Writable, chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void;
             final?(this: Writable, callback: (error?: Error | null) => void): void;
@@ -232,12 +232,12 @@ declare module 'stream' {
         }
 
         interface DuplexOptions extends ReadableOptions, WritableOptions {
-            allowHalfOpen?: boolean;
-            readableObjectMode?: boolean;
-            writableObjectMode?: boolean;
-            readableHighWaterMark?: number;
-            writableHighWaterMark?: number;
-            writableCorked?: number;
+            allowHalfOpen?: boolean | undefined;
+            readableObjectMode?: boolean | undefined;
+            writableObjectMode?: boolean | undefined;
+            readableHighWaterMark?: number | undefined;
+            writableHighWaterMark?: number | undefined;
+            writableCorked?: number | undefined;
             construct?(this: Duplex, callback: (error?: Error | null) => void): void;
             read?(this: Duplex, size: number): void;
             write?(this: Duplex, chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
@@ -302,9 +302,9 @@ declare module 'stream' {
         function addAbortSignal<T extends Stream>(signal: AbortSignal, stream: T): T;
 
         interface FinishedOptions extends Abortable {
-            error?: boolean;
-            readable?: boolean;
-            writable?: boolean;
+            error?: boolean | undefined;
+            readable?: boolean | undefined;
+            writable?: boolean | undefined;
         }
         function finished(stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream, options: FinishedOptions, callback: (err?: NodeJS.ErrnoException | null) => void): () => void;
         function finished(stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream, callback: (err?: NodeJS.ErrnoException | null) => void): () => void;

node/timers.d.ts

@@ -8,7 +8,7 @@ declare module 'timers' {
          * should not require the Node.js event loop to remain active.
          * @default true
          */
-        ref?: boolean;
+        ref?: boolean | undefined;
     }
 
     let setTimeout: typeof global.setTimeout;
@@ -40,18 +40,27 @@ declare module 'timers' {
         }
 
         function setTimeout<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timeout;
+        // util.promisify no rest args compability
+        // tslint:disable-next-line void-return
+        function setTimeout(callback: (args: void) => void): NodeJS.Timeout;
         namespace setTimeout {
             const __promisify__: typeof setTimeoutPromise;
         }
         function clearTimeout(timeoutId: NodeJS.Timeout): void;
 
         function setInterval<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timer;
+        // util.promisify no rest args compability
+        // tslint:disable-next-line void-return
+        function setInterval(callback: (args: void) => void, ms?: number): NodeJS.Timer;
         namespace setInterval {
             const __promisify__: typeof setIntervalPromise;
         }
         function clearInterval(intervalId: NodeJS.Timeout): void;
 
         function setImmediate<TArgs extends any[]>(callback: (...args: TArgs) => void, ...args: TArgs): NodeJS.Immediate;
+        // util.promisify no rest args compability
+        // tslint:disable-next-line void-return
+        function setImmediate(callback: (args: void) => void): NodeJS.Immediate;
         namespace setImmediate {
             const __promisify__: typeof setImmediatePromise;
         }

node/tls.d.ts

@@ -76,7 +76,7 @@ declare module 'tls' {
         /**
          * The name property is available only when type is 'ECDH'.
          */
-        name?: string;
+        name?: string | undefined;
         /**
          * The size of parameter of an ephemeral key exchange.
          */
@@ -91,7 +91,7 @@ declare module 'tls' {
         /**
          * Optional passphrase.
          */
-        passphrase?: string;
+        passphrase?: string | undefined;
     }
 
     interface PxfObject {
@@ -102,7 +102,7 @@ declare module 'tls' {
         /**
          * Optional passphrase.
          */
-        passphrase?: string;
+        passphrase?: string | undefined;
     }
 
     interface TLSSocketOptions extends SecureContextOptions, CommonConnectionOptions {
@@ -110,22 +110,22 @@ declare module 'tls' {
          * If true the TLS socket will be instantiated in server-mode.
          * Defaults to false.
          */
-        isServer?: boolean;
+        isServer?: boolean | undefined;
         /**
          * An optional net.Server instance.
          */
-        server?: net.Server;
+        server?: net.Server | undefined;
 
         /**
          * An optional Buffer instance containing a TLS session.
          */
-        session?: Buffer;
+        session?: Buffer | undefined;
         /**
          * 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;
+        requestOCSP?: boolean | undefined;
     }
 
     class TLSSocket extends net.Socket {
@@ -153,7 +153,7 @@ declare module 'tls' {
          * String containing the selected ALPN protocol.
          * When ALPN has no selected protocol, tlsSocket.alpnProtocol equals false.
          */
-        alpnProtocol?: string;
+        alpnProtocol?: string | undefined;
 
         /**
          * Returns an object representing the local certificate. The returned
@@ -265,7 +265,7 @@ declare module 'tls' {
          * is successfully completed.
          * @return `undefined` when socket is destroy, `false` if negotiaion can't be initiated.
          */
-        renegotiate(options: { rejectUnauthorized?: boolean, requestCert?: boolean }, callback: (err: Error | null) => void): undefined | boolean;
+        renegotiate(options: { rejectUnauthorized?: boolean | undefined, requestCert?: boolean | undefined }, 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
@@ -355,25 +355,25 @@ declare module 'tls' {
         /**
          * An optional TLS context object from tls.createSecureContext()
          */
-        secureContext?: SecureContext;
+        secureContext?: SecureContext | undefined;
 
         /**
          * When enabled, TLS packet trace information is written to `stderr`. This can be
          * used to debug TLS connection problems.
          * @default false
          */
-        enableTrace?: boolean;
+        enableTrace?: boolean | undefined;
         /**
          * If true the server will request a certificate from clients that
          * connect and attempt to verify that certificate. Defaults to
          * false.
          */
-        requestCert?: boolean;
+        requestCert?: boolean | undefined;
         /**
          * An array of strings or a Buffer naming possible ALPN protocols.
          * (Protocols should be ordered by their priority.)
          */
-        ALPNProtocols?: string[] | Uint8Array[] | Uint8Array;
+        ALPNProtocols?: string[] | Uint8Array[] | Uint8Array | undefined;
         /**
          * SNICallback(servername, cb) <Function> A function that will be
          * called if the client supports SNI TLS extension. Two arguments
@@ -383,14 +383,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;
+        SNICallback?: ((servername: string, cb: (err: Error | null, ctx: SecureContext) => void) => void) | undefined;
         /**
          * 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;
+        rejectUnauthorized?: boolean | undefined;
     }
 
     interface TlsOptions extends SecureContextOptions, CommonConnectionOptions, net.ServerOpts {
@@ -400,17 +400,17 @@ declare module 'tls' {
          * the tls.Server object whenever a handshake times out. Default:
          * 120000 (120 seconds).
          */
-        handshakeTimeout?: number;
+        handshakeTimeout?: number | undefined;
         /**
          * 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;
+        sessionTimeout?: number | undefined;
         /**
          * 48-bytes of cryptographically strong pseudo-random data.
          */
-        ticketKeys?: Buffer;
+        ticketKeys?: Buffer | undefined;
 
         /**
          *
@@ -439,7 +439,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;
+        pskIdentityHint?: string | undefined;
     }
 
     interface PSKCallbackNegotation {
@@ -448,16 +448,16 @@ declare module 'tls' {
     }
 
     interface ConnectionOptions extends SecureContextOptions, CommonConnectionOptions {
-        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;
+        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?: net.Socket | 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;
         /**
          * When negotiating TLS-PSK (pre-shared keys), this function is called
          * with optional identity `hint` provided by the server or `null`
@@ -580,7 +580,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>;
+        ca?: string | Buffer | Array<string | Buffer> | undefined;
         /**
          *  Cert chains in PEM format. One cert chain should be provided per
          *  private key. Each cert chain should consist of the PEM formatted
@@ -592,29 +592,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>;
+        cert?: string | Buffer | Array<string | Buffer> | undefined;
         /**
          *  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;
+        sigalgs?: string | undefined;
         /**
          * 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;
+        ciphers?: string | undefined;
         /**
          * Name of an OpenSSL engine which can provide the client certificate.
          */
-        clientCertEngine?: string;
+        clientCertEngine?: string | undefined;
         /**
          * PEM formatted CRLs (Certificate Revocation Lists).
          */
-        crl?: string | Buffer | Array<string | Buffer>;
+        crl?: string | Buffer | Array<string | Buffer> | undefined;
         /**
          * Diffie Hellman parameters, required for Perfect Forward Secrecy. Use
          * openssl dhparam to create the parameters. The key length must be
@@ -623,7 +623,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;
+        dhparam?: string | Buffer | undefined;
         /**
          * 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
@@ -633,13 +633,13 @@ declare module 'tls' {
          * name and description of each available elliptic curve. Default:
          * tls.DEFAULT_ECDH_CURVE.
          */
-        ecdhCurve?: string;
+        ecdhCurve?: string | undefined;
         /**
          * 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;
+        honorCipherOrder?: boolean | undefined;
         /**
          * Private keys in PEM format. PEM allows the option of private keys
          * being encrypted. Encrypted keys will be decrypted with
@@ -650,18 +650,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>;
+        key?: string | Buffer | Array<Buffer | KeyObject> | undefined;
         /**
          * Name of an OpenSSL engine to get private key from. Should be used
          * together with privateKeyIdentifier.
          */
-        privateKeyEngine?: string;
+        privateKeyEngine?: string | undefined;
         /**
          * 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;
+        privateKeyIdentifier?: string | undefined;
         /**
          * Optionally set the maximum TLS version to allow. One
          * of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the
@@ -670,7 +670,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;
+        maxVersion?: SecureVersion | undefined;
         /**
          * Optionally set the minimum TLS version to allow. One
          * of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the
@@ -681,11 +681,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;
+        minVersion?: SecureVersion | undefined;
         /**
          * Shared passphrase used for a single private key and/or a PFX.
          */
-        passphrase?: string;
+        passphrase?: string | undefined;
         /**
          * PFX or PKCS12 encoded private key and certificate chain. pfx is an
          * alternative to providing key and cert individually. PFX is usually
@@ -696,13 +696,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>;
+        pfx?: string | Buffer | Array<string | Buffer | PxfObject> | undefined;
         /**
          * 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; // Value is a numeric bitmask of the `SSL_OP_*` options
+        secureOptions?: number | undefined; // 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,
@@ -714,23 +714,23 @@ declare module 'tls' {
          * TLS versions less than 1.2, but it may be required for
          * interoperability. Default: none, see minVersion.
          */
-        secureProtocol?: string;
+        secureProtocol?: string | undefined;
         /**
          * Opaque identifier used by servers to ensure session state is not
          * shared between applications. Unused by clients.
          */
-        sessionIdContext?: string;
+        sessionIdContext?: string | undefined;
         /**
          * 48-bytes of cryptographically strong pseudo-random data.
          * See Session Resumption for more information.
          */
-        ticketKeys?: Buffer;
+        ticketKeys?: Buffer | undefined;
         /**
          * 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;
+        sessionTimeout?: number | undefined;
     }
 
     interface SecureContext {

node/ts3.6/base.d.ts

@@ -55,7 +55,6 @@
 /// <reference path="../tty.d.ts" />
 /// <reference path="../url.d.ts" />
 /// <reference path="../util.d.ts" />
-/// <reference path="../util/types.d.ts" />
 /// <reference path="../v8.d.ts" />
 /// <reference path="../vm.d.ts" />
 /// <reference path="../worker_threads.d.ts" />

node/url.d.ts

@@ -1,19 +1,20 @@
 declare module 'url' {
+    import { ClientRequestArgs } from 'http';
     import { ParsedUrlQuery, ParsedUrlQueryInput } from 'querystring';
 
     // Input to `url.format`
     interface UrlObject {
-        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;
+        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;
     }
 
     // Output of `url.parse`
@@ -72,11 +73,17 @@ declare module 'url' {
      */
     function pathToFileURL(url: string): URL;
 
+    /**
+     * This utility function converts a URL object into an ordinary options object as
+     * expected by the `http.request()` and `https.request()` APIs.
+     */
+    function urlToHttpOptions(url: URL): ClientRequestArgs;
+
     interface URLFormatOptions {
-        auth?: boolean;
-        fragment?: boolean;
-        search?: boolean;
-        unicode?: boolean;
+        auth?: boolean | undefined;
+        fragment?: boolean | undefined;
+        search?: boolean | undefined;
+        unicode?: boolean | undefined;
     }
 
     class URL {