@socket-mesh/server 18.1.2 → 18.1.4

package/dist/handlers/authenticate.d.ts

@@ -1,11 +1,10 @@
-import { RequestHandlerArgs, SocketTransport } from "@socket-mesh/core";
 import jwt from "jsonwebtoken";
 import { AuthTokenError } from "@socket-mesh/errors";
 import { AuthEngine } from "@socket-mesh/auth-engine";
 import { AuthToken, SignedAuthToken } from "@socket-mesh/auth";
-import { BasicSocketMapServer } from "../maps/socket-map.js";
 import { ServerSocket } from "../server-socket.js";
-import { BasicServerMap } from "../maps/server-map.js";
+import { ServerTransport } from "../server-transport.js";
+import { ServerRequestHandlerArgs } from "./server-request-handler.js";
 export type AuthInfo = ValidAuthInfo | InvalidAuthInfo;
 export interface InvalidAuthInfo {
     signedAuthToken: SignedAuthToken;
@@ -15,6 +14,6 @@ export interface ValidAuthInfo {
     signedAuthToken: SignedAuthToken;
     authToken: AuthToken;
 }
-export declare function authenticateHandler({ isRpc, options: signedAuthToken, socket, transport }: RequestHandlerArgs<string, BasicSocketMapServer, ServerSocket<BasicServerMap>>): Promise<void>;
+export declare function authenticateHandler({ isRpc, options: signedAuthToken, socket, transport }: ServerRequestHandlerArgs<string>): Promise<void>;
 export declare function validateAuthToken(auth: AuthEngine, authToken: SignedAuthToken, verificationOptions?: jwt.VerifyOptions): Promise<AuthInfo>;
-export declare function processAuthentication(socket: ServerSocket<BasicServerMap>, transport: SocketTransport<BasicSocketMapServer>, authInfo: AuthInfo): Promise<boolean>;
+export declare function processAuthentication(socket: ServerSocket, transport: ServerTransport, authInfo: AuthInfo): Promise<boolean>;

package/dist/handlers/handshake.d.ts

@@ -1,7 +1,3 @@
 import { HandshakeOptions, HandshakeStatus } from "@socket-mesh/client";
-import { RequestHandlerArgs } from "@socket-mesh/core";
-import { BasicServerMap } from "../maps/server-map.js";
-import { BasicSocketMapServer } from "../maps/socket-map.js";
-import { ServerSocket } from "../server-socket.js";
-import { ServerTransport } from "../server-transport.js";
-export declare function handshakeHandler({ options, socket, transport }: RequestHandlerArgs<HandshakeOptions, BasicSocketMapServer, ServerSocket<BasicServerMap>, ServerTransport<BasicServerMap>>): Promise<HandshakeStatus>;
+import { ServerRequestHandlerArgs } from "./server-request-handler.js";
+export declare function handshakeHandler({ options, socket, transport }: ServerRequestHandlerArgs<HandshakeOptions>): Promise<HandshakeStatus>;

package/dist/handlers/publish.d.ts

@@ -1,9 +1,5 @@
-import { RequestHandlerArgs } from "@socket-mesh/core";
-import { BasicSocketMapServer } from "../maps/socket-map.js";
 import { PublishOptions } from "@socket-mesh/channels";
-import { ServerSocket } from "../server-socket.js";
-import { BasicServerMap } from "../maps/server-map.js";
-import { ServerTransport } from "../server-transport.js";
-export declare function publishHandler({ socket, transport, options }: RequestHandlerArgs<PublishOptions, BasicSocketMapServer<{}, {
+import { ServerRequestHandlerArgs } from "./server-request-handler.js";
+export declare function publishHandler({ socket, transport, options }: ServerRequestHandlerArgs<PublishOptions, {}, {
     [channel: string]: any;
-}>, ServerSocket<BasicServerMap>, ServerTransport<BasicServerMap>>): Promise<void>;
+}>): Promise<void>;

package/dist/handlers/remove-auth-token.d.ts

@@ -1,3 +1,4 @@
-import { BasicSocketMapServer } from "../maps/socket-map.js";
+import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
 import { SocketTransport } from "@socket-mesh/core";
-export declare function deauthenticate(transport: SocketTransport<BasicSocketMapServer>): Promise<boolean>;
+import { ServerSocketState } from "../server-socket-state.js";
+export declare function deauthenticate(transport: SocketTransport<ServerPrivateMap, {}, ClientPrivateMap, {}, ServerSocketState>): Promise<boolean>;

package/dist/handlers/server-request-handler.d.ts

@@ -0,0 +1,7 @@
+import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
+import { PrivateMethodMap, PublicMethodMap, RequestHandlerArgs, ServiceMap } from "@socket-mesh/core";
+import { ServerSocketState } from "../server-socket-state.js";
+import { ServerSocket } from "../server-socket.js";
+import { ServerTransport } from "../server-transport.js";
+import { ChannelMap } from "@socket-mesh/channels";
+export type ServerRequestHandlerArgs<TOptions, TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}> = RequestHandlerArgs<TOptions, TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState, ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>, ServerTransport<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;

