@bsb/events-rabbitmq 0.0.1

package/lib/plugins/events-rabbitmq/events/emitStreamAndReceiveStream.js

@@ -0,0 +1,515 @@
+import { EventEmitter } from "events";
+import { Readable } from "stream";
+import { randomUUID } from "crypto";
+import { LIB } from "./lib.js";
+import { BSBError } from "@bsb/base";
+export class emitStreamAndReceiveStream extends EventEmitter {
+    myEventsQueueKey() {
+        return LIB.getMyQueueKey(this.plugin, this.eventsChannelKey, this.plugin.myId);
+    }
+    myStreamQueueKey() {
+        return LIB.getMyQueueKey(this.plugin, this.streamChannelKey, this.plugin.myId);
+    }
+    cleanupSelf(streamId, key) {
+        this.removeAllListeners(this.eventsChannelKey + key + streamId);
+        this.removeAllListeners(this.streamChannelKey + key + streamId);
+    }
+    constructor(plugin) {
+        super();
+        this.staticCommsTimeout = 30000;
+        this.eventsChannelKey = "91se";
+        this.streamChannelKey = "91sd";
+        this.queueOpts = {
+            durable: false,
+            autoDelete: true,
+            messageTtl: 60 * 1000,
+            expires: 60 * 1000,
+        };
+        this.plugin = plugin;
+    }
+    dispose() {
+        this.removeAllListeners();
+        if (this.eventsChannel !== undefined) {
+            this.eventsChannel.channel.close();
+        }
+        if (this.streamChannel !== undefined) {
+            this.streamChannel.channel.close();
+        }
+    }
+    async setupChannel(obs, channel, channelKey, queueKeyMethod, logMessage) {
+        if (channel === undefined) {
+            const queueKey = queueKeyMethod();
+            channel = await LIB.setupChannel(this.plugin, obs, this.plugin.receiveConnection, channelKey, null, undefined, undefined, 2);
+            obs.log.debug("Ready {logMessage}: {queueKey}", { logMessage, queueKey });
+            await channel.channel.addSetup(async (iChannel) => {
+                await iChannel.assertQueue(queueKey, this.queueOpts);
+                obs.log.debug("LISTEN: [{queueKey}]", { queueKey });
+                await iChannel.consume(queueKey, async (msg) => {
+                    if (msg === null) {
+                        return obs.log.warn("[RECEIVED {queueKey}]... as null", {
+                            queueKey,
+                        });
+                    }
+                    try {
+                        const body = JSON.parse(msg.content.toString());
+                        obs.log.debug("[RECEIVED {logMessage} {queueKey}]", {
+                            logMessage,
+                            queueKey,
+                        });
+                        this.emit(channelKey +
+                            (logMessage === "stream" ? "r-" : "") +
+                            msg.properties.correlationId, body, () => iChannel.ack(msg), () => iChannel.nack(msg));
+                    }
+                    catch (exc) {
+                        obs.log.error("AMQP Consumed exception: {eMsg}", {
+                            eMsg: exc.message || exc.toString(),
+                        });
+                        throw new Error(`AMQP consume exception: ${exc.message || exc}`);
+                    }
+                }, { noAck: false });
+                obs.log.debug("LISTEN: [{queueKey}]", { queueKey });
+                obs.log.debug("Ready {logMessage} name: {queueKey} OKAY", {
+                    logMessage,
+                    queueKey,
+                });
+            });
+        }
+    }
+    async setupChannelsIfNotSetup(obs) {
+        await this.setupChannel(obs, this.eventsChannel, this.eventsChannelKey, this.myEventsQueueKey, "events");
+        await this.setupChannel(obs, this.streamChannel, this.streamChannelKey, this.myStreamQueueKey, "stream");
+    }
+    async receiveStream(obs, pluginName, event, listener, timeoutSeconds = 5) {
+        const streamId = `${randomUUID()}-${new Date().getTime()}`;
+        let thisTimeoutMS = this.staticCommsTimeout;
+        obs.log.debug("SR: listening to {streamId}", {
+            streamId,
+        });
+        const self = this;
+        let dstEventsQueueKey;
+        let streamObs = null;
+        return new Promise(async (resolve) => {
+            await self.setupChannelsIfNotSetup(obs);
+            let stream = null;
+            let lastResponseTimeoutHandler = null;
+            let lastResponseTimeoutCount = 1;
+            let receiptTimeoutHandler;
+            let createTimeout = async (e) => {
+                throw new BSBError(obs.trace, "not setup yet : createTimeout");
+            };
+            const cleanup = () => {
+                self.cleanupSelf(streamId, "r-");
+                createTimeout = async (e) => {
+                    obs.log.debug("voided timeout creator: {e}", { e });
+                };
+                obs.log.debug("Cleanup stuffR");
+                if (receiptTimeoutHandler !== null) {
+                    clearTimeout(receiptTimeoutHandler);
+                }
+                receiptTimeoutHandler = null;
+                if (lastResponseTimeoutHandler !== null) {
+                    clearTimeout(lastResponseTimeoutHandler);
+                }
+                lastResponseTimeoutHandler = null;
+                lastResponseTimeoutCount = -2;
+                if (stream !== null && !stream.destroyed) {
+                    stream.destroy();
+                }
+                if (streamObs) {
+                    streamObs.end();
+                }
+            };
+            receiptTimeoutHandler = setTimeout(async () => {
+                obs.log.debug("Receive Receipt Timeout");
+                const err = new Error("Receive Receipt Timeout");
+                cleanup();
+                if (!(await self.eventsChannel.channel.sendToQueue(dstEventsQueueKey, {
+                    type: "timeout",
+                    data: err,
+                    trace: streamObs?.trace ?? obs.trace,
+                }, {
+                    expiration: self.queueOpts.messageTtl,
+                    correlationId: "s-" + streamId,
+                    appId: self.plugin.myId,
+                    timestamp: new Date().getTime(),
+                }))) {
+                    throw `Cannot send msg to queue [${dstEventsQueueKey}]`;
+                }
+                await listener(streamObs ?? obs, err, null);
+            }, thisTimeoutMS);
+            const timeoutFunc = async () => {
+                if (lastResponseTimeoutHandler === null) {
+                    return;
+                }
+                if (lastResponseTimeoutCount === -2) {
+                    return;
+                }
+                if (lastResponseTimeoutCount > 0) {
+                    lastResponseTimeoutCount--;
+                    await createTimeout("timeoutFunc");
+                    return;
+                }
+                const err = new Error("Receive Active Timeout");
+                obs.log.error("Receive Active Timeout");
+                cleanup();
+                if (!(await self.eventsChannel.channel.sendToQueue(dstEventsQueueKey, {
+                    type: "timeout",
+                    data: err,
+                    trace: streamObs?.trace ?? obs.trace,
+                }, {
+                    expiration: self.queueOpts.messageTtl,
+                    correlationId: "s-" + streamId,
+                    appId: self.plugin.myId,
+                    timestamp: new Date().getTime(),
+                }))) {
+                    throw `Cannot send msg to queue [${dstEventsQueueKey}]`;
+                }
+                await listener(streamObs ?? obs, err, null);
+            };
+            createTimeout = async () => {
+                if (lastResponseTimeoutCount === -2) {
+                    return;
+                }
+                if (lastResponseTimeoutHandler === null) {
+                    lastResponseTimeoutHandler = setTimeout(timeoutFunc, thisTimeoutMS);
+                }
+            };
+            const updateLastResponseTimer = () => {
+                if (lastResponseTimeoutCount === -2) {
+                    return;
+                }
+                lastResponseTimeoutCount = 1;
+                createTimeout("updateLastResponseTimer");
+            };
+            const startStream = async () => {
+                obs.log.debug("START STREAM RECEIVER");
+                thisTimeoutMS = timeoutSeconds * 1000;
+                if (!(await self.eventsChannel.channel.sendToQueue(dstEventsQueueKey, { type: "receipt", timeout: thisTimeoutMS, trace: streamObs?.trace ?? obs.trace }, {
+                    expiration: self.queueOpts.messageTtl,
+                    correlationId: "s-" + streamId,
+                    appId: self.plugin.myId,
+                    timestamp: new Date().getTime(),
+                }))) {
+                    throw `Cannot send msg to queue [${dstEventsQueueKey}] ${streamId}`;
+                }
+                try {
+                    stream = new Readable({
+                        objectMode: true,
+                        async read() {
+                            if (!(await self.eventsChannel.channel.sendToQueue(dstEventsQueueKey, { type: "read", trace: streamObs?.trace ?? obs.trace }, {
+                                expiration: self.queueOpts.messageTtl,
+                                correlationId: "s-" + streamId,
+                                appId: self.plugin.myId,
+                                timestamp: new Date().getTime(),
+                            }))) {
+                                throw `Cannot send msg to queue [${dstEventsQueueKey}] ${streamId}`;
+                            }
+                        },
+                    });
+                    obs.log.debug("[R RECEVIED {streamRefId}] {streamId}", {
+                        streamRefId: dstEventsQueueKey,
+                        streamId,
+                    });
+                    const eventsToListenTo = [
+                        "error",
+                        "end",
+                    ];
+                    for (const evnt of eventsToListenTo) {
+                        stream.on(evnt, async (e) => {
+                            if (!(await self.eventsChannel.channel.sendToQueue(dstEventsQueueKey, {
+                                type: "event",
+                                event: evnt,
+                                data: e || null,
+                                trace: streamObs?.trace ?? obs.trace,
+                            }, {
+                                expiration: self.queueOpts.messageTtl,
+                                correlationId: "s-" + streamId,
+                                appId: self.plugin.myId,
+                                timestamp: new Date().getTime(),
+                            }))) {
+                                throw `Cannot send msg to queue [${dstEventsQueueKey}] ${streamId}`;
+                            }
+                            if (evnt === "end") {
+                                cleanup();
+                            }
+                        });
+                    }
+                    self.on(self.streamChannelKey + "r-" + streamId, async (data, ack, nack) => {
+                        if (data === null) {
+                            nack();
+                            return obs.log.debug("[R RECEVIED {streamId}]... as null", {
+                                streamId,
+                            });
+                        }
+                        if (!(await self.eventsChannel.channel.sendToQueue(dstEventsQueueKey, {
+                            type: "receipt",
+                            timeout: thisTimeoutMS,
+                            trace: streamObs?.trace ?? obs.trace,
+                        }, {
+                            expiration: self.queueOpts.messageTtl,
+                            correlationId: "s-" + streamId,
+                            appId: self.plugin.myId,
+                            timestamp: new Date().getTime(),
+                        }))) {
+                            throw `Cannot send msg to queue [${dstEventsQueueKey}] ${streamId}`;
+                        }
+                        if (data.type === "event") {
+                            stream.emit(data.event, data.data !== undefined ? data.data : null);
+                            ack();
+                            return;
+                        }
+                        if (data.type === "data") {
+                            stream.push(Buffer.from(data.data));
+                            ack();
+                            return;
+                        }
+                        nack();
+                    });
+                    listener(streamObs ?? obs, null, stream)
+                        .then(async () => {
+                        obs.log.info("stream OK");
+                    })
+                        .catch(async (x) => {
+                        cleanup();
+                        obs.log.error("Stream NOT OK: {e}", {
+                            e: x.message,
+                        });
+                        throw new Error(`Stream processing failed: ${x.message}`);
+                    });
+                }
+                catch (exc) {
+                    cleanup();
+                    obs.log.error("Stream NOT OK: {e}", {
+                        e: exc.message || exc,
+                    });
+                    throw new Error(`Stream setup failed: ${exc.message || exc}`);
+                }
+            };
+            self.on(self.eventsChannelKey + "r-" + streamId, async (data, ack, nack) => {
+                if (receiptTimeoutHandler !== null) {
+                    clearTimeout(receiptTimeoutHandler);
+                    receiptTimeoutHandler = null;
+                }
+                updateLastResponseTimer();
+                if (data === null) {
+                    return obs.log.debug(`[R RECEVIED {streamEventsRefId}]... as null`, { streamEventsRefId: dstEventsQueueKey });
+                }
+                if (data.type === "timeout") {
+                    cleanup();
+                    listener(streamObs ?? obs, data.data, null);
+                    ack();
+                    return;
+                }
+                if (data.type === "start") {
+                    const trace = data.trace ?? obs.trace;
+                    streamObs = this.plugin.createObservableFromTrace(trace, {
+                        pluginName,
+                        event,
+                        streamId,
+                    }).startSpan("stream.receive", { pluginName, event, streamId });
+                    obs.log.debug("Readying to stream from: {fromId}", {
+                        fromId: data.myId,
+                    });
+                    dstEventsQueueKey = LIB.getMyQueueKey(self.plugin, this.eventsChannelKey, data.myId);
+                    await startStream();
+                    obs.log.debug("Starting to stream");
+                    ack();
+                    return;
+                }
+                nack();
+            });
+            resolve(`${this.plugin.myId}||${streamId}||${timeoutSeconds}`);
+        });
+    }
+    async sendStream(obs, pluginName, event, streamIdf, stream) {
+        if (streamIdf.split("||").length !== 3) {
+            throw new BSBError(obs.trace, "invalid stream ID [{id}]", { id: streamIdf });
+        }
+        const streamReceiverId = streamIdf.split("||")[0];
+        const streamId = streamIdf.split("||")[1];
+        const streamTimeoutS = Number.parseInt(streamIdf.split("||")[2]);
+        let thisTimeoutMS = this.staticCommsTimeout;
+        const dstEventsQueueKey = LIB.getMyQueueKey(this.plugin, this.eventsChannelKey, streamReceiverId);
+        const dstStreamQueueKey = LIB.getMyQueueKey(this.plugin, this.streamChannelKey, streamReceiverId);
+        const self = this;
+        const sendObs = obs.startSpan("stream.send", { pluginName, event, streamId });
+        sendObs.log.info("SS: emitting to {dstEventsQueueKey}/{dstStreamQueueKey}", {
+            dstEventsQueueKey,
+            dstStreamQueueKey,
+        });
+        return new Promise(async (resolveI, rejectI) => {
+            await self.setupChannelsIfNotSetup(sendObs);
+            let lastResponseTimeoutHandler = null;
+            let lastResponseTimeoutCount = 1;
+            let receiptTimeoutHandler = setTimeout(() => {
+                reject(new Error("Send Receipt Timeout"));
+            }, thisTimeoutMS);
+            const cleanup = async (eType, e) => {
+                sendObs.log.debug("cleanup: {eType}", { eType });
+                self.cleanupSelf(streamId, "s-");
+                stream.destroy(e);
+                if (receiptTimeoutHandler !== null) {
+                    clearTimeout(receiptTimeoutHandler);
+                }
+                if (lastResponseTimeoutHandler !== null) {
+                    clearTimeout(lastResponseTimeoutHandler);
+                }
+                receiptTimeoutHandler = null;
+                lastResponseTimeoutHandler = null;
+                sendObs.end();
+            };
+            const reject = async (e) => {
+                await cleanup("reject-" + e.message, e);
+                sendObs.error(e);
+                rejectI(e);
+            };
+            const resolve = async () => {
+                await cleanup("resolved");
+                resolveI();
+            };
+            const updateLastResponseTimer = () => {
+                lastResponseTimeoutCount = 1;
+                if (lastResponseTimeoutHandler === null) {
+                    let createTimeout = () => {
+                        throw new BSBError(sendObs.trace, "not setup yet : createTimeout");
+                    };
+                    const timeoutFunc = async () => {
+                        if (lastResponseTimeoutCount > 0) {
+                            lastResponseTimeoutCount--;
+                            createTimeout();
+                            return;
+                        }
+                        sendObs.log.debug("Receive Receipt Timeout");
+                        const err = new Error("Receive Active Timeout");
+                        await cleanup("active-timeout");
+                        if (!(await self.eventsChannel.channel.sendToQueue(dstEventsQueueKey, {
+                            type: "timeout",
+                            data: err,
+                            trace: sendObs.trace,
+                        }, {
+                            expiration: self.queueOpts.messageTtl,
+                            correlationId: "r-" + streamId,
+                            appId: self.plugin.myId,
+                            timestamp: new Date().getTime(),
+                        }))) {
+                            throw `Cannot send msg to queue [${dstEventsQueueKey}]`;
+                        }
+                        rejectI(err);
+                    };
+                    createTimeout = () => {
+                        lastResponseTimeoutHandler = setTimeout(timeoutFunc, thisTimeoutMS);
+                    };
+                    createTimeout();
+                }
+            };
+            const eventsToListenTo = [
+                "error",
+                "end",
+            ];
+            for (const evnt of eventsToListenTo) {
+                stream.on(evnt, async (e, b, ack, nack) => {
+                    if (!(await self.streamChannel.channel.sendToQueue(dstStreamQueueKey, { type: "event", event: evnt, data: e || null, trace: sendObs.trace }, {
+                        expiration: self.queueOpts.messageTtl,
+                        correlationId: streamId,
+                        appId: self.plugin.myId,
+                        timestamp: new Date().getTime(),
+                    }))) {
+                        nack();
+                        throw `Cannot send msg to queue [${dstEventsQueueKey}] ${streamId}`;
+                    }
+                    ack();
+                    if (evnt === "error") {
+                        reject(e);
+                    }
+                });
+            }
+            let pushingData = false;
+            let streamStarted = false;
+            const pushData = async () => {
+                if (pushingData) {
+                    sendObs.log.warn("Stream tried pushing data, but not ready to push data!");
+                    return;
+                }
+                pushingData = true;
+                sendObs.log.warn("Switching to push data model.");
+                stream.on("data", async (data) => {
+                    if (!(await self.streamChannel.channel.sendToQueue(dstStreamQueueKey, { type: "data", data, trace: sendObs.trace }, {
+                        expiration: self.queueOpts.messageTtl,
+                        correlationId: streamId,
+                        appId: self.plugin.myId,
+                        timestamp: new Date().getTime(),
+                    }))) {
+                        pushingData = false;
+                        sendObs.log.error(`Cannot push msg to queue [{dstStreamQueueKey}] {streamId} / switch back to poll model.`, { dstStreamQueueKey, streamId });
+                    }
+                });
+            };
+            self.on(self.eventsChannelKey + "s-" + streamId, async (data, ack, nack) => {
+                if (receiptTimeoutHandler !== null) {
+                    clearTimeout(receiptTimeoutHandler);
+                    receiptTimeoutHandler = null;
+                }
+                updateLastResponseTimer();
+                if (data === null) {
+                    nack();
+                    return sendObs.log.debug(`[S RECEVIED {dstEventsQueueKey}]... as null`, { dstEventsQueueKey });
+                }
+                if (data.type === "timeout") {
+                    await reject(new Error("timeout-receiver"));
+                    return ack();
+                }
+                if (data.type === "receipt") {
+                    thisTimeoutMS = data.timeout;
+                    return ack();
+                }
+                if (data.type === "event") {
+                    if (data.event === "end") {
+                        ack();
+                        return resolve();
+                    }
+                    stream.emit(data.event, data.data || null, "RECEIVED");
+                    return ack();
+                }
+                if (data.type === "read") {
+                    if (pushingData) {
+                        return ack();
+                    }
+                    const readData = stream.read();
+                    if (!stream.readable || readData === null) {
+                        sendObs.log.info("Stream no longer readable.");
+                        if (!streamStarted) {
+                            await pushData();
+                        }
+                        return ack();
+                    }
+                    streamStarted = true;
+                    if (!(await self.streamChannel.channel.sendToQueue(dstStreamQueueKey, { type: "data", data: readData, trace: sendObs.trace }, {
+                        expiration: self.queueOpts.messageTtl,
+                        correlationId: streamId,
+                        appId: self.plugin.myId,
+                        timestamp: new Date().getTime(),
+                    }))) {
+                        nack();
+                        throw `Cannot send msg to queue [${dstStreamQueueKey}] ${streamId}`;
+                    }
+                    ack();
+                    return;
+                }
+                ack();
+            });
+            sendObs.log.info("SS: setup, ready {streamEventsRefId}", {
+                streamEventsRefId: dstEventsQueueKey,
+            });
+            if (!(await self.eventsChannel.channel.sendToQueue(dstEventsQueueKey, { type: "start", myId: self.plugin.myId, trace: sendObs.trace }, {
+                expiration: self.queueOpts.messageTtl,
+                correlationId: "r-" + streamId,
+                appId: self.plugin.myId,
+                timestamp: new Date().getTime(),
+            }))) {
+                throw `Cannot send msg to queue [${dstEventsQueueKey}]`;
+            }
+            thisTimeoutMS = streamTimeoutS * 1000;
+            sendObs.log.info("SS: emitted {dstEventsQueueKey} with timeout of {thisTimeoutMS}", { dstEventsQueueKey, thisTimeoutMS });
+        });
+    }
+}

