@riaskov/nevo-messaging 1.0.1 → 1.1.2

package/dist/transports/nats/nevo-nats.client.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NevoNatsClient = void 0;
+const nats_1 = require("nats");
+const common_1 = require("../../common");
+const node_crypto_1 = require("node:crypto");
+class NevoNatsClient {
+    constructor(nc, serviceNames, options) {
+        this.codec = (0, nats_1.StringCodec)();
+        this.inFlight = new Set();
+        this.discoveryRegistry = new common_1.DiscoveryRegistry();
+        this.nc = nc;
+        this.serviceNames = serviceNames.map((name) => name.toLowerCase());
+        this.timeoutMs = options?.timeoutMs || 20000;
+        this.debug = options?.debug || false;
+        this.serviceName = options?.serviceName;
+        this.authToken = options?.authToken;
+        this.backoffEnabled = options?.backoff?.enabled !== false;
+        this.backoffBaseMs = options?.backoff?.baseMs || 100;
+        this.backoffMaxMs = options?.backoff?.maxMs || 2000;
+        this.backoffMaxAttempts = options?.backoff?.maxAttempts || 0;
+        this.backoffJitter = options?.backoff?.jitter !== false;
+        this.discoveryEnabled = options?.discovery?.enabled !== false;
+        this.discoveryHeartbeatIntervalMs = options?.discovery?.heartbeatIntervalMs || 5000;
+        this.discoveryTtlMs = options?.discovery?.ttlMs || 15000;
+        if (this.discoveryEnabled) {
+            void this.initDiscovery();
+        }
+    }
+    static async create(serviceNames, options) {
+        const nc = await (0, nats_1.connect)({
+            servers: options?.servers && options.servers.length > 0 ? options.servers : ["nats://127.0.0.1:4222"]
+        });
+        return new NevoNatsClient(nc, serviceNames, options);
+    }
+    createMessagePayload(method, params, type) {
+        const uuid = (0, node_crypto_1.randomUUID)();
+        const meta = {
+            type,
+            service: this.serviceName,
+            ts: Date.now(),
+            auth: { token: this.authToken }
+        };
+        return (0, common_1.stringifyWithBigInt)({ uuid, method, params, meta });
+    }
+    async waitForInFlightSlot(key) {
+        if (!this.backoffEnabled) {
+            return;
+        }
+        let attempt = 0;
+        let delay = this.backoffBaseMs;
+        while (this.inFlight.has(key)) {
+            attempt++;
+            if (this.backoffMaxAttempts > 0 && attempt > this.backoffMaxAttempts) {
+                throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, {
+                    message: `Backoff exceeded for ${key}`
+                });
+            }
+            const jitter = this.backoffJitter ? Math.floor(Math.random() * delay * 0.2) : 0;
+            await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+            delay = Math.min(this.backoffMaxMs, delay * 2);
+        }
+    }
+    async query(serviceName, method, params) {
+        const normalizedServiceName = serviceName.toLowerCase();
+        if (!this.serviceNames.includes(normalizedServiceName)) {
+            throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, {
+                message: `Service "${serviceName}" is not registered in nevo nats client`,
+                availableServices: this.serviceNames
+            });
+        }
+        const subject = `${normalizedServiceName}-events`;
+        const payload = this.createMessagePayload(method, params, "query");
+        const inFlightKey = `${normalizedServiceName}:${method}`;
+        if (this.debug) {
+            console.log(`[NevoNatsClient] Sending query to ${subject}:`, { method, params });
+        }
+        let inFlightAcquired = false;
+        await this.waitForInFlightSlot(inFlightKey);
+        this.inFlight.add(inFlightKey);
+        inFlightAcquired = true;
+        try {
+            const msg = await this.nc.request(subject, this.codec.encode(payload), { timeout: this.timeoutMs });
+            const response = (0, common_1.parseWithBigInt)(this.codec.decode(msg.data));
+            if (response?.params?.result === "error" && response?.params?.error) {
+                const errorData = response.params.error;
+                const error = new common_1.MessagingError(errorData.code, errorData.details, errorData.service || serviceName);
+                if (process.env["MODE"] !== "production" && errorData.stack) {
+                    error.stack = errorData.stack;
+                }
+                throw error;
+            }
+            return response?.params?.result;
+        }
+        finally {
+            if (inFlightAcquired) {
+                this.inFlight.delete(inFlightKey);
+            }
+        }
+    }
+    async emit(serviceName, method, params) {
+        const normalizedServiceName = serviceName.toLowerCase();
+        if (!this.serviceNames.includes(normalizedServiceName)) {
+            throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, {
+                message: `Service "${serviceName}" is not registered in nevo nats client`,
+                availableServices: this.serviceNames
+            });
+        }
+        const subject = `${normalizedServiceName}-events`;
+        const payload = this.createMessagePayload(method, params, "emit");
+        if (this.debug) {
+            console.log(`[NevoNatsClient] Emitting to ${subject}:`, { method, params });
+        }
+        this.nc.publish(subject, this.codec.encode(payload));
+    }
+    async publish(serviceName, method, params) {
+        const normalizedServiceName = serviceName.toLowerCase();
+        if (!this.serviceNames.includes(normalizedServiceName)) {
+            throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, {
+                message: `Service "${serviceName}" is not registered in nevo nats client`,
+                availableServices: this.serviceNames
+            });
+        }
+        const subject = `${normalizedServiceName}${common_1.DEFAULT_SUBSCRIPTION_SUFFIX}`;
+        const payload = this.createMessagePayload(method, params, "sub");
+        if (this.debug) {
+            console.log(`[NevoNatsClient] Publishing to ${subject}:`, { method, params });
+        }
+        this.nc.publish(subject, this.codec.encode(payload));
+    }
+    async broadcast(method, params) {
+        const payload = this.createMessagePayload(method, params, "broadcast");
+        if (this.debug) {
+            console.log(`[NevoNatsClient] Broadcasting to ${common_1.DEFAULT_BROADCAST_TOPIC}:`, { method, params });
+        }
+        this.nc.publish(common_1.DEFAULT_BROADCAST_TOPIC, this.codec.encode(payload));
+    }
+    async subscribe(serviceName, method, options, handler) {
+        const normalizedServiceName = serviceName.toLowerCase();
+        const isBroadcast = normalizedServiceName === common_1.DEFAULT_BROADCAST_TOPIC;
+        if (!isBroadcast && !this.serviceNames.includes(normalizedServiceName)) {
+            throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, {
+                message: `Service "${serviceName}" is not registered in nevo nats client`,
+                availableServices: this.serviceNames
+            });
+        }
+        const subject = isBroadcast ? common_1.DEFAULT_BROADCAST_TOPIC : `${normalizedServiceName}${common_1.DEFAULT_SUBSCRIPTION_SUFFIX}`;
+        const sub = this.nc.subscribe(subject);
+        (async () => {
+            for await (const msg of sub) {
+                const raw = this.codec.decode(msg.data);
+                const payload = (0, common_1.parseWithBigInt)(raw);
+                if (method && payload.method !== method) {
+                    continue;
+                }
+                const context = {
+                    meta: payload.meta || {},
+                    ack: async () => {
+                        return;
+                    },
+                    nack: async () => {
+                        return;
+                    }
+                };
+                await handler(payload.params, context);
+            }
+        })();
+        return {
+            unsubscribe: async () => {
+                sub.unsubscribe();
+            }
+        };
+    }
+    getAvailableServices() {
+        return [...this.serviceNames];
+    }
+    getDiscoveredServices() {
+        this.discoveryRegistry.prune(this.discoveryTtlMs);
+        return this.discoveryRegistry.list();
+    }
+    isServiceAvailable(serviceName) {
+        return this.discoveryRegistry.isAvailable(serviceName, this.discoveryTtlMs);
+    }
+    async initDiscovery() {
+        this.discoverySubscription = this.nc.subscribe(common_1.DEFAULT_DISCOVERY_TOPIC);
+        (async () => {
+            for await (const msg of this.discoverySubscription) {
+                try {
+                    const payload = (0, common_1.parseWithBigInt)(this.codec.decode(msg.data));
+                    if (payload?.serviceName) {
+                        this.discoveryRegistry.update(payload);
+                    }
+                }
+                catch (error) {
+                    console.error("[NevoNatsClient] Failed to parse discovery message", error);
+                }
+            }
+        })();
+        this.discoveryTimer = setInterval(() => {
+            const announcement = {
+                serviceName: this.serviceName || "unknown",
+                clientId: this.serviceName,
+                transport: "nats",
+                ts: Date.now()
+            };
+            this.nc.publish(common_1.DEFAULT_DISCOVERY_TOPIC, this.codec.encode((0, common_1.stringifyWithBigInt)(announcement)));
+        }, this.discoveryHeartbeatIntervalMs);
+    }
+}
+exports.NevoNatsClient = NevoNatsClient;

