flow-typed/npm/ws_v7.x.x.js

   1 // flow-typed signature: cf710812f8fe053ca189786d3fa45067
   2 // flow-typed version: be32675b14/ws_v7.x.x/flow_>=v0.104.x
   3
   4 declare type ws$PerMessageDeflateOptions = {|
   5   serverNoContextTakeover?: boolean,
   6   clientNoContextTakeover?: boolean,
   7   serverMaxWindowBits?: boolean | number,
   8   clientMaxWindowBits?: boolean | number,
   9   zlibDeflateOptions?: zlib$options,
  10   zlibInflateOptions?: zlib$options,
  11   threshold?: number,
  12   concurrencyLimit?: number,
  13   isServer?: boolean,
  14   maxPayload?: number,
  15 |};
  16
  17 declare class ws$WebSocketServer extends events$EventEmitter {
  18   /**
  19    * Create a `WebSocketServer` instance.
  20    */
  21   constructor(
  22     options: {|
  23       backlog?: number,
  24       clientTracking?: boolean,
  25       handleProtocols?: () => mixed,
  26       host?: string,
  27       maxPayload?: number,
  28       noServer?: boolean,
  29       path?: string,
  30       perMessageDeflate?: boolean | ws$PerMessageDeflateOptions,
  31       port: number,
  32       server?: http$Server | https$Server,
  33       verifyClient?: () => mixed,
  34     |},
  35     callback?: () => mixed
  36   ): this;
  37   constructor(
  38     options: {|
  39       backlog?: number,
  40       clientTracking?: boolean,
  41       handleProtocols?: () => mixed,
  42       host?: string,
  43       maxPayload?: number,
  44       noServer?: boolean,
  45       path?: string,
  46       perMessageDeflate?: boolean | ws$PerMessageDeflateOptions,
  47       port?: number,
  48       server: http$Server | https$Server,
  49       verifyClient?: () => mixed,
  50     |},
  51     callback?: () => mixed
  52   ): this;
  53   constructor(
  54     options: {|
  55       backlog?: number,
  56       clientTracking?: boolean,
  57       handleProtocols?: () => mixed,
  58       host?: string,
  59       maxPayload?: number,
  60       noServer: boolean,
  61       path?: string,
  62       perMessageDeflate?: boolean | ws$PerMessageDeflateOptions,
  63       port?: number,
  64       server?: http$Server | https$Server,
  65       verifyClient?: () => mixed,
  66     |},
  67     callback?: () => mixed
  68   ): this;
  69
  70   /**
  71    * Emitted when the server closes.
  72    */
  73   on(event: 'close', () => mixed): this;
  74
  75   /**
  76    * Emitted when the handshake is complete.
  77    */
  78   on(
  79     event: 'connection',
  80     (socket: ws$WebSocket, request: http$IncomingMessage<>) => mixed
  81   ): this;
  82
  83   /**
  84    * Emitted when an error occurs on the underlying server.
  85    */
  86   on(event: 'error', (error: Error) => mixed): this;
  87
  88   /**
  89    * Emitted before the response headers are written to the socket as part of
  90    * the handshake.
  91    */
  92   on(
  93     event: 'headers',
  94     (headers: Array<string>, request: http$IncomingMessage<>) => mixed
  95   ): this;
  96
  97   /**
  98    * Emitted when the underlying server has been bound.
  99    */
 100   on(event: 'listening', () => mixed): this;
 101
 102   /**
 103    * Returns the bound address, the address family name, and port of the server
 104    * as reported by the operating system if listening on an IP socket.
 105    * If the server is listening on a pipe or UNIX domain socket, the name is
 106    * returned as a string.
 107    */
 108   address():
 109     | null
 110     | string
 111     | {| port?: number, family?: string, address?: string |};
 112
 113   /**
 114    * A set that stores all connected clients. Please note that this property is
 115    * only added when the `clientTracking` is truthy.
 116    */
 117   clients: Set<ws$WebSocket>;
 118
 119   /**
 120    * Close the server.
 121    */
 122   close(callback?: () => mixed): void;
 123
 124   /**
 125    * Handle a HTTP Upgrade request.
 126    */
 127   handleUpgrade(
 128     request: http$IncomingMessage<>,
 129     socket: net$Socket,
 130     head: Buffer,
 131     callback: (?ws$WebSocket) => mixed
 132   ): void;
 133
 134   /**
 135    * See if a given request should be handled by this server instance.
 136    */
 137   shouldHandle(request: http$IncomingMessage<>): boolean;
 138 }
 139
 140 declare type ws$WebSocketOptions = {
 141   followRedirects?: boolean,
 142   handshakeTimeout?: number,
 143   maxRedirects?: number,
 144   perMessageDeflate?: boolean | ws$PerMessageDeflateOptions,
 145   protocolVersion?: number,
 146   origin?: string,
 147   maxPayload?: number,
 148   ...requestOptions,
 149   agent?: boolean | http$Agent<> | http$Agent<tls$TLSSocket>,
 150   createConnection?:
 151     | ((options: net$connectOptions, callback?: () => mixed) => net$Socket)
 152     | ((options: tls$connectOptions, callback?: () => mixed) => tls$TLSSocket),
 153   ...
 154 };
 155
 156 declare type ws$CloseListener = (code: number, reason: string) => mixed;
 157 declare type ws$ErrorListener = (error: Error) => mixed;
 158 declare type ws$MessageListener = (
 159   data: string | Buffer | ArrayBuffer | Array<Buffer>
 160 ) => mixed;
 161 declare type ws$OpenListener = () => mixed;
 162 declare type ws$PingListener = (Buffer) => mixed;
 163 declare type ws$PongListener = (Buffer) => mixed;
 164 declare type ws$UnexpectedResponseListener = (
 165   request: http$ClientRequest<>,
 166   response: http$IncomingMessage<>
 167 ) => mixed;
 168 declare type ws$UpgradeListener = (response: http$IncomingMessage<>) => mixed;
 169
 170 declare class ws$WebSocket extends events$EventEmitter {
 171   static Server: typeof ws$WebSocketServer;
 172
 173   static createWebSocketStream: (
 174     WebSocket: ws$WebSocket,
 175     options?: duplexStreamOptions
 176   ) => stream$Duplex;
 177
 178   static CONNECTING: number;
 179   static OPEN: number;
 180   static CLOSING: number;
 181   static CLOSED: number;
 182
 183   /**
 184    * Create a `WebSocket` instance.
 185    */
 186   constructor(
 187     address: string | URL,
 188     protocols?: string | Array<string>,
 189     options?: ws$WebSocketOptions
 190   ): this;
 191   constructor(address: string | URL, options: ws$WebSocketOptions): this;
 192
 193   /*
 194    * Emitted when the connection is closed.
 195    */
 196   on('close', ws$CloseListener): this;
 197
 198   /*
 199    * Emitted when an error occurs.
 200    */
 201   on('error', ws$ErrorListener): this;
 202
 203   /*
 204    * Emitted when a message is received from the server.
 205    */
 206   on('message', ws$MessageListener): this;
 207
 208   /*
 209    * Emitted when the connection is established.
 210    */
 211   on('open', ws$OpenListener): this;
 212
 213   /*
 214    * Emitted when a ping is received from the server.
 215    */
 216   on('ping', ws$PingListener): this;
 217
 218   /*
 219    * Emitted when a pong is received from the server.
 220    */
 221   on('pong', ws$PongListener): this;
 222
 223   /*
 224    * Emitted when the server response is not the expected one,
 225    * for example a 401 response.
 226    */
 227   on('unexpected-response', ws$UnexpectedResponseListener): this;
 228
 229   /*
 230    * Emitted when response headers are received from the server as part of the
 231    * handshake.
 232    */
 233   on('upgrade', ws$UpgradeListener): this;
 234
 235   /**
 236    * Register an event listener emulating the `EventTarget` interface.
 237    */
 238   addEventListener(
 239     type: 'close',
 240     listener: ws$CloseListener,
 241     options?: {| once?: boolean |}
 242   ): this;
 243   addEventListener(
 244     type: 'error',
 245     listener: ws$ErrorListener,
 246     options?: {| once?: boolean |}
 247   ): this;
 248   addEventListener(
 249     type: 'message',
 250     listener: ws$MessageListener,
 251     options?: {| once?: boolean |}
 252   ): this;
 253   addEventListener(
 254     type: 'open',
 255     listener: ws$OpenListener,
 256     options?: {| once?: boolean |}
 257   ): this;
 258   addEventListener(
 259     type: 'ping',
 260     listener: ws$PingListener,
 261     options?: {| once?: boolean |}
 262   ): this;
 263   addEventListener(
 264     type: 'pong',
 265     listener: ws$PongListener,
 266     options?: {| once?: boolean |}
 267   ): this;
 268   addEventListener(
 269     type: 'unexpected-response',
 270     ws$UnexpectedResponseListener,
 271     options?: {| once?: boolean |}
 272   ): this;
 273   addEventListener(
 274     type: 'upgrade',
 275     listener: ws$UpgradeListener,
 276     options?: {| once?: boolean |}
 277   ): this;
 278
 279   /**
 280    * A string indicating the type of binary data being transmitted by the
 281    * connection.
 282    */
 283   binaryType: string;
 284
 285   /**
 286    * The number of bytes of data that have been queued using calls to send()
 287    * but not yet transmitted to the network.
 288    */
 289   bufferedAmount: number;
 290
 291   /**
 292    * Initiate a closing handshake.
 293    */
 294   close(code?: number, reason?: string): void;
 295
 296   /**
 297    * The negotiated extensions.
 298    */
 299   extensions: string;
 300
 301   /**
 302    * Send a ping.
 303    */
 304   ping(data?: any, mask?: boolean, callback?: () => mixed): void;
 305   ping(data: any, callback: () => mixed): void;
 306   ping(callback: () => mixed): void;
 307
 308   /**
 309    * Send a pong.
 310    */
 311   pong(data?: any, mask?: boolean, callback?: () => mixed): void;
 312   pong(data: any, callback: () => mixed): void;
 313   pong(callback: () => mixed): void;
 314
 315   /**
 316    * The subprotocol selected by the server.
 317    */
 318   protocol: string;
 319
 320   /**
 321    * The current state of the connection.
 322    */
 323   readyState: number;
 324
 325   /**
 326    * Removes an event listener emulating the `EventTarget` interface.
 327    */
 328   removeEventListener(type: 'close', listener: ws$CloseListener): this;
 329   removeEventListener(type: 'error', listener: ws$ErrorListener): this;
 330   removeEventListener(type: 'message', listener: ws$MessageListener): this;
 331   removeEventListener(type: 'open', listener: ws$OpenListener): this;
 332   removeEventListener(type: 'ping', listener: ws$PingListener): this;
 333   removeEventListener(type: 'pong', listener: ws$PongListener): this;
 334   removeEventListener(
 335     type: 'unexpected-response',
 336     ws$UnexpectedResponseListener
 337   ): this;
 338   removeEventListener(type: 'upgrade', listener: ws$UpgradeListener): this;
 339
 340   /**
 341    * Send a data message.
 342    */
 343   send(
 344     data?: any,
 345     options?: {|
 346       compress?: boolean,
 347       binary?: boolean,
 348       mask?: boolean,
 349       fin?: boolean,
 350     |},
 351     callback?: () => mixed
 352   ): void;
 353   send(data: any, callback: () => mixed): void;
 354
 355   /**
 356    * Forcibly close the connection.
 357    */
 358   terminate(): void;
 359 }
 360
 361 declare module 'ws' {
 362   declare module.exports: typeof ws$WebSocket;
 363 }