@eleven-am/pondsocket 0.1.72 → 0.1.73

package/nest.d.ts

@@ -0,0 +1,31 @@
+import  {
+    OnJoinRequest,
+    DChannel as Channel,
+    Channels, Endpoints,
+    OnConnectionRequest,
+    DEndpoint as Endpoint,
+    OnEvent, PondSocketModule,
+    GetEventParams, GetEventQuery,
+    GetEventRequest, GetEventResponse,
+    GetJoinParams, GetJoinRequest,
+    GetJoinResponse, GetConnectionParams,
+    GetConnectionRequest, GetConnectionResponse,
+    GetConnectionQuery, GetConnectionHeaders,
+    GetConnectionRequestId, GetEventPayload,
+    GetUserData, GetUserPresence, GetInternalChannel,
+} from './types';
+
+export {
+    OnJoinRequest,
+    Endpoint, PondSocketModule,
+    OnConnectionRequest, OnEvent,
+    Channel, Channels, Endpoints,
+    GetEventQuery, GetJoinParams,
+    GetEventParams, GetJoinResponse,
+    GetEventRequest, GetJoinRequest,
+    GetEventResponse, GetConnectionQuery,
+    GetConnectionRequestId, GetEventPayload,
+    GetConnectionParams, GetConnectionRequest,
+    GetConnectionResponse, GetConnectionHeaders,
+    GetUserData, GetUserPresence, GetInternalChannel,
+}

package/nest.js