package/dist/transports/socket-io/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./nevo-socket.client";
+export * from "./socket.client-base";
+export * from "./socket.signal-router.decorator";
+export * from "./socket.config";

package/dist/transports/socket-io/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./nevo-socket.client"), exports);
+__exportStar(require("./socket.client-base"), exports);
+__exportStar(require("./socket.signal-router.decorator"), exports);
+__exportStar(require("./socket.config"), exports);

package/dist/transports/socket-io/nevo-socket.client.d.ts

@@ -0,0 +1,50 @@
+import { Subscription, SubscriptionContext, SubscriptionOptions } from "../../common";
+export interface NevoSocketClientOptions {
+    timeoutMs?: number;
+    debug?: boolean;
+    serviceName?: string;
+    authToken?: string;
+    backoff?: {
+        enabled?: boolean;
+        baseMs?: number;
+        maxMs?: number;
+        maxAttempts?: number;
+        jitter?: boolean;
+    };
+    discovery?: {
+        enabled?: boolean;
+        heartbeatIntervalMs?: number;
+        ttlMs?: number;
+    };
+}
+export declare class NevoSocketClient {
+    private readonly serviceUrls;
+    private readonly timeoutMs;
+    private readonly debug;
+    private readonly serviceName?;
+    private readonly authToken?;
+    private readonly backoffEnabled;
+    private readonly backoffBaseMs;
+    private readonly backoffMaxMs;
+    private readonly backoffMaxAttempts;
+    private readonly backoffJitter;
+    private readonly inFlight;
+    private readonly sockets;
+    private readonly discoveryRegistry;
+    private readonly discoveryEnabled;
+    private readonly discoveryHeartbeatIntervalMs;
+    private readonly discoveryTtlMs;
+    private discoveryTimer?;
+    constructor(serviceUrls: Record<string, string>, options?: NevoSocketClientOptions);
+    private createMessagePayload;
+    private waitForInFlightSlot;
+    private getSocket;
+    query<T = any>(serviceName: string, method: string, params: any): Promise<T>;
+    emit(serviceName: string, method: string, params: any): Promise<void>;
+    publish(serviceName: string, method: string, params: any): Promise<void>;
+    broadcast(method: string, params: any): Promise<void>;
+    subscribe<T = any>(serviceName: string, method: string, options: SubscriptionOptions | undefined, handler: (data: T, context: SubscriptionContext) => Promise<void> | void): Promise<Subscription>;
+    getAvailableServices(): string[];
+    getDiscoveredServices(): import("../../common").DiscoveryEntry[];
+    isServiceAvailable(serviceName: string): boolean;
+}

