@peers-app/peers-sdk 0.1.4

package/dist/device/device.test.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const keys_1 = require("../keys");
+const device_1 = require("./device");
+describe(device_1.Device, () => {
+    it("should create a new device with valid keys", async () => {
+        const userId = (0, utils_1.newid)();
+        const device = new device_1.Device(userId);
+        expect(device.userId).toBe(userId);
+        expect(device.deviceId).toBeTruthy();
+        expect(device.publicKey).toBeTruthy();
+        expect(device.publicBoxKey).toBeTruthy();
+        const msg = "Hello, World!";
+        const signedMsg = device.signMessageWithSecretKey(msg);
+        expect(signedMsg).toBeTruthy();
+        const openedMsg = (0, keys_1.openMessageWithPublicKey)(signedMsg, device.publicKey);
+        expect(openedMsg).toBe(msg);
+        const obj = { msg };
+        const signedObj = device.signObjectWithSecretKey(obj);
+        expect(signedObj.contents).toEqual(obj);
+        const openedObj = (0, keys_1.openSignedObject)(signedObj);
+        expect(openedObj).toEqual(obj);
+        const userId2 = (0, utils_1.newid)();
+        const device2 = new device_1.Device(userId2);
+        {
+            const box = device.boxDataWithKeys(obj, device2.publicBoxKey);
+            expect(box).toBeTruthy();
+            const openedBox = device2.openBoxWithSecretKey(box);
+            expect(openedBox).toEqual(obj);
+        }
+        {
+            const box = device.boxDataForDevice(obj, device2);
+            expect(box).toBeTruthy();
+            const openedBox = device2.openBoxWithSecretKey(box);
+            expect(openedBox).toEqual(obj);
+        }
+    });
+    describe("handshakes", () => {
+        const userId1 = (0, utils_1.newid)();
+        const client = new device_1.Device(userId1);
+        const userId2 = (0, utils_1.newid)();
+        const server = new device_1.Device(userId2);
+        describe("getHandshake", () => {
+            it("should return a valid and correct handshake object", async () => {
+                const connectionId = (0, utils_1.newid)();
+                const handshake = client.getHandshake(connectionId, 'localhost');
+                expect(handshake.publicKey).toBe(client.publicKey);
+                expect(handshake.contents.userId).toBe(userId1);
+                expect(handshake.contents.publicKey).toBe(client.publicKey);
+                expect(handshake.contents.publicBoxKey).toBe(client.publicBoxKey);
+                expect(handshake.contents.connectionId).toBe(connectionId);
+            });
+        });
+        describe("handshakeResponse", () => {
+            it("should return a valid and correct handshake response object", async () => {
+                const connectionId = (0, utils_1.newid)();
+                const handshake = client.getHandshake(connectionId, 'localhost');
+                const handshakeResponse = server.handshakeResponse(handshake, connectionId, 'localhost');
+                expect(handshakeResponse.userId).toBe(userId2);
+                expect(handshakeResponse.deviceId).toBe(server.deviceId);
+                expect(handshakeResponse.publicKey).toBe(server.publicKey);
+                expect(handshakeResponse.publicBoxKey).toBe(server.publicBoxKey);
+                expect(handshakeResponse.connectionId).toBe(connectionId);
+            });
+            it("should detect when requests and responses are being forwarded through a different connection", async () => {
+                const c1 = {
+                    connectionId: (0, utils_1.newid)(),
+                };
+                const c2 = {
+                    connectionId: (0, utils_1.newid)(),
+                };
+                const handshake = client.getHandshake(c1.connectionId, 'localhost');
+                expect(() => server.handshakeResponse(handshake, c2.connectionId, 'localhost')).toThrow(/Invalid connectionId/);
+            });
+            it("should throw when the client can't unbox the data", async () => {
+                const c1 = {
+                    connectionId: (0, utils_1.newid)(),
+                };
+                const c2 = {
+                    connectionId: c1.connectionId,
+                };
+                const clientImposter = new device_1.Device(userId1, client.deviceId, {
+                    secretKey: (0, keys_1.newKeys)().secretKey,
+                    publicKey: client.publicKey,
+                    publicBoxKey: client.publicBoxKey
+                });
+                const handshake = clientImposter.getHandshake(c1.connectionId, 'localhost');
+                const response = server.handshakeResponse(handshake, c2.connectionId, 'localhost');
+                // expect(() =>  clientImposter.openBoxWithSecretKey(response)).toThrow(/Message was null or verification failed/);        
+            });
+            it("should detect when requests and responses are being forwarded through a different address", async () => {
+                const connToServer = {
+                    connectionId: (0, utils_1.newid)(),
+                };
+                const connToClient = {
+                    connectionId: connToServer.connectionId,
+                };
+                const manInTheMiddle = new device_1.Device(userId2);
+                // const mitmAddress = manInTheMiddle.publicAddress || manInTheMiddle.localAddress;
+                // const connToManInTheMiddle = {
+                //   connectionId: connToServer.connectionId,
+                //   remoteAddress: mitmAddress
+                // };
+                // // client is being intercepted 
+                // {
+                //   expect(() => {
+                //     doHandshake(client, connToManInTheMiddle, server, connToClient);
+                //   }).toThrow(/Invalid client address/);                  
+                // }
+                // // server is being intercepted 
+                // {
+                //   expect(() => {
+                //     doHandshake(client, connToServer, server, connToManInTheMiddle);
+                //   }).toThrow(/Invalid server address/);        
+                // }
+            });
+        });
+    });
+});
+/*
+describe(ServerDevice, () => {
+  describe("newConnection", () => {
+    it("should create a new connection with a valid server device and valid client device", async () => {
+      const serverDevice = new Device();
+      const server = new ServerDevice(serverDevice);
+
+      const clientDevice = new Device();
+
+      let conn = await server.newConnection(clientDevice.address);
+
+      // don't allow RPC calls to the server before the handshake is complete
+      {
+        const result: any = await conn.rpcCall('ping', {}).catch((err) => err);
+        expect(result?.message).toMatch(/Connection not verified/);
+      }
+
+      const handshakeSigned = clientDevice.getHandshake({ connectionId: conn.connectionId, remoteAddress: serverDevice.address });
+      const handshakeBoxed = clientDevice.boxDataForDevice(handshakeSigned, serverDevice);
+      const responseBox = await conn.completeHandshake(handshakeBoxed);
+      const responseSigned = clientDevice.openBoxWithSecretKey(responseBox);
+      const response = openSignedObject(responseSigned) as IDeviceHandshake;
+      expect(response.userId).toBe(serverDevice.userId);
+      expect(response.deviceId).toBe(serverDevice.deviceId);
+      expect(response.publicKey).toBe(serverDevice.publicKey);
+      expect(response.publicBoxKey).toBe(serverDevice.publicBoxKey);
+      expect(response.localAddress).toBe(serverDevice.localAddress);
+      expect(response.publicAddress).toBe(serverDevice.publicAddress);
+      expect(response.connectionId).toBe(conn.connectionId);
+      expect(response.remoteAddress).toBe(clientDevice.address);
+
+      conn = await server.getConnection(conn.connectionId);
+
+      expect(conn.server).toEqual({
+        userId: serverDevice.userId,
+        deviceId: serverDevice.deviceId,
+        publicKey: serverDevice.publicKey,
+        publicBoxKey: serverDevice.publicBoxKey
+      });
+      expect(conn.client).toEqual({
+        userId: clientDevice.userId,
+        deviceId: clientDevice.deviceId,
+        publicKey: clientDevice.publicKey,
+        publicBoxKey: clientDevice.publicBoxKey
+      });
+      expect(conn.clientAddress).toBe(clientDevice.address);
+      expect(conn.secure).toBe(true);
+      expect(conn.verified).toBe(true);
+
+      // allow RPC calls to the server after the handshake is complete
+      {
+        const result: any = await conn.rpcCall('ping', {}).catch((err) => err);
+        expect(result).toBe('pong');
+      }
+    });
+
+    it("should leave connections as insecure if the remoteAddress doesn't match", async () => {
+      const serverDevice = new Device();
+      const server = new ServerDevice(serverDevice);
+
+      const clientDevice = new Device();
+
+      let conn = await server.newConnection(clientDevice.address);
+
+      const handshakeSigned = clientDevice.getHandshake({ connectionId: conn.connectionId, remoteAddress: 'using proxy' });
+      const handshakeBoxed = clientDevice.boxDataForDevice(handshakeSigned, serverDevice);
+      const responseBox = await conn.completeHandshake(handshakeBoxed);
+      const response = clientDevice.openBoxedAndSignedData(responseBox) as IDeviceHandshake;
+      expect(response.userId).toBe(serverDevice.userId);
+
+      conn = await server.getConnection(conn.connectionId);
+      
+      expect(conn.verified).toBe(true);
+      expect(conn.secure).toBe(false);
+
+      // confirm responses are signed and boxed
+      const resultBox = await conn.rpcCall('ping', {}).catch((err) => err) as IDataBox;
+      const result = clientDevice.openBoxedAndSignedData(resultBox);
+      expect(result).toBe('pong');
+    });
+  });
+})
+*/ 

