@fluojs/microservices 1.0.0-beta.1

package/dist/transports/nats-transport.js

@@ -0,0 +1,218 @@
+import { logTransportEventHandlerFailure } from './event-handler-logger.js';
+
+/** Options for configuring the NATS microservice transport. */
+
+/**
+ * NATS transport for request-response messages and fire-and-forget event delivery.
+ *
+ * The adapter maps Fluo message traffic onto separate event and request subjects while
+ * preserving JSON framing and NATS request timeout behavior.
+ */
+export class NatsMicroserviceTransport {
+  closing = false;
+  handler;
+  logger;
+  listening = false;
+  eventSubject;
+  messageSubject;
+  pending = new Map();
+  requestTimeoutMs;
+  subscriptions = [];
+  logEventHandlerFailure(error) {
+    logTransportEventHandlerFailure(this.logger, 'NatsMicroserviceTransport', error);
+  }
+  handleEventMessageSafely(message) {
+    void this.handleEventMessage(message).catch(error => {
+      this.logEventHandlerFailure(error);
+    });
+  }
+
+  /**
+   * Creates a NATS transport using a client and codec supplied by the application.
+   *
+   * @param options Subject names, codec, client, and request-timeout settings.
+   */
+  constructor(options) {
+    this.options = options;
+    this.eventSubject = options.eventSubject ?? 'fluo.microservices.events';
+    this.messageSubject = options.messageSubject ?? 'fluo.microservices.messages';
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 3_000;
+  }
+  setLogger(logger) {
+    this.logger = logger;
+  }
+
+  /**
+   * Subscribes to the configured NATS event and message subjects.
+   *
+   * @param handler Runtime callback invoked for inbound event and message packets.
+   * @returns A promise that resolves once subscriptions are active.
+   */
+  async listen(handler) {
+    this.closing = false;
+    this.handler = handler;
+    if (this.listening) {
+      return;
+    }
+    const eventSubscription = this.options.client.subscribe(this.eventSubject, message => {
+      this.handleEventMessageSafely(message);
+    });
+    const messageSubscription = this.options.client.subscribe(this.messageSubject, message => {
+      void this.handleRequestMessage(message);
+    });
+    this.subscriptions = [eventSubscription, messageSubscription];
+    this.listening = true;
+  }
+
+  /**
+   * Sends one request-response message through NATS request/reply.
+   *
+   * @param pattern Pattern identifying the remote message handler.
+   * @param payload Serializable request payload.
+   * @returns The decoded remote handler response payload.
+   */
+  async send(pattern, payload) {
+    if (this.closing) {
+      throw new Error('NATS microservice transport is closing. Wait for close() to complete before send().');
+    }
+    if (!this.listening) {
+      throw new Error('NatsMicroserviceTransport is not listening. Call listen() before send().');
+    }
+    const request = {
+      kind: 'message',
+      pattern,
+      payload
+    };
+    const requestId = crypto.randomUUID();
+    return await new Promise((resolve, reject) => {
+      let settled = false;
+      const cleanup = () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        this.pending.delete(requestId);
+      };
+      const entry = {
+        reject: error => {
+          cleanup();
+          reject(error);
+        },
+        resolve: value => {
+          cleanup();
+          resolve(value);
+        }
+      };
+      this.pending.set(requestId, entry);
+      void Promise.resolve().then(async () => {
+        if (this.closing) {
+          entry.reject(new Error('NATS microservice transport closed before request dispatch.'));
+          return;
+        }
+        const responseMessage = await this.options.client.request(this.messageSubject, this.encode(request), {
+          timeout: this.requestTimeoutMs
+        });
+        const response = this.decode(responseMessage.data);
+        if (response.error) {
+          entry.reject(new Error(response.error));
+          return;
+        }
+        entry.resolve(response.payload);
+      }).catch(error => {
+        entry.reject(error instanceof Error ? error : new Error('Failed to send NATS request.'));
+      });
+    });
+  }
+
+  /**
+   * Emits one fire-and-forget event through the configured NATS event subject.
+   *
+   * @param pattern Pattern identifying the remote event handler.
+   * @param payload Serializable event payload.
+   * @returns A promise that resolves once the event is published.
+   */
+  async emit(pattern, payload) {
+    const event = {
+      kind: 'event',
+      pattern,
+      payload
+    };
+    this.options.client.publish(this.eventSubject, this.encode(event));
+  }
+
+  /**
+   * Unsubscribes from NATS subjects and closes the client when supported.
+   *
+   * @returns A promise that resolves once shutdown cleanup completes.
+   */
+  async close() {
+    this.closing = true;
+    let closeError;
+    try {
+      for (const subscription of this.subscriptions) {
+        subscription.unsubscribe();
+      }
+      this.options.client.close?.();
+    } catch (error) {
+      closeError = error;
+    } finally {
+      this.subscriptions = [];
+      this.listening = false;
+      this.handler = undefined;
+      for (const pending of [...this.pending.values()]) {
+        pending.reject(new Error('NATS microservice transport closed before response.'));
+      }
+    }
+    if (closeError) {
+      throw closeError;
+    }
+  }
+  async handleEventMessage(message) {
+    if (!this.handler) {
+      return;
+    }
+    const packet = this.decode(message.data);
+    if (packet.kind !== 'event') {
+      return;
+    }
+    try {
+      await this.handler({
+        kind: 'event',
+        pattern: packet.pattern,
+        payload: packet.payload
+      });
+    } catch (error) {
+      this.logEventHandlerFailure(error);
+    }
+  }
+  async handleRequestMessage(message) {
+    if (!this.handler) {
+      return;
+    }
+    const packet = this.decode(message.data);
+    if (packet.kind !== 'message') {
+      return;
+    }
+    try {
+      const payload = await this.handler({
+        kind: 'message',
+        pattern: packet.pattern,
+        payload: packet.payload
+      });
+      message.respond(this.encode({
+        payload
+      }));
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unhandled microservice error';
+      message.respond(this.encode({
+        error: errorMessage
+      }));
+    }
+  }
+  decode(data) {
+    return JSON.parse(this.options.codec.decode(data));
+  }
+  encode(value) {
+    return this.options.codec.encode(JSON.stringify(value));
+  }
+}

