@types/node 14.18.9 → 15.0.3

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

@@ -15,37 +15,37 @@ declare module 'http2' {
     export { OutgoingHttpHeaders } from 'http';
 
     export interface IncomingHttpStatusHeader {
-        ":status"?: number | undefined;
+        ":status"?: number;
     }
 
     export interface IncomingHttpHeaders extends Http1IncomingHttpHeaders {
-        ":path"?: string | undefined;
-        ":method"?: string | undefined;
-        ":authority"?: string | undefined;
-        ":scheme"?: string | undefined;
+        ":path"?: string;
+        ":method"?: string;
+        ":authority"?: string;
+        ":scheme"?: string;
     }
 
     // Http2Stream
 
     export interface StreamPriorityOptions {
-        exclusive?: boolean | undefined;
-        parent?: number | undefined;
-        weight?: number | undefined;
-        silent?: boolean | undefined;
+        exclusive?: boolean;
+        parent?: number;
+        weight?: number;
+        silent?: boolean;
     }
 
     export interface StreamState {
-        localWindowSize?: number | undefined;
-        state?: number | undefined;
-        localClose?: number | undefined;
-        remoteClose?: number | undefined;
-        sumDependencyWeight?: number | undefined;
-        weight?: number | undefined;
+        localWindowSize?: number;
+        state?: number;
+        localClose?: number;
+        remoteClose?: number;
+        sumDependencyWeight?: number;
+        weight?: number;
     }
 
     export interface ServerStreamResponseOptions {
-        endStream?: boolean | undefined;
-        waitForTrailers?: boolean | undefined;
+        endStream?: boolean;
+        waitForTrailers?: boolean;
     }
 
     export interface StatOptions {
@@ -55,9 +55,9 @@ declare module 'http2' {
 
     export interface ServerStreamFileResponseOptions {
         statCheck?(stats: fs.Stats, headers: OutgoingHttpHeaders, statOptions: StatOptions): void | boolean;
-        waitForTrailers?: boolean | undefined;
-        offset?: number | undefined;
-        length?: number | undefined;
+        waitForTrailers?: boolean;
+        offset?: number;
+        length?: number;
     }
 
     export interface ServerStreamFileResponseOptionsWithError extends ServerStreamFileResponseOptions {
@@ -74,12 +74,12 @@ declare module 'http2' {
          * indicating that no additional data should be received and the readable side of the Http2Stream will be closed.
          */
         readonly endAfterHeaders: boolean;
-        readonly id?: number | undefined;
+        readonly id?: number;
         readonly pending: boolean;
         readonly rstCode: number;
         readonly sentHeaders: OutgoingHttpHeaders;
-        readonly sentInfoHeaders?: OutgoingHttpHeaders[] | undefined;
-        readonly sentTrailers?: OutgoingHttpHeaders | undefined;
+        readonly sentInfoHeaders?: OutgoingHttpHeaders[];
+        readonly sentTrailers?: OutgoingHttpHeaders;
         readonly session: Http2Session;
         readonly state: StreamState;
 
@@ -237,43 +237,43 @@ declare module 'http2' {
     // Http2Session
 
     export interface Settings {
-        headerTableSize?: number | undefined;
-        enablePush?: boolean | undefined;
-        initialWindowSize?: number | undefined;
-        maxFrameSize?: number | undefined;
-        maxConcurrentStreams?: number | undefined;
-        maxHeaderListSize?: number | undefined;
-        enableConnectProtocol?: boolean | undefined;
+        headerTableSize?: number;
+        enablePush?: boolean;
+        initialWindowSize?: number;
+        maxFrameSize?: number;
+        maxConcurrentStreams?: number;
+        maxHeaderListSize?: number;
+        enableConnectProtocol?: boolean;
     }
 
     export interface ClientSessionRequestOptions {
-        endStream?: boolean | undefined;
-        exclusive?: boolean | undefined;
-        parent?: number | undefined;
-        weight?: number | undefined;
-        waitForTrailers?: boolean | undefined;
+        endStream?: boolean;
+        exclusive?: boolean;
+        parent?: number;
+        weight?: number;
+        waitForTrailers?: boolean;
     }
 
     export interface SessionState {
-        effectiveLocalWindowSize?: number | undefined;
-        effectiveRecvDataLength?: number | undefined;
-        nextStreamID?: number | undefined;
-        localWindowSize?: number | undefined;
-        lastProcStreamID?: number | undefined;
-        remoteWindowSize?: number | undefined;
-        outboundQueueSize?: number | undefined;
-        deflateDynamicTableSize?: number | undefined;
-        inflateDynamicTableSize?: number | undefined;
+        effectiveLocalWindowSize?: number;
+        effectiveRecvDataLength?: number;
+        nextStreamID?: number;
+        localWindowSize?: number;
+        lastProcStreamID?: number;
+        remoteWindowSize?: number;
+        outboundQueueSize?: number;
+        deflateDynamicTableSize?: number;
+        inflateDynamicTableSize?: number;
     }
 
     export interface Http2Session extends EventEmitter {
-        readonly alpnProtocol?: string | undefined;
+        readonly alpnProtocol?: string;
         readonly closed: boolean;
         readonly connecting: boolean;
         readonly destroyed: boolean;
-        readonly encrypted?: boolean | undefined;
+        readonly encrypted?: boolean;
         readonly localSettings: Settings;
-        readonly originSet?: string[] | undefined;
+        readonly originSet?: string[];
         readonly pendingSettingsAck: boolean;
         readonly remoteSettings: Settings;
         readonly socket: net.Socket | tls.TLSSocket;
@@ -430,30 +430,30 @@ declare module 'http2' {
     // Http2Server
 
     export interface SessionOptions {
-        maxDeflateDynamicTableSize?: number | undefined;
-        maxSessionMemory?: number | undefined;
-        maxHeaderListPairs?: number | undefined;
-        maxOutstandingPings?: number | undefined;
-        maxSendHeaderBlockLength?: number | undefined;
-        paddingStrategy?: number | undefined;
-        peerMaxConcurrentStreams?: number | undefined;
-        settings?: Settings | undefined;
+        maxDeflateDynamicTableSize?: number;
+        maxSessionMemory?: number;
+        maxHeaderListPairs?: number;
+        maxOutstandingPings?: number;
+        maxSendHeaderBlockLength?: number;
+        paddingStrategy?: number;
+        peerMaxConcurrentStreams?: number;
+        settings?: Settings;
 
         selectPadding?(frameLen: number, maxFrameLen: number): number;
         createConnection?(authority: url.URL, option: SessionOptions): stream.Duplex;
     }
 
     export interface ClientSessionOptions extends SessionOptions {
-        maxReservedRemoteStreams?: number | undefined;
-        createConnection?: ((authority: url.URL, option: SessionOptions) => stream.Duplex) | undefined;
-        protocol?: 'http:' | 'https:' | undefined;
+        maxReservedRemoteStreams?: number;
+        createConnection?: (authority: url.URL, option: SessionOptions) => stream.Duplex;
+        protocol?: 'http:' | 'https:';
     }
 
     export interface ServerSessionOptions extends SessionOptions {
-        Http1IncomingMessage?: typeof IncomingMessage | undefined;
-        Http1ServerResponse?: typeof ServerResponse | undefined;
-        Http2ServerRequest?: typeof Http2ServerRequest | undefined;
-        Http2ServerResponse?: typeof Http2ServerResponse | undefined;
+        Http1IncomingMessage?: typeof IncomingMessage;
+        Http1ServerResponse?: typeof ServerResponse;
+        Http2ServerRequest?: typeof Http2ServerRequest;
+        Http2ServerResponse?: typeof Http2ServerResponse;
     }
 
     export interface SecureClientSessionOptions extends ClientSessionOptions, tls.ConnectionOptions { }
@@ -462,8 +462,8 @@ declare module 'http2' {
     export interface ServerOptions extends ServerSessionOptions { }
 
     export interface SecureServerOptions extends SecureServerSessionOptions {
-        allowHTTP1?: boolean | undefined;
-        origins?: string[] | undefined;
+        allowHTTP1?: boolean;
+        origins?: string[];
     }
 
     export interface Http2Server extends net.Server {
@@ -594,7 +594,7 @@ declare module 'http2' {
         readonly socket: net.Socket | tls.TLSSocket;
         readonly stream: ServerHttp2Stream;
         readonly trailers: IncomingHttpHeaders;
-        url: string;
+        readonly url: string;
 
         setTimeout(msecs: number, callback?: () => void): void;
         read(size?: number): Buffer | string | null;
@@ -660,9 +660,9 @@ declare module 'http2' {
         statusCode: number;
         statusMessage: '';
         addTrailers(trailers: OutgoingHttpHeaders): void;
-        end(callback?: () => void): this;
-        end(data: string | Uint8Array, callback?: () => void): this;
-        end(data: string | Uint8Array, encoding: BufferEncoding, callback?: () => void): this;
+        end(callback?: () => void): void;
+        end(data: string | Uint8Array, callback?: () => void): void;
+        end(data: string | Uint8Array, encoding: BufferEncoding, callback?: () => void): void;
         getHeader(name: string): string;
         getHeaderNames(): string[];
         getHeaders(): OutgoingHttpHeaders;
@@ -939,6 +939,12 @@ declare module 'http2' {
         const HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED: number;
     }
 
+    /**
+     * This symbol can be set as a property on the HTTP/2 headers object with
+     * an array value in order to provide a list of headers considered sensitive.
+     */
+    export const sensitiveHeaders: symbol;
+
     export function getDefaultSettings(): Settings;
     export function getPackedSettings(settings: Settings): Buffer;
     export function getUnpackedSettings(buf: Uint8Array): Settings;
@@ -956,6 +962,3 @@ declare module 'http2' {
         listener?: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void
     ): ClientHttp2Session;
 }
-declare module 'node:http2' {
-    export * from 'http2';
-}

node/https.d.ts

@@ -0,0 +1,36 @@
+declare module 'https' {
+    import * as tls from 'tls';
+    import * as http from 'http';
+    import { URL } from 'url';
+
+    type ServerOptions = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions;
+
+    type RequestOptions = http.RequestOptions & tls.SecureContextOptions & {
+        rejectUnauthorized?: boolean; // Defaults to true
+        servername?: string; // SNI TLS Extension
+    };
+
+    interface AgentOptions extends http.AgentOptions, tls.ConnectionOptions {
+        rejectUnauthorized?: boolean;
+        maxCachedSessions?: number;
+    }
+
+    class Agent extends http.Agent {
+        constructor(options?: AgentOptions);
+        options: AgentOptions;
+    }
+
+    interface Server extends http.HttpBase {}
+    class Server extends tls.Server {
+        constructor(requestListener?: http.RequestListener);
+        constructor(options: ServerOptions, requestListener?: http.RequestListener);
+    }
+
+    function createServer(requestListener?: http.RequestListener): Server;
+    function createServer(options: ServerOptions, requestListener?: http.RequestListener): Server;
+    function request(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function request(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function get(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function get(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    let globalAgent: Agent;
+}

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

@@ -1,5 +1,5 @@
-// Type definitions for non-npm package Node.js 14.18
-// Project: https://nodejs.org/
+// Type definitions for non-npm package Node.js 15.0
+// Project: http://nodejs.org/
 // Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
 //                 DefinitelyTyped <https://github.com/DefinitelyTyped>
 //                 Alberto Schiabel <https://github.com/jkomyno>
@@ -22,7 +22,6 @@
 //                 Nikita Galkin <https://github.com/galkin>
 //                 Parambir Singh <https://github.com/parambirs>
 //                 Sebastian Silbermann <https://github.com/eps1lon>
-//                 Seth Westphal <https://github.com/westy92>
 //                 Simon Schick <https://github.com/SimonSchick>
 //                 Thomas den Hollander <https://github.com/ThomasdenH>
 //                 Wilco Bakker <https://github.com/WilcoBakker>
@@ -32,67 +31,28 @@
 //                 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>
 //                 Yongsheng Zhang <https://github.com/ZYSzys>
-//                 Bond <https://github.com/bondz>
-//                 Linus Unnebäck <https://github.com/LinusU>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-// NOTE: These definitions support NodeJS and TypeScript 3.7+
+// NOTE: These definitions support NodeJS and TypeScript 3.7.
+// Typically type modifications should be made in base.d.ts instead of here
 
-// Reference required types from the default lib:
-/// <reference lib="es2018" />
-/// <reference lib="esnext.asynciterable" />
-/// <reference lib="esnext.intl" />
-/// <reference lib="esnext.bigint" />
+/// <reference path="base.d.ts" />
 
-// Base definitions for all NodeJS modules that are not specific to any version of TypeScript:
-/// <reference path="assert.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="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="string_decoder.d.ts" />
-/// <reference path="timers.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="wasi.d.ts" />
-/// <reference path="worker_threads.d.ts" />
-/// <reference path="zlib.d.ts" />
+// 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.8
+//          - ~/ts3.5/index.d.ts  - Definitions specific to TypeScript 3.5
 
-/// <reference path="globals.global.d.ts" />
+// NOTE: Augmentations for TypeScript 3.5 and later should use individual files for overrides
+//       within the respective ~/ts3.5 (or later) folder. However, this is disallowed for versions
+//       prior to TypeScript 3.5, so the older definitions will be found here.