@lng2004/node-datachannel 0.31.0-20251228

package/src/cpp/web-socket-wrapper.h

@@ -0,0 +1,63 @@
+#ifndef WEB_SOCKET_WRAPPER_H
+#define WEB_SOCKET_WRAPPER_H
+
+#include <memory>
+#include <unordered_set>
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+
+#include "thread-safe-callback.h"
+
+class WebSocketWrapper : public Napi::ObjectWrap<WebSocketWrapper>
+{
+public:
+  static Napi::FunctionReference constructor;
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  WebSocketWrapper(const Napi::CallbackInfo &info);
+  ~WebSocketWrapper();
+
+  // Functions
+  void open(const Napi::CallbackInfo &info);
+  void close(const Napi::CallbackInfo &info);
+  void forceClose(const Napi::CallbackInfo &info);
+  Napi::Value sendMessage(const Napi::CallbackInfo &info);
+  Napi::Value sendMessageBinary(const Napi::CallbackInfo &info);
+  Napi::Value isOpen(const Napi::CallbackInfo &info);
+  Napi::Value bufferedAmount(const Napi::CallbackInfo &info);
+  Napi::Value maxMessageSize(const Napi::CallbackInfo &info);
+  void setBufferedAmountLowThreshold(const Napi::CallbackInfo &info);
+  Napi::Value remoteAddress(const Napi::CallbackInfo &info);
+  Napi::Value path(const Napi::CallbackInfo &info);
+
+  // Callbacks
+  void onOpen(const Napi::CallbackInfo &info);
+  void onClosed(const Napi::CallbackInfo &info);
+  void onError(const Napi::CallbackInfo &info);
+  void onBufferedAmountLow(const Napi::CallbackInfo &info);
+  void onMessage(const Napi::CallbackInfo &info);
+
+  // Close all existing WebSockets
+  static void CloseAll();
+
+  // Reset all Callbacks for existing WebSockets
+  static void CleanupAll();
+
+private:
+  static std::unordered_set<WebSocketWrapper *> instances;
+
+  void doClose();
+  void doForceClose();
+  void doCleanup();
+
+  std::shared_ptr<rtc::WebSocket> mWebSocketPtr = nullptr;
+
+  // Callback Ptrs
+  std::unique_ptr<ThreadSafeCallback> mOnOpenCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnClosedCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnErrorCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnBufferedAmountLowCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnMessageCallback = nullptr;
+};
+
+#endif // WEB_SOCKET_WRAPPER_H

package/src/index.ts

@@ -0,0 +1,9 @@
+// This file is created for builder process
+// So builder can find and compile all files and folders
+// Not intended to be imported directly
+
+import n from './lib/index';
+import p from './polyfill/index';
+
+export const nodeDataChannel = n;
+export const polyfill = p;

package/src/lib/datachannel-stream.ts