package/dist/transports/socket-io/nevo-socket.client.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NevoSocketClient = void 0;
+const socket_io_client_1 = require("socket.io-client");
+const common_1 = require("../../common");
+const node_crypto_1 = require("node:crypto");
+class NevoSocketClient {
+    constructor(serviceUrls, options) {
+        this.inFlight = new Set();
+        this.sockets = new Map();
+        this.discoveryRegistry = new common_1.DiscoveryRegistry();
+        this.serviceUrls = new Map(Object.entries(serviceUrls).map(([k, v]) => [k.toLowerCase(), v]));
+        this.timeoutMs = options?.timeoutMs || 20000;
+        this.debug = options?.debug || false;
+        this.serviceName = options?.serviceName;
+        this.authToken = options?.authToken;
+        this.backoffEnabled = options?.backoff?.enabled !== false;
+        this.backoffBaseMs = options?.backoff?.baseMs || 100;
+        this.backoffMaxMs = options?.backoff?.maxMs || 2000;
+        this.backoffMaxAttempts = options?.backoff?.maxAttempts || 0;
+        this.backoffJitter = options?.backoff?.jitter !== false;
+        this.discoveryEnabled = options?.discovery?.enabled === true;
+        this.discoveryHeartbeatIntervalMs = options?.discovery?.heartbeatIntervalMs || 5000;
+        this.discoveryTtlMs = options?.discovery?.ttlMs || 15000;
+    }
+    createMessagePayload(method, params, type) {
+        const uuid = (0, node_crypto_1.randomUUID)();
+        const meta = {
+            type,
+            service: this.serviceName,
+            ts: Date.now(),
+            auth: { token: this.authToken }
+        };
+        return { uuid, method, params, meta };
+    }
+    async waitForInFlightSlot(key) {
+        if (!this.backoffEnabled) {
+            return;
+        }
+        let attempt = 0;
+        let delay = this.backoffBaseMs;
+        while (this.inFlight.has(key)) {
+            attempt++;
+            if (this.backoffMaxAttempts > 0 && attempt > this.backoffMaxAttempts) {
+                throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, {
+                    message: `Backoff exceeded for ${key}`
+                });
+            }
+            const jitter = this.backoffJitter ? Math.floor(Math.random() * delay * 0.2) : 0;
+            await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+            delay = Math.min(this.backoffMaxMs, delay * 2);
+        }
+    }
+    getSocket(serviceName) {
+        const normalized = serviceName.toLowerCase();
+        const url = this.serviceUrls.get(normalized);
+        if (!url) {
+            throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, {
+                message: `Service "${serviceName}" is not registered in nevo socket client`,
+                availableServices: [...this.serviceUrls.keys()]
+            });
+        }
+        let socket = this.sockets.get(normalized);
+        if (!socket) {
+            socket = (0, socket_io_client_1.io)(url, { transports: ["websocket"] });
+            this.sockets.set(normalized, socket);
+            if (this.discoveryEnabled) {
+                socket.on(common_1.DEFAULT_DISCOVERY_TOPIC, (raw) => {
+                    try {
+                        const payload = (0, common_1.parseWithBigInt)(raw);
+                        if (payload?.serviceName) {
+                            this.discoveryRegistry.update(payload);
+                        }
+                    }
+                    catch (error) {
+                        console.error("[NevoSocketClient] Failed to parse discovery message", error);
+                    }
+                });
+            }
+        }
+        return socket;
+    }
+    async query(serviceName, method, params) {
+        const socket = this.getSocket(serviceName);
+        const payload = this.createMessagePayload(method, params, "query");
+        const inFlightKey = `${serviceName.toLowerCase()}:${method}`;
+        if (this.debug) {
+            console.log(`[NevoSocketClient] Sending query to ${serviceName}:`, { method, params });
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, {
+                    message: `Socket request timed out after ${this.timeoutMs}ms`
+                }));
+            }, this.timeoutMs);
+            (async () => {
+                let inFlightAcquired = false;
+                try {
+                    await this.waitForInFlightSlot(inFlightKey);
+                    this.inFlight.add(inFlightKey);
+                    inFlightAcquired = true;
+                    socket.emit("nevo:query", payload, (response) => {
+                        clearTimeout(timeout);
+                        if (inFlightAcquired) {
+                            this.inFlight.delete(inFlightKey);
+                        }
+                        if (response?.params?.result === "error" && response?.params?.error) {
+                            const errorData = response.params.error;
+                            const error = new common_1.MessagingError(errorData.code, errorData.details, errorData.service || serviceName);
+                            if (process.env["MODE"] !== "production" && errorData.stack) {
+                                error.stack = errorData.stack;
+                            }
+                            reject(error);
+                            return;
+                        }
+                        resolve(response?.params?.result);
+                    });
+                }
+                catch (error) {
+                    clearTimeout(timeout);
+                    if (inFlightAcquired) {
+                        this.inFlight.delete(inFlightKey);
+                    }
+                    reject(error);
+                }
+            })();
+        });
+    }
+    async emit(serviceName, method, params) {
+        const socket = this.getSocket(serviceName);
+        const payload = this.createMessagePayload(method, params, "emit");
+        if (this.debug) {
+            console.log(`[NevoSocketClient] Emitting to ${serviceName}:`, { method, params });
+        }
+        socket.emit("nevo:emit", payload);
+    }
+    async publish(serviceName, method, params) {
+        const socket = this.getSocket(serviceName);
+        const payload = this.createMessagePayload(method, params, "sub");
+        if (this.debug) {
+            console.log(`[NevoSocketClient] Publishing to ${serviceName}:`, { method, params });
+        }
+        socket.emit("nevo:publish", payload);
+    }
+    async broadcast(method, params) {
+        const first = [...this.serviceUrls.keys()][0];
+        if (!first) {
+            throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, { message: "No base URL available for broadcast" });
+        }
+        const socket = this.getSocket(first);
+        const payload = this.createMessagePayload(method, params, "broadcast");
+        if (this.debug) {
+            console.log(`[NevoSocketClient] Broadcasting:`, { method, params });
+        }
+        socket.emit("nevo:broadcast", payload);
+    }
+    async subscribe(serviceName, method, options, handler) {
+        const normalized = serviceName.toLowerCase();
+        const isBroadcast = normalized === common_1.DEFAULT_BROADCAST_TOPIC;
+        const socket = this.getSocket(isBroadcast ? [...this.serviceUrls.keys()][0] : serviceName);
+        const room = method ? `${normalized}:${method}` : `${normalized}`;
+        if (!isBroadcast) {
+            socket.emit("nevo:subscribe", { serviceName, method, room });
+        }
+        const onMessage = async (raw) => {
+            const payload = typeof raw === "string" ? (0, common_1.parseWithBigInt)(raw) : raw;
+            if (method && payload.method !== method) {
+                return;
+            }
+            const context = {
+                meta: payload.meta || {},
+                ack: async () => {
+                    return;
+                },
+                nack: async () => {
+                    return;
+                }
+            };
+            await handler(payload.params, context);
+        };
+        socket.on(isBroadcast ? "nevo:broadcast" : "nevo:sub", onMessage);
+        return {
+            unsubscribe: async () => {
+                socket.off(isBroadcast ? "nevo:broadcast" : "nevo:sub", onMessage);
+                if (!isBroadcast) {
+                    socket.emit("nevo:unsubscribe", { serviceName, method, room });
+                }
+            }
+        };
+    }
+    getAvailableServices() {
+        return [...this.serviceUrls.keys()];
+    }
+    getDiscoveredServices() {
+        this.discoveryRegistry.prune(this.discoveryTtlMs);
+        return this.discoveryRegistry.list();
+    }
+    isServiceAvailable(serviceName) {
+        return this.discoveryRegistry.isAvailable(serviceName, this.discoveryTtlMs);
+    }
+}
+exports.NevoSocketClient = NevoSocketClient;

