@socket-mesh/server 18.1.4 → 19.0.0

package/dist/server-transport.js

@@ -1,12 +1,17 @@
-import { AuthError, BrokerError, InvalidActionError, socketProtocolErrorStatuses } from "@socket-mesh/errors";
-import { SocketTransport, abortRequest } from "@socket-mesh/core";
-import base64id from "base64id";
-export class ServerTransport extends SocketTransport {
+import { abortRequest, BaseSocketTransport, toError } from '@socket-mesh/core';
+import { AuthError, BrokerError, InvalidActionError, SocketProtocolErrorStatuses } from '@socket-mesh/errors';
+import base64id from 'base64id';
+export class ServerTransport extends BaseSocketTransport {
+    id;
+    plugins;
+    request;
+    service;
+    type;
     constructor(options) {
         super(options);
         this.type = 'server';
         this.request = options.request;
-        this.plugins = options.plugins;
+        this.plugins = options.plugins || [];
         this.service = options.service;
         this.webSocket = options.socket;
         this.id = (options.id || base64id.generateId());
@@ -17,38 +22,41 @@ export class ServerTransport extends SocketTransport {
         if (this.signedAuthToken) {
             const authToken = this.authToken;
             const signedAuthToken = this.signedAuthToken;
-            this.socket.server.emit('socketAuthStateChange', { socket: this.socket, wasAuthenticated: true, isAuthenticated: false });
+            this.socket.server.emit('socketAuthStateChange', { isAuthenticated: false, socket: this.socket, wasAuthenticated: true });
             await super.changeToUnauthenticatedState();
-            this.socket.server.emit('socketDeauthenticate', { socket: this.socket, signedAuthToken, authToken });
+            this.socket.server.emit('socketDeauthenticate', { authToken, signedAuthToken, socket: this.socket });
             return true;
         }
         return false;
     }
-    handleInboudMessage({ packet, timestamp }) {
+    async handleInboudMessage({ packet, timestamp }) {
         if ((packet === null || typeof packet !== 'object') && this.socket.server.strictHandshake && this.status === 'connecting') {
             this.disconnect(4009);
             return;
         }
-        return super.handleInboudMessage({ packet, timestamp });
+        return await super.handleInboudMessage({ packet, timestamp });
+    }
+    invoke(methodOptions, arg) {
+        return super.invoke(methodOptions, arg);
     }
     onClose(code, reason) {
         const status = this.status;
-        const strReason = reason?.toString() || socketProtocolErrorStatuses[code];
+        const strReason = reason?.toString() || SocketProtocolErrorStatuses[code];
         super.onClose(code, reason);
-        this.socket.server.emit('socketClose', { socket: this.socket, code, reason: strReason });
+        this.socket.server.emit('socketClose', { code, reason: strReason, socket: this.socket });
         this.onDisconnect(status, code, strReason);
     }
     onDisconnect(status, code, reason) {
         if (status === 'ready') {
-            this.socket.server.emit('socketDisconnect', { socket: this.socket, code, reason });
+            this.socket.server.emit('socketDisconnect', { code, reason, socket: this.socket });
         }
         else {
-            this.socket.server.emit('socketConnectAbort', { socket: this.socket, code, reason });
+            this.socket.server.emit('socketConnectAbort', { code, reason, socket: this.socket });
         }
         super.onDisconnect(status, code, reason);
         if (this.socket.state.channelSubscriptions) {
             const channels = Object.keys(this.socket.state.channelSubscriptions);
-            channels.map((channel) => this.unsubscribe(channel));
+            channels.map(channel => this.unsubscribe(channel));
         }
         if (this.streamCleanupMode !== 'none') {
             (async () => {
@@ -61,7 +69,7 @@ export class ServerTransport extends SocketTransport {
                 }
                 for (let i = 0; i < this.plugins.length; i++) {
                     const plugin = this.plugins[i];
-                    if (plugin.onEnd) {
+                    if (plugin?.onEnd) {
                         plugin.onEnd({ socket: this.socket, transport: this });
                     }
                 }
@@ -71,7 +79,7 @@ export class ServerTransport extends SocketTransport {
     }
     onError(error) {
         super.onError(error);
-        this.socket.server.emit('socketError', { socket: this.socket, error });
+        this.socket.server.emit('socketError', { error, socket: this.socket });
     }
     onInvoke(request) {
         if (request.method !== '#publish') {
@@ -82,25 +90,25 @@ export class ServerTransport extends SocketTransport {
             .then(() => {
             super.onInvoke(request);
         })
-            .catch(err => {
+            .catch((err) => {
             abortRequest(request, err);
         });
     }
+    /*
+    protected override onPing(data: Buffer): void {
+        if (this.socket.server.strictHandshake && this.status === 'connecting') {
+            this.disconnect(4009);
+            return;
+        }
+
+        super.onPing(data);
+        this.socket.server.emit('socketPing', { socket: this.socket, data });
+    }
+*/
     onMessage(data, isBinary) {
-        this.socket.server.emit('socketMessage', { socket: this.socket, data, isBinary });
+        this.socket.server.emit('socketMessage', { data, isBinary, socket: this.socket });
         super.onMessage(data, isBinary);
     }
-    /*
-        protected override onPing(data: Buffer): void {
-            if (this.socket.server.strictHandshake && this.status === 'connecting') {
-                this.disconnect(4009);
-                return;
-            }
-    
-            super.onPing(data);
-            this.socket.server.emit('socketPing', { socket: this.socket, data });
-        }
-    */
     onPingPong() {
         if (this.socket.server.strictHandshake && this.status === 'connecting') {
             this.disconnect(4009);
@@ -113,8 +121,8 @@ export class ServerTransport extends SocketTransport {
     async onPublish(options) {
         let data = options.data;
         for (const plugin of this.plugins) {
-            if ('onPublishOut' in plugin) {
-                data = await plugin.onPublishOut({ socket: this.socket, transport: this, channel: options.channel, data });
+            if (plugin.onPublishOut) {
+                data = await plugin.onPublishOut({ channel: options.channel, data, socket: this.socket, transport: this });
             }
         }
         options.data = data;
@@ -135,7 +143,7 @@ export class ServerTransport extends SocketTransport {
     }
     onResponse(response) {
         super.onResponse(response);
-        this.socket.server.emit('socketResponse', { socket: this.socket, response });
+        this.socket.server.emit('socketResponse', { response, socket: this.socket });
     }
     onTransmit(request) {
         if (request.method !== '#publish') {
@@ -146,7 +154,7 @@ export class ServerTransport extends SocketTransport {
             .then(() => {
             super.onTransmit(request);
         })
-            .catch(err => {
+            .catch((err) => {
             abortRequest(request, err);
         });
     }
@@ -174,9 +182,10 @@ export class ServerTransport extends SocketTransport {
             signedAuthToken = await auth.signToken(authToken, options);
         }
         catch (err) {
-            this.onError(err);
-            this.disconnect(4002, err.toString());
-            throw err;
+            const error = toError(err);
+            this.onError(error);
+            this.disconnect(4002, error.toString());
+            throw error;
         }
         const changed = await super.setAuthorization(signedAuthToken, authToken);
         if (changed && this.status === 'ready') {
@@ -187,23 +196,17 @@ export class ServerTransport extends SocketTransport {
                 await this.invoke('#setAuthToken', signedAuthToken)[0];
             }
             catch (err) {
-                let error;
-                if (err && typeof err.message === 'string') {
-                    error = new AuthError(`Failed to deliver auth token to client - ${err.message}`);
-                }
-                else {
-                    error = new AuthError('Failed to confirm delivery of auth token to client due to malformatted error response');
-                }
-                this.onError(error);
-                throw error;
+                const authError = new AuthError(`Failed to deliver auth token to client - ${toError(err).message}`);
+                this.onError(authError);
+                throw authError;
             }
-            return;
+            return changed;
         }
         try {
             await this.transmit('#setAuthToken', signedAuthToken);
         }
         catch (err) {
-            if (err.name !== 'BadConnectionError') {
+            if (toError(err).name !== 'BadConnectionError') {
                 throw err;
             }
         }
@@ -211,7 +214,7 @@ export class ServerTransport extends SocketTransport {
     }
     setReadyStatus(pingTimeoutMs, authError) {
         super.setReadyStatus(pingTimeoutMs, authError);
-        this.socket.server.emit('socketConnect', { socket: this.socket, pingTimeoutMs, id: this.socket.id, isAuthenticated: !!this.signedAuthToken, authError });
+        this.socket.server.emit('socketConnect', { authError, id: this.socket.id, isAuthenticated: !!this.signedAuthToken, pingTimeoutMs, socket: this.socket });
     }
     get socket() {
         return super.socket;
@@ -219,10 +222,16 @@ export class ServerTransport extends SocketTransport {
     set socket(value) {
         super.socket = value;
     }
+    transmit(serviceAndMethod, arg) {
+        return super.transmit(serviceAndMethod, arg);
+    }
     triggerAuthenticationEvents(wasSigned, wasAuthenticated) {
+        if (!this.signedAuthToken) {
+            throw new AuthError('Signed auth token should be set to trigger authentication events');
+        }
         super.triggerAuthenticationEvents(wasSigned, wasAuthenticated);
-        this.socket.server.emit('socketAuthStateChange', { socket: this.socket, wasAuthenticated, isAuthenticated: true, authToken: this.authToken, signedAuthToken: this.signedAuthToken });
-        this.socket.server.emit('socketAuthenticate', { socket: this.socket, wasSigned, signedAuthToken: this.signedAuthToken, authToken: this.authToken });
+        this.socket.server.emit('socketAuthStateChange', { authToken: this.authToken, isAuthenticated: true, signedAuthToken: this.signedAuthToken, socket: this.socket, wasAuthenticated });
+        this.socket.server.emit('socketAuthenticate', { authToken: this.authToken, signedAuthToken: this.signedAuthToken, socket: this.socket, wasSigned });
     }
     async unsubscribe(channel) {
         if (typeof channel !== 'string') {

package/dist/server.d.ts

@@ -1,119 +1,118 @@
-import { ServerSocket } from "./server-socket.js";
+import { AsyncStreamEmitter } from '@socket-mesh/async-stream-emitter';
+import { AuthEngine } from '@socket-mesh/auth-engine';
+import { ChannelMap } from '@socket-mesh/channels';
+import { PrivateMethodMap, PublicMethodMap, ServiceMap, StreamCleanupMode } from '@socket-mesh/core';
+import { CodecEngine } from '@socket-mesh/formatter';
+import { DemuxedConsumableStream, StreamEvent } from '@socket-mesh/stream-demux';
 import { Server as HttpServer } from 'http';
-import { CodecEngine } from "@socket-mesh/formatter";
-import { PrivateMethodMap, PublicMethodMap, ServiceMap, StreamCleanupMode } from "@socket-mesh/core";
-import { AuthEngine } from "@socket-mesh/auth-engine";
-import { ServerPlugin } from "./plugin/server-plugin.js";
-import { CloseEvent, ConnectionEvent, ErrorEvent, HandshakeEvent, HeadersEvent, ListeningEvent, ServerEvent, SocketAuthenticateEvent, SocketAuthStateChangeEvent, SocketBadAuthTokenEvent, SocketCloseEvent, SocketConnectEvent, SocketConnectingEvent, SocketDeauthenticateEvent, SocketDisconnectEvent, SocketErrorEvent, SocketMessageEvent, SocketPingEvent, SocketPongEvent, SocketRemoveAuthTokenEvent, SocketRequestEvent, SocketResponseEvent, SocketSubscribeEvent, SocketSubscribeFailEvent, SocketSubscribeStateChangeEvent, SocketUnsubscribeEvent, WarningEvent } from "./server-event.js";
-import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
-import { DemuxedConsumableStream, StreamEvent } from "@socket-mesh/stream-demux";
-import { ServerOptions } from "./server-options.js";
-import { Broker } from "./broker/broker.js";
-import { Exchange } from "./broker/exchange.js";
-import { ChannelMap } from "@socket-mesh/channels";
-export declare class Server<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}> extends AsyncStreamEmitter<ServerEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>> {
+import { Broker } from './broker/broker.js';
+import { Exchange } from './broker/exchange.js';
+import { CloseEvent, ConnectionEvent, ErrorEvent, HandshakeEvent, HeadersEvent, ListeningEvent, ServerEvent, SocketAuthenticateEvent, SocketAuthStateChangeEvent, SocketBadAuthTokenEvent, SocketCloseEvent, SocketConnectEvent, SocketConnectingEvent, SocketDeauthenticateEvent, SocketDisconnectEvent, SocketErrorEvent, SocketMessageEvent, SocketPingEvent, SocketPongEvent, SocketRemoveAuthTokenEvent, SocketRequestEvent, SocketResponseEvent, SocketSubscribeEvent, SocketSubscribeFailEvent, SocketSubscribeStateChangeEvent, SocketUnsubscribeEvent, WarningEvent } from './events/index.js';
+import { ServerPlugin } from './plugin/server-plugin.js';
+import { ServerOptions } from './server-options.js';
+import { ServerSocket } from './server-socket.js';
+export declare class Server<TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TState extends object = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}> extends AsyncStreamEmitter<ServerEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>> {
     private readonly _callIdGenerator;
-    private readonly _wss;
-    private _isReady;
+    private _handlers;
     private _isListening;
+    private _isReady;
     private _pingIntervalRef;
-    private _handlers;
+    private readonly _wss;
     ackTimeoutMs: number;
     allowClientPublish: boolean;
-    pingIntervalMs: number;
-    isPingTimeoutDisabled: boolean;
-    origins: string;
-    pingTimeoutMs: number;
-    socketChannelLimit?: number;
-    strictHandshake: boolean;
     readonly auth: AuthEngine;
     readonly brokerEngine: Broker<TChannel>;
+    clientCount: number;
     readonly clients: {
-        [id: string]: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+        [id: string]: ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
     };
-    clientCount: number;
     readonly codecEngine: CodecEngine;
+    readonly httpServer: HttpServer;
+    isPingTimeoutDisabled: boolean;
+    origins: string;
+    pendingClientCount: number;
     readonly pendingClients: {
-        [id: string]: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+        [id: string]: ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
     };
-    pendingClientCount: number;
+    pingIntervalMs: number;
+    pingTimeoutMs: number;
+    readonly plugins: ServerPlugin<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>[];
+    socketChannelLimit?: number;
     readonly socketStreamCleanupMode: StreamCleanupMode;
-    readonly httpServer: HttpServer;
-    readonly plugins: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
-    constructor(options?: ServerOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>);
-    addPlugin(...plugin: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[]): void;
+    strictHandshake: boolean;
+    constructor(options?: ServerOptions<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>);
+    addPlugin(...plugin: ServerPlugin<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>[]): void;
     private bind;
     close(keepSocketsOpen?: boolean): Promise<void>;
+    emit(event: 'close', data: CloseEvent): void;
+    emit(event: 'connection', data: ConnectionEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'error', data: ErrorEvent): void;
+    emit(event: 'headers', data: HeadersEvent): void;
+    emit(event: 'handshake', data: HandshakeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'listening', data: ListeningEvent): void;
+    emit(event: 'ready', data: {}): void;
+    emit(event: 'socketAuthStateChange', data: SocketAuthStateChangeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketAuthenticate', data: SocketAuthenticateEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketBadAuthToken', data: SocketBadAuthTokenEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketClose', data: SocketCloseEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketConnect', data: SocketConnectEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketConnectAbort', data: SocketDisconnectEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketConnecting', data: SocketConnectingEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketDeauthenticate', data: SocketDeauthenticateEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketDisconnect', data: SocketDisconnectEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketError', data: SocketErrorEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketMessage', data: SocketMessageEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketPing', data: SocketPingEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketPong', data: SocketPongEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketRemoveAuthToken', data: SocketRemoveAuthTokenEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketRequest', data: SocketRequestEvent<TIncoming, TService, TPrivateIncoming>): void;
+    emit(event: 'socketResponse', data: SocketResponseEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketSubscribe', data: SocketSubscribeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketSubscribeFail', data: SocketSubscribeFailEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketSubscribeRequest', data: SocketSubscribeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketSubscribeStateChange', data: SocketSubscribeStateChangeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketUnsubscribe', data: SocketUnsubscribeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'warning', data: WarningEvent): void;
     get exchange(): Exchange<TChannel>;
     get isListening(): boolean;
     get isReady(): boolean;
+    listen(): DemuxedConsumableStream<StreamEvent<ServerEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>>;
+    listen(event: 'close'): DemuxedConsumableStream<CloseEvent>;
+    listen(event: 'connection'): DemuxedConsumableStream<ConnectionEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'error'): DemuxedConsumableStream<ErrorEvent>;
+    listen(event: 'handshake'): DemuxedConsumableStream<HandshakeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'headers'): DemuxedConsumableStream<HeadersEvent>;
+    listen(event: 'listening'): DemuxedConsumableStream<ListeningEvent>;
+    listen(event: 'ready'): DemuxedConsumableStream<{}>;
+    listen(event: 'socketAuthStateChange'): DemuxedConsumableStream<SocketAuthStateChangeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketAuthenticate'): DemuxedConsumableStream<SocketAuthenticateEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketBadAuthToken'): DemuxedConsumableStream<SocketBadAuthTokenEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketClose'): DemuxedConsumableStream<SocketCloseEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketConnect'): DemuxedConsumableStream<SocketConnectEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketConnectAbort'): DemuxedConsumableStream<SocketDisconnectEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketConnecting'): DemuxedConsumableStream<SocketConnectingEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketDeauthenticate'): DemuxedConsumableStream<SocketDeauthenticateEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketDisconnect'): DemuxedConsumableStream<SocketDisconnectEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketError'): DemuxedConsumableStream<SocketErrorEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketMessage'): DemuxedConsumableStream<SocketMessageEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketPing'): DemuxedConsumableStream<SocketPingEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketPong'): DemuxedConsumableStream<SocketPongEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketRemoveAuthToken'): DemuxedConsumableStream<SocketRemoveAuthTokenEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketRequest'): DemuxedConsumableStream<SocketRequestEvent<TIncoming, TService, TPrivateIncoming>>;
+    listen(event: 'socketResponse'): DemuxedConsumableStream<SocketResponseEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketSubscribe'): DemuxedConsumableStream<SocketSubscribeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketSubscribeFail'): DemuxedConsumableStream<SocketSubscribeFailEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketSubscribeRequest'): DemuxedConsumableStream<SocketSubscribeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketSubscribeStateChange'): DemuxedConsumableStream<SocketSubscribeStateChangeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketUnsubscribe'): DemuxedConsumableStream<SocketUnsubscribeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'warning'): DemuxedConsumableStream<WarningEvent>;
     private onClose;
     private onConnection;
     private onError;
     private onHeaders;
     private onListening;
-    private onUnhandledRequest;
     private socketDisconnected;
     private startPinging;
     private stopPinging;
     private verifyClient;
-    emit(event: "close", data: CloseEvent): void;
-    emit(event: "connection", data: ConnectionEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: "error", data: ErrorEvent): void;
-    emit(event: "headers", data: HeadersEvent): void;
-    emit(event: "handshake", data: HandshakeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: "listening", data: ListeningEvent): void;
-    emit(event: "ready", data: {}): void;
-    emit(event: 'socketAuthStateChange', data: SocketAuthStateChangeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketAuthenticate', data: SocketAuthenticateEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketBadAuthToken', data: SocketBadAuthTokenEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketClose', data: SocketCloseEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketConnect', data: SocketConnectEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketConnectAbort', data: SocketDisconnectEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketConnecting', data: SocketConnectingEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketDeauthenticate', data: SocketDeauthenticateEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketDisconnect', data: SocketDisconnectEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketError', data: SocketErrorEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketMessage', data: SocketMessageEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketPing', data: SocketPingEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketPong', data: SocketPongEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketRemoveAuthToken', data: SocketRemoveAuthTokenEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketRequest', data: SocketRequestEvent<TService, TIncoming, TPrivateIncoming>): void;
-    emit(event: 'socketResponse', data: SocketResponseEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketSubscribe', data: SocketSubscribeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketSubscribeFail', data: SocketSubscribeFailEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketSubscribeRequest', data: SocketSubscribeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketSubscribeStateChange', data: SocketSubscribeStateChangeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketUnsubscribe', data: SocketUnsubscribeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: "warning", data: WarningEvent): void;
-    listen(): DemuxedConsumableStream<StreamEvent<ServerEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>>;
-    listen(event: "close"): DemuxedConsumableStream<CloseEvent>;
-    listen(event: "connection"): DemuxedConsumableStream<ConnectionEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: "error"): DemuxedConsumableStream<ErrorEvent>;
-    listen(event: "handshake"): DemuxedConsumableStream<HandshakeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: "headers"): DemuxedConsumableStream<HeadersEvent>;
-    listen(event: "listening"): DemuxedConsumableStream<ListeningEvent>;
-    listen(event: "ready"): DemuxedConsumableStream<{}>;
-    listen(event: 'socketAuthStateChange'): DemuxedConsumableStream<SocketAuthStateChangeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketAuthenticate'): DemuxedConsumableStream<SocketAuthenticateEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketBadAuthToken'): DemuxedConsumableStream<SocketBadAuthTokenEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketClose'): DemuxedConsumableStream<SocketCloseEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketConnect'): DemuxedConsumableStream<SocketConnectEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketConnectAbort'): DemuxedConsumableStream<SocketDisconnectEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketConnecting'): DemuxedConsumableStream<SocketConnectingEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketDeauthenticate'): DemuxedConsumableStream<SocketDeauthenticateEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketDisconnect'): DemuxedConsumableStream<SocketDisconnectEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketError'): DemuxedConsumableStream<SocketErrorEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketMessage'): DemuxedConsumableStream<SocketMessageEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketPing'): DemuxedConsumableStream<SocketPingEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketPong'): DemuxedConsumableStream<SocketPongEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketRemoveAuthToken'): DemuxedConsumableStream<SocketRemoveAuthTokenEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketRequest'): DemuxedConsumableStream<SocketRequestEvent<TService, TIncoming, TPrivateIncoming>>;
-    listen(event: 'socketResponse'): DemuxedConsumableStream<SocketResponseEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketSubscribe'): DemuxedConsumableStream<SocketSubscribeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketSubscribeFail'): DemuxedConsumableStream<SocketSubscribeFailEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketSubscribeRequest'): DemuxedConsumableStream<SocketSubscribeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketSubscribeStateChange'): DemuxedConsumableStream<SocketSubscribeStateChangeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketUnsubscribe'): DemuxedConsumableStream<SocketUnsubscribeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: "warning"): DemuxedConsumableStream<WarningEvent>;
 }