@@ -0,0 +1,100 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as stream from 'stream';
+
+/**
+ * Turns a node-datachannel DataChannel into a real Node.js stream, complete with buffering,
+ * backpressure (up to a point - if the buffer fills up, messages are dropped), and
+ * support for piping data elsewhere.
+ *
+ * Read & written data may be either UTF-8 strings or Buffers - this difference exists at
+ * the protocol level, and is preserved here throughout.
+ */
+export default class DataChannelStream extends stream.Duplex {
+  private _rawChannel: any;
+  private _readActive: boolean;
+
+  constructor(rawChannel: any, streamOptions?: Omit<stream.DuplexOptions, 'objectMode'>) {
+    super({
+      allowHalfOpen: false, // Default to autoclose on end().
+      ...streamOptions,
+      objectMode: true, // Preserve the string/buffer distinction (WebRTC treats them differently)
+    });
+
+    this._rawChannel = rawChannel;
+    this._readActive = true;
+
+    rawChannel.onMessage((msg: any) => {
+      if (!this._readActive) return; // If the buffer is full, drop messages.
+
+      // If the push is rejected, we pause reading until the next call to _read().
+      this._readActive = this.push(msg);
+    });
+
+    // When the DataChannel closes, the readable & writable ends close
+    rawChannel.onClosed(() => {
+      this.push(null);
+      this.destroy();
+    });
+
+    rawChannel.onError((errMsg: string) => {
+      this.destroy(new Error(`DataChannel error: ${errMsg}`));
+    });
+
+    // Buffer all writes until the DataChannel opens
+    if (!rawChannel.isOpen()) {
+      this.cork();
+      rawChannel.onOpen(() => this.uncork());
+    }
+  }
+
+  _read(): void {
+    // Stop dropping messages, if the buffer filling up meant we were doing so before.
+    this._readActive = true;
+  }
+
+  _write(chunk, _encoding, callback): void {
+    let sentOk;
+
+    try {
+      if (Buffer.isBuffer(chunk)) {
+        sentOk = this._rawChannel.sendMessageBinary(chunk);
+      } else if (typeof chunk === 'string') {
+        sentOk = this._rawChannel.sendMessage(chunk);
+      } else {
+        const typeName = chunk.constructor.name || typeof chunk;
+        throw new Error(`Cannot write ${typeName} to DataChannel stream`);
+      }
+    } catch (err) {
+      return callback(err);
+    }
+
+    if (sentOk) {
+      callback(null);
+    } else {
+      callback(new Error('Failed to write to DataChannel'));
+    }
+  }
+
+  _final(callback): void {
+    if (!this.allowHalfOpen) this.destroy();
+    callback(null);
+  }
+
+  _destroy(maybeErr, callback): void {
+    // When the stream is destroyed, we close the DataChannel.
+    this._rawChannel.close();
+    callback(maybeErr);
+  }
+
+  get label(): string {
+    return this._rawChannel.getLabel();
+  }
+
+  get id(): number {
+    return this._rawChannel.getId();
+  }
+
+  get protocol(): string {
+    return this._rawChannel.getProtocol();
+  }
+}

package/src/lib/index.ts

