| // Type definitions for ws 8.2 |
| // Project: https://github.com/websockets/ws |
| // Definitions by: Paul Loyd <https://github.com/loyd> |
| // Margus Lamp <https://github.com/mlamp> |
| // Philippe D'Alva <https://github.com/TitaneBoy> |
| // reduckted <https://github.com/reduckted> |
| // teidesu <https://github.com/teidesu> |
| // Bartosz Wojtkowiak <https://github.com/wojtkowiak> |
| // Kyle Hensel <https://github.com/k-yle> |
| // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped |
| |
| /// <reference types="node" /> |
| |
| import { EventEmitter } from "events"; |
| import { |
| Agent, |
| ClientRequest, |
| ClientRequestArgs, |
| IncomingMessage, |
| OutgoingHttpHeaders, |
| Server as HTTPServer, |
| } from "http"; |
| import { Server as HTTPSServer } from "https"; |
| import { Duplex, DuplexOptions } from "stream"; |
| import { SecureContextOptions } from "tls"; |
| import { URL } from "url"; |
| import { ZlibOptions } from "zlib"; |
| |
| // WebSocket socket. |
| declare class WebSocket extends EventEmitter { |
| /** The connection is not yet open. */ |
| static readonly CONNECTING: 0; |
| /** The connection is open and ready to communicate. */ |
| static readonly OPEN: 1; |
| /** The connection is in the process of closing. */ |
| static readonly CLOSING: 2; |
| /** The connection is closed. */ |
| static readonly CLOSED: 3; |
| |
| binaryType: "nodebuffer" | "arraybuffer" | "fragments"; |
| readonly bufferedAmount: number; |
| readonly extensions: string; |
| readonly protocol: string; |
| /** The current state of the connection */ |
| readonly readyState: |
| | typeof WebSocket.CONNECTING |
| | typeof WebSocket.OPEN |
| | typeof WebSocket.CLOSING |
| | typeof WebSocket.CLOSED; |
| readonly url: string; |
| |
| /** The connection is not yet open. */ |
| readonly CONNECTING: 0; |
| /** The connection is open and ready to communicate. */ |
| readonly OPEN: 1; |
| /** The connection is in the process of closing. */ |
| readonly CLOSING: 2; |
| /** The connection is closed. */ |
| readonly CLOSED: 3; |
| |
| onopen: (event: WebSocket.Event) => void; |
| onerror: (event: WebSocket.ErrorEvent) => void; |
| onclose: (event: WebSocket.CloseEvent) => void; |
| onmessage: (event: WebSocket.MessageEvent) => void; |
| |
| constructor(address: string | URL, options?: WebSocket.ClientOptions | ClientRequestArgs); |
| constructor( |
| address: string | URL, |
| protocols?: string | string[], |
| options?: WebSocket.ClientOptions | ClientRequestArgs, |
| ); |
| |
| close(code?: number, data?: string | Buffer): void; |
| ping(data?: any, mask?: boolean, cb?: (err: Error) => void): void; |
| pong(data?: any, mask?: boolean, cb?: (err: Error) => void): void; |
| send(data: any, cb?: (err?: Error) => void): void; |
| send( |
| data: any, |
| options: { mask?: boolean | undefined; binary?: boolean | undefined; compress?: boolean | undefined; fin?: boolean | undefined }, |
| cb?: (err?: Error) => void, |
| ): void; |
| terminate(): void; |
| |
| // HTML5 WebSocket events |
| addEventListener( |
| method: "message", |
| cb: (event: WebSocket.MessageEvent) => void, |
| options?: WebSocket.EventListenerOptions, |
| ): void; |
| addEventListener( |
| method: "close", |
| cb: (event: WebSocket.CloseEvent) => void, |
| options?: WebSocket.EventListenerOptions, |
| ): void; |
| addEventListener( |
| method: "error", |
| cb: (event: WebSocket.ErrorEvent) => void, |
| options?: WebSocket.EventListenerOptions, |
| ): void; |
| addEventListener( |
| method: "open", |
| cb: (event: WebSocket.Event) => void, |
| options?: WebSocket.EventListenerOptions, |
| ): void; |
| |
| removeEventListener(method: "message", cb: (event: WebSocket.MessageEvent) => void): void; |
| removeEventListener(method: "close", cb: (event: WebSocket.CloseEvent) => void): void; |
| removeEventListener(method: "error", cb: (event: WebSocket.ErrorEvent) => void): void; |
| removeEventListener(method: "open", cb: (event: WebSocket.Event) => void): void; |
| |
| // Events |
| on(event: "close", listener: (this: WebSocket, code: number, reason: Buffer) => void): this; |
| on(event: "error", listener: (this: WebSocket, err: Error) => void): this; |
| on(event: "upgrade", listener: (this: WebSocket, request: IncomingMessage) => void): this; |
| on(event: "message", listener: (this: WebSocket, data: WebSocket.RawData, isBinary: boolean) => void): this; |
| on(event: "open", listener: (this: WebSocket) => void): this; |
| on(event: "ping" | "pong", listener: (this: WebSocket, data: Buffer) => void): this; |
| on( |
| event: "unexpected-response", |
| listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void, |
| ): this; |
| on(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this; |
| |
| once(event: "close", listener: (this: WebSocket, code: number, reason: Buffer) => void): this; |
| once(event: "error", listener: (this: WebSocket, err: Error) => void): this; |
| once(event: "upgrade", listener: (this: WebSocket, request: IncomingMessage) => void): this; |
| once(event: "message", listener: (this: WebSocket, data: WebSocket.RawData, isBinary: boolean) => void): this; |
| once(event: "open", listener: (this: WebSocket) => void): this; |
| once(event: "ping" | "pong", listener: (this: WebSocket, data: Buffer) => void): this; |
| once( |
| event: "unexpected-response", |
| listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void, |
| ): this; |
| once(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this; |
| |
| off(event: "close", listener: (this: WebSocket, code: number, reason: Buffer) => void): this; |
| off(event: "error", listener: (this: WebSocket, err: Error) => void): this; |
| off(event: "upgrade", listener: (this: WebSocket, request: IncomingMessage) => void): this; |
| off(event: "message", listener: (this: WebSocket, data: WebSocket.RawData, isBinary: boolean) => void): this; |
| off(event: "open", listener: (this: WebSocket) => void): this; |
| off(event: "ping" | "pong", listener: (this: WebSocket, data: Buffer) => void): this; |
| off( |
| event: "unexpected-response", |
| listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void, |
| ): this; |
| off(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this; |
| |
| addListener(event: "close", listener: (code: number, reason: Buffer) => void): this; |
| addListener(event: "error", listener: (err: Error) => void): this; |
| addListener(event: "upgrade", listener: (request: IncomingMessage) => void): this; |
| addListener(event: "message", listener: (data: WebSocket.RawData, isBinary: boolean) => void): this; |
| addListener(event: "open", listener: () => void): this; |
| addListener(event: "ping" | "pong", listener: (data: Buffer) => void): this; |
| addListener( |
| event: "unexpected-response", |
| listener: (request: ClientRequest, response: IncomingMessage) => void, |
| ): this; |
| addListener(event: string | symbol, listener: (...args: any[]) => void): this; |
| |
| removeListener(event: "close", listener: (code: number, reason: Buffer) => void): this; |
| removeListener(event: "error", listener: (err: Error) => void): this; |
| removeListener(event: "upgrade", listener: (request: IncomingMessage) => void): this; |
| removeListener(event: "message", listener: (data: WebSocket.RawData, isBinary: boolean) => void): this; |
| removeListener(event: "open", listener: () => void): this; |
| removeListener(event: "ping" | "pong", listener: (data: Buffer) => void): this; |
| removeListener( |
| event: "unexpected-response", |
| listener: (request: ClientRequest, response: IncomingMessage) => void, |
| ): this; |
| removeListener(event: string | symbol, listener: (...args: any[]) => void): this; |
| } |
| |
| declare const WebSocketAlias: typeof WebSocket; |
| type WebSocketAlias = WebSocket; |
| |
| declare namespace WebSocket { |
| /** |
| * Data represents the raw message payload received over the WebSocket. |
| */ |
| type RawData = Buffer | ArrayBuffer | Buffer[]; |
| |
| /** |
| * Data represents the message payload received over the WebSocket. |
| */ |
| type Data = string | Buffer | ArrayBuffer | Buffer[]; |
| |
| /** |
| * CertMeta represents the accepted types for certificate & key data. |
| */ |
| type CertMeta = string | string[] | Buffer | Buffer[]; |
| |
| /** |
| * VerifyClientCallbackSync is a synchronous callback used to inspect the |
| * incoming message. The return value (boolean) of the function determines |
| * whether or not to accept the handshake. |
| */ |
| type VerifyClientCallbackSync = (info: { origin: string; secure: boolean; req: IncomingMessage }) => boolean; |
| |
| /** |
| * VerifyClientCallbackAsync is an asynchronous callback used to inspect the |
| * incoming message. The return value (boolean) of the function determines |
| * whether or not to accept the handshake. |
| */ |
| type VerifyClientCallbackAsync = ( |
| info: { origin: string; secure: boolean; req: IncomingMessage }, |
| callback: (res: boolean, code?: number, message?: string, headers?: OutgoingHttpHeaders) => void, |
| ) => void; |
| |
| interface ClientOptions extends SecureContextOptions { |
| protocol?: string | undefined; |
| followRedirects?: boolean | undefined; |
| handshakeTimeout?: number | undefined; |
| maxRedirects?: number | undefined; |
| perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined; |
| localAddress?: string | undefined; |
| protocolVersion?: number | undefined; |
| headers?: { [key: string]: string } | undefined; |
| origin?: string | undefined; |
| agent?: Agent | undefined; |
| host?: string | undefined; |
| family?: number | undefined; |
| checkServerIdentity?(servername: string, cert: CertMeta): boolean; |
| rejectUnauthorized?: boolean | undefined; |
| maxPayload?: number | undefined; |
| } |
| |
| interface PerMessageDeflateOptions { |
| serverNoContextTakeover?: boolean | undefined; |
| clientNoContextTakeover?: boolean | undefined; |
| serverMaxWindowBits?: number | undefined; |
| clientMaxWindowBits?: number | undefined; |
| zlibDeflateOptions?: { |
| flush?: number | undefined; |
| finishFlush?: number | undefined; |
| chunkSize?: number | undefined; |
| windowBits?: number | undefined; |
| level?: number | undefined; |
| memLevel?: number | undefined; |
| strategy?: number | undefined; |
| dictionary?: Buffer | Buffer[] | DataView | undefined; |
| info?: boolean | undefined; |
| } | undefined; |
| zlibInflateOptions?: ZlibOptions | undefined; |
| threshold?: number | undefined; |
| concurrencyLimit?: number | undefined; |
| } |
| |
| interface Event { |
| type: string; |
| target: WebSocket; |
| } |
| |
| interface ErrorEvent { |
| error: any; |
| message: string; |
| type: string; |
| target: WebSocket; |
| } |
| |
| interface CloseEvent { |
| wasClean: boolean; |
| code: number; |
| reason: string; |
| type: string; |
| target: WebSocket; |
| } |
| |
| interface MessageEvent { |
| data: Data; |
| type: string; |
| target: WebSocket; |
| } |
| |
| interface EventListenerOptions { |
| once?: boolean | undefined; |
| } |
| |
| interface ServerOptions { |
| host?: string | undefined; |
| port?: number | undefined; |
| backlog?: number | undefined; |
| server?: HTTPServer | HTTPSServer | undefined; |
| verifyClient?: VerifyClientCallbackAsync | VerifyClientCallbackSync | undefined; |
| handleProtocols?: (protocols: Set<string>, request: IncomingMessage) => string | false; |
| path?: string | undefined; |
| noServer?: boolean | undefined; |
| clientTracking?: boolean | undefined; |
| perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined; |
| maxPayload?: number | undefined; |
| skipUTF8Validation?: boolean | undefined; |
| } |
| |
| interface AddressInfo { |
| address: string; |
| family: string; |
| port: number; |
| } |
| |
| // WebSocket Server |
| class Server extends EventEmitter { |
| options: ServerOptions; |
| path: string; |
| clients: Set<WebSocket>; |
| |
| constructor(options?: ServerOptions, callback?: () => void); |
| |
| address(): AddressInfo | string; |
| close(cb?: (err?: Error) => void): void; |
| handleUpgrade( |
| request: IncomingMessage, |
| socket: Duplex, |
| upgradeHead: Buffer, |
| callback: (client: WebSocket, request: IncomingMessage) => void, |
| ): void; |
| shouldHandle(request: IncomingMessage): boolean | Promise<boolean>; |
| |
| // Events |
| on(event: "connection", cb: (this: Server, socket: WebSocket, request: IncomingMessage) => void): this; |
| on(event: "error", cb: (this: Server, error: Error) => void): this; |
| on(event: "headers", cb: (this: Server, headers: string[], request: IncomingMessage) => void): this; |
| on(event: "close" | "listening", cb: (this: Server) => void): this; |
| on(event: string | symbol, listener: (this: Server, ...args: any[]) => void): this; |
| |
| once(event: "connection", cb: (this: Server, socket: WebSocket, request: IncomingMessage) => void): this; |
| once(event: "error", cb: (this: Server, error: Error) => void): this; |
| once(event: "headers", cb: (this: Server, headers: string[], request: IncomingMessage) => void): this; |
| once(event: "close" | "listening", cb: (this: Server) => void): this; |
| once(event: string | symbol, listener: (...args: any[]) => void): this; |
| |
| off(event: "connection", cb: (this: Server, socket: WebSocket, request: IncomingMessage) => void): this; |
| off(event: "error", cb: (this: Server, error: Error) => void): this; |
| off(event: "headers", cb: (this: Server, headers: string[], request: IncomingMessage) => void): this; |
| off(event: "close" | "listening", cb: (this: Server) => void): this; |
| off(event: string | symbol, listener: (this: Server, ...args: any[]) => void): this; |
| |
| addListener(event: "connection", cb: (client: WebSocket, request: IncomingMessage) => void): this; |
| addListener(event: "error", cb: (err: Error) => void): this; |
| addListener(event: "headers", cb: (headers: string[], request: IncomingMessage) => void): this; |
| addListener(event: "close" | "listening", cb: () => void): this; |
| addListener(event: string | symbol, listener: (...args: any[]) => void): this; |
| |
| removeListener(event: "connection", cb: (client: WebSocket) => void): this; |
| removeListener(event: "error", cb: (err: Error) => void): this; |
| removeListener(event: "headers", cb: (headers: string[], request: IncomingMessage) => void): this; |
| removeListener(event: "close" | "listening", cb: () => void): this; |
| removeListener(event: string | symbol, listener: (...args: any[]) => void): this; |
| } |
| |
| const WebSocketServer: typeof Server; |
| type WebSocketServer = Server; |
| const WebSocket: typeof WebSocketAlias; |
| type WebSocket = WebSocketAlias; |
| |
| // WebSocket stream |
| function createWebSocketStream(websocket: WebSocket, options?: DuplexOptions): Duplex; |
| } |
| |
| export = WebSocket; |