package/dist/handlers/subscribe.d.ts

@@ -1,7 +1,3 @@
-import { BasicServerMap } from "../maps/server-map.js";
-import { BasicSocketMapServer } from "../maps/socket-map.js";
 import { SubscribeOptions } from "@socket-mesh/client";
-import { RequestHandlerArgs } from "@socket-mesh/core";
-import { ServerSocket } from "../server-socket.js";
-import { ServerTransport } from "../server-transport.js";
-export declare function subscribeHandler({ socket, transport, options }: RequestHandlerArgs<SubscribeOptions, BasicSocketMapServer, ServerSocket<BasicServerMap>, ServerTransport<BasicServerMap>>): Promise<void>;
+import { ServerRequestHandlerArgs } from "./server-request-handler.js";
+export declare function subscribeHandler({ socket, transport, options }: ServerRequestHandlerArgs<SubscribeOptions>): Promise<void>;

package/dist/handlers/unsubscribe.d.ts

@@ -1,6 +1,2 @@
-import { RequestHandlerArgs } from "@socket-mesh/core";
-import { BasicSocketMapServer } from "../maps/socket-map.js";
-import { ServerSocket } from "../server-socket.js";
-import { BasicServerMap } from "../maps/server-map.js";
-import { ServerTransport } from "../server-transport.js";
-export declare function unsubscribeHandler({ transport, options: channel }: RequestHandlerArgs<string, BasicSocketMapServer, ServerSocket<BasicServerMap>, ServerTransport<BasicServerMap>>): Promise<void>;
+import { ServerRequestHandlerArgs } from "./server-request-handler.js";
+export declare function unsubscribeHandler({ transport, options: channel }: ServerRequestHandlerArgs<string>): Promise<void>;

package/dist/index.d.ts

@@ -1,12 +1,12 @@
 import http from "http";
 import { Server } from "./server.js";
 import { ServerOptions } from "./server-options.js";
-import { ServerMap } from "./maps/server-map.js";
+import { ChannelMap } from "@socket-mesh/channels";
+import { PrivateMethodMap, PublicMethodMap, ServiceMap } from "@socket-mesh/core";
 export { Server } from "./server.js";
 export { ServerSocket } from "./server-socket.js";
 export { PluginType } from "@socket-mesh/core";
-export { BasicServerMap } from "./maps/server-map.js";
-export { BasicSocketMapServer } from "./maps/socket-map.js";
+export { ServerRequestHandlerArgs } from './handlers/server-request-handler.js';
 /**
  * Creates an http.Server exclusively used for WS upgrades.
  *
@@ -16,9 +16,9 @@ export { BasicSocketMapServer } from "./maps/socket-map.js";
  * @return {AGServer} websocket cluster server
  * @api public
  */
-export declare function listen<T extends ServerMap>(): Server<T>;
-export declare function listen<T extends ServerMap>(port: number, options: ServerOptions<T>): Server<T>;
-export declare function listen<T extends ServerMap>(port: number, options: ServerOptions<T>, fn: () => void): Server<T>;
+export declare function listen<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}>(): Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+export declare function listen<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}>(port: number, options: ServerOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+export declare function listen<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}>(port: number, options: ServerOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>, fn: () => void): Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
 /**
  * Captures upgrade requests for a http.Server.
  *
@@ -27,4 +27,4 @@ export declare function listen<T extends ServerMap>(port: number, options: Serve
  * @return {AGServer} websocket cluster server
  * @api public
  */