@@ -0,0 +1,283 @@
+import nodeDataChannel from './node-datachannel';
+import _DataChannelStream from './datachannel-stream';
+import { WebSocketServer } from './websocket-server';
+import {
+  Channel,
+  DataChannelInitConfig,
+  DescriptionType,
+  Direction,
+  LogLevel,
+  NalUnitSeparator,
+  ObuPacketization,
+  RtcConfig,
+  RTCIceConnectionState,
+  RTCIceGatheringState,
+  RTCPeerConnectionState,
+  RTCSignalingState,
+  SctpSettings,
+  SelectedCandidateInfo,
+} from './types';
+import { WebSocket } from './websocket';
+import type { CertificateFingerprint, IceUdpMuxRequest, LocalDescriptionInit } from './types';
+
+export function preload(): void {
+  nodeDataChannel.preload();
+}
+export function initLogger(level: LogLevel): void {
+  nodeDataChannel.initLogger(level);
+}
+export function cleanup(): void {
+  nodeDataChannel.cleanup();
+}
+export function setSctpSettings(settings: SctpSettings): void {
+  nodeDataChannel.setSctpSettings(settings);
+}
+export function getLibraryVersion(): string {
+  return nodeDataChannel.getLibraryVersion();
+}
+
+export interface Audio {
+  addAudioCodec(payloadType: number, codec: string, profile?: string): void;
+  addOpusCodec(payloadType: number, profile?: string): string;
+  direction(): Direction;
+  generateSdp(eol: string, addr: string, port: number): string;
+  mid(): string;
+  setDirection(dir: Direction): void;
+  description(): string;
+  removeFormat(fmt: string): void;
+  addSSRC(ssrc: number, name?: string, msid?: string, trackID?: string): void;
+  removeSSRC(ssrc: number): void;
+  replaceSSRC(oldSsrc: number, ssrc: number, name?: string, msid?: string, trackID?: string): void;
+  hasSSRC(ssrc: number): boolean;
+  getSSRCs(): number[];
+  getCNameForSsrc(ssrc: number): string;
+  setBitrate(bitRate: number): void;
+  getBitrate(): number;
+  hasPayloadType(payloadType: number): boolean;
+  addRTXCodec(payloadType: number, originalPayloadType: number, clockRate: number): void;
+  addRTPMap(): void;
+  parseSdpLine(line: string): void;
+}
+export const Audio: {
+  new (mid: string, dir: Direction): Audio;
+} = nodeDataChannel.Audio;
+
+export interface Video {
+  addVideoCodec(payloadType: number, codec: string, profile?: string): void;
+  addH264Codec(payloadType: number, profile?: string): void;
+  addH265Codec(payloadType: number): void;
+  addVP8Codec(payloadType: number): void;
+  addVP9Codec(payloadType: number): void;
+  addAV1Codec(payloadType: number): void;
+  direction(): Direction;
+  generateSdp(eol: string, addr: string, port: number): string;
+  mid(): string;
+  setDirection(dir: Direction): void;
+  description(): string;
+  removeFormat(fmt: string): void;
+  addSSRC(ssrc: number, name?: string, msid?: string, trackID?: string): void;
+  removeSSRC(ssrc: number): void;
+  replaceSSRC(oldSsrc: number, ssrc: number, name?: string, msid?: string, trackID?: string): void;
+  hasSSRC(ssrc: number): boolean;
+  getSSRCs(): number[];
+  getCNameForSsrc(ssrc: number): string;
+  setBitrate(bitRate: number): void;
+  getBitrate(): number;
+  hasPayloadType(payloadType: number): boolean;
+  addRTXCodec(payloadType: number, originalPayloadType: number, clockRate: number): void;
+  addRTPMap(): void;
+  parseSdpLine(line: string): void;
+}
+export const Video: {
+  new (mid: string, dir: Direction): Video;
+} = nodeDataChannel.Video;
+
+export interface Track {
+  direction(): Direction;
+  mid(): string;
+  type(): string;
+  close(): void;
+  sendMessage(msg: string): boolean;
+  sendMessageBinary(buffer: Buffer): boolean;
+  isOpen(): boolean;
+  isClosed(): boolean;
+  bufferedAmount(): number;
+  maxMessageSize(): number;
+  requestBitrate(bitRate: number): boolean;
+  setBufferedAmountLowThreshold(newSize: number): void;
+  requestKeyframe(): boolean;
+  setMediaHandler(handler: MediaHandler): void;
+  onOpen(cb: () => void): void;
+  onClosed(cb: () => void): void;
+  onError(cb: (err: string) => void): void;
+  onMessage(cb: (msg: Buffer) => void): void;
+}
+export const Track: {
+  new (): Track;
+} = nodeDataChannel.Track;
+
+export interface DataChannel extends Channel {
+  getLabel(): string;
+  getId(): number;
+  getProtocol(): string;
+
+  // Channel implementation
+  close(): void;
+  sendMessage(msg: string): boolean;
+  sendMessageBinary(buffer: Buffer | Uint8Array): boolean;
+  isOpen(): boolean;
+  bufferedAmount(): number;
+  maxMessageSize(): number;
+  setBufferedAmountLowThreshold(newSize: number): void;
+  onOpen(cb: () => void): void;
+  onClosed(cb: () => void): void;
+  onError(cb: (err: string) => void): void;
+  onBufferedAmountLow(cb: () => void): void;
+  onMessage(cb: (msg: string | Buffer | ArrayBuffer) => void): void;
+}
+export const DataChannel: {
+  // DataChannel implementation
+} = nodeDataChannel.DataChannel;
+
+export interface PeerConnection {
+  close(): void;
+  setLocalDescription(type?: DescriptionType, init?: LocalDescriptionInit): void;
+  setRemoteDescription(sdp: string, type: DescriptionType): void;
+  localDescription(): { type: DescriptionType; sdp: string } | null;
+  remoteDescription(): { type: DescriptionType; sdp: string } | null;
+  remoteFingerprint(): CertificateFingerprint;
+  addRemoteCandidate(candidate: string, mid: string): void;
+  createDataChannel(label: string, config?: DataChannelInitConfig): DataChannel;
+  addTrack(media: Video | Audio): Track;
+  hasMedia(): boolean;
+  state(): RTCPeerConnectionState;
+  iceState(): RTCIceConnectionState;
+  signalingState(): RTCSignalingState;
+  gatheringState(): RTCIceGatheringState;
+  onLocalDescription(cb: (sdp: string, type: DescriptionType) => void): void;
+  onLocalCandidate(cb: (candidate: string, mid: string) => void): void;
+  onStateChange(cb: (state: string) => void): void;
+  onIceStateChange(cb: (state: string) => void): void;
+  onSignalingStateChange(cb: (state: string) => void): void;
+  onGatheringStateChange(cb: (state: string) => void): void;
+  onDataChannel(cb: (dc: DataChannel) => void): void;
+  onTrack(cb: (track: Track) => void): void;
+  bytesSent(): number;
+  bytesReceived(): number;
+  rtt(): number;
+  getSelectedCandidatePair(): {
+    local: SelectedCandidateInfo;
+    remote: SelectedCandidateInfo;
+  } | null;
+  maxDataChannelId(): number;
+  maxMessageSize(): number;
+}
+export const PeerConnection: {
+  new (peerName: string, config: RtcConfig): PeerConnection;
+} = nodeDataChannel.PeerConnection;
+
+export interface IceUdpMuxListener {
+  address?: string;
+  port: number;
+  stop(): void;
+  onUnhandledStunRequest(cb: (req: IceUdpMuxRequest) => void): void;
+}
+export const IceUdpMuxListener: {
+  new (port: number, address?: string): IceUdpMuxListener;
+} = nodeDataChannel.IceUdpMuxListener;
+
+export interface RtpPacketizationConfig {
+  playoutDelayId: number,
+  playoutDelayMin: number,
+  playoutDelayMax: number,
+  timestamp: number,
+  get clockRate(): number
+}
+
+export const RtpPacketizationConfig: {
+  new(ssrc: number, cname: string, payloadType: number, clockRate: number, videoOrientationId?: number): RtpPacketizationConfig
+} = nodeDataChannel.RtpPacketizationConfig
+
+export interface MediaHandler {
+  addToChain(handler: MediaHandler): void
+}
+
+export interface RtcpReceivingSession extends MediaHandler {}
+
+export const RtcpReceivingSession: {
+  new (): RtcpReceivingSession;
+} = nodeDataChannel.RtcpReceivingSession;
+
+export interface RtcpNackResponder extends MediaHandler {}
+
+export const RtcpNackResponder: {
+  new (maxSize?: number): RtcpNackResponder
+} = nodeDataChannel.RtcpNackResponder;
+
+export interface RtcpSrReporter extends MediaHandler {
+  get rtpConfig(): RtpPacketizationConfig
+}
+
+export const RtcpSrReporter: {
+  new (rtpConfig: RtpPacketizationConfig): RtcpSrReporter
+} = nodeDataChannel.RtcpSrReporter;
+
+export interface RtpPacketizer extends MediaHandler {
+  get rtpConfig(): RtpPacketizationConfig
+}
+
+export const RtpPacketizer: {
+  new (rtpConfig: RtpPacketizationConfig): RtpPacketizer
+} = nodeDataChannel.RtpPacketizer;
+
+export interface H264RtpPacketizer extends RtpPacketizer {}
+
+export const H264RtpPacketizer: {
+  new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): H264RtpPacketizer
+} = nodeDataChannel.H264RtpPacketizer
+
+export interface H265RtpPacketizer extends RtpPacketizer {}
+
+export const H265RtpPacketizer: {
+  new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): H265RtpPacketizer
+} = nodeDataChannel.H265RtpPacketizer
+
+export interface AV1RtpPacketizer extends RtpPacketizer {}
+
+export const AV1RtpPacketizer: {
+  new (packetization: ObuPacketization, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): AV1RtpPacketizer
+} = nodeDataChannel.AV1RtpPacketizer
+
+export { WebSocketServer } from './websocket-server';
+export { WebSocket } from './websocket';
+
+export const DataChannelStream = _DataChannelStream;
+
+export default {
+  initLogger,
+  cleanup,
+  preload,
+  setSctpSettings,
+  getLibraryVersion,
+  RtcpReceivingSession,
+  RtcpNackResponder,
+  RtcpSrReporter,
+  RtpPacketizationConfig,
+  RtpPacketizer,
+  H264RtpPacketizer,
+  H265RtpPacketizer,
+  AV1RtpPacketizer,
+  Track,
+  Video,
+  Audio,
+  DataChannel,
+  PeerConnection,
+  WebSocket,
+  WebSocketServer,
+  DataChannelStream,
+  IceUdpMuxListener,
+};
+
+// Types
+// https://github.com/murat-dogan/node-datachannel/issues/300
+export * from './types';

