2021-09-29 18:17:34 +02:00
2022-04-10 02:18:16 +02:00
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
2021-09-29 18:17:34 +02:00
2023-03-03 11:55:06 +01:00
/ * *
* 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/v16.9.0/lib/http2.js)
* /
2021-09-29 18:17:34 +02:00
declare module 'http2' {
2023-03-03 11:55:06 +01:00
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' ;
2021-09-29 18:17:34 +02:00
export interface IncomingHttpStatusHeader {
2023-03-03 11:55:06 +01:00
':status' ? : number | undefined ;
2021-09-29 18:17:34 +02:00
}
export interface IncomingHttpHeaders extends Http1IncomingHttpHeaders {
2023-03-03 11:55:06 +01:00
':path' ? : string | undefined ;
':method' ? : string | undefined ;
':authority' ? : string | undefined ;
':scheme' ? : string | undefined ;
2021-09-29 18:17:34 +02:00
}
// 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 {
2023-03-03 11:55:06 +01:00
/ * *
* Set to ` true ` if the ` Http2Stream ` instance was aborted abnormally . When set ,
* the ` 'aborted' ` event will have been emitted .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly aborted : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly bufferSize : number ;
2023-03-03 11:55:06 +01:00
/ * *
* Set to ` true ` if the ` Http2Stream ` instance has been closed .
* @since v9 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly closed : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* Set to ` true ` if the ` Http2Stream ` instance has been destroyed and is no longer
* usable .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly destroyed : boolean ;
/ * *
2023-03-03 11:55:06 +01:00
* 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
2021-09-29 18:17:34 +02:00
* /
readonly endAfterHeaders : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* The numeric stream identifier of this ` Http2Stream ` instance . Set to ` undefined ` if the stream identifier has not yet been assigned .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly id? : number | undefined ;
2023-03-03 11:55:06 +01:00
/ * *
* Set to ` true ` if the ` Http2Stream ` instance has not yet been assigned a
* numeric stream identifier .
* @since v9 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly pending : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly rstCode : number ;
2023-03-03 11:55:06 +01:00
/ * *
* An object containing the outbound headers sent for this ` Http2Stream ` .
* @since v9 . 5.0
* /
2021-09-29 18:17:34 +02:00
readonly sentHeaders : OutgoingHttpHeaders ;
2023-03-03 11:55:06 +01:00
/ * *
* An array of objects containing the outbound informational ( additional ) headers
* sent for this ` Http2Stream ` .
* @since v9 . 5.0
* /
2021-09-29 18:17:34 +02:00
readonly sentInfoHeaders? : OutgoingHttpHeaders [ ] | undefined ;
2023-03-03 11:55:06 +01:00
/ * *
* An object containing the outbound trailers sent for this ` HttpStream ` .
* @since v9 . 5.0
* /
2021-09-29 18:17:34 +02:00
readonly sentTrailers? : OutgoingHttpHeaders | undefined ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly session : Http2Session ;
2023-03-03 11:55:06 +01:00
/ * *
* Provides miscellaneous information about the current state of the ` Http2Stream ` .
*
* A current state of this ` Http2Stream ` .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly state : StreamState ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 .
* /
2021-09-29 18:17:34 +02:00
close ( code? : number , callback ? : ( ) = > void ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* Updates the priority for this ` Http2Stream ` instance .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
priority ( options : StreamPriorityOptions ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* ` ` ` 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
* /
2021-09-29 18:17:34 +02:00
setTimeout ( msecs : number , callback ? : ( ) = > void ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
sendTrailers ( headers : OutgoingHttpHeaders ) : void ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
addListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
emit ( event : string | symbol , . . . args : any [ ] ) : boolean ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
on ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
once ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependOnceListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
}
export interface ClientHttp2Stream extends Http2Stream {
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
addListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
emit ( event : string | symbol , . . . args : any [ ] ) : boolean ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
on ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
once ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependOnceListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
}
export interface ServerHttp2Stream extends Http2Stream {
2023-03-03 11:55:06 +01:00
/ * *
* True if headers were sent , false otherwise ( read - only ) .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly headersSent : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly pushAllowed : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* Sends an additional informational ` HEADERS ` frame to the connected HTTP / 2 peer .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
additionalHeaders ( headers : OutgoingHttpHeaders ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 .
* /
2021-09-29 18:17:34 +02:00
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 ;
2023-03-03 11:55:06 +01:00
/ * *
* ` ` ` 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
* /
2021-09-29 18:17:34 +02:00
respond ( headers? : OutgoingHttpHeaders , options? : ServerStreamResponseOptions ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 .
* /
2021-09-29 18:17:34 +02:00
respondWithFD ( fd : number | fs . promises . FileHandle , headers? : OutgoingHttpHeaders , options? : ServerStreamFileResponseOptions ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
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 ;
2023-03-03 11:55:06 +01:00
signal? : AbortSignal | undefined ;
2021-09-29 18:17:34 +02:00
}
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 {
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly alpnProtocol? : string | undefined ;
2023-03-03 11:55:06 +01:00
/ * *
* Will be ` true ` if this ` Http2Session ` instance has been closed , otherwise ` false ` .
* @since v9 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly closed : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly connecting : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* Will be ` true ` if this ` Http2Session ` instance has been destroyed and must no
* longer be used , otherwise ` false ` .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly destroyed : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly encrypted? : boolean | undefined ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly localSettings : Settings ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly originSet? : string [ ] | undefined ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly pendingSettingsAck : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly remoteSettings : Settings ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly socket : net.Socket | tls . TLSSocket ;
2023-03-03 11:55:06 +01:00
/ * *
* Provides miscellaneous information about the current state of the ` Http2Session ` .
*
* An object describing the current status of this ` Http2Session ` .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly state : SessionState ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly type : number ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
close ( callback ? : ( ) = > void ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 ` .
* /
2021-09-29 18:17:34 +02:00
destroy ( error? : Error , code? : number ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 .
* /
2021-09-29 18:17:34 +02:00
goaway ( code? : number , lastStreamID? : number , opaqueData? : NodeJS.ArrayBufferView ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 .
* /
2021-09-29 18:17:34 +02:00
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 ;
2023-03-03 11:55:06 +01:00
/ * *
* Calls ` ref() ` on this ` Http2Session ` instance ' s underlying ` net.Socket ` .
* @since v9 . 4.0
* /
2021-09-29 18:17:34 +02:00
ref ( ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
setLocalWindowSize ( windowSize : number ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
setTimeout ( msecs : number , callback ? : ( ) = > void ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 , callback ? : ( err : Error | null , settings : Settings , duration : number ) = > void ) : void ;
/ * *
* Calls ` unref() ` on this ` Http2Session ` instance ' s underlying ` net.Socket ` .
* @since v9 . 4.0
* /
2021-09-29 18:17:34 +02:00
unref ( ) : void ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
addListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
emit ( event : string | symbol , . . . args : any [ ] ) : boolean ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
on ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
once ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependOnceListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
}
export interface ClientHttp2Session extends Http2Session {
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
request ( headers? : OutgoingHttpHeaders , options? : ClientSessionRequestOptions ) : ClientHttp2Stream ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
addListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
emit ( event : string | symbol , . . . args : any [ ] ) : boolean ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
on ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
once ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
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 ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 .
* /
2021-09-29 18:17:34 +02:00
altsvc ( alt : string , originOrStream : number | string | url . URL | AlternativeServiceOptions ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 ;
2021-09-29 18:17:34 +02:00
addListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
emit ( event : 'connect' , session : ServerHttp2Session , socket : net.Socket | tls . TLSSocket ) : boolean ;
emit ( event : 'stream' , stream : ServerHttp2Stream , headers : IncomingHttpHeaders , flags : number ) : boolean ;
2021-09-29 18:17:34 +02:00
emit ( event : string | symbol , . . . args : any [ ] ) : boolean ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
on ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
once ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
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 ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 ;
2021-09-29 18:17:34 +02:00
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 ;
}
2023-03-03 11:55:06 +01:00
export interface SecureClientSessionOptions extends ClientSessionOptions , tls . ConnectionOptions { }
export interface SecureServerSessionOptions extends ServerSessionOptions , tls . TlsOptions { }
export interface ServerOptions extends ServerSessionOptions { }
2021-09-29 18:17:34 +02:00
export interface SecureServerOptions extends SecureServerSessionOptions {
allowHTTP1? : boolean | undefined ;
origins? : string [ ] | undefined ;
}
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
addListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
emit ( event : string | symbol , . . . args : any [ ] ) : boolean ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
on ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
once ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependOnceListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
}
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
addListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
emit ( event : string | symbol , . . . args : any [ ] ) : boolean ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
on ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
once ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependOnceListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
}
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
export class Http2ServerRequest extends stream . Readable {
constructor ( stream : ServerHttp2Stream , headers : IncomingHttpHeaders , options : stream.ReadableOptions , rawHeaders : ReadonlyArray < string > ) ;
2023-03-03 11:55:06 +01:00
/ * *
* The ` request.aborted ` property will be ` true ` if the request has
* been aborted .
* @since v10 . 1.0
* /
2021-09-29 18:17:34 +02:00
readonly aborted : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly authority : string ;
2023-03-03 11:55:06 +01:00
/ * *
* See ` request.socket ` .
* @since v8 . 4.0
* @deprecated Since v13 . 0.0 - Use ` socket ` .
* /
2021-09-29 18:17:34 +02:00
readonly connection : net.Socket | tls . TLSSocket ;
2023-03-03 11:55:06 +01:00
/ * *
* The ` request.complete ` property will be ` true ` if the request has
* been completed , aborted , or destroyed .
* @since v12 . 10.0
* /
2021-09-29 18:17:34 +02:00
readonly complete : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly headers : IncomingHttpHeaders ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly httpVersion : string ;
readonly httpVersionMinor : number ;
readonly httpVersionMajor : number ;
2023-03-03 11:55:06 +01:00
/ * *
* The request method as a string . Read - only . Examples : ` 'GET' ` , ` 'DELETE' ` .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly method : string ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly rawHeaders : string [ ] ;
2023-03-03 11:55:06 +01:00
/ * *
* The raw request / response trailer keys and values exactly as they were
* received . Only populated at the ` 'end' ` event .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly rawTrailers : string [ ] ;
2023-03-03 11:55:06 +01:00
/ * *
* The request scheme pseudo header field indicating the scheme
* portion of the target URL .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly scheme : string ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly socket : net.Socket | tls . TLSSocket ;
2023-03-03 11:55:06 +01:00
/ * *
* The ` Http2Stream ` object backing the request .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly stream : ServerHttp2Stream ;
2023-03-03 11:55:06 +01:00
/ * *
* The request / response trailers object . Only populated at the ` 'end' ` event .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly trailers : IncomingHttpHeaders ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2022-04-10 02:18:16 +02:00
url : string ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
setTimeout ( msecs : number , callback ? : ( ) = > void ) : void ;
read ( size? : number ) : Buffer | string | null ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
addListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
emit ( event : string | symbol , . . . args : any [ ] ) : boolean ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
on ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
once ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependOnceListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
}
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
export class Http2ServerResponse extends stream . Writable {
constructor ( stream : ServerHttp2Stream ) ;
2023-03-03 11:55:06 +01:00
/ * *
* See ` response.socket ` .
* @since v8 . 4.0
* @deprecated Since v13 . 0.0 - Use ` socket ` .
* /
2021-09-29 18:17:34 +02:00
readonly connection : net.Socket | tls . TLSSocket ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 ` .
* /
2021-09-29 18:17:34 +02:00
readonly finished : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* True if headers were sent , false otherwise ( read - only ) .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly headersSent : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly socket : net.Socket | tls . TLSSocket ;
2023-03-03 11:55:06 +01:00
/ * *
* The ` Http2Stream ` object backing the response .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
readonly stream : ServerHttp2Stream ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
sendDate : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
statusCode : number ;
2023-03-03 11:55:06 +01:00
/ * *
* Status message is not supported by HTTP / 2 ( RFC 7540 8.1 . 2.4 ) . It returns
* an empty string .
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
statusMessage : '' ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
addTrailers ( trailers : OutgoingHttpHeaders ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2022-04-10 02:18:16 +02:00
end ( callback ? : ( ) = > void ) : this ;
end ( data : string | Uint8Array , callback ? : ( ) = > void ) : this ;
end ( data : string | Uint8Array , encoding : BufferEncoding , callback ? : ( ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
getHeader ( name : string ) : string ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
getHeaderNames ( ) : string [ ] ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
getHeaders ( ) : OutgoingHttpHeaders ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
hasHeader ( name : string ) : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* Removes a header that has been queued for implicit sending .
*
* ` ` ` js
* response . removeHeader ( 'Content-Encoding' ) ;
* ` ` `
* @since v8 . 4.0
* /
2021-09-29 18:17:34 +02:00
removeHeader ( name : string ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
setHeader ( name : string , value : number | string | ReadonlyArray < string > ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
setTimeout ( msecs : number , callback ? : ( ) = > void ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
write ( chunk : string | Uint8Array , callback ? : ( err : Error ) = > void ) : boolean ;
write ( chunk : string | Uint8Array , encoding : BufferEncoding , callback ? : ( err : Error ) = > void ) : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
writeContinue ( ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
writeHead ( statusCode : number , headers? : OutgoingHttpHeaders ) : this ;
writeHead ( statusCode : number , statusMessage : string , headers? : OutgoingHttpHeaders ) : this ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
createPushResponse ( headers : OutgoingHttpHeaders , callback : ( err : Error | null , res : Http2ServerResponse ) = > void ) : void ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
addListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
emit ( event : string | symbol , . . . args : any [ ] ) : boolean ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
on ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
once ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependListener ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
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 ;
}
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
export function getDefaultSettings ( ) : Settings ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
export function getPackedSettings ( settings : Settings ) : Buffer ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 .
* /
2021-09-29 18:17:34 +02:00
export function getUnpackedSettings ( buf : Uint8Array ) : Settings ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 `
* /
2021-09-29 18:17:34 +02:00
export function createServer ( onRequestHandler ? : ( request : Http2ServerRequest , response : Http2ServerResponse ) = > void ) : Http2Server ;
export function createServer ( options : ServerOptions , onRequestHandler ? : ( request : Http2ServerRequest , response : Http2ServerResponse ) = > void ) : Http2Server ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 `
* /
2021-09-29 18:17:34 +02:00
export function createSecureServer ( onRequestHandler ? : ( request : Http2ServerRequest , response : Http2ServerResponse ) = > void ) : Http2SecureServer ;
export function createSecureServer ( options : SecureServerOptions , onRequestHandler ? : ( request : Http2ServerRequest , response : Http2ServerResponse ) = > void ) : Http2SecureServer ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 .
* /
2021-09-29 18:17:34 +02:00
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 ;
}
2022-04-10 02:18:16 +02:00
declare module 'node:http2' {
export * from 'http2' ;
}