alemonjs 2.1.18 → 2.1.20

package/lib/app/define-response.d.ts

@@ -1,5 +1,2 @@
 import { DefineResponseFunc } from '../types';
-export declare const lazy: <T extends {
-    default: any;
-}>(fnc: () => Promise<T>) => (() => Promise<T["default"]>);
 export declare const defineResponse: DefineResponseFunc;

package/lib/app/define-response.js

@@ -1,7 +1,3 @@
-const lazy = (fnc) => {
-    const back = async () => (await fnc()).default;
-    return back;
-};
 const defineResponse = responses => {
     return {
         current: responses
@@ -9,4 +5,4 @@ const defineResponse = responses => {
 };
 global.defineResponse = defineResponse;
 
-export { defineResponse, lazy };
+export { defineResponse };

package/lib/app/define-router.d.ts

@@ -0,0 +1,5 @@
+import { DefineRouterFunc } from '../types';
+export declare const lazy: <T extends {
+    default: any;
+}>(fnc: () => Promise<T>) => (() => Promise<T["default"]>);
+export declare const defineRouter: DefineRouterFunc;

package/lib/app/define-router.js

@@ -0,0 +1,20 @@
+const lazy = (fnc) => {
+    let c = null;
+    const back = async () => {
+        if (c) {
+            return c;
+        }
+        const mod = await fnc();
+        if (!mod || !mod.default) ;
+        c = mod.default;
+        return c;
+    };
+    return back;
+};
+const defineRouter = routes => {
+    return {
+        current: routes
+    };
+};
+
+export { defineRouter, lazy };

package/lib/app/event-processor-cycleRoute.js

@@ -4,6 +4,13 @@ import 'path';
 import 'yaml';
 import { showErrorModule } from '../core/utils.js';
 
+function isAsyncFunction(fn) {
+    const AsyncFunction = (async () => { }).constructor;
+    return fn instanceof AsyncFunction;
+}
+function isFunction(value) {
+    return isAsyncFunction(value) || typeof value === 'function' || value instanceof Function;
+}
 const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler) => {
     const processChildren = (nodes, middleware, next) => {
         if (!nodes || nodes.length === 0) {
@@ -25,11 +32,26 @@ const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler)
                     return;
                 }
             }
-            if (EventMessageText.includes(select) && node.regular) {
-                const reg = new RegExp(node.regular);
-                if (!reg.test(valueEvent['MessageText'])) {
-                    void nextNode();
-                    return;
+            if (EventMessageText.includes(select)) {
+                const text = valueEvent['MessageText'] ?? '';
+                if (node.exact !== undefined) {
+                    if (text !== node.exact) {
+                        void nextNode();
+                        return;
+                    }
+                }
+                if (node.prefix !== undefined) {
+                    if (!text.startsWith(node.prefix)) {
+                        void nextNode();
+                        return;
+                    }
+                }
+                if (node.regular) {
+                    const reg = new RegExp(node.regular);
+                    if (!reg.test(text)) {
+                        void nextNode();
+                        return;
+                    }
                 }
             }
             if (!node.handler) {
@@ -45,6 +67,10 @@ const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler)
                 const currents = [];
                 for (const item of currentsAndMiddleware) {
                     const app = await item();
+                    if (isFunction(app)) {
+                        currents.push(app);
+                        continue;
+                    }
                     const selects = Array.isArray(app.select) ? app.select : [app.select];
                     if (!selects.includes(select)) {
                         void nextNode();

package/lib/app/hook-use-api.d.ts

@@ -1,6 +1,6 @@
 import { DataEnums, EventKeys, Events, User } from '../types';
 import { Result } from '../core/utils';
-import { BT, MD } from './message-format';
+import { BT, Format, MD } from './message-format';
 type Options = {
     UserId?: string;
     UserKey?: string;
@@ -9,11 +9,15 @@ type Options = {
     IsBot?: boolean;
 };
 export declare const useMention: <T extends EventKeys>(event: Events[T]) => [{
-    find: (options: Options) => Promise<Result<User[]>>;
-    findOne: (options?: Options) => Promise<Result<User | null>>;
+    find: (options?: Options) => Promise<Result<User[]> & {
+        count: number;
+    }>;
+    findOne: (options?: Options) => Promise<Result<User | null> & {
+        count: number;
+    }>;
 }];
 export declare const useMessage: <T extends EventKeys>(event: Events[T]) => readonly [{
-    "__#7@#format": DataEnums[];
+    "__#8@#format": DataEnums[];
     readonly currentFormat: DataEnums[];
     addText(val: string, options?: {
         style?: "none" | "bold" | "block" | "strikethrough" | "boldItalic" | "italic";
@@ -36,12 +40,16 @@ export declare const useMessage: <T extends EventKeys>(event: Events[T]) => read
     }): any;
     addFormat(val: DataEnums[]): any;
     clear(): any;
-    send(val?: DataEnums[]): Promise<Result[]>;
+    send(params?: {
+        format: Format | DataEnums[];
+    } | DataEnums[]): Promise<Result[]>;
 }];
 export declare const useMember: <T extends EventKeys>(event: Events[T]) => readonly [{}];
 export declare const useChannel: <T extends EventKeys>(event: Events[T]) => readonly [{}];
 export declare const useSend: <T extends EventKeys>(event: Events[T]) => (...val: DataEnums[]) => Promise<Result[]>;
-export declare const useSends: <T extends EventKeys>(event: Events[T]) => readonly [(val?: DataEnums[]) => Promise<Result[]>];
+export declare const useSends: <T extends EventKeys>(event: Events[T]) => readonly [(params?: DataEnums[] | {
+    format: Format | DataEnums[];
+}) => Promise<Result[]>];
 export declare const unChildren: (name?: string) => void;
 export declare const onSelects: <T extends EventKeys[] | EventKeys>(values: T) => T;
 export declare const createSelects: <T extends EventKeys[] | EventKeys>(values: T) => T;

package/lib/app/hook-use-api.js

@@ -3,7 +3,7 @@ import { ChildrenApp } from './store.js';
 import { createResult } from '../core/utils.js';
 import { sendAction } from '../cbp/processor/actions.js';
 import { sendAPI } from '../cbp/processor/api.js';
-import { Text, Link, Image, ImageFile, ImageURL, Mention, BT, MD } from './message-format.js';
+import { Text, Link, Image, ImageFile, ImageURL, Mention, BT, MD, Format } from './message-format.js';
 
 const useMention = (event) => {
     if (!event || typeof event !== 'object') {
@@ -15,94 +15,80 @@ const useMention = (event) => {
         throw new Error('Invalid event: event must be an object');
     }
     let res = null;
+    const load = async () => {
+        if (res) {
+            return;
+        }
+        const results = await sendAction({
+            action: 'mention.get',
+            payload: { event }
+        });
+        const result = results.find(item => item.code === ResultCode.Ok);
+        if (result) {
+            res = result.data;
+        }
+    };
+    const match = (item, options) => {
+        if (options.UserId !== undefined && item.UserId !== options.UserId) {
+            return false;
+        }
+        if (options.UserKey !== undefined && item.UserKey !== options.UserKey) {
+            return false;
+        }
+        if (options.UserName !== undefined && item.UserName !== options.UserName) {
+            return false;
+        }
+        if (options.IsMaster !== undefined && item.IsMaster !== options.IsMaster) {
+            return false;
+        }
+        if (options.IsBot !== undefined && item.IsBot !== options.IsBot) {
+            return false;
+        }
+        if (options.IsBot === undefined && item.IsBot) {
+            return false;
+        }
+        return true;
+    };
     const mention = {
         find: async (options = {}) => {
             try {
-                if (!res) {
-                    const results = await sendAction({
-                        action: 'mention.get',
-                        payload: {
-                            event
-                        }
-                    });
-                    const result = results.find(item => item.code === ResultCode.Ok);
-                    if (result) {
-                        res = result.data;
-                    }
-                }
+                await load();
             }
             catch (err) {
-                return createResult(ResultCode.Fail, err?.message || 'Failed to get mention data', null);
+                const result = createResult(ResultCode.Fail, err?.message || 'Failed to get mention data', null);
+                return {
+                    ...result,
+                    count: 0
+                };
             }
             if (!Array.isArray(res)) {
-                return createResult(ResultCode.Warn, 'No mention data found', null);
+                return {
+                    ...createResult(ResultCode.Warn, 'No mention data found', null),
+                    count: 0
+                };
             }
-            const data = res.filter(item => {
-                if (options.UserId !== undefined && item.UserId !== options.UserId) {
-                    return false;
-                }
-                if (options.UserKey !== undefined && item.UserKey !== options.UserKey) {
-                    return false;
-                }
-                if (options.UserName !== undefined && item.UserName !== options.UserName) {
-                    return false;
-                }
-                if (options.IsMaster !== undefined && item.IsMaster !== options.IsMaster) {
-                    return false;
-                }
-                if (options.IsBot !== undefined && item.IsBot !== options.IsBot) {
-                    return false;
-                }
-                return true;
-            });
-            return createResult(ResultCode.Ok, 'Successfully retrieved mention data', data);
+            const data = res.filter(item => match(item, options));
+            const result = createResult(ResultCode.Ok, 'Successfully retrieved mention data', data);
+            return {
+                ...result,
+                count: data.length || 0
+            };
         },
         findOne: async (options = {}) => {
-            try {
-                if (!res) {
-                    const results = await sendAction({
-                        action: 'mention.get',
-                        payload: {
-                            event
-                        }
-                    });
-                    const result = results.find(item => item.code === ResultCode.Ok);
-                    if (result) {
-                        res = result.data;
-                    }
-                }
-            }
-            catch (err) {
-                return createResult(ResultCode.Fail, err?.message || 'Failed to get mention data', null);
-            }
-            if (!Array.isArray(res)) {
-                return createResult(ResultCode.Warn, 'No mention data found', null);
-            }
-            const data = res.find(item => {
-                if (options.UserId !== undefined && item.UserId !== options.UserId) {
-                    return false;
-                }
-                if (options.UserKey !== undefined && item.UserKey !== options.UserKey) {
-                    return false;
-                }
-                if (options.UserName !== undefined && item.UserName !== options.UserName) {
-                    return false;
-                }
-                if (options.IsMaster !== undefined && item.IsMaster !== options.IsMaster) {
-                    return false;
-                }
-                if (options.IsBot !== undefined && item.IsBot !== options.IsBot) {
-                    return false;
-                }
-                if (item.IsBot) {
-                    return false;
-                }
-                return true;
-            });
-            if (!data) {
-                return createResult(ResultCode.Warn, 'No mention data found', null);
+            const results = await mention.find(options);
+            if (results.code !== ResultCode.Ok || !results.data?.length) {
+                const result = createResult(results.code, results.message, null);
+                return {
+                    ...result,
+                    count: 0
+                };
             }
-            return createResult(ResultCode.Ok, 'Successfully retrieved mention data', data);
+            const data = results?.data[0];
+            const result = createResult(ResultCode.Ok, results.message, data);
+            return {
+                ...result,
+                count: results.data?.length || 0
+            };
         }
     };
     return [mention];
@@ -116,7 +102,13 @@ const useMessage = (event) => {
         });
         throw new Error('Invalid event: event must be an object');
     }
-    const send = async (val) => {
+    const resolveFormat = (params) => {
+        if (params.format instanceof Format) {
+            return params.format.value;
+        }
+        return params.format;
+    };
+    const sendRaw = async (val) => {
         if (!val || val.length === 0) {
             return [createResult(ResultCode.FailParams, 'Invalid val: val must be a non-empty array', null)];
         }
@@ -184,9 +176,15 @@ const useMessage = (event) => {
             this.#format = [];
             return this;
         }
-        send(val) {
-            const dataToSend = val && val.length > 0 ? val : this.#format;
-            return send(dataToSend);
+        send(params) {
+            if (!params) {
+                return sendRaw(this.#format);
+            }
+            if (Array.isArray(params)) {
+                const dataToSend = params.length > 0 ? params : this.#format;
+                return sendRaw(dataToSend);
+            }
+            return sendRaw(resolveFormat(params));
         }
     }
     return [new MessageController()];

package/lib/app/index.d.ts

@@ -4,6 +4,7 @@ export * from './define-children.js';
 export * from './define-platform.js';
 export * from './define-response.js';
 export * from './define-middleware.js';
+export * from './define-router.js';
 export * from './event-group.js';
 export * from './event-middleware';
 export * from './event-processor';

package/lib/app/index.js

@@ -3,8 +3,9 @@ export { loadModels, run } from './load_modules/load.js';
 export { loadChildren, loadChildrenFile } from './load_modules/loadChild.js';
 export { defineChildren } from './define-children.js';
 export { definePlatform } from './define-platform.js';
-export { defineResponse, lazy } from './define-response.js';
+export { defineResponse } from './define-response.js';
 export { defineMiddleware } from './define-middleware.js';
+export { defineRouter, lazy } from './define-router.js';
 export { onGroup } from './event-group.js';
 export { OnMiddleware, onMiddleware } from './event-middleware.js';
 export { OnProcessor, onProcessor } from './event-processor.js';
@@ -17,4 +18,4 @@ export { createSelects, onSelects, unChildren, useChannel, useClient, useMe, use
 export { onState, unState, useState } from './hook-use-state.js';
 export { useObserver, useSubscribe } from './hook-use-subscribe.js';
 export { createDataFormat, createEventValue, format, getMessageIntent, sendToChannel, sendToUser } from './message-api.js';
-export { Ark, BT, Image, ImageFile, ImageURL, Link, MD, Mention, Text } from './message-format.js';
+export { Ark, BT, Format, Image, ImageFile, ImageURL, Link, MD, Mention, Text, createEvent } from './message-format.js';

package/lib/app/load_modules/loadChild.js

@@ -64,7 +64,7 @@ const loadChildren = async (mainPath, appName) => {
         }
         const registerMounted = async () => {
             const res = await app?.register();
-            if (res && res?.response) {
+            if (res && (res?.response || res?.middleware || res?.responseRouter || res?.middlewareRouter)) {
                 App.register(res);
             }
             App.on();

package/lib/app/message-format.d.ts

@@ -1,4 +1,4 @@
-import { DataMention, DataImage, DataText, DataImageURL, DataImageFile, ButtonRow, DataButtonGroup, DataButton, DataArkList, DataArkListTip, DataArkListContent, DataArkListItem, DataArkCard, DataArkBigCard, DataMarkdownTemplate, DataMarkDown, DataMarkdownTitle, DataMarkdownSubtitle, DataMarkdownBold, DataMarkdownItalic, DataMarkdownItalicStar, DataMarkdownStrikethrough, DataMarkdownLink, DataMarkdownImage, DataMarkdownList, DataMarkdownListItem, DataMarkdownBlockquote, DataMarkdownDivider, DataMarkdownNewline, DataLink, DataMarkdownText, DataButtonTemplate, DataMarkdownCode } from '../types';
+import { DataMention, DataImage, DataText, DataImageURL, DataImageFile, ButtonRow, DataButtonGroup, DataButton, DataArkList, DataArkListTip, DataArkListContent, DataArkListItem, DataArkCard, DataArkBigCard, DataMarkdownTemplate, DataMarkDown, DataMarkdownTitle, DataMarkdownSubtitle, DataMarkdownBold, DataMarkdownItalic, DataMarkdownItalicStar, DataMarkdownStrikethrough, DataMarkdownLink, DataMarkdownImage, DataMarkdownList, DataMarkdownListItem, DataMarkdownBlockquote, DataMarkdownDivider, DataMarkdownNewline, DataLink, DataMarkdownText, DataButtonTemplate, DataMarkdownCode, DataEnums, EventKeys, Events } from '../types';
 export declare const Text: (val: DataText["value"], options?: DataText["options"]) => DataText;
 export declare const Link: (val: DataLink["value"], options?: DataText["options"]) => DataText;
 export declare const ImageURL: (val: DataImageURL["value"]) => DataImageURL;
@@ -48,3 +48,32 @@ declare const MD: {
     code(value: DataMarkdownCode["value"], options?: DataMarkdownCode["options"]): DataMarkdownCode;
 };
 export { MD };
+export declare class Format {
+    #private;
+    static create(): Format;
+    get value(): DataEnums[];
+    addText(...args: Parameters<typeof Text>): this;
+    addTextBreak(): this;
+    addLink(...args: Parameters<typeof Link>): this;
+    addImage(...args: Parameters<typeof Image>): this;
+    addImageFile(...args: Parameters<typeof ImageFile>): this;
+    addImageURL(...args: Parameters<typeof ImageURL>): this;
+    addMention(...args: Parameters<typeof Mention>): this;
+    addButtonGroup(...args: Parameters<typeof BT.group>): this;
+    addButtonTemplate(...args: Parameters<typeof BT.template>): this;
+    addMarkdown(...args: Parameters<typeof MD>): this;
+    addMarkdownTemplate(...args: Parameters<typeof MD.template>): this;
+    clear(): this;
+}
+export declare function createEvent<T extends EventKeys>(options: {
+    event: any;
+    selects: T | T[];
+    regular?: RegExp;
+    prefix?: string;
+    exact?: string;
+}): Events[T] & {
+    selects: boolean;
+    regular: boolean;
+    prefix: boolean;
+    exact: boolean;
+};

package/lib/app/message-format.js

@@ -213,5 +213,86 @@ MD.code = (value, options) => {
         options: options
     };
 };
+class Format {
+    #data = [];
+    static create() {
+        return new Format();
+    }
+    get value() {
+        return this.#data;
+    }
+    addText(...args) {
+        this.#data.push(Text(...args));
+        return this;
+    }
+    addTextBreak() {
+        this.#data.push(Text('\n'));
+        return this;
+    }
+    addLink(...args) {
+        this.#data.push(Link(...args));
+        return this;
+    }
+    addImage(...args) {
+        this.#data.push(Image(...args));
+        return this;
+    }
+    addImageFile(...args) {
+        this.#data.push(ImageFile(...args));
+        return this;
+    }
+    addImageURL(...args) {
+        this.#data.push(ImageURL(...args));
+        return this;
+    }
+    addMention(...args) {
+        this.#data.push(Mention(...args));
+        return this;
+    }
+    addButtonGroup(...args) {
+        this.#data.push(BT.group(...args));
+        return this;
+    }
+    addButtonTemplate(...args) {
+        this.#data.push(BT.template(...args));
+        return this;
+    }
+    addMarkdown(...args) {
+        this.#data.push(MD(...args));
+        return this;
+    }
+    addMarkdownTemplate(...args) {
+        this.#data.push(MD.template(...args));
+        return this;
+    }
+    clear() {
+        this.#data = [];
+        return this;
+    }
+}
+function createEvent(options) {
+    const { event, selects, regular, prefix, exact } = options;
+    const { name, MessageText } = event || {};
+    const selectsArr = Array.isArray(selects) ? selects : [selects];
+    const o = {
+        selects: false,
+        regular: false,
+        prefix: false,
+        exact: false
+    };
+    if (selectsArr.includes(name)) {
+        o.selects = true;
+    }
+    if (exact && MessageText && MessageText === exact) {
+        o.exact = true;
+    }
+    if (prefix && MessageText?.startsWith(prefix)) {
+        o.prefix = true;
+    }
+    if (regular && MessageText && new RegExp(regular).test(MessageText)) {
+        o.regular = true;
+    }
+    return { ...event, ...o };
+}
 
-export { Ark, BT, Image, ImageFile, ImageURL, Link, MD, Mention, Text };
+export { Ark, BT, Format, Image, ImageFile, ImageURL, Link, MD, Mention, Text, createEvent };

package/lib/app/store.js

@@ -152,7 +152,13 @@ class ResponseRouter {
             if (!alemonjsCore.storeChildrenApp[key].register) {
                 return [];
             }
-            return alemonjsCore.storeChildrenApp[key].register?.response?.current ?? [];
+            if (alemonjsCore.storeChildrenApp[key].register?.responseRouter) {
+                return alemonjsCore.storeChildrenApp[key].register?.responseRouter?.current ?? [];
+            }
+            if (alemonjsCore.storeChildrenApp[key].register?.response) {
+                return alemonjsCore.storeChildrenApp[key].register?.response?.current ?? [];
+            }
+            return [];
         });
         return data.flat();
     }
@@ -163,7 +169,13 @@ class MiddlewareRouter {
             if (!alemonjsCore.storeChildrenApp[key].register) {
                 return [];
             }
-            return alemonjsCore.storeChildrenApp[key].register?.middleware?.current ?? [];
+            if (alemonjsCore.storeChildrenApp[key].register?.middlewareRouter) {
+                return alemonjsCore.storeChildrenApp[key].register?.middlewareRouter?.current ?? [];
+            }
+            if (alemonjsCore.storeChildrenApp[key].register?.middleware) {
+                return alemonjsCore.storeChildrenApp[key].register?.middleware?.current ?? [];
+            }
+            return [];
         });
         return data.flat();
     }

package/lib/index.js

@@ -10,8 +10,9 @@ export { loadModels, run } from './app/load_modules/load.js';
 export { loadChildren, loadChildrenFile } from './app/load_modules/loadChild.js';
 export { defineChildren } from './app/define-children.js';
 export { definePlatform } from './app/define-platform.js';
-export { defineResponse, lazy } from './app/define-response.js';
+export { defineResponse } from './app/define-response.js';
 export { defineMiddleware } from './app/define-middleware.js';
+export { defineRouter, lazy } from './app/define-router.js';
 export { onGroup } from './app/event-group.js';
 export { OnMiddleware, onMiddleware } from './app/event-middleware.js';
 export { OnProcessor, onProcessor } from './app/event-processor.js';
@@ -24,5 +25,5 @@ export { createSelects, onSelects, unChildren, useChannel, useClient, useMe, use
 export { onState, unState, useState } from './app/hook-use-state.js';
 export { useObserver, useSubscribe } from './app/hook-use-subscribe.js';
 export { createDataFormat, createEventValue, format, getMessageIntent, sendToChannel, sendToUser } from './app/message-api.js';
-export { Ark, BT, Image, ImageFile, ImageURL, Link, MD, Mention, Text } from './app/message-format.js';
+export { Ark, BT, Format, Image, ImageFile, ImageURL, Link, MD, Mention, Text, createEvent } from './app/message-format.js';
 export { start } from './main.js';

package/lib/types/event/index.d.ts

@@ -40,6 +40,8 @@ export type OnGroupItem<C = any, T extends EventKeys = EventKeys> = OnResponseVa
 export type OnGroupFunc = <C, T extends EventKeys, TFirst extends OnGroupItem<C, T>>(...calls: [TFirst, ...Array<TFirst>]) => TFirst;
 export type ResponseRoute = {
     regular?: RegExp;
+    prefix?: string;
+    exact?: string;
     selects?: EventKeys | EventKeys[];
     handler: () => Promise<any>;
     children?: ResponseRoute[];
@@ -47,12 +49,17 @@ export type ResponseRoute = {
 export type DefineResponseFunc = (responses: ResponseRoute[]) => {
     current: ResponseRoute[];
 };
+export type DefineRouterFunc = (routes: ResponseRoute[]) => {
+    current: ResponseRoute[];
+};
 export type defineMiddlewareFunc = (middleware: ResponseRoute[]) => {
     current: ResponseRoute[];
 };
 export type childrenCallbackRes = {
     response?: ReturnType<DefineResponseFunc>;
     middleware?: ReturnType<defineMiddlewareFunc>;
+    responseRouter?: ReturnType<DefineRouterFunc>;
+    middlewareRouter?: ReturnType<DefineRouterFunc>;
 } | void;
 export type childrenCallback = ChildrenCycle & {
     register?: () => (childrenCallbackRes | void) | Promise<childrenCallbackRes | void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.18",
+  "version": "2.1.20",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",

package/lib/app/define-chidren.d.ts

@@ -1,2 +0,0 @@
-import { DefineChildrenFunc } from '../types';
-export declare const defineChildren: DefineChildrenFunc;

package/lib/app/define-chidren.js

@@ -1,19 +0,0 @@
-import { ResultCode } from '../core/variable.js';
-
-const defineChildren = callback => {
-    if (typeof callback === 'function' || typeof callback === 'object') {
-        return {
-            _name: 'app',
-            callback
-        };
-    }
-    logger.error({
-        code: ResultCode.FailParams,
-        message: 'Invalid callback: callback must be a object or function',
-        data: null
-    });
-    throw new Error('Invalid callback: callback must be a object or function');
-};
-global.defineChildren = defineChildren;
-
-export { defineChildren };

package/lib/cbp/core/connection-manager.d.ts

@@ -1,18 +0,0 @@
-import { WebSocket } from 'ws';
-export interface ConnectionState {
-    connections: Map<string, WebSocket>;
-    lastActivity: Map<string, number>;
-    metadata: Map<string, any>;
-}
-export declare const createConnectionState: () => ConnectionState;
-export declare const addConnection: (state: ConnectionState, id: string, ws: WebSocket, metadata?: any) => ConnectionState;
-export declare const removeConnection: (state: ConnectionState, id: string) => ConnectionState;
-export declare const getConnection: (state: ConnectionState, id: string) => WebSocket | undefined;
-export declare const getHealthyConnectionIds: (state: ConnectionState) => string[];
-export declare const getConnectionStats: (state: ConnectionState) => {
-    total: number;
-    healthy: number;
-    unhealthy: number;
-    lastUpdate: number;
-};
-export declare const clearAllConnections: (state: ConnectionState) => ConnectionState;