package/dist/device/get-trust-level.d.ts

@@ -0,0 +1,3 @@
+import { IDeviceInfo, IUser } from "../data";
+import { TrustLevel } from "./socket.type";
+export declare function getTrustLevelFn(me: IUser, serverUrl?: string): (deviceInfo: IDeviceInfo, registerNew?: boolean) => Promise<TrustLevel>;

package/dist/device/get-trust-level.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrustLevelFn = getTrustLevelFn;
+const data_1 = require("../data");
+const socket_type_1 = require("./socket.type");
+function getTrustLevelFn(me, serverUrl) {
+    return async function getTrustLevel(deviceInfo, registerNew) {
+        if (deviceInfo.userId === me.userId && deviceInfo.publicKey === me.publicKey && deviceInfo.publicBoxKey === me.publicBoxKey) {
+            if (deviceInfo.deviceId === (0, data_1.thisDeviceId)()) {
+                // return TrustLevel.Untrusted;
+            }
+            return socket_type_1.TrustLevel.Trusted;
+        }
+        // await Devices().delete(deviceInfo.deviceId);
+        let [user, device] = await Promise.all([
+            (0, data_1.Users)().get(deviceInfo.userId),
+            (0, data_1.Devices)().get(deviceInfo.deviceId),
+        ]);
+        if (user && device && !(deviceInfo.userId === device.userId && deviceInfo.userId === user.userId && deviceInfo.publicKey === user.publicKey && deviceInfo.publicBoxKey === user.publicBoxKey)) {
+            console.error(new Date().toISOString(), 'deviceInfo does not align with local info about user and device', { deviceInfo, user, device });
+            // TODO check if user has changed their public keys
+            return socket_type_1.TrustLevel.Untrusted;
+        }
+        if (user?.trustLevel && user.trustLevel >= socket_type_1.TrustLevel.Trusted && device?.trustLevel && device.trustLevel >= socket_type_1.TrustLevel.Trusted) {
+            device.lastSeen = new Date();
+            await (0, data_1.Devices)().update(device);
+            return socket_type_1.TrustLevel.Trusted;
+        }
+        let trustLevel = device?.trustLevel ?? socket_type_1.TrustLevel.Known;
+        if (!device) {
+            device = {
+                deviceId: deviceInfo.deviceId,
+                userId: deviceInfo.userId,
+                firstSeen: new Date(),
+                lastSeen: new Date(),
+                serverUrl,
+                trustLevel: socket_type_1.TrustLevel.Unknown,
+            };
+            trustLevel = socket_type_1.TrustLevel.NewDevice;
+        }
+        else {
+            device.lastSeen = new Date();
+        }
+        let newUser = false;
+        if (!user) {
+            user = {
+                userId: deviceInfo.userId,
+                publicKey: deviceInfo.publicKey,
+                publicBoxKey: deviceInfo.publicBoxKey,
+                name: serverUrl || deviceInfo.userId,
+            };
+            trustLevel = socket_type_1.TrustLevel.NewUser;
+            newUser = true;
+        }
+        let remoteTrustLevel = socket_type_1.TrustLevel.Unknown;
+        // TODO - reimplement this, checks with peers to see if this is an untrusted device
+        // for (const [serverUrl, conn] of Object.entries(getActiveConnections())) {
+        //   if (conn.trustLevel >= TrustLevel.Trusted) {
+        //     const _remoteTrustLevel: TrustLevel = await conn.emit('getTrustLevel', deviceInfo).catch(err => {
+        //       console.error(new Date().toISOString(), 'Error getting trust level from server', serverUrl, err);
+        //       return TrustLevel.Unknown;
+        //     });
+        //     console.log(new Date().toISOString(), 'Remote trust level', { _remoteTrustLevel, serverUrl, remoteUrlBeingChecked: serverUrl });
+        //     if (_remoteTrustLevel < TrustLevel.Unknown) {
+        //       console.error(new Date().toISOString(), 'Unverified user failed trust check', { user, remoteTrustLevel });
+        //       device.trustLevel = _remoteTrustLevel;
+        //       await Devices().save(device);
+        //       return device.trustLevel;
+        //     }
+        //     if (_remoteTrustLevel > TrustLevel.Unknown) {
+        //       remoteTrustLevel = Math.min(_remoteTrustLevel, device.trustLevel);
+        //       break;
+        //     }
+        //   }
+        // }
+        if (remoteTrustLevel > socket_type_1.TrustLevel.Unknown && !user.trustLevel) {
+            user.trustLevel = socket_type_1.TrustLevel.Known;
+            await (0, data_1.Users)().save(user);
+        }
+        else if (newUser) {
+            await (0, data_1.Users)().insert(user);
+        }
+        device.trustLevel = remoteTrustLevel || trustLevel;
+        await (0, data_1.Devices)().save(device);
+        return device.trustLevel;
+    };
+}