package/src/lib/node-datachannel.ts

@@ -0,0 +1,3 @@
+// @ts-expect-error no types
+import nodeDataChannel = require('../../build/Release/node_datachannel.node');
+export default nodeDataChannel;

package/src/lib/types.ts

@@ -0,0 +1,168 @@
+export interface Channel {
+  close(): void;
+  sendMessage(msg: string): boolean;
+  sendMessageBinary(buffer: Uint8Array): boolean;
+  isOpen(): boolean;
+  bufferedAmount(): number;
+  maxMessageSize(): number;
+  setBufferedAmountLowThreshold(newSize: number): void;
+  onOpen(cb: () => void): void;
+  onClosed(cb: () => void): void;
+  onError(cb: (err: string) => void): void;
+  onBufferedAmountLow(cb: () => void): void;
+  onMessage(cb: (msg: string | Buffer | ArrayBuffer) => void): void;
+}
+
+export interface WebSocketServerConfiguration {
+  port?: number; // default 8080
+  enableTls?: boolean; // default = false;
+  certificatePemFile?: string;
+  keyPemFile?: string;
+  keyPemPass?: string;
+  bindAddress?: string;
+  connectionTimeout?: number; // milliseconds
+  maxMessageSize?: number;
+}
+
+// Enum in d.ts is tricky
+export type LogLevel = 'Verbose' | 'Debug' | 'Info' | 'Warning' | 'Error' | 'Fatal';
+
+// SCTP Settings
+export interface SctpSettings {
+  recvBufferSize?: number;
+  sendBufferSize?: number;
+  maxChunksOnQueue?: number;
+  initialCongestionWindow?: number;
+  congestionControlModule?: number;
+  delayedSackTime?: number;
+}
+
+// Proxy Server
+export type ProxyServerType = 'Socks5' | 'Http';
+export interface ProxyServer {
+  type: ProxyServerType;
+  ip: string;
+  port: number;
+  username?: string;
+  password?: string;
+}
+
+export type RelayType = 'TurnUdp' | 'TurnTcp' | 'TurnTls';
+
+export interface IceServer {
+  hostname: string;
+  port: number;
+  username?: string;
+  password?: string;
+  relayType?: RelayType;
+}
+
+export type TransportPolicy = 'all' | 'relay';
+
+export interface RtcConfig {
+  iceServers: (string | IceServer)[];
+  proxyServer?: ProxyServer;
+  bindAddress?: string;
+  enableIceTcp?: boolean;
+  enableIceUdpMux?: boolean;
+  disableAutoNegotiation?: boolean;
+  forceMediaTransport?: boolean;
+  portRangeBegin?: number;
+  portRangeEnd?: number;
+  maxMessageSize?: number;
+  mtu?: number;
+  iceTransportPolicy?: TransportPolicy;
+  disableFingerprintVerification?: boolean;
+  disableAutoGathering?: boolean;
+  certificatePemFile?: string;
+  keyPemFile?: string;
+  keyPemPass?: string;
+}
+
+// Lowercase to match the description type string from libdatachannel
+export type DescriptionType = 'unspec' | 'offer' | 'answer' | 'pranswer' | 'rollback';
+
+export type RTCSdpType = 'answer' | 'offer' | 'pranswer' | 'rollback';
+
+export type RTCIceTransportState =
+  | 'checking'
+  | 'closed'
+  | 'completed'
+  | 'connected'
+  | 'disconnected'
+  | 'failed'
+  | 'new';
+export type RTCPeerConnectionState =
+  | 'closed'
+  | 'connected'
+  | 'connecting'
+  | 'disconnected'
+  | 'failed'
+  | 'new';
+export type RTCIceConnectionState =
+  | 'checking'
+  | 'closed'
+  | 'completed'
+  | 'connected'
+  | 'disconnected'
+  | 'failed'
+  | 'new';
+export type RTCIceGathererState = 'complete' | 'gathering' | 'new';
+export type RTCIceGatheringState = 'complete' | 'gathering' | 'new';
+export type RTCSignalingState =
+  | 'closed'
+  | 'have-local-offer'
+  | 'have-local-pranswer'
+  | 'have-remote-offer'
+  | 'have-remote-pranswer'
+  | 'stable';
+
+export interface LocalDescriptionInit {
+  iceUfrag?: string;
+  icePwd?: string;
+}
+
+export interface DataChannelInitConfig {
+  protocol?: string;
+  negotiated?: boolean;
+  id?: number;
+  unordered?: boolean; // Reliability
+  maxPacketLifeTime?: number; // Reliability
+  maxRetransmits?: number; // Reliability
+}
+
+export interface CertificateFingerprint {
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/RTCCertificate/getFingerprints#value
+   */
+  value: string;
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/RTCCertificate/getFingerprints#algorithm
+   */
+  algorithm: 'sha-1' | 'sha-224' | 'sha-256' | 'sha-384' | 'sha-512' | 'md5' | 'md2';
+}
+
+export interface SelectedCandidateInfo {
+  address: string;
+  port: number;
+  type: string;
+  transportType: string;
+  candidate: string;
+  mid: string;
+  priority: number;
+}
+
+// Must be same as rtc enum class Direction
+export type Direction = 'SendOnly' | 'RecvOnly' | 'SendRecv' | 'Inactive' | 'Unknown';
+
+export interface IceUdpMuxRequest {
+  ufrag: string;
+  host: string;
+  port: number;
+}
+
+// Same as rtc::NalUnit::Separator
+export type NalUnitSeparator = 'Length' | 'ShortStartSequence' | 'LongStartSequence' | 'StartSequence';
+
+// Same as rtc::AV1RtpPacketizer::Packetization
+export type ObuPacketization = 'Obu' | 'TemporalUnit';

