@socket-mesh/server 18.0.6 → 18.1.1

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

@@ -0,0 +1,19 @@
+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

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

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

@@ -0,0 +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 { 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>;
+    authInfo: AuthInfo;
+}
+export interface PublishPluginArgs<T extends ServerMap> {
+    channel: string;
+    data: any;
+    socket: ServerSocket<T>;
+    transport: ServerTransport<T>;
+}
+export interface SubscribePluginArgs<T extends ServerMap> {
+    channel: string;
+    options: ChannelOptions;
+    socket: ServerSocket<T>;
+    transport: ServerTransport<T>;
+}
+export interface ServerPlugin<T extends ServerMap> extends Plugin<SocketMapFromServer<T>> {
+    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>;
+}

package/dist/plugin/server-plugin.js

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

package/dist/server-event.d.ts

@@ -0,0 +1,52 @@
+import { IncomingMessage } from "http";
+import { ClientSocket } 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>;
+    upgradeReq: IncomingMessage;
+}
+export interface CloseEvent {
+}
+export interface ErrorEvent {
+    error: Error;
+}
+export interface HandshakeEvent<T extends ServerMap> {
+    socket: ServerSocket<T>;
+}
+export interface WarningEvent {
+    warning: Error;
+}
+export interface HeadersEvent {
+    headers: string[];
+    request: IncomingMessage;
+}
+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>;

package/dist/server-event.js

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

package/dist/server-options.d.ts

@@ -0,0 +1,25 @@
+import ws from "ws";
+import { AuthEngine, AuthOptions } from "@socket-mesh/auth-engine";
+import { CallIdGenerator, HandlerMap, EmptySocketMap, StreamCleanupMode } 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 {
+    ackTimeoutMs?: number;
+    allowClientPublish?: boolean;
+    authEngine?: AuthEngine | AuthOptions;
+    brokerEngine?: Broker<T['Channel']>;
+    callIdGenerator?: CallIdGenerator;
+    codecEngine?: CodecEngine;
+    handshakeTimeoutMs?: number;
+    handlers?: HandlerMap<EmptySocketMap>;
+    isPingTimeoutDisabled?: boolean;
+    plugins?: ServerPlugin<T>[];
+    origins?: string;
+    pingIntervalMs?: number;
+    pingTimeoutMs?: number;
+    socketChannelLimit?: number;
+    socketStreamCleanupMode?: StreamCleanupMode;
+    strictHandshake?: boolean;
+}

package/dist/server-options.js

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

package/dist/server-socket-state.d.ts

@@ -0,0 +1,6 @@
+export interface ServerSocketState {
+    channelSubscriptions?: {
+        [channel: string]: true;
+    };
+    channelSubscriptionsCount?: number;
+}

package/dist/server-socket-state.js

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

package/dist/server-socket.d.ts

@@ -0,0 +1,28 @@
+import { HandlerMap, 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>[];
+    id?: string;
+    service?: string;
+    server: Server<T>;
+    request: IncomingMessage;
+    socket: ws.WebSocket;
+}
+export declare class ServerSocket<T extends ServerMap> extends Socket<SocketMapFromServer<T>> {
+    readonly server: Server<T>;
+    private _serverTransport;
+    constructor(options: ServerSocketOptions<T>);
+    deauthenticate(rejectOnFailedDelivery?: boolean): Promise<boolean>;
+    get exchange(): Exchange<T['Channel']>;
+    kickOut(channel: string, message: string): Promise<void[]>;
+    ping(): Promise<void>;
+    get service(): string;
+    get type(): 'server';
+}

package/dist/server-socket.js

@@ -0,0 +1,50 @@
+import { Socket } from "@socket-mesh/core";
+import { ServerTransport } from "./server-transport.js";
+export class ServerSocket extends Socket {
+    constructor(options) {
+        const transport = new ServerTransport(options);
+        super(transport, options);
+        this.server = options.server;
+        this._serverTransport = transport;
+    }
+    async deauthenticate(rejectOnFailedDelivery) {
+        await super.deauthenticate();
+        if (rejectOnFailedDelivery) {
+            try {
+                await this._serverTransport.invoke('#removeAuthToken', undefined)[0];
+            }
+            catch (error) {
+                this._serverTransport.onError(error);
+                throw error;
+            }
+            return;
+        }
+        try {
+            await this.transmit('#removeAuthToken');
+        }
+        catch (err) {
+            if (err.name !== 'BadConnectionError') {
+                throw err;
+            }
+        }
+    }
+    get exchange() {
+        return this.server.exchange;
+    }
+    kickOut(channel, message) {
+        const channels = channel ? [channel] : Object.keys(this.state.channelSubscriptions);
+        return Promise.all(channels.map((channelName) => {
+            this.transmit('#kickOut', { channel: channelName, message });
+            return this._serverTransport.unsubscribe(channelName);
+        }));
+    }
+    ping() {
+        return this._serverTransport.ping();
+    }
+    get service() {
+        return this._serverTransport.service;
+    }
+    get type() {
+        return this._serverTransport.type;
+    }
+}

package/dist/server-transport.d.ts