package/dist/device/socket.type.d.ts

@@ -0,0 +1,20 @@
+export declare const DEFAULT_MAX_CHUNK_SIZE: number;
+export type RPCCallback = (error?: any, result?: any) => void;
+export interface ISocket {
+    id?: string;
+    connected?: boolean;
+    emit(eventName: string, args: any, callback: RPCCallback): void;
+    on(eventName: string, handler: ((...args: any[]) => void)): void;
+    removeAllListeners(eventName: string): void;
+    disconnect(): void;
+}
+export declare enum TrustLevel {
+    Malicious = -20,
+    Untrusted = -10,
+    Unknown = 0,
+    NewUser = 10,
+    NewDevice = 20,
+    Known = 30,
+    Trusted = 50,
+    Self = 100
+}

package/dist/device/socket.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrustLevel = exports.DEFAULT_MAX_CHUNK_SIZE = void 0;
+exports.DEFAULT_MAX_CHUNK_SIZE = 1024 * 1024; // 1MB
+var TrustLevel;
+(function (TrustLevel) {
+    TrustLevel[TrustLevel["Malicious"] = -20] = "Malicious";
+    TrustLevel[TrustLevel["Untrusted"] = -10] = "Untrusted";
+    TrustLevel[TrustLevel["Unknown"] = 0] = "Unknown";
+    TrustLevel[TrustLevel["NewUser"] = 10] = "NewUser";
+    TrustLevel[TrustLevel["NewDevice"] = 20] = "NewDevice";
+    TrustLevel[TrustLevel["Known"] = 30] = "Known";
+    TrustLevel[TrustLevel["Trusted"] = 50] = "Trusted";
+    TrustLevel[TrustLevel["Self"] = 100] = "Self";
+})(TrustLevel || (exports.TrustLevel = TrustLevel = {}));