package/lib/plugins/events-rabbitmq/events/lib.d.ts

@@ -0,0 +1,12 @@
+import * as amqplib from "amqp-connection-manager";
+import { Plugin } from "../index.js";
+import { Observable } from "@bsb/base";
+export interface SetupChannel<T extends string | null = string | null> {
+    exchangeName: T;
+    channel: amqplib.ChannelWrapper;
+}
+export declare class LIB {
+    static getQueueKey(plugin: Plugin, channelKey: string, pluginName: string, event: string, addKey?: string): string;
+    static getMyQueueKey(plugin: Plugin, channelKey: string, id: string, addKey?: string): string;
+    static setupChannel<T extends string | null>(plugin: Plugin, obs: Observable | null, connection: amqplib.AmqpConnectionManager, queueKey: string, exchangeName: T, exType?: string, exOpts?: amqplib.Options.AssertExchange, prefetch?: number, json?: boolean): Promise<SetupChannel<T>>;
+}

package/lib/plugins/events-rabbitmq/events/lib.js

@@ -0,0 +1,59 @@
+const isNil = (value) => value === null || value === undefined;
+export class LIB {
+    static getQueueKey(plugin, channelKey, pluginName, event, addKey) {
+        return `${plugin.getPlatformName(channelKey)}-${pluginName}-${event}${isNil(addKey) ? "" : `-${addKey}`}`;
+    }
+    static getMyQueueKey(plugin, channelKey, id, addKey) {
+        return `${plugin.getPlatformName(channelKey)}-${id}${isNil(addKey) ? "" : `-${addKey}`}`;
+    }
+    static async setupChannel(plugin, obs, connection, queueKey, exchangeName, exType, exOpts, prefetch, json = true) {
+        return new Promise(async (resolve) => {
+            const exName = isNil(exchangeName) || isNil(exType)
+                ? null
+                : plugin.getPlatformName(exchangeName);
+            let returned = false;
+            obs?.log.debug("Create channel ({queueKey})", { queueKey });
+            const channel = await connection.createChannel({
+                json,
+                setup: async (ichannel) => {
+                    if (exName !== null)
+                        await ichannel.assertExchange(exName, exType, exOpts);
+                    if (!isNil(prefetch)) {
+                        obs?.log.debug("prefetch ({queueKey}) {prefetch}", {
+                            queueKey,
+                            prefetch: prefetch,
+                        });
+                        await ichannel.prefetch(prefetch);
+                    }
+                    obs?.log.debug("setup exchange ({queueKey}) OK", {
+                        queueKey,
+                    });
+                    if (!returned) {
+                        resolve({
+                            exchangeName: exName,
+                            channel,
+                        });
+                        returned = true;
+                    }
+                },
+            });
+            channel.on("close", () => {
+                obs?.log.warn("AMQP channel ({queueKey}) close", { queueKey });
+            });
+            channel.on("error", (err) => {
+                obs?.log.error("AMQP channel ({queueKey}) error: {err}", {
+                    queueKey,
+                    err: err.message || err,
+                });
+                throw new Error(`AMQP channel (${queueKey}) error: ${err.message || err}`);
+            });
+            if (exName !== null)
+                obs?.log.debug("Assert exchange ({queueKey}) {exName} {exType}", {
+                    queueKey,
+                    exName,
+                    exType: exType,
+                });
+            obs?.log.debug("Ready ({queueKey})", { queueKey });
+        });
+    }
+}

