@socket-mesh/server 18.1.4 → 19.0.0

package/dist/server.js

@@ -1,17 +1,43 @@
-import ws from "ws";
-import { ServerProtocolError } from "@socket-mesh/errors";
-import { ServerSocket } from "./server-socket.js";
-import defaultCodec from "@socket-mesh/formatter";
-import { removeAuthTokenHandler } from "@socket-mesh/client";
-import { defaultAuthEngine, isAuthEngine } from "@socket-mesh/auth-engine";
-import { handshakeHandler } from "./handlers/handshake.js";
-import { authenticateHandler } from "./handlers/authenticate.js";
-import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
-import { subscribeHandler } from "./handlers/subscribe.js";
-import { unsubscribeHandler } from "./handlers/unsubscribe.js";
-import { SimpleBroker } from "./broker/simple-broker.js";
-import { publishHandler } from "./handlers/publish.js";
+import { AsyncStreamEmitter } from '@socket-mesh/async-stream-emitter';
+import { defaultAuthEngine, isAuthEngine } from '@socket-mesh/auth-engine';
+import { removeAuthTokenHandler } from '@socket-mesh/client';
+import { toError } from '@socket-mesh/core';
+import { ServerProtocolError } from '@socket-mesh/errors';
+import defaultCodec from '@socket-mesh/formatter';
+import { WebSocketServer } from 'ws';
+import { SimpleBroker } from './broker/simple-broker.js';
+import { authenticateHandler } from './handlers/authenticate.js';
+import { handshakeHandler } from './handlers/handshake.js';
+import { publishHandler } from './handlers/publish.js';
+import { subscribeHandler } from './handlers/subscribe.js';
+import { unsubscribeHandler } from './handlers/unsubscribe.js';
+import { ServerSocket } from './server-socket.js';
 export class Server extends AsyncStreamEmitter {
+    _callIdGenerator;
+    _handlers;
+    _isListening;
+    _isReady;
+    _pingIntervalRef;
+    _wss;
+    // | ServerSocket<TIncomingMap, TServiceMap, TOutgoingMap, TPrivateIncomingMap, TPrivateOutgoingMap, TServerState, TSocketState>
+    ackTimeoutMs;
+    allowClientPublish;
+    auth;
+    brokerEngine;
+    clientCount;
+    clients;
+    codecEngine;
+    httpServer;
+    isPingTimeoutDisabled;
+    origins;
+    pendingClientCount;
+    pendingClients;
+    pingIntervalMs;
+    pingTimeoutMs;
+    plugins;
+    socketChannelLimit;
+    socketStreamCleanupMode;
+    strictHandshake;
     constructor(options) {
         super();
         let cid = 1;
@@ -19,6 +45,9 @@ export class Server extends AsyncStreamEmitter {
             options = {};
         }
         options.clientTracking = true;
+        this._isListening = false;
+        this._isReady = false;
+        this._pingIntervalRef = null;
         this.ackTimeoutMs = options.ackTimeoutMs || 10000;
         this.allowClientPublish = options.allowClientPublish ?? true;
         this.auth = isAuthEngine(options.authEngine) ? options.authEngine : defaultAuthEngine(options.authEngine);
@@ -30,12 +59,12 @@ export class Server extends AsyncStreamEmitter {
         this.clientCount = 0;
         this.codecEngine = options.codecEngine || defaultCodec;
         this._handlers = Object.assign({
-            "#authenticate": authenticateHandler,
-            "#handshake": handshakeHandler,
-            "#publish": publishHandler,
-            "#removeAuthToken": removeAuthTokenHandler,
-            "#subscribe": subscribeHandler,
-            "#unsubscribe": unsubscribeHandler
+            '#authenticate': authenticateHandler,
+            '#handshake': handshakeHandler,
+            '#publish': publishHandler,
+            '#removeAuthToken': removeAuthTokenHandler,
+            '#subscribe': subscribeHandler,
+            '#unsubscribe': unsubscribeHandler
         }, options.handlers);
         this.httpServer = options.server;
         this.plugins = options.plugins || [];
@@ -49,14 +78,14 @@ export class Server extends AsyncStreamEmitter {
         this.socketStreamCleanupMode = options.socketStreamCleanupMode || 'kill';
         this.strictHandshake = options.strictHandshake ?? true;
         options.verifyClient = this.verifyClient.bind(this);
-        this._wss = new ws.WebSocketServer(options);
+        this._wss = new WebSocketServer(options);
         this._wss.on('close', this.onClose.bind(this));
         this._wss.on('connection', this.onConnection.bind(this));
         this._wss.on('error', this.onError.bind(this));
         this._wss.on('headers', this.onHeaders.bind(this));
         this._wss.on('listening', this.onListening.bind(this));
         (async () => {
-            for await (let { error } of this.brokerEngine.listen('error')) {
+            for await (const { error } of this.brokerEngine.listen('error')) {
                 this.emit('warning', { warning: error });
             }
         })();
@@ -80,34 +109,34 @@ export class Server extends AsyncStreamEmitter {
     }
     bind(socket) {
         /*
-                if (socket.type === 'client') {
-                    (async () => {
-                        for await (let event of socket.listen()) {
-                            this.emit(
-                                `socket${event.stream[0].toUpperCase()}${event.stream.substring(1)}` as any,
-                                Object.assign(
-                                    { socket },
-                                    event.value
-                                )
-                            );
-                        }
-                    })();
-            
-                    (async () => {
-                        for await (let event of socket.channels.listen()) {
-                            this.emit(
-                                `socket${event.stream[0].toUpperCase()}${event.stream.substring(1)}` as any,
-                                Object.assign(
-                                    { socket },
-                                    event.value
-                                )
-                            );
-                        }
-                    })();
+        if (socket.type === 'client') {
+            (async () => {
+                for await (let event of socket.listen()) {
+                    this.emit(
+                        `socket${event.stream[0].toUpperCase()}${event.stream.substring(1)}` as any,
+                        Object.assign(
+                            { socket },
+                            event.value
+                        )
+                    );
+                }
+            })();
+
+            (async () => {
+                for await (let event of socket.channels.listen()) {
+                    this.emit(
+                        `socket${event.stream[0].toUpperCase()}${event.stream.substring(1)}` as any,
+                        Object.assign(
+                            { socket },
+                            event.value
+                        )
+                    );
                 }
-        */
+            })();
+        }
+*/
         (async () => {
-            for await (let {} of socket.listen('connect')) {
+            for await (const _ of socket.listen('connect')) {
                 if (this.pendingClients[socket.id]) {
                     delete this.pendingClients[socket.id];
                     this.pendingClientCount--;
@@ -118,12 +147,12 @@ export class Server extends AsyncStreamEmitter {
             }
         })();
         (async () => {
-            for await (let {} of socket.listen('connectAbort')) {
+            for await (const _ of socket.listen('connectAbort')) {
                 this.socketDisconnected(socket);
             }
         })();
         (async () => {
-            for await (let {} of socket.listen('disconnect')) {
+            for await (const _ of socket.listen('disconnect')) {
                 this.socketDisconnected(socket);
             }
         })();
@@ -139,12 +168,15 @@ export class Server extends AsyncStreamEmitter {
                 resolve();
             });
             if (!keepSocketsOpen) {
-                for (let socket of Object.values(this.clients)) {
+                for (const socket of Object.values(this.clients)) {
                     socket.disconnect();
                 }
             }
         });
     }
+    emit(event, data) {
+        super.emit(event, data);
+    }
     get exchange() {
         return this.brokerEngine.exchange;
     }
@@ -154,32 +186,35 @@ export class Server extends AsyncStreamEmitter {
     get isReady() {
         return this._isReady;
     }
+    listen(event) {
+        return event ? super.listen(event) : super.listen();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     onClose(code, reason) {
         this.emit('close', {});
     }
     onConnection(wsSocket, upgradeReq) {
         /*
-                if (!wsSocket.upgradeReq) {
-                    // Normalize ws modules to match.
-                    wsSocket.upgradeReq = upgradeReq;
-                }
-        */
+        if (!wsSocket.upgradeReq) {
+            // Normalize ws modules to match.
+            wsSocket.upgradeReq = upgradeReq;
+        }
+*/
         const socket = new ServerSocket({
             ackTimeoutMs: this.ackTimeoutMs,
             callIdGenerator: this._callIdGenerator,
             codecEngine: this.codecEngine,
             handlers: this._handlers,
             plugins: this.plugins,
-            onUnhandledRequest: this.onUnhandledRequest.bind(this),
             request: upgradeReq,
-            socket: wsSocket,
             server: this,
+            socket: wsSocket,
             state: {},
             streamCleanupMode: this.socketStreamCleanupMode
         });
         this.pendingClientCount++;
         this.bind(this.pendingClients[socket.id] = socket);
-        //		ws.on('error', console.error);
+        // ws.on('error', console.error);
         this.emit('connection', { socket, upgradeReq });
         // Emit event to signal that a socket handshake has been initiated.
         this.emit('handshake', { socket });
@@ -197,14 +232,12 @@ export class Server extends AsyncStreamEmitter {
         this._isListening = true;
         this.emit('listening', {});
     }
-    onUnhandledRequest(socket, packet) {
-    }
     socketDisconnected(socket) {
-        if (!!this.pendingClients[socket.id]) {
+        if (this.pendingClients[socket.id]) {
             delete this.pendingClients[socket.id];
             this.pendingClientCount--;
         }
-        if (!!this.clients[socket.id]) {
+        if (this.clients[socket.id]) {
             delete this.clients[socket.id];
             this.clientCount--;
         }
@@ -218,7 +251,7 @@ export class Server extends AsyncStreamEmitter {
                 for (const id in this.clients) {
                     this.clients[id]
                         .ping()
-                        .catch(err => {
+                        .catch((err) => {
                         this.onError(err);
                     });
                 }
@@ -237,16 +270,18 @@ export class Server extends AsyncStreamEmitter {
                 info.origin = '*';
             }
             if (this.origins.indexOf('*:*') === -1) {
-                let ok = false;
+                let isOk = false;
                 try {
                     const url = new URL(info.origin);
                     url.port = url.port || (url.protocol === 'https:' ? '443' : '80');
-                    ok = !!(~this.origins.indexOf(url.hostname + ':' + url.port) ||
-                        ~this.origins.indexOf(url.hostname + ':*') ||
-                        ~this.origins.indexOf('*:' + url.port));
+                    isOk = !!(~this.origins.indexOf(url.hostname + ':' + url.port)
+                        || ~this.origins.indexOf(url.hostname + ':*')
+                        || ~this.origins.indexOf('*:' + url.port));
+                }
+                catch (e) {
+                    // Intentional
                 }
-                catch (e) { }
-                if (!ok) {
+                if (!isOk) {
                     const error = new ServerProtocolError(`Failed to authorize socket handshake - Invalid origin: ${info.origin}`);
                     this.emit('warning', { warning: error });
                     callback(false, 403, error.message);
@@ -261,21 +296,17 @@ export class Server extends AsyncStreamEmitter {
                 }
             }
             catch (err) {
-                callback(false, 401, typeof err === 'string' ? err : err.message);
+                const error = toError(err);
+                callback(false, 401, typeof err === 'string' ? err : error.message);
                 return;
             }
             callback(true);
         }
         catch (err) {
-            this.onError(err);
-            this.emit('warning', { warning: err });
-            callback(false, 403, typeof err === 'string' ? err : err.message);
+            const error = toError(err);
+            this.onError(error);
+            this.emit('warning', { warning: error });
+            callback(false, 403, typeof err === 'string' ? err : error.message);
         }
     }
-    emit(event, data) {
-        super.emit(event, data);
-    }
-    listen(event) {
-        return super.listen(event);
-    }
 }

package/package.json

@@ -1,18 +1,42 @@
 {
 	"name": "@socket-mesh/server",
 	"description": "A TCP socket pair for easily transmitting full messages without worrying about request size limits.",
-	"version": "18.1.4",
+	"version": "19.0.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"files": ["./dist"],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./broker": {
+			"types": "./dist/broker/index.d.ts",
+			"import": "./dist/broker/index.js",
+			"default": "./dist/broker/index.js"
+		},
+		"./events": {
+			"types": "./dist/events/index.d.ts",
+			"import": "./dist/events/index.js",
+			"default": "./dist/events/index.js"
+		},
+		"./handlers": {
+			"types": "./dist/handlers/index.d.ts",
+			"import": "./dist/handlers/index.js",
+			"default": "./dist/handlers/index.js"
+		}
+	},
 	"author": {
 		"name": "Greg Kimmy"
 	},
 	"scripts": {
 		"build": "node ../../scripts/build.mjs && tsc --project tsconfig.build.json",
-		"deploy": "npm run build && node ../../scripts/publish.mjs",
-		"test": "cross-env node --test --import=./run-test.js test/server-test.ts"
+		"deploy": "node ../../scripts/publish.mjs",
+		"lint": "eslint . --c ../../eslint.config.mjs",
+		"lint:fix": "eslint . --c ../../eslint.config.mjs --fix",
+		"test": "tsx --tsconfig ./tsconfig.build.json --test ./src/**/*.{spec,test}.ts ./test/**/*.{spec,test}.ts"
 	},
 	"repository": {
 		"type": "git",
@@ -22,22 +46,27 @@
 		"url": "https://github.com/socket-mesh/client-server/labels/server"
 	},	
 	"devDependencies": {
-		"@socket-mesh/local-storage": "^1.0.2",
-		"@types/base64id": "^2.0.2",
-		"@types/jsonwebtoken": "^9.0.6",
-		"@types/ws": "^8.5.10"
+		"@socket-mesh/local-storage": "workspace:^",
+		"@socket-mesh/typescript-config": "workspace:^",
+		"@types/base64id": "catalog:base64id",
+		"@types/jsonwebtoken": "catalog:json-web-token",
+		"@types/ws": "catalog:ws"
 	},
 	"dependencies": {
-		"@socket-mesh/async-stream-emitter": "^7.1.2",
-		"@socket-mesh/auth": "^2.2.0",
-		"@socket-mesh/auth-engine": "^1.0.0",
-		"@socket-mesh/client": "^18.1.5",
-		"@socket-mesh/errors": "^3.2.0",
-		"@socket-mesh/formatter": "^4.1.0",
-		"base64id": "^2.0.0",
-		"events": "^3.3.0",
-		"jsonwebtoken": "^9.0.2",
-		"ws": "^8.18.0"
+		"@socket-mesh/async-stream-emitter": "workspace:^",
+		"@socket-mesh/auth": "workspace:^",
+		"@socket-mesh/auth-engine": "workspace:^",
+		"@socket-mesh/channels": "workspace:^",
+		"@socket-mesh/client": "workspace:^",
+		"@socket-mesh/core": "workspace:^",
+		"@socket-mesh/errors": "workspace:^",
+		"@socket-mesh/formatter": "workspace:^",
+		"@socket-mesh/stream-demux": "workspace:^",
+		"@socket-mesh/writable-consumable-stream": "workspace:^",
+		"base64id": "catalog:base64id",
+		"events": "catalog:",
+		"jsonwebtoken": "catalog:json-web-token",
+		"ws": "catalog:ws"
 	},
 	"keywords": [
 		"ncom",

package/dist/server-event.d.ts

@@ -1,49 +0,0 @@
-import { IncomingMessage } from "http";
-import { ClientSocket, ServerPrivateMap } from "@socket-mesh/client";
-import { ServerSocket } from "./server-socket.js";
-import { AuthenticateEvent, BadAuthTokenEvent, ConnectEvent, CloseEvent as SCloseEvent, DisconnectEvent, ErrorEvent as SErrorEvent, MessageEvent, PingEvent, PongEvent, RequestEvent, ResponseEvent, ConnectingEvent, RemoveAuthTokenEvent, DeauthenticateEvent, AuthStateChangeEvent, ServiceMap, PublicMethodMap, PrivateMethodMap } from "@socket-mesh/core";
-import { ChannelMap, SubscribeEvent, SubscribeFailEvent, SubscribeStateChangeEvent, UnsubscribeEvent } from "@socket-mesh/channels";
-export type ServerEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = ConnectionEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | CloseEvent | ErrorEvent | HeadersEvent | HandshakeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | ListeningEvent | SocketAuthStateChangeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketAuthenticateEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketBadAuthTokenEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketCloseEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketDeauthenticateEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketErrorEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketMessageEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketConnectEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketConnectingEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketDisconnectEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketPingEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketPongEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketRemoveAuthTokenEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketRequestEvent<TService, TIncoming, TPrivateIncoming> | SocketResponseEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | WarningEvent;
-export interface ConnectionEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> {
-    socket: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-    upgradeReq: IncomingMessage;
-}
-export interface CloseEvent {
-}
-export interface ErrorEvent {
-    error: Error;
-}
-export interface HandshakeEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> {
-    socket: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-}
-export interface WarningEvent {
-    warning: Error;
-}
-export interface HeadersEvent {
-    headers: string[];
-    request: IncomingMessage;
-}
-export interface ListeningEvent {
-}
-export interface ServerSocketEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> {
-    socket: ClientSocket<PublicMethodMap, TChannel, TService, TState, TOutgoing & TPrivateOutgoing, TPrivateIncoming> | ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-}
-export type SocketAuthStateChangeEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = AuthStateChangeEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketAuthenticateEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = AuthenticateEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketBadAuthTokenEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = BadAuthTokenEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketCloseEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = SCloseEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketDeauthenticateEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = DeauthenticateEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketErrorEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = SErrorEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketMessageEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = MessageEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketConnectEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = ConnectEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketConnectingEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = ConnectingEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketDisconnectEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = DisconnectEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketPingEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = PingEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketPongEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = PongEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketRemoveAuthTokenEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = RemoveAuthTokenEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketRequestEvent<TService extends ServiceMap, TIncoming extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap> = RequestEvent<TIncoming & TPrivateIncoming & ServerPrivateMap, TService>;
-export type SocketResponseEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = ResponseEvent<TOutgoing, TPrivateOutgoing, TService> & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketSubscribeEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = SubscribeEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketSubscribeFailEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = SubscribeFailEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketSubscribeStateChangeEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = SubscribeStateChangeEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketUnsubscribeEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = UnsubscribeEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;