package/dist/device/streamed-socket.d.ts

@@ -0,0 +1,27 @@
+import { ISocket, RPCCallback } from "./socket.type";
+export interface IMessageChunk {
+    messageId: string;
+    chunkIndex: number;
+    totalChunks?: number;
+    eventName?: string;
+    data: string;
+}
+export declare class StreamedSocket implements ISocket {
+    readonly socket: ISocket;
+    maxChunkSize: number;
+    readonly safeSocketChunkEventName = "__streamed-socket-chunk";
+    readonly safeSocketResponseEventName = "__streamed-socket-response";
+    constructor(socket: ISocket, maxChunkSize?: number);
+    get id(): string | undefined;
+    get connected(): boolean | undefined;
+    disconnect(): void;
+    private readonly callbacks;
+    emit(eventName: string, args: any, callback: RPCCallback): void;
+    private handlers;
+    on(eventName: string, handler: ((...args: any[]) => void)): void;
+    removeAllListeners(eventName: string): void;
+    private readonly chunkBuffers;
+    private handleChunk;
+    private processChunks;
+    private handleResponse;
+}

package/dist/device/streamed-socket.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamedSocket = void 0;
+const lodash_1 = require("lodash");
+const serial_json_1 = require("../serial-json");
+const utils_1 = require("../utils");
+const socket_type_1 = require("./socket.type");
+class StreamedSocket {
+    socket;
+    maxChunkSize;
+    safeSocketChunkEventName = '__streamed-socket-chunk';
+    safeSocketResponseEventName = '__streamed-socket-response';
+    constructor(socket, maxChunkSize = socket_type_1.DEFAULT_MAX_CHUNK_SIZE) {
+        this.socket = socket;
+        this.maxChunkSize = maxChunkSize;
+        socket.on(this.safeSocketChunkEventName, (chunk) => this.handleChunk(chunk));
+    }
+    get id() {
+        return this.socket.id;
+    }
+    get connected() {
+        return this.socket.connected;
+    }
+    disconnect() {
+        this.socket.disconnect();
+    }
+    callbacks = {};
+    emit(eventName, args, callback) {
+        const strArgs = (0, serial_json_1.toJSONString)(args);
+        // if (strArgs.length < this.maxChunkSize) {
+        //   // If the data is small enough, send it directly
+        //   this.socket.emit(eventName, args, callback);
+        //   return;
+        // }
+        const messageId = (0, utils_1.newid)();
+        if (callback !== lodash_1.noop) {
+            this.callbacks[messageId] = callback;
+        }
+        const chunks = [];
+        for (let i = 0; i < strArgs.length; i += this.maxChunkSize) {
+            const chunkData = strArgs.slice(i, i + this.maxChunkSize);
+            chunks.push({
+                messageId,
+                chunkIndex: Math.floor(i / this.maxChunkSize),
+                data: chunkData
+            });
+            if (i === 0) {
+                // The first chunk contains metadata about the chunks
+                chunks[0].eventName = eventName;
+                chunks[0].totalChunks = Math.ceil(strArgs.length / this.maxChunkSize);
+            }
+        }
+        if (chunks.length > 1) {
+            console.debug(`Sending ${chunks.length} chunks for event ${eventName} with messageId ${messageId}`);
+        }
+        for (const chunk of chunks) {
+            // TODO on error or timeout retry
+            this.socket.emit(this.safeSocketChunkEventName, chunk, lodash_1.noop);
+        }
+    }
+    handlers = {};
+    on(eventName, handler) {
+        this.handlers[eventName] = handler;
+        // TODO I think this needs to come back to a handleResult method on this class
+        this.socket.on(eventName, handler);
+    }
+    removeAllListeners(eventName) {
+        this.socket.removeAllListeners(eventName);
+        delete this.handlers[eventName];
+    }
+    chunkBuffers = {};
+    async handleChunk(chunk) {
+        if (!this.chunkBuffers[chunk.messageId]) {
+            // TODO handle timeout for chunks and cleanup data to prevent memory leaks
+            this.chunkBuffers[chunk.messageId] = [];
+        }
+        const chunks = this.chunkBuffers[chunk.messageId];
+        const chunkIndex = chunk.chunkIndex;
+        if (chunkIndex < 0) {
+            console.warn(`Received chunk with negative index ${chunk.chunkIndex} for messageId: ${chunk.messageId}`, chunk);
+            return;
+        }
+        chunks[chunkIndex] = chunk;
+        const chunkZero = chunks[0];
+        if (!chunkZero && chunks.length > 100) {
+            console.error(`Received over 100 chunks without a chunkZero for messageId: ${chunk.messageId}. This could indicate a memory attack`, chunk);
+        }
+        if (chunkZero) {
+            if (chunkZero?.totalChunks <= chunkIndex) {
+                console.warn(`Received chunk with index ${chunk.chunkIndex} which is greater than totalChunks ${chunkZero.totalChunks} for messageId: ${chunk.messageId}`, chunk);
+                return;
+            }
+            if (chunks.length >= chunkZero.totalChunks) {
+                this.processChunks(chunks);
+            }
+        }
+    }
+    async processChunks(chunks) {
+        try {
+            const chunkZero = chunks[0];
+            const strData = chunks.map(c => c.data).join('');
+            delete this.chunkBuffers[chunkZero.messageId];
+            const eventName = chunkZero.eventName;
+            const args = (0, serial_json_1.fromJSONString)(strData);
+            if (eventName === this.safeSocketResponseEventName) {
+                this.handleResponse(args.messageId, args.error, args.result);
+                return;
+            }
+            const handler = this.handlers[eventName];
+            if (!handler) {
+                throw new Error(`No handler registered for event ${eventName}`);
+            }
+            let error = undefined;
+            let result = undefined;
+            try {
+                await new Promise((resolve) => {
+                    handler(args, (...params) => {
+                        [error, result] = params;
+                        resolve();
+                    });
+                });
+            }
+            catch (err) {
+                error = err;
+            }
+            this.emit(this.safeSocketResponseEventName, {
+                messageId: chunkZero.messageId,
+                error,
+                result
+            }, lodash_1.noop);
+        }
+        catch (error) {
+            console.error(`Error handling chunked request:`, error);
+            return;
+        }
+    }
+    async handleResponse(messageId, error, result) {
+        const callback = this.callbacks[messageId];
+        if (!callback) {
+            console.warn(`No callback found for messageId ${messageId}`);
+        }
+        delete this.callbacks[messageId];
+        if (error) {
+            console.error(`Error in SafeSocket response for messageId ${messageId}:`, error);
+        }
+        try {
+            await callback(error, result);
+        }
+        catch (err) {
+            console.error(`Error in SafeSocket callback for messageId ${messageId}:`, err);
+        }
+    }
+}
+exports.StreamedSocket = StreamedSocket;

