You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2100 lines
110 KiB
2100 lines
110 KiB
/** |
|
* The `http2` module provides an implementation of the [HTTP/2](https://tools.ietf.org/html/rfc7540) protocol. It |
|
* can be accessed using: |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* ``` |
|
* @since v8.4.0 |
|
* @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/http2.js) |
|
*/ |
|
declare module 'http2' { |
|
import EventEmitter = require('node:events'); |
|
import * as fs from 'node:fs'; |
|
import * as net from 'node:net'; |
|
import * as stream from 'node:stream'; |
|
import * as tls from 'node:tls'; |
|
import * as url from 'node:url'; |
|
import { IncomingHttpHeaders as Http1IncomingHttpHeaders, OutgoingHttpHeaders, IncomingMessage, ServerResponse } from 'node:http'; |
|
export { OutgoingHttpHeaders } from 'node:http'; |
|
export interface IncomingHttpStatusHeader { |
|
':status'?: number | undefined; |
|
} |
|
export interface IncomingHttpHeaders extends Http1IncomingHttpHeaders { |
|
':path'?: string | undefined; |
|
':method'?: string | undefined; |
|
':authority'?: string | undefined; |
|
':scheme'?: string | undefined; |
|
} |
|
// Http2Stream |
|
export interface StreamPriorityOptions { |
|
exclusive?: boolean | undefined; |
|
parent?: number | undefined; |
|
weight?: number | undefined; |
|
silent?: boolean | undefined; |
|
} |
|
export interface StreamState { |
|
localWindowSize?: number | undefined; |
|
state?: number | undefined; |
|
localClose?: number | undefined; |
|
remoteClose?: number | undefined; |
|
sumDependencyWeight?: number | undefined; |
|
weight?: number | undefined; |
|
} |
|
export interface ServerStreamResponseOptions { |
|
endStream?: boolean | undefined; |
|
waitForTrailers?: boolean | undefined; |
|
} |
|
export interface StatOptions { |
|
offset: number; |
|
length: number; |
|
} |
|
export interface ServerStreamFileResponseOptions { |
|
statCheck?(stats: fs.Stats, headers: OutgoingHttpHeaders, statOptions: StatOptions): void | boolean; |
|
waitForTrailers?: boolean | undefined; |
|
offset?: number | undefined; |
|
length?: number | undefined; |
|
} |
|
export interface ServerStreamFileResponseOptionsWithError extends ServerStreamFileResponseOptions { |
|
onError?(err: NodeJS.ErrnoException): void; |
|
} |
|
export interface Http2Stream extends stream.Duplex { |
|
/** |
|
* Set to `true` if the `Http2Stream` instance was aborted abnormally. When set, |
|
* the `'aborted'` event will have been emitted. |
|
* @since v8.4.0 |
|
*/ |
|
readonly aborted: boolean; |
|
/** |
|
* This property shows the number of characters currently buffered to be written. |
|
* See `net.Socket.bufferSize` for details. |
|
* @since v11.2.0, v10.16.0 |
|
*/ |
|
readonly bufferSize: number; |
|
/** |
|
* Set to `true` if the `Http2Stream` instance has been closed. |
|
* @since v9.4.0 |
|
*/ |
|
readonly closed: boolean; |
|
/** |
|
* Set to `true` if the `Http2Stream` instance has been destroyed and is no longer |
|
* usable. |
|
* @since v8.4.0 |
|
*/ |
|
readonly destroyed: boolean; |
|
/** |
|
* Set the `true` if the `END_STREAM` flag was set in the request or response |
|
* HEADERS frame received, indicating that no additional data should be received |
|
* and the readable side of the `Http2Stream` will be closed. |
|
* @since v10.11.0 |
|
*/ |
|
readonly endAfterHeaders: boolean; |
|
/** |
|
* The numeric stream identifier of this `Http2Stream` instance. Set to `undefined`if the stream identifier has not yet been assigned. |
|
* @since v8.4.0 |
|
*/ |
|
readonly id?: number | undefined; |
|
/** |
|
* Set to `true` if the `Http2Stream` instance has not yet been assigned a |
|
* numeric stream identifier. |
|
* @since v9.4.0 |
|
*/ |
|
readonly pending: boolean; |
|
/** |
|
* Set to the `RST_STREAM` `error code` reported when the `Http2Stream` is |
|
* destroyed after either receiving an `RST_STREAM` frame from the connected peer, |
|
* calling `http2stream.close()`, or `http2stream.destroy()`. Will be`undefined` if the `Http2Stream` has not been closed. |
|
* @since v8.4.0 |
|
*/ |
|
readonly rstCode: number; |
|
/** |
|
* An object containing the outbound headers sent for this `Http2Stream`. |
|
* @since v9.5.0 |
|
*/ |
|
readonly sentHeaders: OutgoingHttpHeaders; |
|
/** |
|
* An array of objects containing the outbound informational (additional) headers |
|
* sent for this `Http2Stream`. |
|
* @since v9.5.0 |
|
*/ |
|
readonly sentInfoHeaders?: OutgoingHttpHeaders[] | undefined; |
|
/** |
|
* An object containing the outbound trailers sent for this `HttpStream`. |
|
* @since v9.5.0 |
|
*/ |
|
readonly sentTrailers?: OutgoingHttpHeaders | undefined; |
|
/** |
|
* A reference to the `Http2Session` instance that owns this `Http2Stream`. The |
|
* value will be `undefined` after the `Http2Stream` instance is destroyed. |
|
* @since v8.4.0 |
|
*/ |
|
readonly session: Http2Session; |
|
/** |
|
* Provides miscellaneous information about the current state of the`Http2Stream`. |
|
* |
|
* A current state of this `Http2Stream`. |
|
* @since v8.4.0 |
|
*/ |
|
readonly state: StreamState; |
|
/** |
|
* Closes the `Http2Stream` instance by sending an `RST_STREAM` frame to the |
|
* connected HTTP/2 peer. |
|
* @since v8.4.0 |
|
* @param [code=http2.constants.NGHTTP2_NO_ERROR] Unsigned 32-bit integer identifying the error code. |
|
* @param callback An optional function registered to listen for the `'close'` event. |
|
*/ |
|
close(code?: number, callback?: () => void): void; |
|
/** |
|
* Updates the priority for this `Http2Stream` instance. |
|
* @since v8.4.0 |
|
*/ |
|
priority(options: StreamPriorityOptions): void; |
|
/** |
|
* ```js |
|
* const http2 = require('http2'); |
|
* const client = http2.connect('http://example.org:8000'); |
|
* const { NGHTTP2_CANCEL } = http2.constants; |
|
* const req = client.request({ ':path': '/' }); |
|
* |
|
* // Cancel the stream if there's no activity after 5 seconds |
|
* req.setTimeout(5000, () => req.close(NGHTTP2_CANCEL)); |
|
* ``` |
|
* @since v8.4.0 |
|
*/ |
|
setTimeout(msecs: number, callback?: () => void): void; |
|
/** |
|
* Sends a trailing `HEADERS` frame to the connected HTTP/2 peer. This method |
|
* will cause the `Http2Stream` to be immediately closed and must only be |
|
* called after the `'wantTrailers'` event has been emitted. When sending a |
|
* request or sending a response, the `options.waitForTrailers` option must be set |
|
* in order to keep the `Http2Stream` open after the final `DATA` frame so that |
|
* trailers can be sent. |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* const server = http2.createServer(); |
|
* server.on('stream', (stream) => { |
|
* stream.respond(undefined, { waitForTrailers: true }); |
|
* stream.on('wantTrailers', () => { |
|
* stream.sendTrailers({ xyz: 'abc' }); |
|
* }); |
|
* stream.end('Hello World'); |
|
* }); |
|
* ``` |
|
* |
|
* The HTTP/1 specification forbids trailers from containing HTTP/2 pseudo-header |
|
* fields (e.g. `':method'`, `':path'`, etc). |
|
* @since v10.0.0 |
|
*/ |
|
sendTrailers(headers: OutgoingHttpHeaders): void; |
|
addListener(event: 'aborted', listener: () => void): this; |
|
addListener(event: 'close', listener: () => void): this; |
|
addListener(event: 'data', listener: (chunk: Buffer | string) => void): this; |
|
addListener(event: 'drain', listener: () => void): this; |
|
addListener(event: 'end', listener: () => void): this; |
|
addListener(event: 'error', listener: (err: Error) => void): this; |
|
addListener(event: 'finish', listener: () => void): this; |
|
addListener(event: 'frameError', listener: (frameType: number, errorCode: number) => void): this; |
|
addListener(event: 'pipe', listener: (src: stream.Readable) => void): this; |
|
addListener(event: 'unpipe', listener: (src: stream.Readable) => void): this; |
|
addListener(event: 'streamClosed', listener: (code: number) => void): this; |
|
addListener(event: 'timeout', listener: () => void): this; |
|
addListener(event: 'trailers', listener: (trailers: IncomingHttpHeaders, flags: number) => void): this; |
|
addListener(event: 'wantTrailers', listener: () => void): this; |
|
addListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
emit(event: 'aborted'): boolean; |
|
emit(event: 'close'): boolean; |
|
emit(event: 'data', chunk: Buffer | string): boolean; |
|
emit(event: 'drain'): boolean; |
|
emit(event: 'end'): boolean; |
|
emit(event: 'error', err: Error): boolean; |
|
emit(event: 'finish'): boolean; |
|
emit(event: 'frameError', frameType: number, errorCode: number): boolean; |
|
emit(event: 'pipe', src: stream.Readable): boolean; |
|
emit(event: 'unpipe', src: stream.Readable): boolean; |
|
emit(event: 'streamClosed', code: number): boolean; |
|
emit(event: 'timeout'): boolean; |
|
emit(event: 'trailers', trailers: IncomingHttpHeaders, flags: number): boolean; |
|
emit(event: 'wantTrailers'): boolean; |
|
emit(event: string | symbol, ...args: any[]): boolean; |
|
on(event: 'aborted', listener: () => void): this; |
|
on(event: 'close', listener: () => void): this; |
|
on(event: 'data', listener: (chunk: Buffer | string) => void): this; |
|
on(event: 'drain', listener: () => void): this; |
|
on(event: 'end', listener: () => void): this; |
|
on(event: 'error', listener: (err: Error) => void): this; |
|
on(event: 'finish', listener: () => void): this; |
|
on(event: 'frameError', listener: (frameType: number, errorCode: number) => void): this; |
|
on(event: 'pipe', listener: (src: stream.Readable) => void): this; |
|
on(event: 'unpipe', listener: (src: stream.Readable) => void): this; |
|
on(event: 'streamClosed', listener: (code: number) => void): this; |
|
on(event: 'timeout', listener: () => void): this; |
|
on(event: 'trailers', listener: (trailers: IncomingHttpHeaders, flags: number) => void): this; |
|
on(event: 'wantTrailers', listener: () => void): this; |
|
on(event: string | symbol, listener: (...args: any[]) => void): this; |
|
once(event: 'aborted', listener: () => void): this; |
|
once(event: 'close', listener: () => void): this; |
|
once(event: 'data', listener: (chunk: Buffer | string) => void): this; |
|
once(event: 'drain', listener: () => void): this; |
|
once(event: 'end', listener: () => void): this; |
|
once(event: 'error', listener: (err: Error) => void): this; |
|
once(event: 'finish', listener: () => void): this; |
|
once(event: 'frameError', listener: (frameType: number, errorCode: number) => void): this; |
|
once(event: 'pipe', listener: (src: stream.Readable) => void): this; |
|
once(event: 'unpipe', listener: (src: stream.Readable) => void): this; |
|
once(event: 'streamClosed', listener: (code: number) => void): this; |
|
once(event: 'timeout', listener: () => void): this; |
|
once(event: 'trailers', listener: (trailers: IncomingHttpHeaders, flags: number) => void): this; |
|
once(event: 'wantTrailers', listener: () => void): this; |
|
once(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependListener(event: 'aborted', listener: () => void): this; |
|
prependListener(event: 'close', listener: () => void): this; |
|
prependListener(event: 'data', listener: (chunk: Buffer | string) => void): this; |
|
prependListener(event: 'drain', listener: () => void): this; |
|
prependListener(event: 'end', listener: () => void): this; |
|
prependListener(event: 'error', listener: (err: Error) => void): this; |
|
prependListener(event: 'finish', listener: () => void): this; |
|
prependListener(event: 'frameError', listener: (frameType: number, errorCode: number) => void): this; |
|
prependListener(event: 'pipe', listener: (src: stream.Readable) => void): this; |
|
prependListener(event: 'unpipe', listener: (src: stream.Readable) => void): this; |
|
prependListener(event: 'streamClosed', listener: (code: number) => void): this; |
|
prependListener(event: 'timeout', listener: () => void): this; |
|
prependListener(event: 'trailers', listener: (trailers: IncomingHttpHeaders, flags: number) => void): this; |
|
prependListener(event: 'wantTrailers', listener: () => void): this; |
|
prependListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependOnceListener(event: 'aborted', listener: () => void): this; |
|
prependOnceListener(event: 'close', listener: () => void): this; |
|
prependOnceListener(event: 'data', listener: (chunk: Buffer | string) => void): this; |
|
prependOnceListener(event: 'drain', listener: () => void): this; |
|
prependOnceListener(event: 'end', listener: () => void): this; |
|
prependOnceListener(event: 'error', listener: (err: Error) => void): this; |
|
prependOnceListener(event: 'finish', listener: () => void): this; |
|
prependOnceListener(event: 'frameError', listener: (frameType: number, errorCode: number) => void): this; |
|
prependOnceListener(event: 'pipe', listener: (src: stream.Readable) => void): this; |
|
prependOnceListener(event: 'unpipe', listener: (src: stream.Readable) => void): this; |
|
prependOnceListener(event: 'streamClosed', listener: (code: number) => void): this; |
|
prependOnceListener(event: 'timeout', listener: () => void): this; |
|
prependOnceListener(event: 'trailers', listener: (trailers: IncomingHttpHeaders, flags: number) => void): this; |
|
prependOnceListener(event: 'wantTrailers', listener: () => void): this; |
|
prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
} |
|
export interface ClientHttp2Stream extends Http2Stream { |
|
addListener(event: 'continue', listener: () => {}): this; |
|
addListener(event: 'headers', listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void): this; |
|
addListener(event: 'push', listener: (headers: IncomingHttpHeaders, flags: number) => void): this; |
|
addListener(event: 'response', listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void): this; |
|
addListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
emit(event: 'continue'): boolean; |
|
emit(event: 'headers', headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number): boolean; |
|
emit(event: 'push', headers: IncomingHttpHeaders, flags: number): boolean; |
|
emit(event: 'response', headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number): boolean; |
|
emit(event: string | symbol, ...args: any[]): boolean; |
|
on(event: 'continue', listener: () => {}): this; |
|
on(event: 'headers', listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void): this; |
|
on(event: 'push', listener: (headers: IncomingHttpHeaders, flags: number) => void): this; |
|
on(event: 'response', listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void): this; |
|
on(event: string | symbol, listener: (...args: any[]) => void): this; |
|
once(event: 'continue', listener: () => {}): this; |
|
once(event: 'headers', listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void): this; |
|
once(event: 'push', listener: (headers: IncomingHttpHeaders, flags: number) => void): this; |
|
once(event: 'response', listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void): this; |
|
once(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependListener(event: 'continue', listener: () => {}): this; |
|
prependListener(event: 'headers', listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void): this; |
|
prependListener(event: 'push', listener: (headers: IncomingHttpHeaders, flags: number) => void): this; |
|
prependListener(event: 'response', listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void): this; |
|
prependListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependOnceListener(event: 'continue', listener: () => {}): this; |
|
prependOnceListener(event: 'headers', listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void): this; |
|
prependOnceListener(event: 'push', listener: (headers: IncomingHttpHeaders, flags: number) => void): this; |
|
prependOnceListener(event: 'response', listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void): this; |
|
prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
} |
|
export interface ServerHttp2Stream extends Http2Stream { |
|
/** |
|
* True if headers were sent, false otherwise (read-only). |
|
* @since v8.4.0 |
|
*/ |
|
readonly headersSent: boolean; |
|
/** |
|
* Read-only property mapped to the `SETTINGS_ENABLE_PUSH` flag of the remote |
|
* client's most recent `SETTINGS` frame. Will be `true` if the remote peer |
|
* accepts push streams, `false` otherwise. Settings are the same for every`Http2Stream` in the same `Http2Session`. |
|
* @since v8.4.0 |
|
*/ |
|
readonly pushAllowed: boolean; |
|
/** |
|
* Sends an additional informational `HEADERS` frame to the connected HTTP/2 peer. |
|
* @since v8.4.0 |
|
*/ |
|
additionalHeaders(headers: OutgoingHttpHeaders): void; |
|
/** |
|
* Initiates a push stream. The callback is invoked with the new `Http2Stream`instance created for the push stream passed as the second argument, or an`Error` passed as the first argument. |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* const server = http2.createServer(); |
|
* server.on('stream', (stream) => { |
|
* stream.respond({ ':status': 200 }); |
|
* stream.pushStream({ ':path': '/' }, (err, pushStream, headers) => { |
|
* if (err) throw err; |
|
* pushStream.respond({ ':status': 200 }); |
|
* pushStream.end('some pushed data'); |
|
* }); |
|
* stream.end('some data'); |
|
* }); |
|
* ``` |
|
* |
|
* Setting the weight of a push stream is not allowed in the `HEADERS` frame. Pass |
|
* a `weight` value to `http2stream.priority` with the `silent` option set to`true` to enable server-side bandwidth balancing between concurrent streams. |
|
* |
|
* Calling `http2stream.pushStream()` from within a pushed stream is not permitted |
|
* and will throw an error. |
|
* @since v8.4.0 |
|
* @param callback Callback that is called once the push stream has been initiated. |
|
*/ |
|
pushStream(headers: OutgoingHttpHeaders, callback?: (err: Error | null, pushStream: ServerHttp2Stream, headers: OutgoingHttpHeaders) => void): void; |
|
pushStream(headers: OutgoingHttpHeaders, options?: StreamPriorityOptions, callback?: (err: Error | null, pushStream: ServerHttp2Stream, headers: OutgoingHttpHeaders) => void): void; |
|
/** |
|
* ```js |
|
* const http2 = require('http2'); |
|
* const server = http2.createServer(); |
|
* server.on('stream', (stream) => { |
|
* stream.respond({ ':status': 200 }); |
|
* stream.end('some data'); |
|
* }); |
|
* ``` |
|
* |
|
* When the `options.waitForTrailers` option is set, the `'wantTrailers'` event |
|
* will be emitted immediately after queuing the last chunk of payload data to be |
|
* sent. The `http2stream.sendTrailers()` method can then be used to sent trailing |
|
* header fields to the peer. |
|
* |
|
* When `options.waitForTrailers` is set, the `Http2Stream` will not automatically |
|
* close when the final `DATA` frame is transmitted. User code must call either`http2stream.sendTrailers()` or `http2stream.close()` to close the`Http2Stream`. |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* const server = http2.createServer(); |
|
* server.on('stream', (stream) => { |
|
* stream.respond({ ':status': 200 }, { waitForTrailers: true }); |
|
* stream.on('wantTrailers', () => { |
|
* stream.sendTrailers({ ABC: 'some value to send' }); |
|
* }); |
|
* stream.end('some data'); |
|
* }); |
|
* ``` |
|
* @since v8.4.0 |
|
*/ |
|
respond(headers?: OutgoingHttpHeaders, options?: ServerStreamResponseOptions): void; |
|
/** |
|
* Initiates a response whose data is read from the given file descriptor. No |
|
* validation is performed on the given file descriptor. If an error occurs while |
|
* attempting to read data using the file descriptor, the `Http2Stream` will be |
|
* closed using an `RST_STREAM` frame using the standard `INTERNAL_ERROR` code. |
|
* |
|
* When used, the `Http2Stream` object's `Duplex` interface will be closed |
|
* automatically. |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* const fs = require('fs'); |
|
* |
|
* const server = http2.createServer(); |
|
* server.on('stream', (stream) => { |
|
* const fd = fs.openSync('/some/file', 'r'); |
|
* |
|
* const stat = fs.fstatSync(fd); |
|
* const headers = { |
|
* 'content-length': stat.size, |
|
* 'last-modified': stat.mtime.toUTCString(), |
|
* 'content-type': 'text/plain; charset=utf-8' |
|
* }; |
|
* stream.respondWithFD(fd, headers); |
|
* stream.on('close', () => fs.closeSync(fd)); |
|
* }); |
|
* ``` |
|
* |
|
* The optional `options.statCheck` function may be specified to give user code |
|
* an opportunity to set additional content headers based on the `fs.Stat` details |
|
* of the given fd. If the `statCheck` function is provided, the`http2stream.respondWithFD()` method will perform an `fs.fstat()` call to |
|
* collect details on the provided file descriptor. |
|
* |
|
* The `offset` and `length` options may be used to limit the response to a |
|
* specific range subset. This can be used, for instance, to support HTTP Range |
|
* requests. |
|
* |
|
* The file descriptor or `FileHandle` is not closed when the stream is closed, |
|
* so it will need to be closed manually once it is no longer needed. |
|
* Using the same file descriptor concurrently for multiple streams |
|
* is not supported and may result in data loss. Re-using a file descriptor |
|
* after a stream has finished is supported. |
|
* |
|
* When the `options.waitForTrailers` option is set, the `'wantTrailers'` event |
|
* will be emitted immediately after queuing the last chunk of payload data to be |
|
* sent. The `http2stream.sendTrailers()` method can then be used to sent trailing |
|
* header fields to the peer. |
|
* |
|
* When `options.waitForTrailers` is set, the `Http2Stream` will not automatically |
|
* close when the final `DATA` frame is transmitted. User code _must_ call either`http2stream.sendTrailers()` or `http2stream.close()` to close the`Http2Stream`. |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* const fs = require('fs'); |
|
* |
|
* const server = http2.createServer(); |
|
* server.on('stream', (stream) => { |
|
* const fd = fs.openSync('/some/file', 'r'); |
|
* |
|
* const stat = fs.fstatSync(fd); |
|
* const headers = { |
|
* 'content-length': stat.size, |
|
* 'last-modified': stat.mtime.toUTCString(), |
|
* 'content-type': 'text/plain; charset=utf-8' |
|
* }; |
|
* stream.respondWithFD(fd, headers, { waitForTrailers: true }); |
|
* stream.on('wantTrailers', () => { |
|
* stream.sendTrailers({ ABC: 'some value to send' }); |
|
* }); |
|
* |
|
* stream.on('close', () => fs.closeSync(fd)); |
|
* }); |
|
* ``` |
|
* @since v8.4.0 |
|
* @param fd A readable file descriptor. |
|
*/ |
|
respondWithFD(fd: number | fs.promises.FileHandle, headers?: OutgoingHttpHeaders, options?: ServerStreamFileResponseOptions): void; |
|
/** |
|
* Sends a regular file as the response. The `path` must specify a regular file |
|
* or an `'error'` event will be emitted on the `Http2Stream` object. |
|
* |
|
* When used, the `Http2Stream` object's `Duplex` interface will be closed |
|
* automatically. |
|
* |
|
* The optional `options.statCheck` function may be specified to give user code |
|
* an opportunity to set additional content headers based on the `fs.Stat` details |
|
* of the given file: |
|
* |
|
* If an error occurs while attempting to read the file data, the `Http2Stream`will be closed using an `RST_STREAM` frame using the standard `INTERNAL_ERROR`code. If the `onError` callback is |
|
* defined, then it will be called. Otherwise |
|
* the stream will be destroyed. |
|
* |
|
* Example using a file path: |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* const server = http2.createServer(); |
|
* server.on('stream', (stream) => { |
|
* function statCheck(stat, headers) { |
|
* headers['last-modified'] = stat.mtime.toUTCString(); |
|
* } |
|
* |
|
* function onError(err) { |
|
* // stream.respond() can throw if the stream has been destroyed by |
|
* // the other side. |
|
* try { |
|
* if (err.code === 'ENOENT') { |
|
* stream.respond({ ':status': 404 }); |
|
* } else { |
|
* stream.respond({ ':status': 500 }); |
|
* } |
|
* } catch (err) { |
|
* // Perform actual error handling. |
|
* console.log(err); |
|
* } |
|
* stream.end(); |
|
* } |
|
* |
|
* stream.respondWithFile('/some/file', |
|
* { 'content-type': 'text/plain; charset=utf-8' }, |
|
* { statCheck, onError }); |
|
* }); |
|
* ``` |
|
* |
|
* The `options.statCheck` function may also be used to cancel the send operation |
|
* by returning `false`. For instance, a conditional request may check the stat |
|
* results to determine if the file has been modified to return an appropriate`304` response: |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* const server = http2.createServer(); |
|
* server.on('stream', (stream) => { |
|
* function statCheck(stat, headers) { |
|
* // Check the stat here... |
|
* stream.respond({ ':status': 304 }); |
|
* return false; // Cancel the send operation |
|
* } |
|
* stream.respondWithFile('/some/file', |
|
* { 'content-type': 'text/plain; charset=utf-8' }, |
|
* { statCheck }); |
|
* }); |
|
* ``` |
|
* |
|
* The `content-length` header field will be automatically set. |
|
* |
|
* The `offset` and `length` options may be used to limit the response to a |
|
* specific range subset. This can be used, for instance, to support HTTP Range |
|
* requests. |
|
* |
|
* The `options.onError` function may also be used to handle all the errors |
|
* that could happen before the delivery of the file is initiated. The |
|
* default behavior is to destroy the stream. |
|
* |
|
* When the `options.waitForTrailers` option is set, the `'wantTrailers'` event |
|
* will be emitted immediately after queuing the last chunk of payload data to be |
|
* sent. The `http2stream.sendTrailers()` method can then be used to sent trailing |
|
* header fields to the peer. |
|
* |
|
* When `options.waitForTrailers` is set, the `Http2Stream` will not automatically |
|
* close when the final `DATA` frame is transmitted. User code must call either`http2stream.sendTrailers()` or `http2stream.close()` to close the`Http2Stream`. |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* const server = http2.createServer(); |
|
* server.on('stream', (stream) => { |
|
* stream.respondWithFile('/some/file', |
|
* { 'content-type': 'text/plain; charset=utf-8' }, |
|
* { waitForTrailers: true }); |
|
* stream.on('wantTrailers', () => { |
|
* stream.sendTrailers({ ABC: 'some value to send' }); |
|
* }); |
|
* }); |
|
* ``` |
|
* @since v8.4.0 |
|
*/ |
|
respondWithFile(path: string, headers?: OutgoingHttpHeaders, options?: ServerStreamFileResponseOptionsWithError): void; |
|
} |
|
// 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; |
|
} |
|
export interface ClientSessionRequestOptions { |
|
endStream?: boolean | undefined; |
|
exclusive?: boolean | undefined; |
|
parent?: number | undefined; |
|
weight?: number | undefined; |
|
waitForTrailers?: boolean | undefined; |
|
} |
|
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; |
|
} |
|
export interface Http2Session extends EventEmitter { |
|
/** |
|
* Value will be `undefined` if the `Http2Session` is not yet connected to a |
|
* socket, `h2c` if the `Http2Session` is not connected to a `TLSSocket`, or |
|
* will return the value of the connected `TLSSocket`'s own `alpnProtocol`property. |
|
* @since v9.4.0 |
|
*/ |
|
readonly alpnProtocol?: string | undefined; |
|
/** |
|
* Will be `true` if this `Http2Session` instance has been closed, otherwise`false`. |
|
* @since v9.4.0 |
|
*/ |
|
readonly closed: boolean; |
|
/** |
|
* Will be `true` if this `Http2Session` instance is still connecting, will be set |
|
* to `false` before emitting `connect` event and/or calling the `http2.connect`callback. |
|
* @since v10.0.0 |
|
*/ |
|
readonly connecting: boolean; |
|
/** |
|
* Will be `true` if this `Http2Session` instance has been destroyed and must no |
|
* longer be used, otherwise `false`. |
|
* @since v8.4.0 |
|
*/ |
|
readonly destroyed: boolean; |
|
/** |
|
* Value is `undefined` if the `Http2Session` session socket has not yet been |
|
* connected, `true` if the `Http2Session` is connected with a `TLSSocket`, |
|
* and `false` if the `Http2Session` is connected to any other kind of socket |
|
* or stream. |
|
* @since v9.4.0 |
|
*/ |
|
readonly encrypted?: boolean | undefined; |
|
/** |
|
* A prototype-less object describing the current local settings of this`Http2Session`. The local settings are local to _this_`Http2Session` instance. |
|
* @since v8.4.0 |
|
*/ |
|
readonly localSettings: Settings; |
|
/** |
|
* If the `Http2Session` is connected to a `TLSSocket`, the `originSet` property |
|
* will return an `Array` of origins for which the `Http2Session` may be |
|
* considered authoritative. |
|
* |
|
* The `originSet` property is only available when using a secure TLS connection. |
|
* @since v9.4.0 |
|
*/ |
|
readonly originSet?: string[] | undefined; |
|
/** |
|
* Indicates whether the `Http2Session` is currently waiting for acknowledgment of |
|
* a sent `SETTINGS` frame. Will be `true` after calling the`http2session.settings()` method. Will be `false` once all sent `SETTINGS`frames have been acknowledged. |
|
* @since v8.4.0 |
|
*/ |
|
readonly pendingSettingsAck: boolean; |
|
/** |
|
* A prototype-less object describing the current remote settings of this`Http2Session`. The remote settings are set by the _connected_ HTTP/2 peer. |
|
* @since v8.4.0 |
|
*/ |
|
readonly remoteSettings: Settings; |
|
/** |
|
* Returns a `Proxy` object that acts as a `net.Socket` (or `tls.TLSSocket`) but |
|
* limits available methods to ones safe to use with HTTP/2. |
|
* |
|
* `destroy`, `emit`, `end`, `pause`, `read`, `resume`, and `write` will throw |
|
* an error with code `ERR_HTTP2_NO_SOCKET_MANIPULATION`. See `Http2Session and Sockets` for more information. |
|
* |
|
* `setTimeout` method will be called on this `Http2Session`. |
|
* |
|
* All other interactions will be routed directly to the socket. |
|
* @since v8.4.0 |
|
*/ |
|
readonly socket: net.Socket | tls.TLSSocket; |
|
/** |
|
* Provides miscellaneous information about the current state of the`Http2Session`. |
|
* |
|
* An object describing the current status of this `Http2Session`. |
|
* @since v8.4.0 |
|
*/ |
|
readonly state: SessionState; |
|
/** |
|
* The `http2session.type` will be equal to`http2.constants.NGHTTP2_SESSION_SERVER` if this `Http2Session` instance is a |
|
* server, and `http2.constants.NGHTTP2_SESSION_CLIENT` if the instance is a |
|
* client. |
|
* @since v8.4.0 |
|
*/ |
|
readonly type: number; |
|
/** |
|
* Gracefully closes the `Http2Session`, allowing any existing streams to |
|
* complete on their own and preventing new `Http2Stream` instances from being |
|
* created. Once closed, `http2session.destroy()`_might_ be called if there |
|
* are no open `Http2Stream` instances. |
|
* |
|
* If specified, the `callback` function is registered as a handler for the`'close'` event. |
|
* @since v9.4.0 |
|
*/ |
|
close(callback?: () => void): void; |
|
/** |
|
* Immediately terminates the `Http2Session` and the associated `net.Socket` or`tls.TLSSocket`. |
|
* |
|
* Once destroyed, the `Http2Session` will emit the `'close'` event. If `error`is not undefined, an `'error'` event will be emitted immediately before the`'close'` event. |
|
* |
|
* If there are any remaining open `Http2Streams` associated with the`Http2Session`, those will also be destroyed. |
|
* @since v8.4.0 |
|
* @param error An `Error` object if the `Http2Session` is being destroyed due to an error. |
|
* @param code The HTTP/2 error code to send in the final `GOAWAY` frame. If unspecified, and `error` is not undefined, the default is `INTERNAL_ERROR`, otherwise defaults to `NO_ERROR`. |
|
*/ |
|
destroy(error?: Error, code?: number): void; |
|
/** |
|
* Transmits a `GOAWAY` frame to the connected peer _without_ shutting down the`Http2Session`. |
|
* @since v9.4.0 |
|
* @param code An HTTP/2 error code |
|
* @param lastStreamID The numeric ID of the last processed `Http2Stream` |
|
* @param opaqueData A `TypedArray` or `DataView` instance containing additional data to be carried within the `GOAWAY` frame. |
|
*/ |
|
goaway(code?: number, lastStreamID?: number, opaqueData?: NodeJS.ArrayBufferView): void; |
|
/** |
|
* Sends a `PING` frame to the connected HTTP/2 peer. A `callback` function must |
|
* be provided. The method will return `true` if the `PING` was sent, `false`otherwise. |
|
* |
|
* The maximum number of outstanding (unacknowledged) pings is determined by the`maxOutstandingPings` configuration option. The default maximum is 10. |
|
* |
|
* If provided, the `payload` must be a `Buffer`, `TypedArray`, or `DataView`containing 8 bytes of data that will be transmitted with the `PING` and |
|
* returned with the ping acknowledgment. |
|
* |
|
* The callback will be invoked with three arguments: an error argument that will |
|
* be `null` if the `PING` was successfully acknowledged, a `duration` argument |
|
* that reports the number of milliseconds elapsed since the ping was sent and the |
|
* acknowledgment was received, and a `Buffer` containing the 8-byte `PING`payload. |
|
* |
|
* ```js |
|
* session.ping(Buffer.from('abcdefgh'), (err, duration, payload) => { |
|
* if (!err) { |
|
* console.log(`Ping acknowledged in ${duration} milliseconds`); |
|
* console.log(`With payload '${payload.toString()}'`); |
|
* } |
|
* }); |
|
* ``` |
|
* |
|
* If the `payload` argument is not specified, the default payload will be the |
|
* 64-bit timestamp (little endian) marking the start of the `PING` duration. |
|
* @since v8.9.3 |
|
* @param payload Optional ping payload. |
|
*/ |
|
ping(callback: (err: Error | null, duration: number, payload: Buffer) => void): boolean; |
|
ping(payload: NodeJS.ArrayBufferView, callback: (err: Error | null, duration: number, payload: Buffer) => void): boolean; |
|
/** |
|
* Calls `ref()` on this `Http2Session`instance's underlying `net.Socket`. |
|
* @since v9.4.0 |
|
*/ |
|
ref(): void; |
|
/** |
|
* Sets the local endpoint's window size. |
|
* The `windowSize` is the total window size to set, not |
|
* the delta. |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* |
|
* const server = http2.createServer(); |
|
* const expectedWindowSize = 2 ** 20; |
|
* server.on('connect', (session) => { |
|
* |
|
* // Set local window size to be 2 ** 20 |
|
* session.setLocalWindowSize(expectedWindowSize); |
|
* }); |
|
* ``` |
|
* @since v15.3.0, v14.18.0 |
|
*/ |
|
setLocalWindowSize(windowSize: number): void; |
|
/** |
|
* Used to set a callback function that is called when there is no activity on |
|
* the `Http2Session` after `msecs` milliseconds. The given `callback` is |
|
* registered as a listener on the `'timeout'` event. |
|
* @since v8.4.0 |
|
*/ |
|
setTimeout(msecs: number, callback?: () => void): void; |
|
/** |
|
* Updates the current local settings for this `Http2Session` and sends a new`SETTINGS` frame to the connected HTTP/2 peer. |
|
* |
|
* Once called, the `http2session.pendingSettingsAck` property will be `true`while the session is waiting for the remote peer to acknowledge the new |
|
* settings. |
|
* |
|
* The new settings will not become effective until the `SETTINGS` acknowledgment |
|
* is received and the `'localSettings'` event is emitted. It is possible to send |
|
* multiple `SETTINGS` frames while acknowledgment is still pending. |
|
* @since v8.4.0 |
|
* @param callback Callback that is called once the session is connected or right away if the session is already connected. |
|
*/ |
|
settings(settings: Settings): void; |
|
/** |
|
* Calls `unref()` on this `Http2Session`instance's underlying `net.Socket`. |
|
* @since v9.4.0 |
|
*/ |
|
unref(): void; |
|
addListener(event: 'close', listener: () => void): this; |
|
addListener(event: 'error', listener: (err: Error) => void): this; |
|
addListener(event: 'frameError', listener: (frameType: number, errorCode: number, streamID: number) => void): this; |
|
addListener(event: 'goaway', listener: (errorCode: number, lastStreamID: number, opaqueData: Buffer) => void): this; |
|
addListener(event: 'localSettings', listener: (settings: Settings) => void): this; |
|
addListener(event: 'ping', listener: () => void): this; |
|
addListener(event: 'remoteSettings', listener: (settings: Settings) => void): this; |
|
addListener(event: 'timeout', listener: () => void): this; |
|
addListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
emit(event: 'close'): boolean; |
|
emit(event: 'error', err: Error): boolean; |
|
emit(event: 'frameError', frameType: number, errorCode: number, streamID: number): boolean; |
|
emit(event: 'goaway', errorCode: number, lastStreamID: number, opaqueData: Buffer): boolean; |
|
emit(event: 'localSettings', settings: Settings): boolean; |
|
emit(event: 'ping'): boolean; |
|
emit(event: 'remoteSettings', settings: Settings): boolean; |
|
emit(event: 'timeout'): boolean; |
|
emit(event: string | symbol, ...args: any[]): boolean; |
|
on(event: 'close', listener: () => void): this; |
|
on(event: 'error', listener: (err: Error) => void): this; |
|
on(event: 'frameError', listener: (frameType: number, errorCode: number, streamID: number) => void): this; |
|
on(event: 'goaway', listener: (errorCode: number, lastStreamID: number, opaqueData: Buffer) => void): this; |
|
on(event: 'localSettings', listener: (settings: Settings) => void): this; |
|
on(event: 'ping', listener: () => void): this; |
|
on(event: 'remoteSettings', listener: (settings: Settings) => void): this; |
|
on(event: 'timeout', listener: () => void): this; |
|
on(event: string | symbol, listener: (...args: any[]) => void): this; |
|
once(event: 'close', listener: () => void): this; |
|
once(event: 'error', listener: (err: Error) => void): this; |
|
once(event: 'frameError', listener: (frameType: number, errorCode: number, streamID: number) => void): this; |
|
once(event: 'goaway', listener: (errorCode: number, lastStreamID: number, opaqueData: Buffer) => void): this; |
|
once(event: 'localSettings', listener: (settings: Settings) => void): this; |
|
once(event: 'ping', listener: () => void): this; |
|
once(event: 'remoteSettings', listener: (settings: Settings) => void): this; |
|
once(event: 'timeout', listener: () => void): this; |
|
once(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependListener(event: 'close', listener: () => void): this; |
|
prependListener(event: 'error', listener: (err: Error) => void): this; |
|
prependListener(event: 'frameError', listener: (frameType: number, errorCode: number, streamID: number) => void): this; |
|
prependListener(event: 'goaway', listener: (errorCode: number, lastStreamID: number, opaqueData: Buffer) => void): this; |
|
prependListener(event: 'localSettings', listener: (settings: Settings) => void): this; |
|
prependListener(event: 'ping', listener: () => void): this; |
|
prependListener(event: 'remoteSettings', listener: (settings: Settings) => void): this; |
|
prependListener(event: 'timeout', listener: () => void): this; |
|
prependListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependOnceListener(event: 'close', listener: () => void): this; |
|
prependOnceListener(event: 'error', listener: (err: Error) => void): this; |
|
prependOnceListener(event: 'frameError', listener: (frameType: number, errorCode: number, streamID: number) => void): this; |
|
prependOnceListener(event: 'goaway', listener: (errorCode: number, lastStreamID: number, opaqueData: Buffer) => void): this; |
|
prependOnceListener(event: 'localSettings', listener: (settings: Settings) => void): this; |
|
prependOnceListener(event: 'ping', listener: () => void): this; |
|
prependOnceListener(event: 'remoteSettings', listener: (settings: Settings) => void): this; |
|
prependOnceListener(event: 'timeout', listener: () => void): this; |
|
prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
} |
|
export interface ClientHttp2Session extends Http2Session { |
|
/** |
|
* For HTTP/2 Client `Http2Session` instances only, the `http2session.request()`creates and returns an `Http2Stream` instance that can be used to send an |
|
* HTTP/2 request to the connected server. |
|
* |
|
* This method is only available if `http2session.type` is equal to`http2.constants.NGHTTP2_SESSION_CLIENT`. |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* const clientSession = http2.connect('https://localhost:1234'); |
|
* const { |
|
* HTTP2_HEADER_PATH, |
|
* HTTP2_HEADER_STATUS |
|
* } = http2.constants; |
|
* |
|
* const req = clientSession.request({ [HTTP2_HEADER_PATH]: '/' }); |
|
* req.on('response', (headers) => { |
|
* console.log(headers[HTTP2_HEADER_STATUS]); |
|
* req.on('data', (chunk) => { // .. }); |
|
* req.on('end', () => { // .. }); |
|
* }); |
|
* ``` |
|
* |
|
* When the `options.waitForTrailers` option is set, the `'wantTrailers'` event |
|
* is emitted immediately after queuing the last chunk of payload data to be sent. |
|
* The `http2stream.sendTrailers()` method can then be called to send trailing |
|
* headers to the peer. |
|
* |
|
* When `options.waitForTrailers` is set, the `Http2Stream` will not automatically |
|
* close when the final `DATA` frame is transmitted. User code must call either`http2stream.sendTrailers()` or `http2stream.close()` to close the`Http2Stream`. |
|
* |
|
* When `options.signal` is set with an `AbortSignal` and then `abort` on the |
|
* corresponding `AbortController` is called, the request will emit an `'error'`event with an `AbortError` error. |
|
* |
|
* The `:method` and `:path` pseudo-headers are not specified within `headers`, |
|
* they respectively default to: |
|
* |
|
* * `:method` \= `'GET'` |
|
* * `:path` \= `/` |
|
* @since v8.4.0 |
|
*/ |
|
request(headers?: OutgoingHttpHeaders, options?: ClientSessionRequestOptions): ClientHttp2Stream; |
|
addListener(event: 'altsvc', listener: (alt: string, origin: string, stream: number) => void): this; |
|
addListener(event: 'origin', listener: (origins: string[]) => void): this; |
|
addListener(event: 'connect', listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this; |
|
addListener(event: 'stream', listener: (stream: ClientHttp2Stream, headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void): this; |
|
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: '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; |
|
on(event: 'altsvc', listener: (alt: string, origin: string, stream: number) => void): this; |
|
on(event: 'origin', listener: (origins: string[]) => void): this; |
|
on(event: 'connect', listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this; |
|
on(event: 'stream', listener: (stream: ClientHttp2Stream, headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void): this; |
|
on(event: string | symbol, listener: (...args: any[]) => void): this; |
|
once(event: 'altsvc', listener: (alt: string, origin: string, stream: number) => void): this; |
|
once(event: 'origin', listener: (origins: string[]) => void): this; |
|
once(event: 'connect', listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this; |
|
once(event: 'stream', listener: (stream: ClientHttp2Stream, headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void): this; |
|
once(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependListener(event: 'altsvc', listener: (alt: string, origin: string, stream: number) => void): this; |
|
prependListener(event: 'origin', listener: (origins: string[]) => void): this; |
|
prependListener(event: 'connect', listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this; |
|
prependListener(event: 'stream', listener: (stream: ClientHttp2Stream, headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void): this; |
|
prependListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependOnceListener(event: 'altsvc', listener: (alt: string, origin: string, stream: number) => void): this; |
|
prependOnceListener(event: 'origin', listener: (origins: string[]) => void): this; |
|
prependOnceListener(event: 'connect', listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this; |
|
prependOnceListener(event: 'stream', listener: (stream: ClientHttp2Stream, headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void): this; |
|
prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
} |
|
export interface AlternativeServiceOptions { |
|
origin: number | string | url.URL; |
|
} |
|
export interface ServerHttp2Session extends Http2Session { |
|
readonly server: Http2Server | Http2SecureServer; |
|
/** |
|
* Submits an `ALTSVC` frame (as defined by [RFC 7838](https://tools.ietf.org/html/rfc7838)) to the connected client. |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* |
|
* const server = http2.createServer(); |
|
* server.on('session', (session) => { |
|
* // Set altsvc for origin https://example.org:80 |
|
* session.altsvc('h2=":8000"', 'https://example.org:80'); |
|
* }); |
|
* |
|
* server.on('stream', (stream) => { |
|
* // Set altsvc for a specific stream |
|
* stream.session.altsvc('h2=":8000"', stream.id); |
|
* }); |
|
* ``` |
|
* |
|
* Sending an `ALTSVC` frame with a specific stream ID indicates that the alternate |
|
* service is associated with the origin of the given `Http2Stream`. |
|
* |
|
* The `alt` and origin string _must_ contain only ASCII bytes and are |
|
* strictly interpreted as a sequence of ASCII bytes. The special value `'clear'`may be passed to clear any previously set alternative service for a given |
|
* domain. |
|
* |
|
* When a string is passed for the `originOrStream` argument, it will be parsed as |
|
* a URL and the origin will be derived. For instance, the origin for the |
|
* HTTP URL `'https://example.org/foo/bar'` is the ASCII string`'https://example.org'`. An error will be thrown if either the given string |
|
* cannot be parsed as a URL or if a valid origin cannot be derived. |
|
* |
|
* A `URL` object, or any object with an `origin` property, may be passed as`originOrStream`, in which case the value of the `origin` property will be |
|
* used. The value of the `origin` property _must_ be a properly serialized |
|
* ASCII origin. |
|
* @since v9.4.0 |
|
* @param alt A description of the alternative service configuration as defined by `RFC 7838`. |
|
* @param originOrStream Either a URL string specifying the origin (or an `Object` with an `origin` property) or the numeric identifier of an active `Http2Stream` as given by the |
|
* `http2stream.id` property. |
|
*/ |
|
altsvc(alt: string, originOrStream: number | string | url.URL | AlternativeServiceOptions): void; |
|
/** |
|
* Submits an `ORIGIN` frame (as defined by [RFC 8336](https://tools.ietf.org/html/rfc8336)) to the connected client |
|
* to advertise the set of origins for which the server is capable of providing |
|
* authoritative responses. |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* const options = getSecureOptionsSomehow(); |
|
* const server = http2.createSecureServer(options); |
|
* server.on('stream', (stream) => { |
|
* stream.respond(); |
|
* stream.end('ok'); |
|
* }); |
|
* server.on('session', (session) => { |
|
* session.origin('https://example.com', 'https://example.org'); |
|
* }); |
|
* ``` |
|
* |
|
* When a string is passed as an `origin`, it will be parsed as a URL and the |
|
* origin will be derived. For instance, the origin for the HTTP URL`'https://example.org/foo/bar'` is the ASCII string`'https://example.org'`. An error will be thrown if either the given |
|
* string |
|
* cannot be parsed as a URL or if a valid origin cannot be derived. |
|
* |
|
* A `URL` object, or any object with an `origin` property, may be passed as |
|
* an `origin`, in which case the value of the `origin` property will be |
|
* used. The value of the `origin` property _must_ be a properly serialized |
|
* ASCII origin. |
|
* |
|
* Alternatively, the `origins` option may be used when creating a new HTTP/2 |
|
* server using the `http2.createSecureServer()` method: |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* const options = getSecureOptionsSomehow(); |
|
* options.origins = ['https://example.com', 'https://example.org']; |
|
* const server = http2.createSecureServer(options); |
|
* server.on('stream', (stream) => { |
|
* stream.respond(); |
|
* stream.end('ok'); |
|
* }); |
|
* ``` |
|
* @since v10.12.0 |
|
* @param origins One or more URL Strings passed as separate arguments. |
|
*/ |
|
origin( |
|
...origins: Array< |
|
| string |
|
| url.URL |
|
| { |
|
origin: string; |
|
} |
|
> |
|
): void; |
|
addListener(event: 'connect', listener: (session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this; |
|
addListener(event: 'stream', listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this; |
|
addListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
emit(event: 'connect', session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket): boolean; |
|
emit(event: 'stream', stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number): boolean; |
|
emit(event: string | symbol, ...args: any[]): boolean; |
|
on(event: 'connect', listener: (session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this; |
|
on(event: 'stream', listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this; |
|
on(event: string | symbol, listener: (...args: any[]) => void): this; |
|
once(event: 'connect', listener: (session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this; |
|
once(event: 'stream', listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this; |
|
once(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependListener(event: 'connect', listener: (session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this; |
|
prependListener(event: 'stream', listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this; |
|
prependListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependOnceListener(event: 'connect', listener: (session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this; |
|
prependOnceListener(event: 'stream', listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this; |
|
prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
} |
|
// 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; |
|
/** |
|
* Specifies a timeout in milliseconds that |
|
* a server should wait when an [`'unknownProtocol'`][] is emitted. If the |
|
* socket has not been destroyed by that time the server will destroy it. |
|
* @default 100000 |
|
*/ |
|
unknownProtocolTimeout?: number | undefined; |
|
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; |
|
} |
|
export interface ServerSessionOptions extends SessionOptions { |
|
Http1IncomingMessage?: typeof IncomingMessage | undefined; |
|
Http1ServerResponse?: typeof ServerResponse | undefined; |
|
Http2ServerRequest?: typeof Http2ServerRequest | undefined; |
|
Http2ServerResponse?: typeof Http2ServerResponse | undefined; |
|
} |
|
export interface SecureClientSessionOptions extends ClientSessionOptions, tls.ConnectionOptions {} |
|
export interface SecureServerSessionOptions extends ServerSessionOptions, tls.TlsOptions {} |
|
export interface ServerOptions extends ServerSessionOptions {} |
|
export interface SecureServerOptions extends SecureServerSessionOptions { |
|
allowHTTP1?: boolean | undefined; |
|
origins?: string[] | undefined; |
|
} |
|
interface HTTP2ServerCommon { |
|
setTimeout(msec?: number, callback?: () => void): this; |
|
/** |
|
* Throws ERR_HTTP2_INVALID_SETTING_VALUE for invalid settings values. |
|
* Throws ERR_INVALID_ARG_TYPE for invalid settings argument. |
|
*/ |
|
updateSettings(settings: Settings): void; |
|
} |
|
export interface Http2Server extends net.Server, HTTP2ServerCommon { |
|
addListener(event: 'checkContinue', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
addListener(event: 'request', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
addListener(event: 'session', listener: (session: ServerHttp2Session) => void): this; |
|
addListener(event: 'sessionError', listener: (err: Error) => void): this; |
|
addListener(event: 'stream', listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this; |
|
addListener(event: 'timeout', listener: () => void): this; |
|
addListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
emit(event: 'checkContinue', request: Http2ServerRequest, response: Http2ServerResponse): boolean; |
|
emit(event: 'request', request: Http2ServerRequest, response: Http2ServerResponse): boolean; |
|
emit(event: 'session', session: ServerHttp2Session): boolean; |
|
emit(event: 'sessionError', err: Error): boolean; |
|
emit(event: 'stream', stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number): boolean; |
|
emit(event: 'timeout'): boolean; |
|
emit(event: string | symbol, ...args: any[]): boolean; |
|
on(event: 'checkContinue', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
on(event: 'request', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
on(event: 'session', listener: (session: ServerHttp2Session) => void): this; |
|
on(event: 'sessionError', listener: (err: Error) => void): this; |
|
on(event: 'stream', listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this; |
|
on(event: 'timeout', listener: () => void): this; |
|
on(event: string | symbol, listener: (...args: any[]) => void): this; |
|
once(event: 'checkContinue', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
once(event: 'request', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
once(event: 'session', listener: (session: ServerHttp2Session) => void): this; |
|
once(event: 'sessionError', listener: (err: Error) => void): this; |
|
once(event: 'stream', listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this; |
|
once(event: 'timeout', listener: () => void): this; |
|
once(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependListener(event: 'checkContinue', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
prependListener(event: 'request', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
prependListener(event: 'session', listener: (session: ServerHttp2Session) => void): this; |
|
prependListener(event: 'sessionError', listener: (err: Error) => void): this; |
|
prependListener(event: 'stream', listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this; |
|
prependListener(event: 'timeout', listener: () => void): this; |
|
prependListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependOnceListener(event: 'checkContinue', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
prependOnceListener(event: 'request', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
prependOnceListener(event: 'session', listener: (session: ServerHttp2Session) => void): this; |
|
prependOnceListener(event: 'sessionError', listener: (err: Error) => void): this; |
|
prependOnceListener(event: 'stream', listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this; |
|
prependOnceListener(event: 'timeout', listener: () => void): this; |
|
prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
} |
|
export interface Http2SecureServer extends tls.Server, HTTP2ServerCommon { |
|
addListener(event: 'checkContinue', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
addListener(event: 'request', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
addListener(event: 'session', listener: (session: ServerHttp2Session) => void): this; |
|
addListener(event: 'sessionError', listener: (err: Error) => void): this; |
|
addListener(event: 'stream', listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this; |
|
addListener(event: 'timeout', listener: () => void): this; |
|
addListener(event: 'unknownProtocol', listener: (socket: tls.TLSSocket) => void): this; |
|
addListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
emit(event: 'checkContinue', request: Http2ServerRequest, response: Http2ServerResponse): boolean; |
|
emit(event: 'request', request: Http2ServerRequest, response: Http2ServerResponse): boolean; |
|
emit(event: 'session', session: ServerHttp2Session): boolean; |
|
emit(event: 'sessionError', err: Error): boolean; |
|
emit(event: 'stream', stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number): boolean; |
|
emit(event: 'timeout'): boolean; |
|
emit(event: 'unknownProtocol', socket: tls.TLSSocket): boolean; |
|
emit(event: string | symbol, ...args: any[]): boolean; |
|
on(event: 'checkContinue', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
on(event: 'request', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
on(event: 'session', listener: (session: ServerHttp2Session) => void): this; |
|
on(event: 'sessionError', listener: (err: Error) => void): this; |
|
on(event: 'stream', listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this; |
|
on(event: 'timeout', listener: () => void): this; |
|
on(event: 'unknownProtocol', listener: (socket: tls.TLSSocket) => void): this; |
|
on(event: string | symbol, listener: (...args: any[]) => void): this; |
|
once(event: 'checkContinue', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
once(event: 'request', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
once(event: 'session', listener: (session: ServerHttp2Session) => void): this; |
|
once(event: 'sessionError', listener: (err: Error) => void): this; |
|
once(event: 'stream', listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this; |
|
once(event: 'timeout', listener: () => void): this; |
|
once(event: 'unknownProtocol', listener: (socket: tls.TLSSocket) => void): this; |
|
once(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependListener(event: 'checkContinue', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
prependListener(event: 'request', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
prependListener(event: 'session', listener: (session: ServerHttp2Session) => void): this; |
|
prependListener(event: 'sessionError', listener: (err: Error) => void): this; |
|
prependListener(event: 'stream', listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this; |
|
prependListener(event: 'timeout', listener: () => void): this; |
|
prependListener(event: 'unknownProtocol', listener: (socket: tls.TLSSocket) => void): this; |
|
prependListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependOnceListener(event: 'checkContinue', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
prependOnceListener(event: 'request', listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this; |
|
prependOnceListener(event: 'session', listener: (session: ServerHttp2Session) => void): this; |
|
prependOnceListener(event: 'sessionError', listener: (err: Error) => void): this; |
|
prependOnceListener(event: 'stream', listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this; |
|
prependOnceListener(event: 'timeout', listener: () => void): this; |
|
prependOnceListener(event: 'unknownProtocol', listener: (socket: tls.TLSSocket) => void): this; |
|
prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
} |
|
/** |
|
* A `Http2ServerRequest` object is created by {@link Server} or {@link SecureServer} and passed as the first argument to the `'request'` event. It may be used to access a request status, |
|
* headers, and |
|
* data. |
|
* @since v8.4.0 |
|
*/ |
|
export class Http2ServerRequest extends stream.Readable { |
|
constructor(stream: ServerHttp2Stream, headers: IncomingHttpHeaders, options: stream.ReadableOptions, rawHeaders: ReadonlyArray<string>); |
|
/** |
|
* The `request.aborted` property will be `true` if the request has |
|
* been aborted. |
|
* @since v10.1.0 |
|
*/ |
|
readonly aborted: boolean; |
|
/** |
|
* The request authority pseudo header field. Because HTTP/2 allows requests |
|
* to set either `:authority` or `host`, this value is derived from`req.headers[':authority']` if present. Otherwise, it is derived from`req.headers['host']`. |
|
* @since v8.4.0 |
|
*/ |
|
readonly authority: string; |
|
/** |
|
* See `request.socket`. |
|
* @since v8.4.0 |
|
* @deprecated Since v13.0.0 - Use `socket`. |
|
*/ |
|
readonly connection: net.Socket | tls.TLSSocket; |
|
/** |
|
* The `request.complete` property will be `true` if the request has |
|
* been completed, aborted, or destroyed. |
|
* @since v12.10.0 |
|
*/ |
|
readonly complete: boolean; |
|
/** |
|
* The request/response headers object. |
|
* |
|
* Key-value pairs of header names and values. Header names are lower-cased. |
|
* |
|
* ```js |
|
* // Prints something like: |
|
* // |
|
* // { 'user-agent': 'curl/7.22.0', |
|
* // host: '127.0.0.1:8000', |
|
* // accept: '*' } |
|
* console.log(request.headers); |
|
* ``` |
|
* |
|
* See `HTTP/2 Headers Object`. |
|
* |
|
* In HTTP/2, the request path, host name, protocol, and method are represented as |
|
* special headers prefixed with the `:` character (e.g. `':path'`). These special |
|
* headers will be included in the `request.headers` object. Care must be taken not |
|
* to inadvertently modify these special headers or errors may occur. For instance, |
|
* removing all headers from the request will cause errors to occur: |
|
* |
|
* ```js |
|
* removeAllHeaders(request.headers); |
|
* assert(request.url); // Fails because the :path header has been removed |
|
* ``` |
|
* @since v8.4.0 |
|
*/ |
|
readonly headers: IncomingHttpHeaders; |
|
/** |
|
* In case of server request, the HTTP version sent by the client. In the case of |
|
* client response, the HTTP version of the connected-to server. Returns`'2.0'`. |
|
* |
|
* Also `message.httpVersionMajor` is the first integer and`message.httpVersionMinor` is the second. |
|
* @since v8.4.0 |
|
*/ |
|
readonly httpVersion: string; |
|
readonly httpVersionMinor: number; |
|
readonly httpVersionMajor: number; |
|
/** |
|
* The request method as a string. Read-only. Examples: `'GET'`, `'DELETE'`. |
|
* @since v8.4.0 |
|
*/ |
|
readonly method: string; |
|
/** |
|
* The raw request/response headers list exactly as they were received. |
|
* |
|
* The keys and values are in the same list. It is _not_ a |
|
* list of tuples. So, the even-numbered offsets are key values, and the |
|
* odd-numbered offsets are the associated values. |
|
* |
|
* Header names are not lowercased, and duplicates are not merged. |
|
* |
|
* ```js |
|
* // Prints something like: |
|
* // |
|
* // [ 'user-agent', |
|
* // 'this is invalid because there can be only one', |
|
* // 'User-Agent', |
|
* // 'curl/7.22.0', |
|
* // 'Host', |
|
* // '127.0.0.1:8000', |
|
* // 'ACCEPT', |
|
* // '*' ] |
|
* console.log(request.rawHeaders); |
|
* ``` |
|
* @since v8.4.0 |
|
*/ |
|
readonly rawHeaders: string[]; |
|
/** |
|
* The raw request/response trailer keys and values exactly as they were |
|
* received. Only populated at the `'end'` event. |
|
* @since v8.4.0 |
|
*/ |
|
readonly rawTrailers: string[]; |
|
/** |
|
* The request scheme pseudo header field indicating the scheme |
|
* portion of the target URL. |
|
* @since v8.4.0 |
|
*/ |
|
readonly scheme: string; |
|
/** |
|
* Returns a `Proxy` object that acts as a `net.Socket` (or `tls.TLSSocket`) but |
|
* applies getters, setters, and methods based on HTTP/2 logic. |
|
* |
|
* `destroyed`, `readable`, and `writable` properties will be retrieved from and |
|
* set on `request.stream`. |
|
* |
|
* `destroy`, `emit`, `end`, `on` and `once` methods will be called on`request.stream`. |
|
* |
|
* `setTimeout` method will be called on `request.stream.session`. |
|
* |
|
* `pause`, `read`, `resume`, and `write` will throw an error with code`ERR_HTTP2_NO_SOCKET_MANIPULATION`. See `Http2Session and Sockets` for |
|
* more information. |
|
* |
|
* All other interactions will be routed directly to the socket. With TLS support, |
|
* use `request.socket.getPeerCertificate()` to obtain the client's |
|
* authentication details. |
|
* @since v8.4.0 |
|
*/ |
|
readonly socket: net.Socket | tls.TLSSocket; |
|
/** |
|
* The `Http2Stream` object backing the request. |
|
* @since v8.4.0 |
|
*/ |
|
readonly stream: ServerHttp2Stream; |
|
/** |
|
* The request/response trailers object. Only populated at the `'end'` event. |
|
* @since v8.4.0 |
|
*/ |
|
readonly trailers: IncomingHttpHeaders; |
|
/** |
|
* Request URL string. This contains only the URL that is present in the actual |
|
* HTTP request. If the request is: |
|
* |
|
* ```http |
|
* GET /status?name=ryan HTTP/1.1 |
|
* Accept: text/plain |
|
* ``` |
|
* |
|
* Then `request.url` will be: |
|
* |
|
* ```js |
|
* '/status?name=ryan' |
|
* ``` |
|
* |
|
* To parse the url into its parts, `new URL()` can be used: |
|
* |
|
* ```console |
|
* $ node |
|
* > new URL('/status?name=ryan', 'http://example.com') |
|
* URL { |
|
* href: 'http://example.com/status?name=ryan', |
|
* origin: 'http://example.com', |
|
* protocol: 'http:', |
|
* username: '', |
|
* password: '', |
|
* host: 'example.com', |
|
* hostname: 'example.com', |
|
* port: '', |
|
* pathname: '/status', |
|
* search: '?name=ryan', |
|
* searchParams: URLSearchParams { 'name' => 'ryan' }, |
|
* hash: '' |
|
* } |
|
* ``` |
|
* @since v8.4.0 |
|
*/ |
|
url: string; |
|
/** |
|
* Sets the `Http2Stream`'s timeout value to `msecs`. If a callback is |
|
* provided, then it is added as a listener on the `'timeout'` event on |
|
* the response object. |
|
* |
|
* If no `'timeout'` listener is added to the request, the response, or |
|
* the server, then `Http2Stream` s are destroyed when they time out. If a |
|
* handler is assigned to the request, the response, or the server's `'timeout'`events, timed out sockets must be handled explicitly. |
|
* @since v8.4.0 |
|
*/ |
|
setTimeout(msecs: number, callback?: () => void): void; |
|
read(size?: number): Buffer | string | null; |
|
addListener(event: 'aborted', listener: (hadError: boolean, code: number) => void): this; |
|
addListener(event: 'close', listener: () => void): this; |
|
addListener(event: 'data', listener: (chunk: Buffer | string) => void): this; |
|
addListener(event: 'end', listener: () => void): this; |
|
addListener(event: 'readable', listener: () => void): this; |
|
addListener(event: 'error', listener: (err: Error) => void): this; |
|
addListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
emit(event: 'aborted', hadError: boolean, code: number): boolean; |
|
emit(event: 'close'): boolean; |
|
emit(event: 'data', chunk: Buffer | string): boolean; |
|
emit(event: 'end'): boolean; |
|
emit(event: 'readable'): boolean; |
|
emit(event: 'error', err: Error): boolean; |
|
emit(event: string | symbol, ...args: any[]): boolean; |
|
on(event: 'aborted', listener: (hadError: boolean, code: number) => void): this; |
|
on(event: 'close', listener: () => void): this; |
|
on(event: 'data', listener: (chunk: Buffer | string) => void): this; |
|
on(event: 'end', listener: () => void): this; |
|
on(event: 'readable', listener: () => void): this; |
|
on(event: 'error', listener: (err: Error) => void): this; |
|
on(event: string | symbol, listener: (...args: any[]) => void): this; |
|
once(event: 'aborted', listener: (hadError: boolean, code: number) => void): this; |
|
once(event: 'close', listener: () => void): this; |
|
once(event: 'data', listener: (chunk: Buffer | string) => void): this; |
|
once(event: 'end', listener: () => void): this; |
|
once(event: 'readable', listener: () => void): this; |
|
once(event: 'error', listener: (err: Error) => void): this; |
|
once(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependListener(event: 'aborted', listener: (hadError: boolean, code: number) => void): this; |
|
prependListener(event: 'close', listener: () => void): this; |
|
prependListener(event: 'data', listener: (chunk: Buffer | string) => void): this; |
|
prependListener(event: 'end', listener: () => void): this; |
|
prependListener(event: 'readable', listener: () => void): this; |
|
prependListener(event: 'error', listener: (err: Error) => void): this; |
|
prependListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependOnceListener(event: 'aborted', listener: (hadError: boolean, code: number) => void): this; |
|
prependOnceListener(event: 'close', listener: () => void): this; |
|
prependOnceListener(event: 'data', listener: (chunk: Buffer | string) => void): this; |
|
prependOnceListener(event: 'end', listener: () => void): this; |
|
prependOnceListener(event: 'readable', listener: () => void): this; |
|
prependOnceListener(event: 'error', listener: (err: Error) => void): this; |
|
prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
} |
|
/** |
|
* This object is created internally by an HTTP server, not by the user. It is |
|
* passed as the second parameter to the `'request'` event. |
|
* @since v8.4.0 |
|
*/ |
|
export class Http2ServerResponse extends stream.Writable { |
|
constructor(stream: ServerHttp2Stream); |
|
/** |
|
* See `response.socket`. |
|
* @since v8.4.0 |
|
* @deprecated Since v13.0.0 - Use `socket`. |
|
*/ |
|
readonly connection: net.Socket | tls.TLSSocket; |
|
/** |
|
* Boolean value that indicates whether the response has completed. Starts |
|
* as `false`. After `response.end()` executes, the value will be `true`. |
|
* @since v8.4.0 |
|
* @deprecated Since v13.4.0,v12.16.0 - Use `writableEnded`. |
|
*/ |
|
readonly finished: boolean; |
|
/** |
|
* True if headers were sent, false otherwise (read-only). |
|
* @since v8.4.0 |
|
*/ |
|
readonly headersSent: boolean; |
|
/** |
|
* A reference to the original HTTP2 request object. |
|
* @since v15.7.0 |
|
*/ |
|
readonly req: Http2ServerRequest; |
|
/** |
|
* Returns a `Proxy` object that acts as a `net.Socket` (or `tls.TLSSocket`) but |
|
* applies getters, setters, and methods based on HTTP/2 logic. |
|
* |
|
* `destroyed`, `readable`, and `writable` properties will be retrieved from and |
|
* set on `response.stream`. |
|
* |
|
* `destroy`, `emit`, `end`, `on` and `once` methods will be called on`response.stream`. |
|
* |
|
* `setTimeout` method will be called on `response.stream.session`. |
|
* |
|
* `pause`, `read`, `resume`, and `write` will throw an error with code`ERR_HTTP2_NO_SOCKET_MANIPULATION`. See `Http2Session and Sockets` for |
|
* more information. |
|
* |
|
* All other interactions will be routed directly to the socket. |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* const server = http2.createServer((req, res) => { |
|
* const ip = req.socket.remoteAddress; |
|
* const port = req.socket.remotePort; |
|
* res.end(`Your IP address is ${ip} and your source port is ${port}.`); |
|
* }).listen(3000); |
|
* ``` |
|
* @since v8.4.0 |
|
*/ |
|
readonly socket: net.Socket | tls.TLSSocket; |
|
/** |
|
* The `Http2Stream` object backing the response. |
|
* @since v8.4.0 |
|
*/ |
|
readonly stream: ServerHttp2Stream; |
|
/** |
|
* When true, the Date header will be automatically generated and sent in |
|
* the response if it is not already present in the headers. Defaults to true. |
|
* |
|
* This should only be disabled for testing; HTTP requires the Date header |
|
* in responses. |
|
* @since v8.4.0 |
|
*/ |
|
sendDate: boolean; |
|
/** |
|
* When using implicit headers (not calling `response.writeHead()` explicitly), |
|
* this property controls the status code that will be sent to the client when |
|
* the headers get flushed. |
|
* |
|
* ```js |
|
* response.statusCode = 404; |
|
* ``` |
|
* |
|
* After response header was sent to the client, this property indicates the |
|
* status code which was sent out. |
|
* @since v8.4.0 |
|
*/ |
|
statusCode: number; |
|
/** |
|
* Status message is not supported by HTTP/2 (RFC 7540 8.1.2.4). It returns |
|
* an empty string. |
|
* @since v8.4.0 |
|
*/ |
|
statusMessage: ''; |
|
/** |
|
* This method adds HTTP trailing headers (a header but at the end of the |
|
* message) to the response. |
|
* |
|
* Attempting to set a header field name or value that contains invalid characters |
|
* will result in a `TypeError` being thrown. |
|
* @since v8.4.0 |
|
*/ |
|
addTrailers(trailers: OutgoingHttpHeaders): void; |
|
/** |
|
* This method signals to the server that all of the response headers and body |
|
* have been sent; that server should consider this message complete. |
|
* The method, `response.end()`, MUST be called on each response. |
|
* |
|
* If `data` is specified, it is equivalent to calling `response.write(data, encoding)` followed by `response.end(callback)`. |
|
* |
|
* If `callback` is specified, it will be called when the response stream |
|
* is finished. |
|
* @since v8.4.0 |
|
*/ |
|
end(callback?: () => void): this; |
|
end(data: string | Uint8Array, callback?: () => void): this; |
|
end(data: string | Uint8Array, encoding: BufferEncoding, callback?: () => void): this; |
|
/** |
|
* Reads out a header that has already been queued but not sent to the client. |
|
* The name is case-insensitive. |
|
* |
|
* ```js |
|
* const contentType = response.getHeader('content-type'); |
|
* ``` |
|
* @since v8.4.0 |
|
*/ |
|
getHeader(name: string): string; |
|
/** |
|
* Returns an array containing the unique names of the current outgoing headers. |
|
* All header names are lowercase. |
|
* |
|
* ```js |
|
* response.setHeader('Foo', 'bar'); |
|
* response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']); |
|
* |
|
* const headerNames = response.getHeaderNames(); |
|
* // headerNames === ['foo', 'set-cookie'] |
|
* ``` |
|
* @since v8.4.0 |
|
*/ |
|
getHeaderNames(): string[]; |
|
/** |
|
* Returns a shallow copy of the current outgoing headers. Since a shallow copy |
|
* is used, array values may be mutated without additional calls to various |
|
* header-related http module methods. The keys of the returned object are the |
|
* header names and the values are the respective header values. All header names |
|
* are lowercase. |
|
* |
|
* The object returned by the `response.getHeaders()` method _does not_prototypically inherit from the JavaScript `Object`. This means that typical`Object` methods such as `obj.toString()`, |
|
* `obj.hasOwnProperty()`, and others |
|
* are not defined and _will not work_. |
|
* |
|
* ```js |
|
* response.setHeader('Foo', 'bar'); |
|
* response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']); |
|
* |
|
* const headers = response.getHeaders(); |
|
* // headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] } |
|
* ``` |
|
* @since v8.4.0 |
|
*/ |
|
getHeaders(): OutgoingHttpHeaders; |
|
/** |
|
* Returns `true` if the header identified by `name` is currently set in the |
|
* outgoing headers. The header name matching is case-insensitive. |
|
* |
|
* ```js |
|
* const hasContentType = response.hasHeader('content-type'); |
|
* ``` |
|
* @since v8.4.0 |
|
*/ |
|
hasHeader(name: string): boolean; |
|
/** |
|
* Removes a header that has been queued for implicit sending. |
|
* |
|
* ```js |
|
* response.removeHeader('Content-Encoding'); |
|
* ``` |
|
* @since v8.4.0 |
|
*/ |
|
removeHeader(name: string): void; |
|
/** |
|
* Sets a single header value for implicit headers. If this header already exists |
|
* in the to-be-sent headers, its value will be replaced. Use an array of strings |
|
* here to send multiple headers with the same name. |
|
* |
|
* ```js |
|
* response.setHeader('Content-Type', 'text/html; charset=utf-8'); |
|
* ``` |
|
* |
|
* or |
|
* |
|
* ```js |
|
* response.setHeader('Set-Cookie', ['type=ninja', 'language=javascript']); |
|
* ``` |
|
* |
|
* Attempting to set a header field name or value that contains invalid characters |
|
* will result in a `TypeError` being thrown. |
|
* |
|
* When headers have been set with `response.setHeader()`, they will be merged |
|
* with any headers passed to `response.writeHead()`, with the headers passed |
|
* to `response.writeHead()` given precedence. |
|
* |
|
* ```js |
|
* // Returns content-type = text/plain |
|
* const server = http2.createServer((req, res) => { |
|
* res.setHeader('Content-Type', 'text/html; charset=utf-8'); |
|
* res.setHeader('X-Foo', 'bar'); |
|
* res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' }); |
|
* res.end('ok'); |
|
* }); |
|
* ``` |
|
* @since v8.4.0 |
|
*/ |
|
setHeader(name: string, value: number | string | ReadonlyArray<string>): void; |
|
/** |
|
* Sets the `Http2Stream`'s timeout value to `msecs`. If a callback is |
|
* provided, then it is added as a listener on the `'timeout'` event on |
|
* the response object. |
|
* |
|
* If no `'timeout'` listener is added to the request, the response, or |
|
* the server, then `Http2Stream` s are destroyed when they time out. If a |
|
* handler is assigned to the request, the response, or the server's `'timeout'`events, timed out sockets must be handled explicitly. |
|
* @since v8.4.0 |
|
*/ |
|
setTimeout(msecs: number, callback?: () => void): void; |
|
/** |
|
* If this method is called and `response.writeHead()` has not been called, |
|
* it will switch to implicit header mode and flush the implicit headers. |
|
* |
|
* This sends a chunk of the response body. This method may |
|
* be called multiple times to provide successive parts of the body. |
|
* |
|
* In the `http` module, the response body is omitted when the |
|
* request is a HEAD request. Similarly, the `204` and `304` responses_must not_ include a message body. |
|
* |
|
* `chunk` can be a string or a buffer. If `chunk` is a string, |
|
* the second parameter specifies how to encode it into a byte stream. |
|
* By default the `encoding` is `'utf8'`. `callback` will be called when this chunk |
|
* of data is flushed. |
|
* |
|
* This is the raw HTTP body and has nothing to do with higher-level multi-part |
|
* body encodings that may be used. |
|
* |
|
* The first time `response.write()` is called, it will send the buffered |
|
* header information and the first chunk of the body to the client. The second |
|
* time `response.write()` is called, Node.js assumes data will be streamed, |
|
* and sends the new data separately. That is, the response is buffered up to the |
|
* first chunk of the body. |
|
* |
|
* Returns `true` if the entire data was flushed successfully to the kernel |
|
* buffer. Returns `false` if all or part of the data was queued in user memory.`'drain'` will be emitted when the buffer is free again. |
|
* @since v8.4.0 |
|
*/ |
|
write(chunk: string | Uint8Array, callback?: (err: Error) => void): boolean; |
|
write(chunk: string | Uint8Array, encoding: BufferEncoding, callback?: (err: Error) => void): boolean; |
|
/** |
|
* Sends a status `100 Continue` to the client, indicating that the request body |
|
* should be sent. See the `'checkContinue'` event on `Http2Server` and`Http2SecureServer`. |
|
* @since v8.4.0 |
|
*/ |
|
writeContinue(): void; |
|
/** |
|
* Sends a response header to the request. The status code is a 3-digit HTTP |
|
* status code, like `404`. The last argument, `headers`, are the response headers. |
|
* |
|
* Returns a reference to the `Http2ServerResponse`, so that calls can be chained. |
|
* |
|
* For compatibility with `HTTP/1`, a human-readable `statusMessage` may be |
|
* passed as the second argument. However, because the `statusMessage` has no |
|
* meaning within HTTP/2, the argument will have no effect and a process warning |
|
* will be emitted. |
|
* |
|
* ```js |
|
* const body = 'hello world'; |
|
* response.writeHead(200, { |
|
* 'Content-Length': Buffer.byteLength(body), |
|
* 'Content-Type': 'text/plain; charset=utf-8', |
|
* }); |
|
* ``` |
|
* |
|
* `Content-Length` is given in bytes not characters. The`Buffer.byteLength()` API may be used to determine the number of bytes in a |
|
* given encoding. On outbound messages, Node.js does not check if Content-Length |
|
* and the length of the body being transmitted are equal or not. However, when |
|
* receiving messages, Node.js will automatically reject messages when the`Content-Length` does not match the actual payload size. |
|
* |
|
* This method may be called at most one time on a message before `response.end()` is called. |
|
* |
|
* If `response.write()` or `response.end()` are called before calling |
|
* this, the implicit/mutable headers will be calculated and call this function. |
|
* |
|
* When headers have been set with `response.setHeader()`, they will be merged |
|
* with any headers passed to `response.writeHead()`, with the headers passed |
|
* to `response.writeHead()` given precedence. |
|
* |
|
* ```js |
|
* // Returns content-type = text/plain |
|
* const server = http2.createServer((req, res) => { |
|
* res.setHeader('Content-Type', 'text/html; charset=utf-8'); |
|
* res.setHeader('X-Foo', 'bar'); |
|
* res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' }); |
|
* res.end('ok'); |
|
* }); |
|
* ``` |
|
* |
|
* Attempting to set a header field name or value that contains invalid characters |
|
* will result in a `TypeError` being thrown. |
|
* @since v8.4.0 |
|
*/ |
|
writeHead(statusCode: number, headers?: OutgoingHttpHeaders): this; |
|
writeHead(statusCode: number, statusMessage: string, headers?: OutgoingHttpHeaders): this; |
|
/** |
|
* Call `http2stream.pushStream()` with the given headers, and wrap the |
|
* given `Http2Stream` on a newly created `Http2ServerResponse` as the callback |
|
* parameter if successful. When `Http2ServerRequest` is closed, the callback is |
|
* called with an error `ERR_HTTP2_INVALID_STREAM`. |
|
* @since v8.4.0 |
|
* @param headers An object describing the headers |
|
* @param callback Called once `http2stream.pushStream()` is finished, or either when the attempt to create the pushed `Http2Stream` has failed or has been rejected, or the state of |
|
* `Http2ServerRequest` is closed prior to calling the `http2stream.pushStream()` method |
|
*/ |
|
createPushResponse(headers: OutgoingHttpHeaders, callback: (err: Error | null, res: Http2ServerResponse) => void): void; |
|
addListener(event: 'close', listener: () => void): this; |
|
addListener(event: 'drain', listener: () => void): this; |
|
addListener(event: 'error', listener: (error: Error) => void): this; |
|
addListener(event: 'finish', listener: () => void): this; |
|
addListener(event: 'pipe', listener: (src: stream.Readable) => void): this; |
|
addListener(event: 'unpipe', listener: (src: stream.Readable) => void): this; |
|
addListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
emit(event: 'close'): boolean; |
|
emit(event: 'drain'): boolean; |
|
emit(event: 'error', error: Error): boolean; |
|
emit(event: 'finish'): boolean; |
|
emit(event: 'pipe', src: stream.Readable): boolean; |
|
emit(event: 'unpipe', src: stream.Readable): boolean; |
|
emit(event: string | symbol, ...args: any[]): boolean; |
|
on(event: 'close', listener: () => void): this; |
|
on(event: 'drain', listener: () => void): this; |
|
on(event: 'error', listener: (error: Error) => void): this; |
|
on(event: 'finish', listener: () => void): this; |
|
on(event: 'pipe', listener: (src: stream.Readable) => void): this; |
|
on(event: 'unpipe', listener: (src: stream.Readable) => void): this; |
|
on(event: string | symbol, listener: (...args: any[]) => void): this; |
|
once(event: 'close', listener: () => void): this; |
|
once(event: 'drain', listener: () => void): this; |
|
once(event: 'error', listener: (error: Error) => void): this; |
|
once(event: 'finish', listener: () => void): this; |
|
once(event: 'pipe', listener: (src: stream.Readable) => void): this; |
|
once(event: 'unpipe', listener: (src: stream.Readable) => void): this; |
|
once(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependListener(event: 'close', listener: () => void): this; |
|
prependListener(event: 'drain', listener: () => void): this; |
|
prependListener(event: 'error', listener: (error: Error) => void): this; |
|
prependListener(event: 'finish', listener: () => void): this; |
|
prependListener(event: 'pipe', listener: (src: stream.Readable) => void): this; |
|
prependListener(event: 'unpipe', listener: (src: stream.Readable) => void): this; |
|
prependListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
prependOnceListener(event: 'close', listener: () => void): this; |
|
prependOnceListener(event: 'drain', listener: () => void): this; |
|
prependOnceListener(event: 'error', listener: (error: Error) => void): this; |
|
prependOnceListener(event: 'finish', listener: () => void): this; |
|
prependOnceListener(event: 'pipe', listener: (src: stream.Readable) => void): this; |
|
prependOnceListener(event: 'unpipe', listener: (src: stream.Readable) => void): this; |
|
prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; |
|
} |
|
export namespace constants { |
|
const NGHTTP2_SESSION_SERVER: number; |
|
const NGHTTP2_SESSION_CLIENT: number; |
|
const NGHTTP2_STREAM_STATE_IDLE: number; |
|
const NGHTTP2_STREAM_STATE_OPEN: number; |
|
const NGHTTP2_STREAM_STATE_RESERVED_LOCAL: number; |
|
const NGHTTP2_STREAM_STATE_RESERVED_REMOTE: number; |
|
const NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL: number; |
|
const NGHTTP2_STREAM_STATE_HALF_CLOSED_REMOTE: number; |
|
const NGHTTP2_STREAM_STATE_CLOSED: number; |
|
const NGHTTP2_NO_ERROR: number; |
|
const NGHTTP2_PROTOCOL_ERROR: number; |
|
const NGHTTP2_INTERNAL_ERROR: number; |
|
const NGHTTP2_FLOW_CONTROL_ERROR: number; |
|
const NGHTTP2_SETTINGS_TIMEOUT: number; |
|
const NGHTTP2_STREAM_CLOSED: number; |
|
const NGHTTP2_FRAME_SIZE_ERROR: number; |
|
const NGHTTP2_REFUSED_STREAM: number; |
|
const NGHTTP2_CANCEL: number; |
|
const NGHTTP2_COMPRESSION_ERROR: number; |
|
const NGHTTP2_CONNECT_ERROR: number; |
|
const NGHTTP2_ENHANCE_YOUR_CALM: number; |
|
const NGHTTP2_INADEQUATE_SECURITY: number; |
|
const NGHTTP2_HTTP_1_1_REQUIRED: number; |
|
const NGHTTP2_ERR_FRAME_SIZE_ERROR: number; |
|
const NGHTTP2_FLAG_NONE: number; |
|
const NGHTTP2_FLAG_END_STREAM: number; |
|
const NGHTTP2_FLAG_END_HEADERS: number; |
|
const NGHTTP2_FLAG_ACK: number; |
|
const NGHTTP2_FLAG_PADDED: number; |
|
const NGHTTP2_FLAG_PRIORITY: number; |
|
const DEFAULT_SETTINGS_HEADER_TABLE_SIZE: number; |
|
const DEFAULT_SETTINGS_ENABLE_PUSH: number; |
|
const DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE: number; |
|
const DEFAULT_SETTINGS_MAX_FRAME_SIZE: number; |
|
const MAX_MAX_FRAME_SIZE: number; |
|
const MIN_MAX_FRAME_SIZE: number; |
|
const MAX_INITIAL_WINDOW_SIZE: number; |
|
const NGHTTP2_DEFAULT_WEIGHT: number; |
|
const NGHTTP2_SETTINGS_HEADER_TABLE_SIZE: number; |
|
const NGHTTP2_SETTINGS_ENABLE_PUSH: number; |
|
const NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS: number; |
|
const NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE: number; |
|
const NGHTTP2_SETTINGS_MAX_FRAME_SIZE: number; |
|
const NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE: number; |
|
const PADDING_STRATEGY_NONE: number; |
|
const PADDING_STRATEGY_MAX: number; |
|
const PADDING_STRATEGY_CALLBACK: number; |
|
const HTTP2_HEADER_STATUS: string; |
|
const HTTP2_HEADER_METHOD: string; |
|
const HTTP2_HEADER_AUTHORITY: string; |
|
const HTTP2_HEADER_SCHEME: string; |
|
const HTTP2_HEADER_PATH: string; |
|
const HTTP2_HEADER_ACCEPT_CHARSET: string; |
|
const HTTP2_HEADER_ACCEPT_ENCODING: string; |
|
const HTTP2_HEADER_ACCEPT_LANGUAGE: string; |
|
const HTTP2_HEADER_ACCEPT_RANGES: string; |
|
const HTTP2_HEADER_ACCEPT: string; |
|
const HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN: string; |
|
const HTTP2_HEADER_AGE: string; |
|
const HTTP2_HEADER_ALLOW: string; |
|
const HTTP2_HEADER_AUTHORIZATION: string; |
|
const HTTP2_HEADER_CACHE_CONTROL: string; |
|
const HTTP2_HEADER_CONNECTION: string; |
|
const HTTP2_HEADER_CONTENT_DISPOSITION: string; |
|
const HTTP2_HEADER_CONTENT_ENCODING: string; |
|
const HTTP2_HEADER_CONTENT_LANGUAGE: string; |
|
const HTTP2_HEADER_CONTENT_LENGTH: string; |
|
const HTTP2_HEADER_CONTENT_LOCATION: string; |
|
const HTTP2_HEADER_CONTENT_MD5: string; |
|
const HTTP2_HEADER_CONTENT_RANGE: string; |
|
const HTTP2_HEADER_CONTENT_TYPE: string; |
|
const HTTP2_HEADER_COOKIE: string; |
|
const HTTP2_HEADER_DATE: string; |
|
const HTTP2_HEADER_ETAG: string; |
|
const HTTP2_HEADER_EXPECT: string; |
|
const HTTP2_HEADER_EXPIRES: string; |
|
const HTTP2_HEADER_FROM: string; |
|
const HTTP2_HEADER_HOST: string; |
|
const HTTP2_HEADER_IF_MATCH: string; |
|
const HTTP2_HEADER_IF_MODIFIED_SINCE: string; |
|
const HTTP2_HEADER_IF_NONE_MATCH: string; |
|
const HTTP2_HEADER_IF_RANGE: string; |
|
const HTTP2_HEADER_IF_UNMODIFIED_SINCE: string; |
|
const HTTP2_HEADER_LAST_MODIFIED: string; |
|
const HTTP2_HEADER_LINK: string; |
|
const HTTP2_HEADER_LOCATION: string; |
|
const HTTP2_HEADER_MAX_FORWARDS: string; |
|
const HTTP2_HEADER_PREFER: string; |
|
const HTTP2_HEADER_PROXY_AUTHENTICATE: string; |
|
const HTTP2_HEADER_PROXY_AUTHORIZATION: string; |
|
const HTTP2_HEADER_RANGE: string; |
|
const HTTP2_HEADER_REFERER: string; |
|
const HTTP2_HEADER_REFRESH: string; |
|
const HTTP2_HEADER_RETRY_AFTER: string; |
|
const HTTP2_HEADER_SERVER: string; |
|
const HTTP2_HEADER_SET_COOKIE: string; |
|
const HTTP2_HEADER_STRICT_TRANSPORT_SECURITY: string; |
|
const HTTP2_HEADER_TRANSFER_ENCODING: string; |
|
const HTTP2_HEADER_TE: string; |
|
const HTTP2_HEADER_UPGRADE: string; |
|
const HTTP2_HEADER_USER_AGENT: string; |
|
const HTTP2_HEADER_VARY: string; |
|
const HTTP2_HEADER_VIA: string; |
|
const HTTP2_HEADER_WWW_AUTHENTICATE: string; |
|
const HTTP2_HEADER_HTTP2_SETTINGS: string; |
|
const HTTP2_HEADER_KEEP_ALIVE: string; |
|
const HTTP2_HEADER_PROXY_CONNECTION: string; |
|
const HTTP2_METHOD_ACL: string; |
|
const HTTP2_METHOD_BASELINE_CONTROL: string; |
|
const HTTP2_METHOD_BIND: string; |
|
const HTTP2_METHOD_CHECKIN: string; |
|
const HTTP2_METHOD_CHECKOUT: string; |
|
const HTTP2_METHOD_CONNECT: string; |
|
const HTTP2_METHOD_COPY: string; |
|
const HTTP2_METHOD_DELETE: string; |
|
const HTTP2_METHOD_GET: string; |
|
const HTTP2_METHOD_HEAD: string; |
|
const HTTP2_METHOD_LABEL: string; |
|
const HTTP2_METHOD_LINK: string; |
|
const HTTP2_METHOD_LOCK: string; |
|
const HTTP2_METHOD_MERGE: string; |
|
const HTTP2_METHOD_MKACTIVITY: string; |
|
const HTTP2_METHOD_MKCALENDAR: string; |
|
const HTTP2_METHOD_MKCOL: string; |
|
const HTTP2_METHOD_MKREDIRECTREF: string; |
|
const HTTP2_METHOD_MKWORKSPACE: string; |
|
const HTTP2_METHOD_MOVE: string; |
|
const HTTP2_METHOD_OPTIONS: string; |
|
const HTTP2_METHOD_ORDERPATCH: string; |
|
const HTTP2_METHOD_PATCH: string; |
|
const HTTP2_METHOD_POST: string; |
|
const HTTP2_METHOD_PRI: string; |
|
const HTTP2_METHOD_PROPFIND: string; |
|
const HTTP2_METHOD_PROPPATCH: string; |
|
const HTTP2_METHOD_PUT: string; |
|
const HTTP2_METHOD_REBIND: string; |
|
const HTTP2_METHOD_REPORT: string; |
|
const HTTP2_METHOD_SEARCH: string; |
|
const HTTP2_METHOD_TRACE: string; |
|
const HTTP2_METHOD_UNBIND: string; |
|
const HTTP2_METHOD_UNCHECKOUT: string; |
|
const HTTP2_METHOD_UNLINK: string; |
|
const HTTP2_METHOD_UNLOCK: string; |
|
const HTTP2_METHOD_UPDATE: string; |
|
const HTTP2_METHOD_UPDATEREDIRECTREF: string; |
|
const HTTP2_METHOD_VERSION_CONTROL: string; |
|
const HTTP_STATUS_CONTINUE: number; |
|
const HTTP_STATUS_SWITCHING_PROTOCOLS: number; |
|
const HTTP_STATUS_PROCESSING: number; |
|
const HTTP_STATUS_OK: number; |
|
const HTTP_STATUS_CREATED: number; |
|
const HTTP_STATUS_ACCEPTED: number; |
|
const HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION: number; |
|
const HTTP_STATUS_NO_CONTENT: number; |
|
const HTTP_STATUS_RESET_CONTENT: number; |
|
const HTTP_STATUS_PARTIAL_CONTENT: number; |
|
const HTTP_STATUS_MULTI_STATUS: number; |
|
const HTTP_STATUS_ALREADY_REPORTED: number; |
|
const HTTP_STATUS_IM_USED: number; |
|
const HTTP_STATUS_MULTIPLE_CHOICES: number; |
|
const HTTP_STATUS_MOVED_PERMANENTLY: number; |
|
const HTTP_STATUS_FOUND: number; |
|
const HTTP_STATUS_SEE_OTHER: number; |
|
const HTTP_STATUS_NOT_MODIFIED: number; |
|
const HTTP_STATUS_USE_PROXY: number; |
|
const HTTP_STATUS_TEMPORARY_REDIRECT: number; |
|
const HTTP_STATUS_PERMANENT_REDIRECT: number; |
|
const HTTP_STATUS_BAD_REQUEST: number; |
|
const HTTP_STATUS_UNAUTHORIZED: number; |
|
const HTTP_STATUS_PAYMENT_REQUIRED: number; |
|
const HTTP_STATUS_FORBIDDEN: number; |
|
const HTTP_STATUS_NOT_FOUND: number; |
|
const HTTP_STATUS_METHOD_NOT_ALLOWED: number; |
|
const HTTP_STATUS_NOT_ACCEPTABLE: number; |
|
const HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED: number; |
|
const HTTP_STATUS_REQUEST_TIMEOUT: number; |
|
const HTTP_STATUS_CONFLICT: number; |
|
const HTTP_STATUS_GONE: number; |
|
const HTTP_STATUS_LENGTH_REQUIRED: number; |
|
const HTTP_STATUS_PRECONDITION_FAILED: number; |
|
const HTTP_STATUS_PAYLOAD_TOO_LARGE: number; |
|
const HTTP_STATUS_URI_TOO_LONG: number; |
|
const HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE: number; |
|
const HTTP_STATUS_RANGE_NOT_SATISFIABLE: number; |
|
const HTTP_STATUS_EXPECTATION_FAILED: number; |
|
const HTTP_STATUS_TEAPOT: number; |
|
const HTTP_STATUS_MISDIRECTED_REQUEST: number; |
|
const HTTP_STATUS_UNPROCESSABLE_ENTITY: number; |
|
const HTTP_STATUS_LOCKED: number; |
|
const HTTP_STATUS_FAILED_DEPENDENCY: number; |
|
const HTTP_STATUS_UNORDERED_COLLECTION: number; |
|
const HTTP_STATUS_UPGRADE_REQUIRED: number; |
|
const HTTP_STATUS_PRECONDITION_REQUIRED: number; |
|
const HTTP_STATUS_TOO_MANY_REQUESTS: number; |
|
const HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE: number; |
|
const HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS: number; |
|
const HTTP_STATUS_INTERNAL_SERVER_ERROR: number; |
|
const HTTP_STATUS_NOT_IMPLEMENTED: number; |
|
const HTTP_STATUS_BAD_GATEWAY: number; |
|
const HTTP_STATUS_SERVICE_UNAVAILABLE: number; |
|
const HTTP_STATUS_GATEWAY_TIMEOUT: number; |
|
const HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED: number; |
|
const HTTP_STATUS_VARIANT_ALSO_NEGOTIATES: number; |
|
const HTTP_STATUS_INSUFFICIENT_STORAGE: number; |
|
const HTTP_STATUS_LOOP_DETECTED: number; |
|
const HTTP_STATUS_BANDWIDTH_LIMIT_EXCEEDED: number; |
|
const HTTP_STATUS_NOT_EXTENDED: number; |
|
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; |
|
/** |
|
* Returns an object containing the default settings for an `Http2Session`instance. This method returns a new object instance every time it is called |
|
* so instances returned may be safely modified for use. |
|
* @since v8.4.0 |
|
*/ |
|
export function getDefaultSettings(): Settings; |
|
/** |
|
* Returns a `Buffer` instance containing serialized representation of the given |
|
* HTTP/2 settings as specified in the [HTTP/2](https://tools.ietf.org/html/rfc7540) specification. This is intended |
|
* for use with the `HTTP2-Settings` header field. |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* |
|
* const packed = http2.getPackedSettings({ enablePush: false }); |
|
* |
|
* console.log(packed.toString('base64')); |
|
* // Prints: AAIAAAAA |
|
* ``` |
|
* @since v8.4.0 |
|
*/ |
|
export function getPackedSettings(settings: Settings): Buffer; |
|
/** |
|
* Returns a `HTTP/2 Settings Object` containing the deserialized settings from |
|
* the given `Buffer` as generated by `http2.getPackedSettings()`. |
|
* @since v8.4.0 |
|
* @param buf The packed settings. |
|
*/ |
|
export function getUnpackedSettings(buf: Uint8Array): Settings; |
|
/** |
|
* Returns a `net.Server` instance that creates and manages `Http2Session`instances. |
|
* |
|
* Since there are no browsers known that support [unencrypted HTTP/2](https://http2.github.io/faq/#does-http2-require-encryption), the use of {@link createSecureServer} is necessary when |
|
* communicating |
|
* with browser clients. |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* |
|
* // Create an unencrypted HTTP/2 server. |
|
* // Since there are no browsers known that support |
|
* // unencrypted HTTP/2, the use of `http2.createSecureServer()` |
|
* // is necessary when communicating with browser clients. |
|
* const server = http2.createServer(); |
|
* |
|
* server.on('stream', (stream, headers) => { |
|
* stream.respond({ |
|
* 'content-type': 'text/html; charset=utf-8', |
|
* ':status': 200 |
|
* }); |
|
* stream.end('<h1>Hello World</h1>'); |
|
* }); |
|
* |
|
* server.listen(80); |
|
* ``` |
|
* @since v8.4.0 |
|
* @param onRequestHandler See `Compatibility API` |
|
*/ |
|
export function createServer(onRequestHandler?: (request: Http2ServerRequest, response: Http2ServerResponse) => void): Http2Server; |
|
export function createServer(options: ServerOptions, onRequestHandler?: (request: Http2ServerRequest, response: Http2ServerResponse) => void): Http2Server; |
|
/** |
|
* Returns a `tls.Server` instance that creates and manages `Http2Session`instances. |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* const fs = require('fs'); |
|
* |
|
* const options = { |
|
* key: fs.readFileSync('server-key.pem'), |
|
* cert: fs.readFileSync('server-cert.pem') |
|
* }; |
|
* |
|
* // Create a secure HTTP/2 server |
|
* const server = http2.createSecureServer(options); |
|
* |
|
* server.on('stream', (stream, headers) => { |
|
* stream.respond({ |
|
* 'content-type': 'text/html; charset=utf-8', |
|
* ':status': 200 |
|
* }); |
|
* stream.end('<h1>Hello World</h1>'); |
|
* }); |
|
* |
|
* server.listen(80); |
|
* ``` |
|
* @since v8.4.0 |
|
* @param onRequestHandler See `Compatibility API` |
|
*/ |
|
export function createSecureServer(onRequestHandler?: (request: Http2ServerRequest, response: Http2ServerResponse) => void): Http2SecureServer; |
|
export function createSecureServer(options: SecureServerOptions, onRequestHandler?: (request: Http2ServerRequest, response: Http2ServerResponse) => void): Http2SecureServer; |
|
/** |
|
* Returns a `ClientHttp2Session` instance. |
|
* |
|
* ```js |
|
* const http2 = require('http2'); |
|
* const client = http2.connect('https://localhost:1234'); |
|
* |
|
* // Use the client |
|
* |
|
* client.close(); |
|
* ``` |
|
* @since v8.4.0 |
|
* @param authority The remote HTTP/2 server to connect to. This must be in the form of a minimal, valid URL with the `http://` or `https://` prefix, host name, and IP port (if a non-default port |
|
* is used). Userinfo (user ID and password), path, querystring, and fragment details in the URL will be ignored. |
|
* @param listener Will be registered as a one-time listener of the {@link 'connect'} event. |
|
*/ |
|
export function connect(authority: string | url.URL, listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void): ClientHttp2Session; |
|
export function connect( |
|
authority: string | url.URL, |
|
options?: ClientSessionOptions | SecureClientSessionOptions, |
|
listener?: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void |
|
): ClientHttp2Session; |
|
} |
|
declare module 'node:http2' { |
|
export * from 'http2'; |
|
}
|
|
|