package/dist/transports/socket-io/socket.client-base.d.ts

@@ -0,0 +1,13 @@
+import { NevoSocketClient } from "./nevo-socket.client";
+export declare abstract class SocketClientBase {
+    protected readonly universalClient: NevoSocketClient;
+    protected constructor(universalClient: NevoSocketClient);
+    protected query<T = any>(serviceName: string, method: string, params: any): Promise<T>;
+    protected emit(serviceName: string, method: string, params: any): Promise<void>;
+    protected publish(serviceName: string, method: string, params: any): Promise<void>;
+    protected broadcast(method: string, params: any): Promise<void>;
+    protected subscribe<T = any>(serviceName: string, method: string, options: Parameters<NevoSocketClient["subscribe"]>[2], handler: Parameters<NevoSocketClient["subscribe"]>[3]): Promise<import("../..").Subscription>;
+    protected getAvailableServices(): string[];
+    protected getDiscoveredServices(): import("../..").DiscoveryEntry[];
+    protected isServiceAvailable(serviceName: string): boolean;
+}

package/dist/transports/socket-io/socket.client-base.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketClientBase = void 0;
+class SocketClientBase {
+    constructor(universalClient) {
+        this.universalClient = universalClient;
+    }
+    async query(serviceName, method, params) {
+        return this.universalClient.query(serviceName, method, params);
+    }
+    async emit(serviceName, method, params) {
+        return this.universalClient.emit(serviceName, method, params);
+    }
+    async publish(serviceName, method, params) {
+        return this.universalClient.publish(serviceName, method, params);
+    }
+    async broadcast(method, params) {
+        return this.universalClient.broadcast(method, params);
+    }
+    async subscribe(serviceName, method, options, handler) {
+        return this.universalClient.subscribe(serviceName, method, options, handler);
+    }
+    getAvailableServices() {
+        return this.universalClient.getAvailableServices();
+    }
+    getDiscoveredServices() {
+        return this.universalClient.getDiscoveredServices();
+    }
+    isServiceAvailable(serviceName) {
+        return this.universalClient.isServiceAvailable(serviceName);
+    }
+}
+exports.SocketClientBase = SocketClientBase;