package/lib/plugins/events-rabbitmq/index.d.ts

@@ -0,0 +1,55 @@
+import * as amqplib from "amqp-connection-manager";
+import { Readable } from "stream";
+import { BSBEvents, BSBEventsConstructor, Observable, DTrace } from "@bsb/base";
+import * as av from "anyvali";
+export declare const Config: import("@bsb/base").BSBPluginConfigClass<av.ObjectSchema<{
+    platformKey: av.NullableSchema<av.StringSchema>;
+    fatalOnDisconnect: av.BoolSchema;
+    prefetch: av.Int32Schema;
+    endpoints: av.ArraySchema<av.StringSchema>;
+    credentials: av.ObjectSchema<{
+        username: av.StringSchema;
+        password: av.StringSchema;
+    }>;
+    uniqueId: av.NullableSchema<av.StringSchema>;
+}>>;
+export declare class Plugin extends BSBEvents<InstanceType<typeof Config>> {
+    static Config: import("@bsb/base").BSBPluginConfigClass<av.ObjectSchema<{
+        platformKey: av.NullableSchema<av.StringSchema>;
+        fatalOnDisconnect: av.BoolSchema;
+        prefetch: av.Int32Schema;
+        endpoints: av.ArraySchema<av.StringSchema>;
+        credentials: av.ObjectSchema<{
+            username: av.StringSchema;
+            password: av.StringSchema;
+        }>;
+        uniqueId: av.NullableSchema<av.StringSchema>;
+    }>>;
+    publishConnection: amqplib.AmqpConnectionManager;
+    receiveConnection: amqplib.AmqpConnectionManager;
+    myId: string;
+    private ear;
+    private broadcast;
+    private emit;
+    private eas;
+    constructor(config: BSBEventsConstructor<InstanceType<typeof Config>>);
+    getPlatformName(name: string): string;
+    init(obs: Observable): Promise<void>;
+    createObservableFromTrace(trace?: DTrace, attributes?: Record<string, string | number | boolean>): Observable;
+    private _connectToAMQP;
+    dispose(): void;
+    onBroadcast(obs: Observable, pluginName: string, event: string, listener: {
+        (obs: Observable, args: any[]): Promise<void>;
+    }): Promise<void>;
+    emitBroadcast(obs: Observable, pluginName: string, event: string, args: any[]): Promise<void>;
+    onEvent(obs: Observable, pluginName: string, event: string, listener: {
+        (obs: Observable, args: any[]): Promise<void>;
+    }): Promise<void>;
+    emitEvent(obs: Observable, pluginName: string, event: string, args: any[]): Promise<void>;
+    onReturnableEvent(obs: Observable, pluginName: string, event: string, listener: {
+        (obs: Observable, args: any[]): Promise<any>;
+    }): Promise<void>;
+    emitEventAndReturn(obs: Observable, pluginName: string, event: string, timeoutSeconds: number, args: any[]): Promise<any>;
+    receiveStream(obs: Observable, pluginName: string, event: string, listener: (obs: Observable, error: Error | null, stream: Readable) => Promise<void>, timeoutSeconds?: number | undefined): Promise<string>;
+    sendStream(obs: Observable, pluginName: string, event: string, streamId: string, stream: Readable): Promise<void>;
+}