@@ -0,0 +1,507 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PondSocketModule = exports.Endpoints = exports.Endpoint = exports.Channels = exports.Channel = exports.OnConnectionRequest = exports.OnEvent = exports.OnJoinRequest = exports.GetConnectionQuery = exports.GetConnectionHeaders = exports.GetConnectionParams = exports.GetConnectionRequestId = exports.GetConnectionResponse = exports.GetConnectionRequest = exports.GetEventRequest = exports.GetEventResponse = exports.GetEventQuery = exports.GetEventParams = exports.GetEventPayload = exports.GetUserPresence = exports.GetInternalChannel = exports.GetUserData = exports.GetJoinParams = exports.GetJoinResponse = exports.GetJoinRequest = void 0;
+require("reflect-metadata");
+const common_1 = require("@nestjs/common");
+const pondSocket_1 = require("./server/pondSocket");
+const joinRequestKey = Symbol('joinRequestKey');
+const joinResponseKey = Symbol('joinResponseKey');
+const joinParamsKey = Symbol('joinParamsKey');
+const userDataKey = Symbol('userDataKey');
+const internalChannelKey = Symbol('internalChannelKey');
+const userPresenceKey = Symbol('userPresenceKey');
+const eventRequestKey = Symbol('eventRequestKey');
+const eventPayloadKey = Symbol('eventPayloadKey');
+const eventParamsKey = Symbol('eventParamsKey');
+const eventQueryKey = Symbol('eventQueryKey');
+const eventResponseKey = Symbol('eventResponseKey');
+const connectionRequestKey = Symbol('connectionRequestKey');
+const connectionResponseKey = Symbol('connectionResponseKey');
+const connectionRequestIdKey = Symbol('connectionRequestIdKey');
+const connectionParamsKey = Symbol('connectionParamsKey');
+const connectionQueryKey = Symbol('connectionQueryKey');
+const connectionHeadersKey = Symbol('connectionHeadersKey');
+const onJoinHandlerKey = Symbol('onJoinHandlerKey');
+const onEventHandlerKey = Symbol('onEventHandlerKey');
+const onConnectionHandlerKey = Symbol('onConnectionHandlerKey');
+const channelsKey = Symbol('channelsKey');
+const endpointsKey = Symbol('endpointsKey');
+function createParamDecorator(key, error) {
+    return (target, propertyKey, parameterIndex) => {
+        const existingParams = Reflect.getMetadata(key, target, propertyKey);
+        if (existingParams) {
+            throw new Error(error);
+        }
+        Reflect.defineMetadata(key, parameterIndex, target, propertyKey);
+    };
+}
+function resolveParamDecorator(key, target, propertyKey) {
+    const index = Reflect.getMetadata(key, target, propertyKey);
+    if (typeof index !== 'number') {
+        return null;
+    }
+    return index;
+}
+function createClassDecorator(key, target) {
+    return {
+        get() {
+            return (Reflect.getMetadata(key, target) || []);
+        },
+        set(value) {
+            Reflect.defineMetadata(key, value, target);
+        },
+    };
+}
+function manageHandlers(key, target) {
+    return {
+        get() {
+            return (Reflect.getMetadata(key, target) || []);
+        },
+        set(path, value) {
+            const handlers = Reflect.getMetadata(key, target) || [];
+            Reflect.defineMetadata(key, [
+                ...handlers, { path,
+                    value },
+            ], target);
+        },
+    };
+}
+function manageJoinHandlers(target) {
+    return manageHandlers(onJoinHandlerKey, target);
+}
+function manageEventHandlers(target) {
+    return manageHandlers(onEventHandlerKey, target);
+}
+function manageConnectionHandlers(target) {
+    return manageHandlers(onConnectionHandlerKey, target);
+}
+function manageChannels(target) {
+    return createClassDecorator(channelsKey, target);
+}
+function manageEndpoints(target) {
+    return createClassDecorator(endpointsKey, target);
+}
+function GetJoinRequest() {
+    return createParamDecorator(joinRequestKey, 'JoinRequest decorator already applied');
+}
+exports.GetJoinRequest = GetJoinRequest;
+function GetJoinResponse() {
+    return createParamDecorator(joinResponseKey, 'JoinResponse decorator already applied');
+}
+exports.GetJoinResponse = GetJoinResponse;
+function GetJoinParams() {
+    return createParamDecorator(joinParamsKey, 'JoinParams decorator already applied');
+}
+exports.GetJoinParams = GetJoinParams;
+function GetUserData() {
+    return createParamDecorator(userDataKey, 'UserData decorator already applied');
+}
+exports.GetUserData = GetUserData;
+function GetInternalChannel() {
+    return createParamDecorator(internalChannelKey, 'InternalChannel decorator already applied');
+}
+exports.GetInternalChannel = GetInternalChannel;
+function GetUserPresence() {
+    return createParamDecorator(userPresenceKey, 'UserPresence decorator already applied');
+}
+exports.GetUserPresence = GetUserPresence;
+function GetEventPayload() {
+    return createParamDecorator(eventPayloadKey, 'EventPayload decorator already applied');
+}
+exports.GetEventPayload = GetEventPayload;
+function GetEventParams() {
+    return createParamDecorator(eventParamsKey, 'EventParams decorator already applied');
+}
+exports.GetEventParams = GetEventParams;
+function GetEventQuery() {
+    return createParamDecorator(eventQueryKey, 'EventQuery decorator already applied');
+}
+exports.GetEventQuery = GetEventQuery;
+function GetEventResponse() {
+    return createParamDecorator(eventResponseKey, 'EventResponse decorator already applied');
+}
+exports.GetEventResponse = GetEventResponse;
+function GetEventRequest() {
+    return createParamDecorator(eventRequestKey, 'EventRequest decorator already applied');
+}
+exports.GetEventRequest = GetEventRequest;
+function GetConnectionRequest() {
+    return createParamDecorator(connectionRequestKey, 'ConnectionRequest decorator already applied');
+}
+exports.GetConnectionRequest = GetConnectionRequest;
+function GetConnectionResponse() {
+    return createParamDecorator(connectionResponseKey, 'ConnectionResponse decorator already applied');
+}
+exports.GetConnectionResponse = GetConnectionResponse;
+function GetConnectionRequestId() {
+    return createParamDecorator(connectionRequestIdKey, 'ConnectionRequestId decorator already applied');
+}
+exports.GetConnectionRequestId = GetConnectionRequestId;
+function GetConnectionParams() {
+    return createParamDecorator(connectionParamsKey, 'ConnectionParams decorator already applied');
+}
+exports.GetConnectionParams = GetConnectionParams;
+function GetConnectionHeaders() {
+    return createParamDecorator(connectionHeadersKey, 'ConnectionHeaders decorator already applied');
+}
+exports.GetConnectionHeaders = GetConnectionHeaders;
+function GetConnectionQuery() {
+    return createParamDecorator(connectionQueryKey, 'ConnectionQuery decorator already applied');
+}
+exports.GetConnectionQuery = GetConnectionQuery;
+function resolveJoinParameters(request, response, target, propertyKey) {
+    const joinRequestIndex = resolveParamDecorator(joinRequestKey, target, propertyKey);
+    const joinParamsIndex = resolveParamDecorator(joinParamsKey, target, propertyKey);
+    const userDataIndex = resolveParamDecorator(userDataKey, target, propertyKey);
+    const internalChannelIndex = resolveParamDecorator(internalChannelKey, target, propertyKey);
+    const eventParamsIndex = resolveParamDecorator(eventParamsKey, target, propertyKey);
+    const eventQueryIndex = resolveParamDecorator(eventQueryKey, target, propertyKey);
+    const JoinResponseIndex = resolveParamDecorator(joinResponseKey, target, propertyKey);
+    const array = [
+        joinRequestIndex,
+        joinParamsIndex,
+        userDataIndex,
+        internalChannelIndex,
+        eventParamsIndex,
+        eventQueryIndex,
+        JoinResponseIndex,
+    ].filter((index) => typeof index === 'number');
+    const rejectedKeys = [
+        eventPayloadKey,
+        eventRequestKey,
+        eventResponseKey,
+        userPresenceKey,
+        connectionRequestKey,
+        connectionResponseKey,
+        connectionRequestIdKey,
+        connectionParamsKey,
+        connectionQueryKey,
+    ]
+        .map((key) => resolveParamDecorator(key, target, propertyKey))
+        .filter((index) => typeof index === 'number');
+    if (rejectedKeys.length) {
+        throw new Error(`Invalid parameter decorators: ${rejectedKeys.join(', ')}`);
+    }
+    return array
+        .sort((a, b) => a - b)
+        .map((index) => {
+        switch (index) {
+            case joinRequestIndex:
+                return request;
+            case joinParamsIndex:
+                return request.joinParams;
+            case userDataIndex:
+                return request.user;
+            case internalChannelIndex:
+                return request.channel;
+            case eventParamsIndex:
+                return request.event.params;
+            case eventQueryIndex:
+                return request.event.query;
+            case JoinResponseIndex:
+                return response;
+            default:
+                throw new Error('Invalid parameter decorator');
+        }
+    });
+}
+function resolveEventParameters(request, response, target, propertyKey) {
+    const userDataIndex = resolveParamDecorator(userDataKey, target, propertyKey);
+    const internalChannelIndex = resolveParamDecorator(internalChannelKey, target, propertyKey);
+    const eventParamsIndex = resolveParamDecorator(eventParamsKey, target, propertyKey);
+    const eventQueryIndex = resolveParamDecorator(eventQueryKey, target, propertyKey);
+    const eventPayloadIndex = resolveParamDecorator(eventPayloadKey, target, propertyKey);
+    const eventResponseIndex = resolveParamDecorator(eventResponseKey, target, propertyKey);
+    const eventRequestIndex = resolveParamDecorator(eventRequestKey, target, propertyKey);
+    const array = [
+        userDataIndex,
+        internalChannelIndex,
+        eventParamsIndex,
+        eventQueryIndex,
+        eventPayloadIndex,
+        eventResponseIndex,
+        eventRequestIndex,
+    ].filter((index) => typeof index === 'number');
+    const rejectedKeys = [
+        joinRequestKey,
+        joinResponseKey,
+        joinParamsKey,
+        userPresenceKey,
+        connectionRequestKey,
+        connectionResponseKey,
+        connectionRequestIdKey,
+        connectionParamsKey,
+        connectionQueryKey,
+    ]
+        .map((key) => resolveParamDecorator(key, target, propertyKey))
+        .filter((index) => typeof index === 'number');
+    if (rejectedKeys.length) {
+        throw new Error(`Invalid parameter decorators: ${rejectedKeys.join(', ')}`);
+    }
+    return array
+        .sort((a, b) => a - b)
+        .map((index) => {
+        switch (index) {
+            case userDataIndex:
+                return request.user;
+            case internalChannelIndex:
+                return request.channel;
+            case eventParamsIndex:
+                return request.event.params;
+            case eventQueryIndex:
+                return request.event.query;
+            case eventPayloadIndex:
+                return request.event.payload;
+            case eventResponseIndex:
+                return response;
+            case eventRequestIndex:
+                return request;
+            default:
+                throw new Error('Invalid parameter decorator');
+        }
+    });
+}
+function resolveConnectionParameters(request, response, target, propertyKey) {
+    const connectionRequestIndex = resolveParamDecorator(connectionRequestKey, target, propertyKey);
+    const connectionResponseIndex = resolveParamDecorator(connectionResponseKey, target, propertyKey);
+    const connectionRequestIdIndex = resolveParamDecorator(connectionRequestIdKey, target, propertyKey);
+    const connectionParamsIndex = resolveParamDecorator(connectionParamsKey, target, propertyKey);
+    const connectionQueryIndex = resolveParamDecorator(connectionQueryKey, target, propertyKey);
+    const connectionHeadersIndex = resolveParamDecorator(connectionHeadersKey, target, propertyKey);
+    const array = [
+        connectionRequestIndex,
+        connectionResponseIndex,
+        connectionRequestIdIndex,
+        connectionParamsIndex,
+        connectionQueryIndex,
+        connectionHeadersIndex,
+    ].filter((index) => typeof index === 'number');
+    const rejectedKeys = [
+        joinRequestKey,
+        joinResponseKey,
+        joinParamsKey,
+        userDataKey,
+        internalChannelKey,
+        eventParamsKey,
+        eventQueryKey,
+        eventPayloadKey,
+        eventResponseKey,
+        userPresenceKey,
+        eventRequestKey,
+    ]
+        .map((key) => resolveParamDecorator(key, target, propertyKey))
+        .filter((index) => typeof index === 'number');
+    if (rejectedKeys.length) {
+        throw new Error(`Invalid parameter decorators: ${rejectedKeys.join(', ')}`);
+    }
+    return array
+        .sort((a, b) => a - b)
+        .map((index) => {
+        switch (index) {
+            case connectionRequestIndex:
+                return request;
+            case connectionResponseIndex:
+                return response;
+            case connectionRequestIdIndex:
+                return request.id;
+            case connectionParamsIndex:
+                return request.params;
+            case connectionQueryIndex:
+                return request.query;
+            case connectionHeadersIndex:
+                return request.headers;
+            default:
+                throw new Error('Invalid parameter decorator');
+        }
+    });
+}
+function OnJoinRequest() {
+    return (target, propertyKey, descriptor) => {
+        const originalMethod = descriptor.value;
+        const { set } = manageJoinHandlers(target);
+        set('', (request, response) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield originalMethod.apply(target, resolveJoinParameters(request, response, target, propertyKey));
+                if (!response.hasResponded) {
+                    if (data) {
+                        const { event } = data, rest = __rest(data, ["event"]);
+                        response.send(event !== null && event !== void 0 ? event : 'response', rest);
+                    }
+                    else {
+                        response.accept();
+                    }
+                }
+            }
+            catch (error) {
+                response.reject(String(error));
+            }
+        }));
+    };
+}
+exports.OnJoinRequest = OnJoinRequest;
+function OnEvent(event = '*') {
+    return (target, propertyKey, descriptor) => {
+        const originalMethod = descriptor.value;
+        const { set } = manageEventHandlers(target);
+        set(event, (request, response) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield originalMethod.apply(target, resolveEventParameters(request, response, target, propertyKey));
+                if (!response.hasResponded) {
+                    if (data) {
+                        const { event } = data, rest = __rest(data, ["event"]);
+                        response.send(event !== null && event !== void 0 ? event : 'response', rest);
+                    }
+                    else {
+                        response.accept();
+                    }
+                }
+            }
+            catch (error) {
+                response.reject(String(error));
+            }
+        }));
+    };
+}
+exports.OnEvent = OnEvent;
+function OnConnectionRequest() {
+    return (target, propertyKey, descriptor) => {
+        const originalMethod = descriptor.value;
+        const { set } = manageConnectionHandlers(target);
+        set('', (request, response) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield originalMethod.apply(target, resolveConnectionParameters(request, response, target, propertyKey));
+                if (!response.hasResponded) {
+                    if (data) {
+                        const { event } = data, rest = __rest(data, ["event"]);
+                        response.send(event !== null && event !== void 0 ? event : 'response', rest);
+                    }
+                    else {
+                        response.accept();
+                    }
+                }
+            }
+            catch (error) {
+                response.reject(String(error));
+            }
+        }));
+    };
+}
+exports.OnConnectionRequest = OnConnectionRequest;
+function Channel(path = '*') {
+    return (constructor) => class extends constructor {
+        _setEndpoint(endpoint) {
+            const channel = endpoint.createChannel(path, (request, response) => __awaiter(this, void 0, void 0, function* () {
+                const { get } = manageJoinHandlers(this);
+                const [handler] = get();
+                if (handler) {
+                    yield handler.value(request, response);
+                }
+                else {
+                    response.accept();
+                }
+            }));
+            const { get } = manageEventHandlers(this);
+            const handlers = get();
+            handlers.forEach((handler) => {
+                channel.onEvent(handler.path, (request, response) => __awaiter(this, void 0, void 0, function* () {
+                    yield handler.value(request, response);
+                }));
+            });
+        }
+    };
+}
+exports.Channel = Channel;
+function Channels(channels) {
+    return (constructor) => {
+        const { set } = manageChannels(constructor.prototype);
+        set(channels);
+        return class extends constructor {
+            constructor() {
+                super(...arguments);
+                this._channels = channels;
+            }
+        };
+    };
+}
+exports.Channels = Channels;
+function Endpoint(path = '*') {
+    return (constructor) => class extends constructor {
+        _setSocket(moduleRef, socket) {
+            var _a;
+            const { get } = manageConnectionHandlers(this);
+            const [handler] = get();
+            const endpoint = socket.createEndpoint(path, (request, response) => __awaiter(this, void 0, void 0, function* () {
+                if (handler) {
+                    yield handler.value(request, response);
+                }
+                else {
+                    response.accept();
+                }
+            }));
+            const channels = (_a = this._channels) !== null && _a !== void 0 ? _a : [];
+            channels.forEach((channel) => {
+                const chan = moduleRef.get(channel, {
+                    strict: false,
+                });
+                chan._setEndpoint(endpoint);
+            });
+        }
+    };
+}
+exports.Endpoint = Endpoint;
+function Endpoints(endpoints) {
+    return (constructor) => {
+        const channels = endpoints.reduce((acc, endpoint) => {
+            const { get } = manageChannels(endpoint.prototype);
+            const channels = get();
+            return [...acc, ...channels];
+        }, []);
+        // eslint-disable-next-line new-cap
+        const NestJSModule = (0, common_1.Module)({
+            providers: [...endpoints, ...channels],
+        });
+        const { set } = manageEndpoints(constructor.prototype);
+        set(endpoints);
+        // eslint-disable-next-line new-cap
+        return NestJSModule(constructor);
+    };
+}
+exports.Endpoints = Endpoints;
+class PondSocketModule {
+    constructor(moduleRef, adapterHost) {
+        this.moduleRef = moduleRef;
+        this.adapterHost = adapterHost;
+        const expressInstance = this.adapterHost.httpAdapter;
+        const server = expressInstance.getHttpServer();
+        this.socket = new pondSocket_1.PondSocket(server);
+        expressInstance.listen = (...args) => {
+            const { get } = manageEndpoints(this);
+            get().forEach((endpoint) => {
+                const instance = this.moduleRef.get(endpoint, { strict: false });
+                instance._setSocket(this.moduleRef, this.socket);
+            });
+            this.socket.listen(...args);
+        };
+    }
+}
+exports.PondSocketModule = PondSocketModule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.72",
+  "version": "0.1.73",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -29,8 +29,11 @@
     "url": "git+https://github.com/Eleven-am/pondSocket.git"
   },
   "dependencies": {
+    "@nestjs/common": "^10.2.10",
+    "@nestjs/core": "^10.2.10",
+    "reflect-metadata": "^0.1.14",
     "websocket": "^1.0.34",
-    "ws": "^8.15.0"
+    "ws": "^8.15.1"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",
@@ -38,7 +41,7 @@
     "@types/node": "^20.10.4",
     "@types/websocket": "^1.0.10",
     "@types/ws": "^8.5.10",
-    "@typescript-eslint/eslint-plugin": "^6.13.2",
+    "@typescript-eslint/eslint-plugin": "^6.14.0",
     "eslint": "^8.55.0",
     "eslint-plugin-file-progress": "^1.3.0",
     "eslint-plugin-import": "^2.29.0",

package/types.d.ts

@@ -1,10 +1,13 @@
 import { Server as HTTPServer, IncomingHttpHeaders } from 'http';
 
+import type { ModuleRef, HttpAdapterHost } from '@nestjs/core';
 import type { Express } from 'express';
 import { WebSocketServer } from 'ws';
 
 type Unsubscribe = () => void;
 
+type Constructor<T> = new (...args: any[]) => T;
+type MethodDecorator = (target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<unknown>) => TypedPropertyDescriptor<unknown> | void;
 export type default_t<T = any> = Record<string, T>;
 type IsParam<Path> = Path extends `:${infer Param}` ? Param : never;
 
@@ -615,3 +618,161 @@ declare class PondClient {
 
 declare const pondSocket: (app: Express) => PondSocketExpressApp;
 
+/**
+ * @desc The Decorator for retrieving the JoinRequest object from the request in a handler
+ * @returns {JoinRequest}
+ */
+declare function GetJoinRequest(): MethodDecorator;
+
+/**
+ * @desc The Decorator for retrieving the JoinResponse object from the response in a handler
+ * @returns {JoinResponse}
+ */
+declare function GetJoinResponse(): MethodDecorator;
+
+/**
+ * @desc The Decorator for retrieving the JoinParams object from the request in a handler
+ * @returns {JoinParams}
+ */
+declare function GetJoinParams(): MethodDecorator;
+
+/**
+ * @desc The Decorator for retrieving the UserData object from the request in a handler
+ * @returns {UserData}
+ */
+declare function GetUserData(): MethodDecorator;
+
+/**
+ * @desc The Decorator for retrieving the Channel object from the request in a handler
+ * @returns {Channel}
+ */
+declare function GetInternalChannel(): MethodDecorator;
+
+/**
+ * @desc The Decorator for retrieving the UserPresence object from the request in a handler
+ * @returns {PondPresence}
+ */
+declare function GetUserPresence(): MethodDecorator;
+
+/**
+ * @desc The Decorator for retrieving the event payload from the request in a handler
+ * @returns {PondMessage}
+ */
+declare function GetEventPayload(): MethodDecorator;
+
+/**
+ * @desc The Decorator for retrieving the EventRequest Params object from the request in a handler
+ * @returns {EventParams}
+ */
+declare function GetEventParams(): MethodDecorator;
+
+/**
+ * @desc The Decorator for retrieving the EventRequest Query object from the request in a handler
+ * @returns {EventParams}
+ */
+declare function GetEventQuery(): MethodDecorator;
+
+/**
+ * @desc The Decorator for retrieving the EventResponse in a handler
+ * @returns {EventResponse}
+ */
+declare function GetEventResponse(): MethodDecorator;
+
+/**
+ * @desc The Decorator for retrieving the EventRequest in a handler
+ * @returns {EventRequest}
+ */
+declare function GetEventRequest(): MethodDecorator;
+
+/**
+ * @desc The Decorator for retrieving the ConnectionReQuest in a handler
+ * @returns {IncomingConnection}
+ */
+declare function GetConnectionRequest(): MethodDecorator;
+
+/**
+ * @desc The Decorator for retrieving the ConnectionResponse in a handler
+ * @returns {ConnectionResponse}
+ */
+declare function GetConnectionResponse(): MethodDecorator;
+
+/**
+ * @desc The Decorator for retrieving the ConnectionRequestId in a handler
+ * @returns {string}
+ */
+declare function GetConnectionRequestId(): MethodDecorator;
+
+/**
+ * @desc The Decorator for retrieving the ConnectionParams in a handler
+ * @returns {EventParams}
+ */
+declare function GetConnectionParams(): MethodDecorator;
+
+/**
+ * @desc The Decorator for retrieving the ConnectionHeaders from the request in a handler
+ * @returns {EventParams}
+ */
+declare function GetConnectionHeaders(): MethodDecorator;
+
+/**
+ * @desc The Decorator for retrieving the ConnectionQuery in a handler
+ * @returns {EventParams}
+ */
+declare function GetConnectionQuery(): MethodDecorator;
+
+/**
+ * @desc Marks a method as a handler for JoinRequest events.
+ */
+declare function OnJoinRequest(): MethodDecorator;
+
+/**
+ * @desc Marks a method as a handler for events with the specified name.
+ * @param event - The name of the event to handle.
+ */
+declare function OnEvent(event?: string): MethodDecorator;
+
+/**
+ * @desc Marks a method as a handler for ConnectionRequest events.
+ */
+declare function OnConnectionRequest(): MethodDecorator;
+
+/**
+ * Decorator to mark a class as a channel.
+ * @param path - The path for the channel (default is '*').
+ */
+declare function DChannel<T extends Constructor<NonNullable<unknown>>>(
+    path?: string
+): (constructor: T) => void;
+
+/**
+ * Decorator to mark a class as having multiple channels.
+ * @param channels - The array of channels.
+ */
+declare function Channels<T extends Constructor<NonNullable<unknown>>>(
+    channels: Constructor<NonNullable<unknown>>[]
+): (constructor: T) => void;
+
+/**
+ * Decorator to mark a class as an endpoint.
+ * @param path - The path for the endpoint (default is '*').
+ */
+declare function DEndpoint<T extends Constructor<NonNullable<unknown>>>(
+    path?: string
+): (constructor: T) => void;
+
+/**
+ * Decorator to mark a class as having multiple endpoints.
+ * @param endpoints - The array of endpoints.
+ */
+declare function Endpoints<T extends Constructor<NonNullable<unknown>>>(
+    endpoints: Constructor<NonNullable<unknown>>[]
+): (constructor: T) => void;
+
+declare class PondSocketModule {
+    /**
+     * @desc The NestJS module for the PondSocketModule
+     * @param moduleRef - The NestJS moduleRef
+     * @param adapterHost - The NestJS adapterHost
+     */
+    constructor (moduleRef: ModuleRef, adapterHost: HttpAdapterHost);
+}