package/dist/transports/rabbitmq-transport.d.ts

@@ -0,0 +1,77 @@
+import type { MicroserviceTransport, TransportHandler } from '../types.js';
+interface RabbitMqConsumerLike {
+    consume(queue: string, handler: (message: string) => Promise<void> | void): Promise<void>;
+    cancel(queue: string): Promise<void>;
+}
+interface RabbitMqPublisherLike {
+    publish(queue: string, message: string): Promise<void>;
+}
+/** Options for configuring the RabbitMQ microservice transport. */
+export interface RabbitMqMicroserviceTransportOptions {
+    consumer: RabbitMqConsumerLike;
+    eventQueue?: string;
+    messageQueue?: string;
+    publisher: RabbitMqPublisherLike;
+    requestTimeoutMs?: number;
+    responseQueue?: string;
+}
+/**
+ * RabbitMQ transport for queue-backed request-response and event delivery.
+ *
+ * The adapter uses dedicated event, message, and response queues so applications can keep
+ * a queue-oriented topology while still consuming the generic Fluo transport API.
+ */
+export declare class RabbitMqMicroserviceTransport implements MicroserviceTransport {
+    private readonly options;
+    private handler;
+    private listening;
+    private listenPromise;
+    private readonly eventQueue;
+    private readonly messageQueue;
+    private readonly pending;
+    private readonly requestTimeoutMs;
+    private readonly responseQueue;
+    private readonly subscribedQueues;
+    /**
+     * Creates a RabbitMQ transport with explicit consumer and publisher collaborators.
+     *
+     * @param options Queue names and timeout settings for request-response traffic.
+     */
+    constructor(options: RabbitMqMicroserviceTransportOptions);
+    /**
+     * Starts consuming the configured event, message, and response queues.
+     *
+     * @param handler Runtime callback invoked for inbound event and message packets.
+     * @returns A promise that resolves once queue consumers are registered.
+     */
+    listen(handler: TransportHandler): Promise<void>;
+    /**
+     * Sends one request-response message through RabbitMQ.
+     *
+     * @param pattern Pattern identifying the remote message handler.
+     * @param payload Serializable request payload.
+     * @param signal Optional abort signal used to cancel the request.
+     * @returns The remote handler response payload.
+     */
+    send(pattern: string, payload: unknown, signal?: AbortSignal): Promise<unknown>;
+    /**
+     * Emits one fire-and-forget event through RabbitMQ.
+     *
+     * @param pattern Pattern identifying the remote event handler.
+     * @param payload Serializable event payload.
+     * @returns A promise that resolves once the event is published.
+     */
+    emit(pattern: string, payload: unknown): Promise<void>;
+    /**
+     * Cancels queue consumers and rejects any in-flight requests.
+     *
+     * @returns A promise that resolves once shutdown cleanup completes.
+     */
+    close(): Promise<void>;
+    private handleInboundMessage;
+    private handleRequest;
+    private handleResponse;
+    private rejectPendingRequests;
+}
+export {};
+//# sourceMappingURL=rabbitmq-transport.d.ts.map