package/dist/transports/socket-io/socket.config.d.ts

@@ -0,0 +1,8 @@
+import { NevoSocketClient, NevoSocketClientOptions } from "./nevo-socket.client";
+export interface SocketClientFactoryOptions extends NevoSocketClientOptions {
+    clientIdPrefix: string;
+}
+export declare const createNevoSocketClient: (serviceUrls: Record<string, string>, options: SocketClientFactoryOptions) => {
+    provide: string;
+    useFactory: () => Promise<NevoSocketClient>;
+};

package/dist/transports/socket-io/socket.config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNevoSocketClient = void 0;
+const nevo_socket_client_1 = require("./nevo-socket.client");
+const createNevoSocketClient = (serviceUrls, options) => {
+    return {
+        provide: "NEVO_SOCKET_CLIENT",
+        useFactory: async () => {
+            return new nevo_socket_client_1.NevoSocketClient(serviceUrls, {
+                ...options,
+                serviceName: options.serviceName || options.clientIdPrefix
+            });
+        }
+    };
+};
+exports.createNevoSocketClient = createNevoSocketClient;

package/dist/transports/socket-io/socket.signal-router.decorator.d.ts

@@ -0,0 +1,13 @@
+import { Type } from "@nestjs/common";
+import { SignalRouterOptions } from "../../signal-router.utils";
+export interface SocketSignalRouterOptions extends SignalRouterOptions {
+    port?: number;
+    path?: string;
+    cors?: any;
+    serviceName?: string;
+    discovery?: {
+        enabled?: boolean;
+        heartbeatIntervalMs?: number;
+    };
+}
+export declare function SocketSignalRouter(serviceType: Type<any> | Type<any>[], options?: SocketSignalRouterOptions): (target: any) => any;