@@ -0,0 +1,37 @@
+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 { 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>[];
+    readonly service?: string;
+    readonly request: IncomingMessage;
+    constructor(options: ServerSocketOptions<T>);
+    changeToUnauthenticatedState(): Promise<boolean>;
+    protected handleInboudMessage({ packet, timestamp }: InboundMessage<SocketMapFromServer<T>>): 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 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;
+    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>);
+    triggerAuthenticationEvents(wasSigned: boolean, wasAuthenticated: boolean): void;
+    type: 'server';
+    unsubscribe(channel: string): Promise<void>;
+}

package/dist/server-transport.js

@@ -0,0 +1,247 @@
+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 {
+    constructor(options) {
+        super(options);
+        this.type = 'server';
+        this.request = options.request;
+        this.plugins = options.plugins;
+        this.service = options.service;
+        this.webSocket = options.socket;
+        this.id = (options.id || base64id.generateId());
+        // Server is not set on socket until the socket constructor is completed so pull it from the options.
+        this.resetPingTimeout(options.server.isPingTimeoutDisabled ? false : options.server.pingTimeoutMs, 4001);
+    }
+    async changeToUnauthenticatedState() {
+        if (this.signedAuthToken) {
+            const authToken = this.authToken;
+            const signedAuthToken = this.signedAuthToken;
+            this.socket.server.emit('socketAuthStateChange', { socket: this.socket, wasAuthenticated: true, isAuthenticated: false });
+            await super.changeToUnauthenticatedState();
+            this.socket.server.emit('socketDeauthenticate', { socket: this.socket, signedAuthToken, authToken });
+            return true;
+        }
+        return false;
+    }
+    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 });
+    }
+    onClose(code, reason) {
+        const status = this.status;
+        const strReason = reason?.toString() || socketProtocolErrorStatuses[code];
+        super.onClose(code, reason);
+        this.socket.server.emit('socketClose', { socket: this.socket, code, reason: strReason });
+        this.onDisconnect(status, code, strReason);
+    }
+    onDisconnect(status, code, reason) {
+        if (status === 'ready') {
+            this.socket.server.emit('socketDisconnect', { socket: this.socket, code, reason });
+        }
+        else {
+            this.socket.server.emit('socketConnectAbort', { socket: this.socket, code, reason });
+        }
+        super.onDisconnect(status, code, reason);
+        if (this.socket.state.channelSubscriptions) {
+            const channels = Object.keys(this.socket.state.channelSubscriptions);
+            channels.map((channel) => this.unsubscribe(channel));
+        }
+        if (this.streamCleanupMode !== 'none') {
+            (async () => {
+                await this.socket.listen('end').once();
+                if (this.streamCleanupMode === 'kill') {
+                    this.socket.killListeners();
+                }
+                else if (this.streamCleanupMode === 'close') {
+                    this.socket.closeListeners();
+                }
+                for (let i = 0; i < this.plugins.length; i++) {
+                    const plugin = this.plugins[i];
+                    if (plugin.onEnd) {
+                        plugin.onEnd({ socket: this.socket, transport: this });
+                    }
+                }
+            })();
+        }
+        this.socket.emit('end');
+    }
+    onError(error) {
+        super.onError(error);
+        this.socket.server.emit('socketError', { socket: this.socket, error });
+    }
+    onInvoke(request) {
+        if (request.method !== '#publish') {
+            super.onInvoke(request);
+            return;
+        }
+        this.onPublish(request.data)
+            .then(() => {
+            super.onInvoke(request);
+        })
+            .catch(err => {
+            abortRequest(request, err);
+        });
+    }
+    onMessage(data, isBinary) {
+        this.socket.server.emit('socketMessage', { socket: this.socket, data, isBinary });
+        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);
+            return;
+        }
+        this.resetPingTimeout(this.socket.server.isPingTimeoutDisabled ? false : this.socket.server.pingTimeoutMs, 4001);
+        this.socket.emit('pong', {});
+        this.socket.server.emit('socketPong', { socket: this.socket });
+    }
+    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 });
+            }
+        }
+        options.data = data;
+    }
+    async onRequest(packet, timestamp, pluginError) {
+        let wasHandled = false;
+        if (!this.service || !('service' in packet) || packet.service === this.service) {
+            if (this.socket.server.strictHandshake && this.status === 'connecting' && packet.method !== '#handshake') {
+                this.disconnect(4009);
+                return true;
+            }
+            wasHandled = await super.onRequest(packet, timestamp, pluginError);
+        }
+        else {
+            wasHandled = this.onUnhandledRequest(packet);
+        }
+        return wasHandled;
+    }
+    onResponse(response) {
+        super.onResponse(response);
+        this.socket.server.emit('socketResponse', { socket: this.socket, response });
+    }
+    onTransmit(request) {
+        if (request.method !== '#publish') {
+            super.onTransmit(request);
+            return;
+        }
+        this.onPublish(request.data)
+            .then(() => {
+            super.onTransmit(request);
+        })
+            .catch(err => {
+            abortRequest(request, err);
+        });
+    }
+    ping() {
+        return this.send('');
+    }
+    async setAuthorization(authToken, options) {
+        const wasAuthenticated = !!this.signedAuthToken;
+        if (typeof authToken === 'string') {
+            const changed = await super.setAuthorization(authToken, options);
+            if (changed && this.status === 'ready') {
+                this.triggerAuthenticationEvents(false, wasAuthenticated);
+            }
+            return changed;
+        }
+        if (this.status === 'connecting') {
+            const err = new InvalidActionError('Cannot call setAuthToken before completing the handshake');
+            throw err;
+        }
+        const auth = this.socket.server.auth;
+        const rejectOnFailedDelivery = options?.rejectOnFailedDelivery;
+        let signedAuthToken;
+        delete options?.rejectOnFailedDelivery;
+        try {
+            signedAuthToken = await auth.signToken(authToken, options);
+        }
+        catch (err) {
+            this.onError(err);
+            this.disconnect(4002, err.toString());
+            throw err;
+        }
+        const changed = await super.setAuthorization(signedAuthToken, authToken);
+        if (changed && this.status === 'ready') {
+            this.triggerAuthenticationEvents(true, wasAuthenticated);
+        }
+        if (rejectOnFailedDelivery) {
+            try {
+                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;
+            }
+            return;
+        }
+        try {
+            await this.transmit('#setAuthToken', signedAuthToken);
+        }
+        catch (err) {
+            if (err.name !== 'BadConnectionError') {
+                throw err;
+            }
+        }
+        return changed;
+    }
+    setReadyStatus(pingTimeoutMs, authError) {
+        super.setReadyStatus(pingTimeoutMs, authError);
+        this.socket.server.emit('socketConnect', { socket: this.socket, pingTimeoutMs, id: this.socket.id, isAuthenticated: !!this.signedAuthToken, authError });
+    }
+    get socket() {
+        return super.socket;
+    }
+    set socket(value) {
+        super.socket = value;
+    }
+    triggerAuthenticationEvents(wasSigned, wasAuthenticated) {
+        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 });
+    }
+    async unsubscribe(channel) {
+        if (typeof channel !== 'string') {
+            throw new InvalidActionError(`Socket ${this.id} tried to unsubscribe from an invalid channel name`);
+        }
+        if (!this.socket.state.channelSubscriptions?.[channel]) {
+            throw new InvalidActionError(`Socket ${this.id} tried to unsubscribe from a channel which it is not subscribed to`);
+        }
+        try {
+            const server = this.socket.server;
+            await server.brokerEngine.unsubscribe(this, channel);
+            delete this.socket.state.channelSubscriptions[channel];
+            if (this.socket.state.channelSubscriptionsCount != null) {
+                this.socket.state.channelSubscriptionsCount--;
+            }
+            server.exchange.emit('unsubscribe', { channel });
+        }
+        catch (err) {
+            throw new BrokerError(`Failed to unsubscribe socket from the ${channel} channel - ${err}`);
+        }
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,119 @@
+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 { 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>> {
+    private readonly _callIdGenerator;
+    private readonly _wss;
+    private _isReady;
+    private _isListening;
+    private _pingIntervalRef;
+    private _handlers;
+    ackTimeoutMs: number;
+    allowClientPublish: boolean;
+    pingIntervalMs: number;
+    isPingTimeoutDisabled: boolean;
+    origins: string;
+    pingTimeoutMs: number;
+    socketChannelLimit?: number;
+    strictHandshake: boolean;
+    readonly auth: AuthEngine;
+    readonly brokerEngine: Broker<T['Channel']>;
+    readonly clients: {
+        [id: string]: ServerSocket<T>;
+    };
+    clientCount: number;
+    readonly codecEngine: CodecEngine;
+    readonly pendingClients: {
+        [id: string]: ServerSocket<T>;
+    };
+    pendingClientCount: number;
+    readonly socketStreamCleanupMode: StreamCleanupMode;
+    readonly httpServer: HttpServer;
+    readonly plugins: ServerPlugin<T>[];
+    constructor(options?: ServerOptions<T>);
+    addPlugin(...plugin: ServerPlugin<T>[]): void;
+    private bind;
+    close(keepSocketsOpen?: boolean): Promise<void>;
+    get exchange(): Exchange<T['Channel']>;
+    get isListening(): boolean;
+    get isReady(): boolean;
+    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<T>): void;
+    emit(event: "error", data: ErrorEvent): void;
+    emit(event: "headers", data: HeadersEvent): void;
+    emit(event: "handshake", data: HandshakeEvent<T>): 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: "warning", data: WarningEvent): void;
+    listen(): DemuxedConsumableStream<StreamEvent<ServerEvent<T>>>;
+    listen(event: "close"): DemuxedConsumableStream<CloseEvent>;
+    listen(event: "connection"): DemuxedConsumableStream<ConnectionEvent<T>>;
+    listen(event: "error"): DemuxedConsumableStream<ErrorEvent>;
+    listen(event: "handshake"): DemuxedConsumableStream<HandshakeEvent<T>>;
+    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: "warning"): DemuxedConsumableStream<WarningEvent>;
+}