package/dist/transports/rabbitmq-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rabbitmq-transport.d.ts","sourceRoot":"","sources":["../../src/transports/rabbitmq-transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE3E,UAAU,oBAAoB;IAC5B,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1F,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAED,UAAU,qBAAqB;IAC7B,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACxD;AAWD,mEAAmE;AACnE,MAAM,WAAW,oCAAoC;IACnD,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,qBAAqB,CAAC;IACjC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,qBAAa,6BAA8B,YAAW,qBAAqB;IAoB7D,OAAO,CAAC,QAAQ,CAAC,OAAO;IAnBpC,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAInB;IACL,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAqB;IAEtD;;;;OAIG;gBAC0B,OAAO,EAAE,oCAAoC;IAO1E;;;;;OAKG;IACG,MAAM,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IA2CtD;;;;;;;OAOG;IACG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAoErF;;;;;;OAMG;IACG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAU5D;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YA6Bd,oBAAoB;YAiCpB,aAAa;IAmC3B,OAAO,CAAC,cAAc;IAqBtB,OAAO,CAAC,qBAAqB;CAO9B"}

package/dist/transports/rabbitmq-transport.js

@@ -0,0 +1,263 @@
+/** Options for configuring the RabbitMQ microservice transport. */
+
+/**
+ * RabbitMQ transport for queue-backed request-response and event delivery.
+ *
+ * The adapter uses dedicated event, message, and response queues so applications can keep
+ * a queue-oriented topology while still consuming the generic Fluo transport API.
+ */
+export class RabbitMqMicroserviceTransport {
+  handler;
+  listening = false;
+  listenPromise;
+  eventQueue;
+  messageQueue;
+  pending = new Map();
+  requestTimeoutMs;
+  responseQueue;
+  subscribedQueues = new Set();
+
+  /**
+   * Creates a RabbitMQ transport with explicit consumer and publisher collaborators.
+   *
+   * @param options Queue names and timeout settings for request-response traffic.
+   */
+  constructor(options) {
+    this.options = options;
+    this.eventQueue = options.eventQueue ?? 'fluo.microservices.events';
+    this.messageQueue = options.messageQueue ?? 'fluo.microservices.messages';
+    this.responseQueue = options.responseQueue ?? `fluo.microservices.responses.${crypto.randomUUID()}`;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 3_000;
+  }
+
+  /**
+   * Starts consuming the configured event, message, and response queues.
+   *
+   * @param handler Runtime callback invoked for inbound event and message packets.
+   * @returns A promise that resolves once queue consumers are registered.
+   */
+  async listen(handler) {
+    this.handler = handler;
+    if (this.listening) {
+      return;
+    }
+    if (this.listenPromise) {
+      await this.listenPromise;
+      return;
+    }
+    this.listenPromise = (async () => {
+      const queues = new Set([this.eventQueue, this.messageQueue, this.responseQueue]);
+      try {
+        for (const queue of queues) {
+          await this.options.consumer.consume(queue, message => {
+            void this.handleInboundMessage(message).catch(() => undefined);
+          });
+          this.subscribedQueues.add(queue);
+        }
+      } catch (error) {
+        for (const queue of this.subscribedQueues) {
+          await this.options.consumer.cancel(queue).catch(() => undefined);
+        }
+        this.subscribedQueues.clear();
+        throw error;
+      }
+      this.listening = true;
+    })();
+    try {
+      await this.listenPromise;
+    } finally {
+      this.listenPromise = undefined;
+    }
+  }
+
+  /**
+   * Sends one request-response message through RabbitMQ.
+   *
+   * @param pattern Pattern identifying the remote message handler.
+   * @param payload Serializable request payload.
+   * @param signal Optional abort signal used to cancel the request.
+   * @returns The remote handler response payload.
+   */
+  async send(pattern, payload, signal) {
+    if (this.listenPromise) {
+      await this.listenPromise;
+    }
+    if (!this.listening) {
+      throw new Error('RabbitMqMicroserviceTransport is not listening. Call listen() before send().');
+    }
+    const requestId = crypto.randomUUID();
+    const message = {
+      kind: 'message',
+      pattern,
+      payload,
+      replyTo: this.responseQueue,
+      requestId
+    };
+    return await new Promise((resolve, reject) => {
+      let abortHandler;
+      const timeout = setTimeout(() => {
+        cleanup();
+        reject(new Error(`RabbitMQ request timed out after ${this.requestTimeoutMs}ms waiting for pattern "${pattern}".`));
+      }, this.requestTimeoutMs);
+      const cleanup = () => {
+        clearTimeout(timeout);
+        this.pending.delete(requestId);
+        if (abortHandler && signal) {
+          signal.removeEventListener('abort', abortHandler);
+        }
+      };
+      this.pending.set(requestId, {
+        reject: error => {
+          cleanup();
+          reject(error);
+        },
+        resolve: value => {
+          cleanup();
+          resolve(value);
+        },
+        timeout
+      });
+      if (signal) {
+        if (signal.aborted) {
+          cleanup();
+          reject(new Error('RabbitMQ request aborted before publish.'));
+          return;
+        }
+        abortHandler = () => {
+          cleanup();
+          reject(new Error('RabbitMQ request aborted.'));
+        };
+        signal.addEventListener('abort', abortHandler, {
+          once: true
+        });
+      }
+      void this.options.publisher.publish(this.messageQueue, JSON.stringify(message)).catch(error => {
+        cleanup();
+        reject(error instanceof Error ? error : new Error('Failed to publish RabbitMQ request.'));
+      });
+    });
+  }
+
+  /**
+   * Emits one fire-and-forget event through RabbitMQ.
+   *
+   * @param pattern Pattern identifying the remote event handler.
+   * @param payload Serializable event payload.
+   * @returns A promise that resolves once the event is published.
+   */
+  async emit(pattern, payload) {
+    const message = {
+      kind: 'event',
+      pattern,
+      payload
+    };
+    await this.options.publisher.publish(this.eventQueue, JSON.stringify(message));
+  }
+
+  /**
+   * Cancels queue consumers and rejects any in-flight requests.
+   *
+   * @returns A promise that resolves once shutdown cleanup completes.
+   */
+  async close() {
+    let closeError;
+    if (this.listenPromise) {
+      await this.listenPromise;
+    }
+    try {
+      if (this.listening) {
+        for (const queue of this.subscribedQueues) {
+          try {
+            await this.options.consumer.cancel(queue);
+          } catch (error) {
+            closeError ??= error;
+          }
+        }
+      }
+    } finally {
+      this.subscribedQueues.clear();
+      this.rejectPendingRequests(new Error('RabbitMQ microservice transport closed before response.'));
+      this.listening = false;
+      this.handler = undefined;
+    }
+    if (closeError) {
+      throw closeError;
+    }
+  }
+  async handleInboundMessage(rawMessage) {
+    let message;
+    try {
+      message = JSON.parse(rawMessage);
+    } catch {
+      return;
+    }
+    if (message.kind === 'response') {
+      this.handleResponse(message);
+      return;
+    }
+    if (!this.handler) {
+      return;
+    }
+    if (message.kind === 'event') {
+      await this.handler({
+        kind: 'event',
+        pattern: message.pattern,
+        payload: message.payload
+      });
+      return;
+    }
+    if (message.kind === 'message' && message.requestId) {
+      await this.handleRequest(message);
+    }
+  }
+  async handleRequest(message) {
+    if (!this.handler || !message.requestId) {
+      return;
+    }
+    const replyQueue = typeof message.replyTo === 'string' && message.replyTo.length > 0 ? message.replyTo : this.responseQueue;
+    try {
+      const payload = await this.handler({
+        kind: 'message',
+        pattern: message.pattern,
+        payload: message.payload,
+        requestId: message.requestId
+      });
+      await this.options.publisher.publish(replyQueue, JSON.stringify({
+        kind: 'response',
+        pattern: message.pattern,
+        payload,
+        requestId: message.requestId
+      }));
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unhandled microservice error';
+      await this.options.publisher.publish(replyQueue, JSON.stringify({
+        error: errorMessage,
+        kind: 'response',
+        pattern: message.pattern,
+        requestId: message.requestId
+      }));
+    }
+  }
+  handleResponse(message) {
+    if (!message.requestId) {
+      return;
+    }
+    const pending = this.pending.get(message.requestId);
+    if (!pending) {
+      return;
+    }
+    this.pending.delete(message.requestId);
+    if (message.error) {
+      pending.reject(new Error(message.error));
+      return;
+    }
+    pending.resolve(message.payload);
+  }
+  rejectPendingRequests(error) {
+    for (const [requestId, entry] of this.pending) {
+      clearTimeout(entry.timeout);
+      this.pending.delete(requestId);
+      entry.reject(error);
+    }
+  }
+}