-export declare function attach<T extends ServerMap>(server: http.Server, options?: ServerOptions<T>): Server<T>;
+export declare function attach<TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}>(server: http.Server, options?: ServerOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;

package/dist/plugin/server-plugin.d.ts

@@ -1,33 +1,33 @@
 import { IncomingMessage } from "http";
-import { ServerMap } from "../maps/server-map.js";
-import { SocketMapFromServer } from "../maps/socket-map.js";
-import { Plugin } from "@socket-mesh/core";
+import { Plugin, PrivateMethodMap, PublicMethodMap, ServiceMap } from "@socket-mesh/core";
 import { AuthInfo } from "../handlers/authenticate.js";
 import { ServerSocket } from "../server-socket.js";
 import { ServerTransport } from "../server-transport.js";
-import { ChannelOptions } from "@socket-mesh/channels";
-export interface HandshakePluginArgs<T extends ServerMap> {
-    socket: ServerSocket<T>;
-    transport: ServerTransport<T>;
+import { ChannelMap, ChannelOptions } from "@socket-mesh/channels";
+import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
+import { ServerSocketState } from "../server-socket-state.js";
+export interface HandshakePluginArgs<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>;
+    transport: ServerTransport<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
     authInfo: AuthInfo;
 }
-export interface PublishPluginArgs<T extends ServerMap> {
+export interface PublishPluginArgs<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> {
     channel: string;
     data: any;
-    socket: ServerSocket<T>;
-    transport: ServerTransport<T>;
+    socket: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+    transport: ServerTransport<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
 }
-export interface SubscribePluginArgs<T extends ServerMap> {
+export interface SubscribePluginArgs<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> {
     channel: string;
     options: ChannelOptions;
-    socket: ServerSocket<T>;
-    transport: ServerTransport<T>;
+    socket: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+    transport: ServerTransport<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
 }
-export interface ServerPlugin<T extends ServerMap> extends Plugin<SocketMapFromServer<T>> {
+export interface ServerPlugin<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 Plugin<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState> {
     onAuthenticate?: (authInfo: AuthInfo) => void;
     onConnection?: (request: IncomingMessage) => Promise<void>;
-    onHandshake?: (options: HandshakePluginArgs<T>) => Promise<void>;
-    onPublishIn?: (options: PublishPluginArgs<T>) => Promise<any>;
-    onPublishOut?: (options: PublishPluginArgs<T>) => Promise<any>;
-    onSubscribe?: (options: SubscribePluginArgs<T>) => Promise<void>;
+    onHandshake?: (options: HandshakePluginArgs<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>) => Promise<void>;
+    onPublishIn?: (options: PublishPluginArgs<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>) => Promise<any>;
+    onPublishOut?: (options: PublishPluginArgs<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>) => Promise<any>;
+    onSubscribe?: (options: SubscribePluginArgs<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>) => Promise<void>;
 }

package/dist/server-event.d.ts

@@ -1,14 +1,11 @@
 import { IncomingMessage } from "http";
-import { ClientSocket } from "@socket-mesh/client";
+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 } from "@socket-mesh/core";
-import { ServerMap } from "./maps/server-map.js";
-import { ClientMapFromServer } from "./maps/client-map.js";
-import { SubscribeEvent, SubscribeFailEvent, SubscribeStateChangeEvent, UnsubscribeEvent } from "@socket-mesh/channels";
-import { SocketMapFromServer } from "./maps/socket-map.js";
-export type ServerEvent<T extends ServerMap> = ConnectionEvent<T> | CloseEvent | ErrorEvent | HeadersEvent | HandshakeEvent<T> | ListeningEvent | SocketAuthStateChangeEvent<T> | SocketAuthenticateEvent<T> | SocketBadAuthTokenEvent<T> | SocketCloseEvent<T> | SocketDeauthenticateEvent<T> | SocketErrorEvent<T> | SocketMessageEvent<T> | SocketConnectEvent<T> | SocketConnectingEvent<T> | SocketDisconnectEvent<T> | SocketPingEvent<T> | SocketPongEvent<T> | SocketRemoveAuthTokenEvent<T> | SocketRequestEvent<T> | SocketResponseEvent<T> | WarningEvent;
-export interface ConnectionEvent<T extends ServerMap> {
-    socket: ServerSocket<T>;
+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 {
@@ -16,8 +13,8 @@ export interface CloseEvent {
 export interface ErrorEvent {
     error: Error;
 }
-export interface HandshakeEvent<T extends ServerMap> {
-    socket: ServerSocket<T>;
+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;
@@ -28,25 +25,25 @@ export interface HeadersEvent {
 }
 export interface ListeningEvent {
 }
-export interface ServerSocketEvent<T extends ServerMap> {
-    socket: ClientSocket<ClientMapFromServer<T>> | ServerSocket<T>;
-}
-export type SocketAuthStateChangeEvent<T extends ServerMap> = AuthStateChangeEvent & ServerSocketEvent<T>;
-export type SocketAuthenticateEvent<T extends ServerMap> = AuthenticateEvent & ServerSocketEvent<T>;
-export type SocketBadAuthTokenEvent<T extends ServerMap> = BadAuthTokenEvent & ServerSocketEvent<T>;
-export type SocketCloseEvent<T extends ServerMap> = SCloseEvent & ServerSocketEvent<T>;
-export type SocketDeauthenticateEvent<T extends ServerMap> = DeauthenticateEvent & ServerSocketEvent<T>;
-export type SocketErrorEvent<T extends ServerMap> = SErrorEvent & ServerSocketEvent<T>;
-export type SocketMessageEvent<T extends ServerMap> = MessageEvent & ServerSocketEvent<T>;
-export type SocketConnectEvent<T extends ServerMap> = ConnectEvent & ServerSocketEvent<T>;
-export type SocketConnectingEvent<T extends ServerMap> = ConnectingEvent & ServerSocketEvent<T>;
-export type SocketDisconnectEvent<T extends ServerMap> = DisconnectEvent & ServerSocketEvent<T>;
-export type SocketPingEvent<T extends ServerMap> = PingEvent & ServerSocketEvent<T>;
-export type SocketPongEvent<T extends ServerMap> = PongEvent & ServerSocketEvent<T>;
-export type SocketRemoveAuthTokenEvent<T extends ServerMap> = RemoveAuthTokenEvent & ServerSocketEvent<T>;
-export type SocketRequestEvent<T extends ServerMap> = RequestEvent<SocketMapFromServer<T>>;
-export type SocketResponseEvent<T extends ServerMap> = ResponseEvent<T> & ServerSocketEvent<T>;
-export type SocketSubscribeEvent<T extends ServerMap> = SubscribeEvent & ServerSocketEvent<T>;
-export type SocketSubscribeFailEvent<T extends ServerMap> = SubscribeFailEvent & ServerSocketEvent<T>;
-export type SocketSubscribeStateChangeEvent<T extends ServerMap> = SubscribeStateChangeEvent & ServerSocketEvent<T>;
-export type SocketUnsubscribeEvent<T extends ServerMap> = UnsubscribeEvent & ServerSocketEvent<T>;
+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>;

package/dist/server-options.d.ts

@@ -1,21 +1,22 @@
 import ws from "ws";
 import { AuthEngine, AuthOptions } from "@socket-mesh/auth-engine";
-import { CallIdGenerator, HandlerMap, EmptySocketMap, StreamCleanupMode } from "@socket-mesh/core";
+import { CallIdGenerator, HandlerMap, StreamCleanupMode, ServiceMap, PublicMethodMap, PrivateMethodMap } from "@socket-mesh/core";
 import { CodecEngine } from "@socket-mesh/formatter";
 import { ServerPlugin } from "./plugin/server-plugin.js";
-import { ServerMap } from "./maps/server-map.js";
 import { Broker } from "./broker/broker.js";
-export interface ServerOptions<T extends ServerMap> extends ws.ServerOptions {
+import { ChannelMap } from "@socket-mesh/channels";
+import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
+export interface ServerOptions<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 ws.ServerOptions {
     ackTimeoutMs?: number;
     allowClientPublish?: boolean;
     authEngine?: AuthEngine | AuthOptions;
-    brokerEngine?: Broker<T['Channel']>;
+    brokerEngine?: Broker<TChannel>;
     callIdGenerator?: CallIdGenerator;
     codecEngine?: CodecEngine;
     handshakeTimeoutMs?: number;
-    handlers?: HandlerMap<EmptySocketMap>;
+    handlers?: HandlerMap<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState>;
     isPingTimeoutDisabled?: boolean;
-    plugins?: ServerPlugin<T>[];
+    plugins?: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
     origins?: string;
     pingIntervalMs?: number;
     pingTimeoutMs?: number;

package/dist/server-socket.d.ts

@@ -1,26 +1,27 @@
-import { HandlerMap, Socket, SocketOptions } from "@socket-mesh/core";
+import { HandlerMap, PrivateMethodMap, PublicMethodMap, ServiceMap, Socket, SocketOptions } from "@socket-mesh/core";
 import ws from "ws";
-import { SocketMapFromServer } from "./maps/socket-map.js";
-import { ServerMap } from "./maps/server-map.js";
 import { Exchange } from "./broker/exchange.js";
 import { Server } from "./server.js";
 import { IncomingMessage } from "http";
 import { ServerPlugin } from "./plugin/server-plugin.js";
-export interface ServerSocketOptions<T extends ServerMap> extends SocketOptions<SocketMapFromServer<T>> {
-    handlers: HandlerMap<SocketMapFromServer<T>>;
-    plugins?: ServerPlugin<T>[];
+import { ChannelMap } from "@socket-mesh/channels";
+import { ServerSocketState } from "./server-socket-state.js";
+import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
+export interface ServerSocketOptions<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 SocketOptions<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState> {
+    handlers: HandlerMap<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState>;
+    plugins?: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
     id?: string;
     service?: string;
-    server: Server<T>;
+    server: Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
     request: IncomingMessage;
     socket: ws.WebSocket;
 }
-export declare class ServerSocket<T extends ServerMap> extends Socket<SocketMapFromServer<T>> {
-    readonly server: Server<T>;
+export declare class ServerSocket<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 Socket<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState> {
+    readonly server: Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
     private _serverTransport;
-    constructor(options: ServerSocketOptions<T>);
+    constructor(options: ServerSocketOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>);
     deauthenticate(rejectOnFailedDelivery?: boolean): Promise<boolean>;
-    get exchange(): Exchange<T['Channel']>;
+    get exchange(): Exchange<TChannel>;
     kickOut(channel: string, message: string): Promise<void[]>;
     ping(): Promise<void>;
     get service(): string;

package/dist/server-transport.d.ts

@@ -1,36 +1,36 @@
-import { ServerMap } from "./maps/server-map.js";
 import { ServerSocket, ServerSocketOptions } from "./server-socket.js";
 import { AuthToken, SignedAuthToken } from "@socket-mesh/auth";
-import { SocketMapFromServer } from "./maps/socket-map.js";
 import { AuthTokenOptions } from "@socket-mesh/auth-engine";
 import { Data } from "ws";
-import { AnyPacket, AnyResponse, SocketStatus, SocketTransport, InvokeMethodRequest, InvokeServiceRequest, TransmitMethodRequest, TransmitServiceRequest, InboundMessage } from "@socket-mesh/core";
+import { AnyPacket, AnyResponse, SocketStatus, SocketTransport, InvokeMethodRequest, InvokeServiceRequest, TransmitMethodRequest, TransmitServiceRequest, InboundMessage, ServiceMap, PublicMethodMap, PrivateMethodMap } from "@socket-mesh/core";
 import { IncomingMessage } from "http";
 import { ServerPlugin } from "./plugin/server-plugin.js";
-import { PublishOptions } from "@socket-mesh/channels";
-export declare class ServerTransport<T extends ServerMap> extends SocketTransport<SocketMapFromServer<T>> {
-    readonly plugins: ServerPlugin<T>[];
+import { ChannelMap, PublishOptions } from "@socket-mesh/channels";
+import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
+import { ServerSocketState } from "./server-socket-state.js";
+export declare class ServerTransport<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 SocketTransport<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState> {
+    readonly plugins: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
     readonly service?: string;
     readonly request: IncomingMessage;
-    constructor(options: ServerSocketOptions<T>);
+    constructor(options: ServerSocketOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>);
     changeToUnauthenticatedState(): Promise<boolean>;
-    protected handleInboudMessage({ packet, timestamp }: InboundMessage<SocketMapFromServer<T>>): Promise<void>;
+    protected handleInboudMessage({ packet, timestamp }: InboundMessage<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService>): Promise<void>;
     protected onClose(code: number, reason?: string | Buffer): void;
     protected onDisconnect(status: SocketStatus, code: number, reason?: string): void;
     onError(error: Error): void;
-    protected onInvoke<TService extends keyof T["Service"], TServiceMethod extends keyof T["Service"][TService], TMethod extends keyof T["Outgoing"], TPrivateMethod extends keyof T["PrivateOutgoing"]>(request: InvokeMethodRequest<T["Outgoing"], TMethod> | InvokeMethodRequest<T["PrivateOutgoing"], TPrivateMethod> | InvokeServiceRequest<T["Service"], TService, TServiceMethod>): void;
+    protected onInvoke<TServiceName extends keyof TService, TServiceMethod extends keyof TService[TServiceName], TMethod extends keyof TOutgoing, TPrivateMethod extends keyof TPrivateOutgoing>(request: InvokeMethodRequest<TOutgoing, TMethod> | InvokeMethodRequest<TPrivateOutgoing, TPrivateMethod> | InvokeServiceRequest<TService, TServiceName, TServiceMethod>): void;
     protected onMessage(data: Data, isBinary: boolean): void;
     protected onPingPong(): void;
     protected onPublish(options: PublishOptions): Promise<void>;
-    protected onRequest(packet: AnyPacket<SocketMapFromServer<T>>, timestamp: Date, pluginError?: Error): Promise<boolean>;
-    protected onResponse(response: AnyResponse<SocketMapFromServer<T>>): void;
-    protected onTransmit<TService extends keyof T["Service"], TServiceMethod extends keyof T["Service"][TService], TMethod extends keyof T["Outgoing"]>(request: TransmitMethodRequest<T["Outgoing"], TMethod> | TransmitServiceRequest<T["Service"], TService, TServiceMethod>): void;
+    protected onRequest(packet: AnyPacket<TIncoming & TPrivateIncoming & ServerPrivateMap, TService>, timestamp: Date, pluginError?: Error): Promise<boolean>;
+    protected onResponse(response: AnyResponse<TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService>): void;
+    protected onTransmit<TServiceName extends keyof TService, TServiceMethod extends keyof TService[TServiceName], TMethod extends keyof TOutgoing>(request: TransmitMethodRequest<TOutgoing, TMethod> | TransmitServiceRequest<TService, TServiceName, TServiceMethod>): void;
     ping(): Promise<void>;
     setAuthorization(authToken: AuthToken, options?: AuthTokenOptions): Promise<boolean>;
     setAuthorization(signedAuthToken: SignedAuthToken, authToken?: AuthToken): Promise<boolean>;
     setReadyStatus(pingTimeoutMs: number, authError?: Error): void;
-    get socket(): ServerSocket<T>;
-    set socket(value: ServerSocket<T>);
+    get socket(): ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+    set socket(value: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>);
     triggerAuthenticationEvents(wasSigned: boolean, wasAuthenticated: boolean): void;
     type: 'server';
     unsubscribe(channel: string): Promise<void>;

package/dist/server.d.ts

@@ -1,17 +1,17 @@
 import { ServerSocket } from "./server-socket.js";
 import { Server as HttpServer } from 'http';
 import { CodecEngine } from "@socket-mesh/formatter";
-import { StreamCleanupMode } from "@socket-mesh/core";
+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 { ServerMap } from "./maps/server-map.js";
 import { Broker } from "./broker/broker.js";
 import { Exchange } from "./broker/exchange.js";
-export declare class Server<T extends ServerMap> extends AsyncStreamEmitter<ServerEvent<T>> {
+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>> {
     private readonly _callIdGenerator;
     private readonly _wss;
     private _isReady;
@@ -27,24 +27,24 @@ export declare class Server<T extends ServerMap> extends AsyncStreamEmitter<Serv
     socketChannelLimit?: number;
     strictHandshake: boolean;
     readonly auth: AuthEngine;
-    readonly brokerEngine: Broker<T['Channel']>;
+    readonly brokerEngine: Broker<TChannel>;
     readonly clients: {
-        [id: string]: ServerSocket<T>;
+        [id: string]: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
     };
     clientCount: number;
     readonly codecEngine: CodecEngine;
     readonly pendingClients: {
-        [id: string]: ServerSocket<T>;
+        [id: string]: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
     };
     pendingClientCount: number;
     readonly socketStreamCleanupMode: StreamCleanupMode;
     readonly httpServer: HttpServer;
-    readonly plugins: ServerPlugin<T>[];
-    constructor(options?: ServerOptions<T>);
-    addPlugin(...plugin: ServerPlugin<T>[]): void;
+    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;
     private bind;
     close(keepSocketsOpen?: boolean): Promise<void>;
-    get exchange(): Exchange<T['Channel']>;
+    get exchange(): Exchange<TChannel>;
     get isListening(): boolean;
     get isReady(): boolean;
     private onClose;
@@ -58,62 +58,62 @@ export declare class Server<T extends ServerMap> extends AsyncStreamEmitter<Serv
     private stopPinging;
     private verifyClient;
     emit(event: "close", data: CloseEvent): void;
-    emit(event: "connection", data: ConnectionEvent<T>): 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<T>): 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<T>): void;
-    emit(event: 'socketAuthenticate', data: SocketAuthenticateEvent<T>): void;
-    emit(event: 'socketBadAuthToken', data: SocketBadAuthTokenEvent<T>): void;
-    emit(event: 'socketClose', data: SocketCloseEvent<T>): void;
-    emit(event: 'socketConnect', data: SocketConnectEvent<T>): void;
-    emit(event: 'socketConnectAbort', data: SocketDisconnectEvent<T>): void;
-    emit(event: 'socketConnecting', data: SocketConnectingEvent<T>): void;
-    emit(event: 'socketDeauthenticate', data: SocketDeauthenticateEvent<T>): void;
-    emit(event: 'socketDisconnect', data: SocketDisconnectEvent<T>): void;
-    emit(event: 'socketError', data: SocketErrorEvent<T>): void;
-    emit(event: 'socketMessage', data: SocketMessageEvent<T>): void;
-    emit(event: 'socketPing', data: SocketPingEvent<T>): void;
-    emit(event: 'socketPong', data: SocketPongEvent<T>): void;
-    emit(event: 'socketRemoveAuthToken', data: SocketRemoveAuthTokenEvent<T>): void;
-    emit(event: 'socketRequest', data: SocketRequestEvent<T>): void;
-    emit(event: 'socketResponse', data: SocketResponseEvent<T>): void;
-    emit(event: 'socketSubscribe', data: SocketSubscribeEvent<T>): void;
-    emit(event: 'socketSubscribeFail', data: SocketSubscribeFailEvent<T>): void;
-    emit(event: 'socketSubscribeRequest', data: SocketSubscribeEvent<T>): void;
-    emit(event: 'socketSubscribeStateChange', data: SocketSubscribeStateChangeEvent<T>): void;
-    emit(event: 'socketUnsubscribe', data: SocketUnsubscribeEvent<T>): 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<T>>>;
+    listen(): DemuxedConsumableStream<StreamEvent<ServerEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>>;
     listen(event: "close"): DemuxedConsumableStream<CloseEvent>;
-    listen(event: "connection"): DemuxedConsumableStream<ConnectionEvent<T>>;
+    listen(event: "connection"): DemuxedConsumableStream<ConnectionEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
     listen(event: "error"): DemuxedConsumableStream<ErrorEvent>;
-    listen(event: "handshake"): DemuxedConsumableStream<HandshakeEvent<T>>;
+    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<T>>;
-    listen(event: 'socketAuthenticate'): DemuxedConsumableStream<SocketAuthenticateEvent<T>>;
-    listen(event: 'socketBadAuthToken'): DemuxedConsumableStream<SocketBadAuthTokenEvent<T>>;
-    listen(event: 'socketClose'): DemuxedConsumableStream<SocketCloseEvent<T>>;
-    listen(event: 'socketConnect'): DemuxedConsumableStream<SocketConnectEvent<T>>;
-    listen(event: 'socketConnectAbort'): DemuxedConsumableStream<SocketDisconnectEvent<T>>;
-    listen(event: 'socketConnecting'): DemuxedConsumableStream<SocketConnectingEvent<T>>;
-    listen(event: 'socketDeauthenticate'): DemuxedConsumableStream<SocketDeauthenticateEvent<T>>;
-    listen(event: 'socketDisconnect'): DemuxedConsumableStream<SocketDisconnectEvent<T>>;
-    listen(event: 'socketError'): DemuxedConsumableStream<SocketErrorEvent<T>>;
-    listen(event: 'socketMessage'): DemuxedConsumableStream<SocketMessageEvent<T>>;
-    listen(event: 'socketPing'): DemuxedConsumableStream<SocketPingEvent<T>>;
-    listen(event: 'socketPong'): DemuxedConsumableStream<SocketPongEvent<T>>;
-    listen(event: 'socketRemoveAuthToken'): DemuxedConsumableStream<SocketRemoveAuthTokenEvent<T>>;
-    listen(event: 'socketRequest'): DemuxedConsumableStream<SocketRequestEvent<T>>;
-    listen(event: 'socketResponse'): DemuxedConsumableStream<SocketResponseEvent<T>>;
-    listen(event: 'socketSubscribe'): DemuxedConsumableStream<SocketSubscribeEvent<T>>;
-    listen(event: 'socketSubscribeFail'): DemuxedConsumableStream<SocketSubscribeFailEvent<T>>;
-    listen(event: 'socketSubscribeRequest'): DemuxedConsumableStream<SocketSubscribeEvent<T>>;
-    listen(event: 'socketSubscribeStateChange'): DemuxedConsumableStream<SocketSubscribeStateChangeEvent<T>>;
-    listen(event: 'socketUnsubscribe'): DemuxedConsumableStream<SocketUnsubscribeEvent<T>>;
+    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>;
 }

package/package.json

@@ -1,26 +1,26 @@
 {
 	"name": "@socket-mesh/server",
 	"description": "A TCP socket pair for easily transmitting full messages without worrying about request size limits.",
-	"version": "18.1.2",
-  "type": "module",
-  "main": "dist/index.js",
+	"version": "18.1.4",
+	"type": "module",
+	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"files": ["./dist"],
 	"author": {
 		"name": "Greg Kimmy"
 	},
 	"scripts": {
-    "build": "node ../../scripts/build.mjs && tsc --project tsconfig.build.json",
-    "deploy": "npm run build && node ../../scripts/publish.mjs",
+		"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"
 	},
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/socket-mesh/client-server.git"
-  },
-  "bugs": {
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/socket-mesh/client-server.git"
+	},
+	"bugs": {
 		"url": "https://github.com/socket-mesh/client-server/labels/server"
-  },	
+	},	
 	"devDependencies": {
 		"@socket-mesh/local-storage": "^1.0.2",
 		"@types/base64id": "^2.0.2",
@@ -31,7 +31,7 @@
 		"@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.3",
+		"@socket-mesh/client": "^18.1.5",
 		"@socket-mesh/errors": "^3.2.0",
 		"@socket-mesh/formatter": "^4.1.0",
 		"base64id": "^2.0.0",

package/dist/maps/client-map.d.ts

@@ -1,10 +0,0 @@
-import { PublicMethodMap } from "@socket-mesh/core";
-import { ServerMap } from "./server-map.js";
-export interface ClientMapFromServer<T extends ServerMap> {
-    Channel: T['Channel'];
-    Incoming: T['Outgoing'] & T['PrivateOutgoing'];
-    Service: T['Service'];
-    Outgoing: PublicMethodMap;
-    PrivateOutgoing: T['PrivateIncoming'];
-    State: object;
-}

package/dist/maps/server-map.d.ts

@@ -1,24 +0,0 @@
-import { ChannelMap } from "@socket-mesh/channels";
-import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
-import { PrivateMethodMap, PublicMethodMap, ServiceMap } from "@socket-mesh/core";
-import { ServerSocketState } from "../server-socket-state.js";
-export interface ServerMap {
-    Channel: ChannelMap;
-    Service: ServiceMap;
-    Incoming: PublicMethodMap;
-    Outgoing: PublicMethodMap;
-    PrivateIncoming: PrivateMethodMap;
-    PrivateOutgoing: PrivateMethodMap;
-    ServerState: object;
-    State: object;
-}
-export interface BasicServerMap<TIncoming extends PublicMethodMap = {}, TChannels extends ChannelMap = {}, TState extends object = {}, TOutgoing extends object = {}> {
-    Channel: TChannels;
-    Service: {};
-    Incoming: TIncoming;
-    Outgoing: TOutgoing;
-    PrivateIncoming: ServerPrivateMap;
-    PrivateOutgoing: ClientPrivateMap;
-    ServerState: {};
-    State: TState & ServerSocketState;
-}

package/dist/maps/server-map.js

@@ -1 +0,0 @@
-export {};

package/dist/maps/socket-map.d.ts

@@ -1,19 +0,0 @@
-import { ChannelMap } from "@socket-mesh/channels";
-import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
-import { PublicMethodMap } from "@socket-mesh/core";
-import { ServerSocketState } from "../server-socket-state.js";
-import { ServerMap } from "./server-map.js";
-export interface BasicSocketMapServer<TIncoming extends PublicMethodMap = {}, TChannels extends ChannelMap = {}, TState extends object = {}, TOutgoing extends object = {}> {
-    Incoming: TIncoming & ServerPrivateMap;
-    Service: {};
-    Outgoing: TOutgoing;
-    PrivateOutgoing: ClientPrivateMap;
-    State: TState & ServerSocketState;
-}
-export interface SocketMapFromServer<T extends ServerMap> {
-    Incoming: T['Incoming'] & T['PrivateIncoming'] & ServerPrivateMap;
-    Service: T['Service'];
-    Outgoing: T['Outgoing'];
-    PrivateOutgoing: T['PrivateOutgoing'] & ClientPrivateMap;
-    State: T['State'] & ServerSocketState;
-}

package/dist/maps/socket-map.js

@@ -1 +0,0 @@
-export {};