package/dist/device/streamed-socket.test.d.ts

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

package/dist/device/streamed-socket.test.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const streamed_socket_1 = require("./streamed-socket");
+const utils_1 = require("../utils");
+function createMockSocket() {
+    const emittedEvents = [];
+    const socket = {
+        id: (0, utils_1.newid)(),
+        emit(eventName, args, callback) {
+            emittedEvents.push({ eventName, args, callback });
+        },
+        on(eventName, handler) {
+            // Simple mock - we'll manually trigger events in tests
+        },
+        removeAllListeners(eventName) {
+            // Simple mock
+        },
+        disconnect() {
+            // Simple mock - we'll assume the socket is disconnected
+        },
+    };
+    return {
+        socket,
+        getEmittedEvents: () => emittedEvents
+    };
+}
+describe('StreamedSocket', () => {
+    it('should emit a single chunk for small messages', () => {
+        const mock = createMockSocket();
+        const streamedSocket = new streamed_socket_1.StreamedSocket(mock.socket, 1000); // Large chunk size
+        const testData = { message: 'hello' };
+        streamedSocket.emit('test-event', testData, () => { });
+        // Should emit a single chunk
+        const emittedEvents = mock.getEmittedEvents();
+        expect(emittedEvents).toHaveLength(1);
+        const chunkEvent = emittedEvents[0];
+        expect(chunkEvent.eventName).toBe('__streamed-socket-chunk');
+        expect(chunkEvent.args.messageId).toBeTruthy();
+        expect(chunkEvent.args.chunkIndex).toBe(0);
+        expect(chunkEvent.args.totalChunks).toBe(1);
+        expect(chunkEvent.args.eventName).toBe('test-event');
+        expect(JSON.parse(chunkEvent.args.data)).toEqual(testData);
+    });
+});