package/dist/transports/redis-streams-transport.d.ts

@@ -0,0 +1,136 @@
+import type { MicroserviceTransport, MicroserviceTransportLogger, TransportHandler } from '../types.js';
+interface StreamReadGroupResult {
+    readonly id: string;
+    readonly fields: Readonly<Record<string, string>>;
+}
+/** Optional Redis Streams write controls used for bounded retention. */
+export interface RedisStreamWriteOptions {
+    /** Approximate maximum stream length preserved by Redis after this append. */
+    readonly maxLenApproximate?: number;
+}
+/** Minimal Redis Streams client contract required by {@link RedisStreamsMicroserviceTransport}. */
+export interface RedisStreamClientLike {
+    xadd(stream: string, fields: Record<string, string>, options?: RedisStreamWriteOptions): Promise<string>;
+    xreadgroup(group: string, consumer: string, streams: readonly string[], options?: {
+        blockMs?: number;
+        count?: number;
+    }): Promise<readonly StreamReadGroupResult[] | null>;
+    xack(stream: string, group: string, id: string): Promise<void>;
+    get?(key: string): Promise<string | null>;
+    incr?(key: string): Promise<number>;
+    decr?(key: string): Promise<number>;
+    set?(key: string, value: string): Promise<unknown>;
+    xdel?(stream: string, id: string): Promise<void>;
+    del?(stream: string): Promise<void>;
+    xgroupCreate(stream: string, group: string, startId: string, mkstream: boolean): Promise<void>;
+    xgroupDestroy(stream: string, group: string): Promise<void>;
+}
+/** Options for configuring the Redis Streams microservice transport. */
+export interface RedisStreamsMicroserviceTransportOptions {
+    readerClient: RedisStreamClientLike;
+    writerClient: RedisStreamClientLike;
+    /**
+     * Approximate maximum request stream length applied at publish time.
+     *
+     * Disabled by default so pending request entries are never trimmed before `xack`/recovery.
+     */
+    messageRetentionMaxLen?: number;
+    /**
+     * Approximate maximum event stream length applied at publish time.
+     *
+     * Disabled by default so pending event entries are never trimmed before consumer-group recovery.
+     */
+    eventRetentionMaxLen?: number;
+    /** Approximate maximum per-consumer response stream length. Defaults to `1_000`. */
+    responseRetentionMaxLen?: number;
+    consumerGroup?: string;
+    namespace?: string;
+    requestTimeoutMs?: number;
+    pollBlockMs?: number;
+}
+/**
+ * Redis Streams transport for durable request-response messages and event fan-out.
+ *
+ * The adapter uses consumer groups and a per-consumer response stream so callers can combine
+ * at-least-once delivery with request timeouts while preserving Fluo's transport abstraction.
+ */
+export declare class RedisStreamsMicroserviceTransport implements MicroserviceTransport {
+    private readonly options;
+    private closing;
+    private readonly consumerId;
+    private handler;
+    private logger;
+    private listening;
+    private listenPromise;
+    private messageGroupLeaseRegistered;
+    private ownsMessageGroup;
+    private readonly pending;
+    private pollPromises;
+    private readonly namespace;
+    private readonly consumerGroup;
+    private readonly requestTimeoutMs;
+    private readonly pollBlockMs;
+    private readonly messageRetentionMaxLen;
+    private readonly eventRetentionMaxLen;
+    private readonly responseRetentionMaxLen;
+    /**
+     * Creates a Redis Streams transport with dedicated reader and writer clients.
+     *
+     * @param options Namespace, consumer-group, polling, and timeout settings.
+     */
+    constructor(options: RedisStreamsMicroserviceTransportOptions);
+    setLogger(logger: MicroserviceTransportLogger): void;
+    /**
+     * Creates consumer groups and starts polling the request, event, and response streams.
+     *
+     * @param handler Runtime callback invoked for inbound event and message packets.
+     * @returns A promise that resolves once all stream consumers are initialized.
+     */
+    listen(handler: TransportHandler): Promise<void>;
+    /**
+     * Sends one request-response message through Redis Streams.
+     *
+     * @param pattern Pattern identifying the remote message handler.
+     * @param payload Serializable request payload.
+     * @param signal Optional abort signal used to cancel the request.
+     * @returns The remote handler response payload.
+     */
+    send(pattern: string, payload: unknown, signal?: AbortSignal): Promise<unknown>;
+    /**
+     * Emits one fire-and-forget event through Redis Streams.
+     *
+     * @param pattern Pattern identifying the remote event handlers.
+     * @param payload Serializable event payload.
+     * @returns A promise that resolves once the event frame is appended to the stream.
+     */
+    emit(pattern: string, payload: unknown): Promise<void>;
+    /**
+     * Stops polling and tears down the owned request, event, and response consumer resources.
+     *
+     * @returns A promise that resolves once shutdown cleanup finishes.
+     */
+    close(): Promise<void>;
+    private ensureConsumerGroup;
+    private registerMessageGroupLease;
+    private releaseMessageGroupLease;
+    private pollStream;
+    private handleStreamEntry;
+    private handleInboundRequest;
+    private publishFrame;
+    private cleanupAcknowledgedEntry;
+    private handleInboundEvent;
+    private handleInboundResponse;
+    private parseFields;
+    private logEventHandlerFailure;
+    private isBusyGroupError;
+    private get messageStream();
+    private get eventStream();
+    private get responseStream();
+    private get messageGroup();
+    private get messageGroupOwnerKey();
+    private get messageGroupRefCountKey();
+    private get eventGroup();
+    private get responseGroup();
+}
+export {};
+//# sourceMappingURL=redis-streams-transport.d.ts.map