@types/node 12.20.41 → 13.1.2

node v12.20/http2.d.ts → node/http2.d.ts

@@ -1,51 +1,46 @@
-declare module 'http2' {
-    import EventEmitter = require('events');
-    import * as fs from 'fs';
-    import * as net from 'net';
-    import * as stream from 'stream';
-    import * as tls from 'tls';
-    import * as url from 'url';
-
-    import {
-        IncomingHttpHeaders as Http1IncomingHttpHeaders,
-        OutgoingHttpHeaders,
-        IncomingMessage,
-        ServerResponse,
-    } from 'http';
-    export { OutgoingHttpHeaders } from 'http';
+declare module "http2" {
+    import * as events from "events";
+    import * as fs from "fs";
+    import * as net from "net";
+    import * as stream from "stream";
+    import * as tls from "tls";
+    import * as url from "url";
+
+    import { IncomingHttpHeaders as Http1IncomingHttpHeaders, OutgoingHttpHeaders, IncomingMessage, ServerResponse } from "http";
+    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 +50,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 +69,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 +232,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;
+    export interface Http2Session extends events.EventEmitter {
+        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;
@@ -361,7 +356,7 @@ declare module 'http2' {
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
         emit(event: "altsvc", alt: string, origin: string, stream: number): boolean;
-        emit(event: "origin", origins: ReadonlyArray<string>): boolean;
+        emit(event: "origin", origins: string[]): boolean;
         emit(event: "connect", session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket): boolean;
         emit(event: "stream", stream: ClientHttp2Stream, headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
@@ -429,29 +424,29 @@ 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;
+        maxReservedRemoteStreams?: number;
+        createConnection?: (authority: url.URL, option: SessionOptions) => stream.Duplex;
     }
 
     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 { }
@@ -460,8 +455,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 {
@@ -575,7 +570,7 @@ declare module 'http2' {
     }
 
     export class Http2ServerRequest extends stream.Readable {
-        constructor(stream: ServerHttp2Stream, headers: IncomingHttpHeaders, options: stream.ReadableOptions, rawHeaders: ReadonlyArray<string>);
+        constructor(stream: ServerHttp2Stream, headers: IncomingHttpHeaders, options: stream.ReadableOptions, rawHeaders: string[]);
 
         readonly aborted: boolean;
         readonly authority: string;
@@ -588,7 +583,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;
@@ -642,7 +637,7 @@ declare module 'http2' {
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
     }
 
-    export class Http2ServerResponse extends stream.Writable {
+    export class Http2ServerResponse extends stream.Stream {
         constructor(stream: ServerHttp2Stream);
 
         readonly connection: net.Socket | tls.TLSSocket;
@@ -654,15 +649,15 @@ 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: string, callback?: () => void): this;
+        end(callback?: () => void): void;
+        end(data: string | Uint8Array, callback?: () => void): void;
+        end(data: string | Uint8Array, encoding: string, callback?: () => void): void;
         getHeader(name: string): string;
         getHeaderNames(): string[];
         getHeaders(): OutgoingHttpHeaders;
         hasHeader(name: string): boolean;
         removeHeader(name: string): void;
-        setHeader(name: string, value: number | string | ReadonlyArray<string>): void;
+        setHeader(name: string, value: number | string | string[]): void;
         setTimeout(msecs: number, callback?: () => void): void;
         write(chunk: string | Uint8Array, callback?: (err: Error) => void): boolean;
         write(chunk: string | Uint8Array, encoding: string, callback?: (err: Error) => void): boolean;

node/https.d.ts

@@ -0,0 +1,53 @@
+declare module "https" {
+    import * as tls from "tls";
+    import * as events from "events";
+    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;
+    }
+
+    class Server extends tls.Server {
+        constructor(requestListener?: http.RequestListener);
+        constructor(options: ServerOptions, requestListener?: http.RequestListener);
+
+        setTimeout(callback: () => void): this;
+        setTimeout(msecs?: number, callback?: () => void): this;
+        /**
+         * Limits maximum incoming headers count. If set to 0, no limit will be applied.
+         * @default 2000
+         * {@link https://nodejs.org/api/http.html#http_server_maxheaderscount}
+         */
+        maxHeadersCount: number | null;
+        timeout: number;
+        /**
+         * Limit the amount of time the parser will wait to receive the complete HTTP headers.
+         * @default 40000
+         * {@link https://nodejs.org/api/http.html#http_server_headerstimeout}
+         */
+        headersTimeout: number;
+        keepAliveTimeout: number;
+    }
+
+    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/index.d.ts

@@ -0,0 +1,83 @@
+// Type definitions for non-npm package Node.js 13.1
+// Project: http://nodejs.org/
+// Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
+//                 DefinitelyTyped <https://github.com/DefinitelyTyped>
+//                 Alberto Schiabel <https://github.com/jkomyno>
+//                 Alexander T. <https://github.com/a-tarasyuk>
+//                 Alvis HT Tang <https://github.com/alvis>
+//                 Andrew Makarov <https://github.com/r3nya>
+//                 Benjamin Toueg <https://github.com/btoueg>
+//                 Bruno Scheufler <https://github.com/brunoscheufler>
+//                 Chigozirim C. <https://github.com/smac89>
+//                 Christian Vaagland Tellnes <https://github.com/tellnes>
+//                 David Junger <https://github.com/touffy>
+//                 Deividas Bakanas <https://github.com/DeividasBakanas>
+//                 Eugene Y. Q. Shen <https://github.com/eyqs>
+//                 Flarna <https://github.com/Flarna>
+//                 Hannes Magnusson <https://github.com/Hannes-Magnusson-CK>
+//                 Hoàng Văn Khải <https://github.com/KSXGitHub>
+//                 Huw <https://github.com/hoo29>
+//                 Kelvin Jin <https://github.com/kjin>
+//                 Klaus Meinhardt <https://github.com/ajafff>
+//                 Lishude <https://github.com/islishude>
+//                 Mariusz Wiktorczyk <https://github.com/mwiktorczyk>
+//                 Mohsen Azimi <https://github.com/mohsen1>
+//                 Nicolas Even <https://github.com/n-e>
+//                 Nicolas Voigt <https://github.com/octo-sniffle>
+//                 Nikita Galkin <https://github.com/galkin>
+//                 Parambir Singh <https://github.com/parambirs>
+//                 Sebastian Silbermann <https://github.com/eps1lon>
+//                 Simon Schick <https://github.com/SimonSchick>
+//                 Thomas den Hollander <https://github.com/ThomasdenH>
+//                 Wilco Bakker <https://github.com/WilcoBakker>
+//                 wwwy3y3 <https://github.com/wwwy3y3>
+//                 Zane Hannan AU <https://github.com/ZaneHannanAU>
+//                 Samuel Ainsworth <https://github.com/samuela>
+//                 Kyle Uehlein <https://github.com/kuehlein>
+//                 Jordi Oliveras Rovira <https://github.com/j-oliveras>
+//                 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>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// NOTE: These definitions support NodeJS and TypeScript 3.2.
+
+// 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.2/index.d.ts  - Definitions specific to TypeScript 3.2
+
+// NOTE: Augmentations for TypeScript 3.2 and later should use individual files for overrides
+//       within the respective ~/ts3.2 (or later) folder. However, this is disallowed for versions
+//       prior to TypeScript 3.2, so the older definitions will be found here.
+
+// Base definitions for all NodeJS modules that are not specific to any version of TypeScript:
+/// <reference path="base.d.ts" />
+
+// Forward-declarations for needed types from es2015 and later (in case users are using `--lib es5`)
+// Empty interfaces are used here which merge fine with the real declarations in the lib XXX files
+// just to ensure the names are known and node typings can be sued without importing these libs.
+// if someone really needs these types the libs need to be added via --lib or in tsconfig.json
+interface AsyncIterable<T> { }
+interface IterableIterator<T> { }
+interface AsyncIterableIterator<T> {}
+interface SymbolConstructor {
+    readonly asyncIterator: symbol;
+}
+declare var Symbol: SymbolConstructor;
+// even this is just a forward declaration some properties are added otherwise
+// it would be allowed to pass anything to e.g. Buffer.from()
+interface SharedArrayBuffer {
+    readonly byteLength: number;
+    slice(begin?: number, end?: number): SharedArrayBuffer;
+}
+
+declare module "util" {
+    namespace types {
+        function isBigInt64Array(value: any): boolean;
+        function isBigUint64Array(value: any): boolean;
+    }
+}