package/dist/events.d.ts

@@ -0,0 +1,35 @@
+import { IEventData } from "./rpc-types";
+export type IEventFilter = (event: IEventData) => boolean;
+export type IEventHandler<T = any> = (eventData: IEventData<T>) => boolean | void | Promise<boolean> | Promise<void>;
+export interface ISubscription {
+    filter: IEventFilter;
+    handler: IEventHandler;
+}
+export interface ISubscriptionResult {
+    unsubscribe: () => boolean;
+}
+export declare function subscribe<T = any>(nameOrFilter: string | IEventFilter, handler: IEventHandler<T>): ISubscriptionResult;
+export declare function subscribeDebounce<T = any>(nameOrFilter: string | IEventFilter, handler: IEventHandler<T>, debounceMs: number): ISubscriptionResult;
+export declare function emit(event: IEventData, dontPropagate?: boolean): Promise<boolean>;
+export type IHandler<T> = (data: T) => boolean | void | Promise<boolean> | Promise<void>;
+export interface IEvent<T> {
+    eventName: () => string;
+    subscribe: (handler: IHandler<T>) => ISubscriptionResult;
+    next: () => Promise<T>;
+    union: <U>(event: IEvent<U>) => IEvent<T | U>;
+}
+export declare class Event<T> implements IEvent<T> {
+    private _eventName;
+    constructor(_eventName: string);
+    eventName: () => string;
+    subscribe: (handler: IHandler<T>, debounceMs?: number) => ISubscriptionResult;
+    next: () => Promise<T>;
+    union: <U>(event: IEvent<U>) => IEvent<T | U>;
+}
+export declare class Emitter<T> {
+    readonly eventName: string;
+    constructor(eventName: string);
+    readonly event: Event<T>;
+    emit(data: T): Promise<boolean>;
+}
+export declare function unionEvents(...events: IEvent<any>[]): IEvent<any>;