@types/node 14.18.9 → 15.0.3

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

@@ -8,7 +8,7 @@ interface ErrorConstructor {
      *
      * @see https://v8.dev/docs/stack-trace-api#customizing-stack-traces
      */
-    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    prepareStackTrace?: (err: Error, stackTraces: NodeJS.CallSite[]) => any;
 
     stackTraceLimit: number;
 }
@@ -75,53 +75,10 @@ type BufferEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2"
 
 type WithImplicitCoercion<T> = T | { valueOf(): T };
 
-//#region borrowed
-// from https://github.com/microsoft/TypeScript/blob/38da7c600c83e7b31193a62495239a0fe478cb67/lib/lib.webworker.d.ts#L633 until moved to separate lib
-/**
- * A controller object that allows you to abort one or more DOM requests as and when desired.
- * @since v14.7.0
- */
-interface AbortController {
-    /**
-     * Returns the AbortSignal object associated with this object.
-     * @since v14.7.0
-     */
-    readonly signal: AbortSignal;
-    /**
-     * Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
-     * @since v14.7.0
-     */
-    abort(): void;
-}
-
-/**
- * A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object.
- * @since v14.7.0
- */
-interface AbortSignal {
-    /**
-     * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
-     * @since v14.7.0
-     */
-    readonly aborted: boolean;
-}
-
-declare var AbortController: {
-    prototype: AbortController;
-    new(): AbortController;
-};
-
-declare var AbortSignal: {
-    prototype: AbortSignal;
-    new(): AbortSignal;
-    // TODO: Add abort() static
-};
-//#endregion borrowed
-
 /**
  * Raw data is stored in instances of the Buffer class.
  * A Buffer is similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap.  A Buffer cannot be resized.
- * Valid string encodings: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'base64url'|'binary'(deprecated)|'hex'
+ * Valid string encodings: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex'
  */
 declare class Buffer extends Uint8Array {
     /**
@@ -203,7 +160,7 @@ declare class Buffer extends Uint8Array {
     static isBuffer(obj: any): obj is Buffer;
     /**
      * Returns true if {encoding} is a valid encoding argument.
-     * Valid string encodings in Node 0.12: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'base64url'|'binary'(deprecated)|'hex'
+     * Valid string encodings in Node 0.12: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex'
      *
      * @param encoding string to test.
      */
@@ -354,6 +311,39 @@ declare class Buffer extends Uint8Array {
     values(): IterableIterator<number>;
 }
 
+//#region borrowed
+// from https://github.com/microsoft/TypeScript/blob/38da7c600c83e7b31193a62495239a0fe478cb67/lib/lib.webworker.d.ts#L633 until moved to separate lib
+/** A controller object that allows you to abort one or more DOM requests as and when desired. */
+interface AbortController {
+    /**
+     * Returns the AbortSignal object associated with this object.
+     */
+    readonly signal: AbortSignal;
+    /**
+     * Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
+     */
+    abort(): void;
+}
+
+/** A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object. */
+interface AbortSignal {
+    /**
+     * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
+     */
+    readonly aborted: boolean;
+}
+
+declare var AbortController: {
+    prototype: AbortController;
+    new(): AbortController;
+};
+
+declare var AbortSignal: {
+    prototype: AbortSignal;
+    new(): AbortSignal;
+};
+//#endregion borrowed
+
 /*----------------------------------------------*
 *                                               *
 *               GLOBAL INTERFACES               *
@@ -369,24 +359,24 @@ declare namespace NodeJS {
          * the getter function.
          * @default `false`
          */
-        getters?: 'get' | 'set' | boolean | undefined;
-        showHidden?: boolean | undefined;
+        getters?: 'get' | 'set' | boolean;
+        showHidden?: boolean;
         /**
          * @default 2
          */
-        depth?: number | null | undefined;
-        colors?: boolean | undefined;
-        customInspect?: boolean | undefined;
-        showProxy?: boolean | undefined;
-        maxArrayLength?: number | null | undefined;
+        depth?: number | null;
+        colors?: boolean;
+        customInspect?: boolean;
+        showProxy?: boolean;
+        maxArrayLength?: number | null;
         /**
          * Specifies the maximum number of characters to
          * include when formatting. Set to `null` or `Infinity` to show all elements.
          * Set to `0` or negative to show no characters.
-         * @default Infinity
+         * @default 10000
          */
-        maxStringLength?: number | null | undefined;
-        breakLength?: number | undefined;
+        maxStringLength?: number | null;
+        breakLength?: number;
         /**
          * Setting this to `false` causes each object key
          * to be displayed on a new line. It will also add new lines to text that is
@@ -397,8 +387,8 @@ declare namespace NodeJS {
          * For more information, see the example below.
          * @default `true`
          */
-        compact?: boolean | number | undefined;
-        sorted?: boolean | ((a: string, b: string) => number) | undefined;
+        compact?: boolean | number;
+        sorted?: boolean | ((a: string, b: string) => number);
     }
 
     interface CallSite {
@@ -476,10 +466,11 @@ declare namespace NodeJS {
     }
 
     interface ErrnoException extends Error {
-        errno?: number | undefined;
-        code?: string | undefined;
-        path?: string | undefined;
-        syscall?: string | undefined;
+        errno?: number;
+        code?: string;
+        path?: string;
+        syscall?: string;
+        stack?: string;
     }
 
     interface ReadableStream extends EventEmitter {
@@ -489,7 +480,7 @@ declare namespace NodeJS {
         pause(): this;
         resume(): this;
         isPaused(): boolean;
-        pipe<T extends WritableStream>(destination: T, options?: { end?: boolean | undefined; }): T;
+        pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
         unpipe(destination?: WritableStream): this;
         unshift(chunk: string | Uint8Array, encoding?: BufferEncoding): void;
         wrap(oldStream: ReadableStream): this;
@@ -500,14 +491,16 @@ declare namespace NodeJS {
         writable: boolean;
         write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
         write(str: string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
-        end(cb?: () => void): this;
-        end(data: string | Uint8Array, cb?: () => void): this;
-        end(str: string, encoding?: BufferEncoding, cb?: () => void): this;
+        end(cb?: () => void): void;
+        end(data: string | Uint8Array, cb?: () => void): void;
+        end(str: string, encoding?: BufferEncoding, cb?: () => void): void;
     }
 
     interface ReadWriteStream extends ReadableStream, WritableStream { }
 
     interface Global {
+        AbortController: typeof AbortController;
+        AbortSignal: typeof AbortSignal;
         Array: typeof Array;
         ArrayBuffer: typeof ArrayBuffer;
         Boolean: typeof Boolean;
@@ -619,7 +612,7 @@ declare namespace NodeJS {
     }
 
     interface RequireResolve {
-        (id: string, options?: { paths?: string[] | undefined; }): string;
+        (id: string, options?: { paths?: string[]; }): string;
         paths(request: string): string[] | null;
     }
 

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

@@ -1,73 +1,73 @@
 declare module 'http' {
     import * as stream from 'stream';
     import { URL } from 'url';
-    import { Socket, Server as NetServer, LookupFunction } from 'net';
+    import { Socket, Server as NetServer } from 'net';
 
     // incoming headers will never contain number
     interface IncomingHttpHeaders extends NodeJS.Dict<string | string[]> {
-        'accept'?: string | undefined;
-        'accept-language'?: string | undefined;
-        'accept-patch'?: string | undefined;
-        'accept-ranges'?: string | undefined;
-        'access-control-allow-credentials'?: string | undefined;
-        'access-control-allow-headers'?: string | undefined;
-        'access-control-allow-methods'?: string | undefined;
-        'access-control-allow-origin'?: string | undefined;
-        'access-control-expose-headers'?: string | undefined;
-        'access-control-max-age'?: string | undefined;
-        'access-control-request-headers'?: string | undefined;
-        'access-control-request-method'?: string | undefined;
-        'age'?: string | undefined;
-        'allow'?: string | undefined;
-        'alt-svc'?: string | undefined;
-        'authorization'?: string | undefined;
-        'cache-control'?: string | undefined;
-        'connection'?: string | undefined;
-        'content-disposition'?: string | undefined;
-        'content-encoding'?: string | undefined;
-        'content-language'?: string | undefined;
-        'content-length'?: string | undefined;
-        'content-location'?: string | undefined;
-        'content-range'?: string | undefined;
-        'content-type'?: string | undefined;
-        'cookie'?: string | undefined;
-        'date'?: string | undefined;
-        'etag'?: string | undefined;
-        'expect'?: string | undefined;
-        'expires'?: string | undefined;
-        'forwarded'?: string | undefined;
-        'from'?: string | undefined;
-        'host'?: string | undefined;
-        'if-match'?: string | undefined;
-        'if-modified-since'?: string | undefined;
-        'if-none-match'?: string | undefined;
-        'if-unmodified-since'?: string | undefined;
-        'last-modified'?: string | undefined;
-        'location'?: string | undefined;
-        'origin'?: string | undefined;
-        'pragma'?: string | undefined;
-        'proxy-authenticate'?: string | undefined;
-        'proxy-authorization'?: string | undefined;
-        'public-key-pins'?: string | undefined;
-        'range'?: string | undefined;
-        'referer'?: string | undefined;
-        'retry-after'?: string | undefined;
-        'sec-websocket-accept'?: string | undefined;
-        'sec-websocket-extensions'?: string | undefined;
-        'sec-websocket-key'?: string | undefined;
-        'sec-websocket-protocol'?: string | undefined;
-        'sec-websocket-version'?: string | undefined;
-        'set-cookie'?: string[] | undefined;
-        'strict-transport-security'?: string | undefined;
-        'tk'?: string | undefined;
-        'trailer'?: string | undefined;
-        'transfer-encoding'?: string | undefined;
-        'upgrade'?: string | undefined;
-        'user-agent'?: string | undefined;
-        'vary'?: string | undefined;
-        'via'?: string | undefined;
-        'warning'?: string | undefined;
-        'www-authenticate'?: string | undefined;
+        'accept'?: string;
+        'accept-language'?: string;
+        'accept-patch'?: string;
+        'accept-ranges'?: string;
+        'access-control-allow-credentials'?: string;
+        'access-control-allow-headers'?: string;
+        'access-control-allow-methods'?: string;
+        'access-control-allow-origin'?: string;
+        'access-control-expose-headers'?: string;
+        'access-control-max-age'?: string;
+        'access-control-request-headers'?: string;
+        'access-control-request-method'?: string;
+        'age'?: string;
+        'allow'?: string;
+        'alt-svc'?: string;
+        'authorization'?: string;
+        'cache-control'?: string;
+        'connection'?: string;
+        'content-disposition'?: string;
+        'content-encoding'?: string;
+        'content-language'?: string;
+        'content-length'?: string;
+        'content-location'?: string;
+        'content-range'?: string;
+        'content-type'?: string;
+        'cookie'?: string;
+        'date'?: string;
+        'etag'?: string;
+        'expect'?: string;
+        'expires'?: string;
+        'forwarded'?: string;
+        'from'?: string;
+        'host'?: string;
+        'if-match'?: string;
+        'if-modified-since'?: string;
+        'if-none-match'?: string;
+        'if-unmodified-since'?: string;
+        'last-modified'?: string;
+        'location'?: string;
+        'origin'?: string;
+        'pragma'?: string;
+        'proxy-authenticate'?: string;
+        'proxy-authorization'?: string;
+        'public-key-pins'?: string;
+        'range'?: string;
+        'referer'?: string;
+        'retry-after'?: string;
+        'sec-websocket-accept'?: string;
+        'sec-websocket-extensions'?: string;
+        'sec-websocket-key'?: string;
+        'sec-websocket-protocol'?: string;
+        'sec-websocket-version'?: string;
+        'set-cookie'?: string[];
+        'strict-transport-security'?: string;
+        'tk'?: string;
+        'trailer'?: string;
+        'transfer-encoding'?: string;
+        'upgrade'?: string;
+        'user-agent'?: string;
+        'vary'?: string;
+        'via'?: string;
+        'warning'?: string;
+        'www-authenticate'?: string;
     }
 
     // outgoing headers allows numbers (as they are converted internally to strings)
@@ -77,55 +77,52 @@ declare module 'http' {
     }
 
     interface ClientRequestArgs {
-        protocol?: string | null | undefined;
-        host?: string | null | undefined;
-        hostname?: string | null | undefined;
-        family?: number | undefined;
-        port?: number | string | null | undefined;
-        defaultPort?: number | string | undefined;
-        localAddress?: string | undefined;
-        socketPath?: string | undefined;
+        protocol?: string | null;
+        host?: string | null;
+        hostname?: string | null;
+        family?: number;
+        port?: number | string | null;
+        defaultPort?: number | string;
+        localAddress?: string;
+        socketPath?: string;
         /**
          * @default 8192
          */
-        maxHeaderSize?: number | undefined;
-        method?: string | undefined;
-        path?: string | null | undefined;
-        headers?: OutgoingHttpHeaders | undefined;
-        auth?: string | null | undefined;
-        agent?: Agent | boolean | undefined;
-        _defaultAgent?: Agent | undefined;
-        timeout?: number | undefined;
-        setHost?: boolean | undefined;
+        maxHeaderSize?: number;
+        method?: string;
+        path?: string | null;
+        headers?: OutgoingHttpHeaders;
+        auth?: string | null;
+        agent?: Agent | boolean;
+        _defaultAgent?: Agent;
+        timeout?: number;
+        setHost?: boolean;
         // https://github.com/nodejs/node/blob/master/lib/_http_client.js#L278
-        createConnection?: ((options: ClientRequestArgs, oncreate: (err: Error, socket: Socket) => void) => Socket) | undefined;
-        lookup?: LookupFunction | undefined;
+        createConnection?: (options: ClientRequestArgs, oncreate: (err: Error, socket: Socket) => void) => Socket;
     }
 
     interface ServerOptions {
-        IncomingMessage?: typeof IncomingMessage | undefined;
-        ServerResponse?: typeof ServerResponse | undefined;
+        IncomingMessage?: typeof IncomingMessage;
+        ServerResponse?: typeof ServerResponse;
         /**
          * Optionally overrides the value of
          * [`--max-http-header-size`][] for requests received by this server, i.e.
          * the maximum length of request headers in bytes.
          * @default 8192
          */
-        maxHeaderSize?: number | undefined;
+        maxHeaderSize?: number;
         /**
          * Use an insecure HTTP parser that accepts invalid HTTP headers when true.
          * Using the insecure parser should be avoided.
          * See --insecure-http-parser for more information.
          * @default false
          */
-        insecureHTTPParser?: boolean | undefined;
+        insecureHTTPParser?: boolean;
     }
 
     type RequestListener = (req: IncomingMessage, res: ServerResponse) => void;
 
-    class Server extends NetServer {
-        constructor(requestListener?: RequestListener);
-        constructor(options: ServerOptions, requestListener?: RequestListener);
+    interface HttpBase {
         setTimeout(msecs?: number, callback?: () => void): this;
         setTimeout(callback: () => void): this;
         /**
@@ -148,72 +145,12 @@ declare module 'http' {
          * {@link https://nodejs.org/api/http.html#http_server_requesttimeout}
          */
         requestTimeout: number;
-        addListener(event: string, listener: (...args: any[]) => void): this;
-        addListener(event: 'close', listener: () => void): this;
-        addListener(event: 'connection', listener: (socket: Socket) => void): this;
-        addListener(event: 'error', listener: (err: Error) => void): this;
-        addListener(event: 'listening', listener: () => void): this;
-        addListener(event: 'checkContinue', listener: RequestListener): this;
-        addListener(event: 'checkExpectation', listener: RequestListener): this;
-        addListener(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
-        addListener(event: 'connect', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
-        addListener(event: 'request', listener: RequestListener): this;
-        addListener(event: 'upgrade', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
-        emit(event: string, ...args: any[]): boolean;
-        emit(event: 'close'): boolean;
-        emit(event: 'connection', socket: Socket): boolean;
-        emit(event: 'error', err: Error): boolean;
-        emit(event: 'listening'): boolean;
-        emit(event: 'checkContinue', req: IncomingMessage, res: ServerResponse): boolean;
-        emit(event: 'checkExpectation', req: IncomingMessage, res: ServerResponse): boolean;
-        emit(event: 'clientError', err: Error, socket: stream.Duplex): boolean;
-        emit(event: 'connect', req: IncomingMessage, socket: stream.Duplex, head: Buffer): boolean;
-        emit(event: 'request', req: IncomingMessage, res: ServerResponse): boolean;
-        emit(event: 'upgrade', req: IncomingMessage, socket: stream.Duplex, head: Buffer): boolean;
-        on(event: string, listener: (...args: any[]) => void): this;
-        on(event: 'close', listener: () => void): this;
-        on(event: 'connection', listener: (socket: Socket) => void): this;
-        on(event: 'error', listener: (err: Error) => void): this;
-        on(event: 'listening', listener: () => void): this;
-        on(event: 'checkContinue', listener: RequestListener): this;
-        on(event: 'checkExpectation', listener: RequestListener): this;
-        on(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
-        on(event: 'connect', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
-        on(event: 'request', listener: RequestListener): this;
-        on(event: 'upgrade', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
-        once(event: string, listener: (...args: any[]) => void): this;
-        once(event: 'close', listener: () => void): this;
-        once(event: 'connection', listener: (socket: Socket) => void): this;
-        once(event: 'error', listener: (err: Error) => void): this;
-        once(event: 'listening', listener: () => void): this;
-        once(event: 'checkContinue', listener: RequestListener): this;
-        once(event: 'checkExpectation', listener: RequestListener): this;
-        once(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
-        once(event: 'connect', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
-        once(event: 'request', listener: RequestListener): this;
-        once(event: 'upgrade', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
-        prependListener(event: string, listener: (...args: any[]) => void): this;
-        prependListener(event: 'close', listener: () => void): this;
-        prependListener(event: 'connection', listener: (socket: Socket) => void): this;
-        prependListener(event: 'error', listener: (err: Error) => void): this;
-        prependListener(event: 'listening', listener: () => void): this;
-        prependListener(event: 'checkContinue', listener: RequestListener): this;
-        prependListener(event: 'checkExpectation', listener: RequestListener): this;
-        prependListener(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
-        prependListener(event: 'connect', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
-        prependListener(event: 'request', listener: RequestListener): this;
-        prependListener(event: 'upgrade', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
-        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: 'close', listener: () => void): this;
-        prependOnceListener(event: 'connection', listener: (socket: Socket) => void): this;
-        prependOnceListener(event: 'error', listener: (err: Error) => void): this;
-        prependOnceListener(event: 'listening', listener: () => void): this;
-        prependOnceListener(event: 'checkContinue', listener: RequestListener): this;
-        prependOnceListener(event: 'checkExpectation', listener: RequestListener): this;
-        prependOnceListener(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
-        prependOnceListener(event: 'connect', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
-        prependOnceListener(event: 'request', listener: RequestListener): this;
-        prependOnceListener(event: 'upgrade', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
+    }
+
+    interface Server extends HttpBase {}
+    class Server extends NetServer {
+        constructor(requestListener?: RequestListener);
+        constructor(options: ServerOptions, requestListener?: RequestListener);
     }
 
     // https://github.com/nodejs/node/blob/master/lib/_http_outgoing.js
@@ -229,7 +166,7 @@ declare module 'http' {
         finished: boolean;
         headersSent: boolean;
         /**
-         * @deprecated Use `socket` instead.
+         * @deprecate Use `socket` instead.
          */
         connection: Socket | null;
         socket: Socket | null;
@@ -237,7 +174,7 @@ declare module 'http' {
         constructor();
 
         setTimeout(msecs: number, callback?: () => void): this;
-        setHeader(name: string, value: number | string | ReadonlyArray<string>): this;
+        setHeader(name: string, value: number | string | ReadonlyArray<string>): void;
         getHeader(name: string): number | string | string[] | undefined;
         getHeaders(): OutgoingHttpHeaders;
         getHeaderNames(): string[];
@@ -259,7 +196,7 @@ declare module 'http' {
         // https://github.com/nodejs/node/blob/master/test/parallel/test-http-write-callbacks.js#L53
         // no args in writeContinue callback
         writeContinue(callback?: () => void): void;
-        writeHead(statusCode: number, statusMessage?: string, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]): this;
+        writeHead(statusCode: number, reasonPhrase?: string, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]): this;
         writeHead(statusCode: number, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]): this;
         writeProcessing(): void;
     }
@@ -279,8 +216,6 @@ declare module 'http' {
         aborted: boolean;
         host: string;
         protocol: string;
-        reusedSocket: boolean;
-        maxHeadersCount: number;
 
         constructor(url: string | URL | ClientRequestArgs, cb?: (res: IncomingMessage) => void);
 
@@ -395,52 +330,52 @@ declare module 'http' {
         /**
          * Only valid for request obtained from http.Server.
          */
-        method?: string | undefined;
+        method?: string;
         /**
          * Only valid for request obtained from http.Server.
          */
-        url?: string | undefined;
+        url?: string;
         /**
          * Only valid for response obtained from http.ClientRequest.
          */
-        statusCode?: number | undefined;
+        statusCode?: number;
         /**
          * Only valid for response obtained from http.ClientRequest.
          */
-        statusMessage?: string | undefined;
-        destroy(error?: Error): this;
+        statusMessage?: string;
+        destroy(error?: Error): void;
     }
 
     interface AgentOptions {
         /**
          * Keep sockets around in a pool to be used by other requests in the future. Default = false
          */
-        keepAlive?: boolean | undefined;
+        keepAlive?: boolean;
         /**
          * When using HTTP KeepAlive, how often to send TCP KeepAlive packets over sockets being kept alive. Default = 1000.
          * Only relevant if keepAlive is set to true.
          */
-        keepAliveMsecs?: number | undefined;
+        keepAliveMsecs?: number;
         /**
          * Maximum number of sockets to allow per host. Default for Node 0.10 is 5, default for Node 0.12 is Infinity
          */
-        maxSockets?: number | undefined;
+        maxSockets?: number;
         /**
          * Maximum number of sockets allowed for all hosts in total. Each request will use a new socket until the maximum is reached. Default: Infinity.
          */
-        maxTotalSockets?: number | undefined;
+        maxTotalSockets?: number;
         /**
          * Maximum number of sockets to leave open in a free state. Only relevant if keepAlive is set to true. Default = 256.
          */
-        maxFreeSockets?: number | undefined;
+        maxFreeSockets?: number;
         /**
          * Socket timeout in milliseconds. This will set the timeout after the socket is connected.
          */
-        timeout?: number | undefined;
+        timeout?: number;
         /**
          * Scheduling strategy to apply when picking the next free socket to use. Default: 'fifo'.
          */
-        scheduling?: 'fifo' | 'lifo' | undefined;
+        scheduling?: 'fifo' | 'lifo';
     }
 
     class Agent {
@@ -487,6 +422,3 @@ declare module 'http' {
      */
     const maxHeaderSize: number;
 }
-declare module 'node:http' {
-    export * from 'http';
-}