package/src/lib/websocket-server.ts

@@ -0,0 +1,37 @@
+import { EventEmitter } from 'events';
+import nodeDataChannel from './node-datachannel';
+import { WebSocketServerConfiguration } from './types';
+import { WebSocket } from './websocket';
+
+export class WebSocketServer extends EventEmitter {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  #server: any;
+  #clients: WebSocket[] = [];
+
+  constructor(options: WebSocketServerConfiguration) {
+    super();
+    this.#server = new nodeDataChannel.WebSocketServer(options);
+
+    this.#server.onClient((client) => {
+      this.emit('client', client);
+      this.#clients.push(client);
+    });
+  }
+
+  port(): number {
+    return this.#server?.port() || 0;
+  }
+
+  stop(): void {
+    this.#clients.forEach((client) => {
+      client?.close();
+    });
+    this.#server?.stop();
+    this.#server = null;
+    this.removeAllListeners();
+  }
+
+  onClient(cb: (clientSocket: WebSocket) => void): void {
+    if (this.#server) this.on('client', cb);
+  }
+}

package/src/lib/websocket.ts

@@ -0,0 +1,26 @@
+import nodeDataChannel from './node-datachannel';
+import { Channel, WebSocketServerConfiguration } from './types';
+
+export interface WebSocket extends Channel {
+  open(url: string): void;
+  forceClose(): void;
+  remoteAddress(): string | undefined;
+  path(): string | undefined;
+
+  // Channel implementation
+  close(): void;
+  sendMessage(msg: string): boolean;
+  sendMessageBinary(buffer: Uint8Array): boolean;
+  isOpen(): boolean;
+  bufferedAmount(): number;
+  maxMessageSize(): number;
+  setBufferedAmountLowThreshold(newSize: number): void;
+  onOpen(cb: () => void): void;
+  onClosed(cb: () => void): void;
+  onError(cb: (err: string) => void): void;
+  onBufferedAmountLow(cb: () => void): void;
+  onMessage(cb: (msg: string | Buffer) => void): void;
+}
+export const WebSocket: {
+  new (config?: WebSocketServerConfiguration): WebSocket;
+} = nodeDataChannel.WebSocket;