@glowlabs-org/events-sdk 0.1.1 → 1.0.0

package/README.md

@@ -1,6 +1,6 @@
 # Glow Events SDK
 
-A TypeScript-first SDK for consuming and emitting typed events on the Glow platform, powered by RabbitMQ (fanout exchange). Provides runtime validation and type inference using Zod schemas.
+A TypeScript-first SDK for consuming and emitting typed events on the Glow platform, powered by RabbitMQ (topic exchange). Provides runtime validation and type inference using Zod schemas.
 
 ---
 
@@ -12,190 +12,285 @@ A TypeScript-first SDK for consuming and emitting typed events on the Glow platf
 pnpm install @glowlabs-org/events-sdk
 ```
 
-### 2. Available Events
+---
+
+## 📚 Zones
+
+The following zones are currently available:
+
+| Zone ID | Zone Name          |
+| ------- | ------------------ |
+| 0       | All Zones          |
+| 1       | Clean Grid Project |
+| 2       | Coming Soon Zone   |
+
+- Use `zoneId: 0` (with `zoneName: "All Zones"`) to emit to or listen to all zones.
+- The SDK types and runtime validation now officially support `zoneId: 0` and `zoneName: "All Zones"` everywhere (emitter, listener, event types).
+
+---
+
+## 📦 Event Types & Versions
+
+Currently supported event types and versions:
+
+| Event Name         | Version | Payload Type              | Description                         |
+| ------------------ | ------- | ------------------------- | ----------------------------------- |
+| `audit.pushed`     | 1       | `AuditPushedV1Payload`    | Emitted when an audit is pushed     |
+| `audit.slashed`    | 1       | `AuditSlashedV1Payload`   | Emitted when a farm is slashed      |
+| `audit.pfees.paid` | 1       | `AuditPfeesPaidV1Payload` | Emitted when protocol fees are paid |
+
+---
+
+## 📝 Event Payload Schemas
+
+### `audit.pushed` v1
 
-| Event Name     | Payload Type       | Description                      |
-| -------------- | ------------------ | -------------------------------- |
-| `AuditPushed`  | `AuditPushedEvent` | Emitted when an audit is pushed  |
-| `AuditSlashed` | `AuditSlashedId`   | Emitted when an audit is slashed |
+```ts
+export interface AuditPushedV1Payload {
+  farmId: string; // bytes32 hex string (0x...)
+  protocolFeeUSDPrice_12Decimals: string; // uint256 (decimal) − 12 implied decimals
+  expectedProduction_12Decimals: string; // uint256 (decimal) − 12 implied decimals
+}
+```
+
+**Validation:**
+
+- `farmId` must be a 32-byte hex string (e.g., `0x...`).
+- `protocolFeeUSDPrice_12Decimals` and `expectedProduction_12Decimals` must be decimal strings representing unsigned big integers.
+
+### `audit.slashed` v1
+
+```ts
+export interface AuditSlashedV1Payload {
+  farmId: string; // bytes32 hex string (0x...)
+  slasher: string; // Ethereum address (0x...)
+}
+```
+
+**Validation:**
 
-#### Event Payload Types
+- `farmId` must be a 32-byte hex string (e.g., `0x...`).
+- `slasher` must be a valid Ethereum address (0x...40 hex chars).
+
+### `audit.pfees.paid` v1
 
 ```ts
-// AuditPushedEvent
-import type { AuditPushedEvent } from "@glowlabs-org/events-sdk";
-// type AuditPushedEvent = {
-//   farmId: string;
-//   protocolFeeUSDPrice_12Decimals: string;
-//   tokenPrices: { token: string; priceWAD_usd12Decimals: string }[];
-//   expectedProduction_12Decimals: string;
-//   glowRewardSplits: { receiver: string; percent: number }[];
-//   cashRewardSplits: { receiver: string; percent: number }[];
-// }
-
-// AuditSlashedId
-// type AuditSlashedId = `0x${string}`;
+export interface AuditPfeesPaidV1Payload {
+  farmId: string; // bytes32 hex string (0x...)
+  payer: string; // Ethereum address (0x...)
+  amount_12Decimals: string; // uint256 (decimal) − 12 implied decimals
+}
 ```
 
+**Validation:**
+
+- `farmId` must be a 32-byte hex string (e.g., `0x...`).
+- `payer` must be a valid Ethereum address (0x...40 hex chars).
+- `amount_12Decimals` must be a decimal string representing an unsigned big integer (12 implied decimals).
+
 ---
 
 ## ✨ Usage Example
 
-### Listen to Events
+### Listen to Specific Event Types/Versions
 
 ```ts
-import { createGlowListener } from "@glowlabs-org/events-sdk";
-
-async function main() {
-  const sdk = await createGlowListener({
-    username: "listener", // or "admin"
-    password: "your-password-here",
-    queueName: "my.precreated.queue", // REQUIRED: must be pre-created and bound by an admin
-    // Optionally specify a custom exchange:
-    // exchange: "glow.audit.v2.exchange",
-  });
+import { createGlowEventListener } from "@glowlabs-org/events-sdk";
 
-  sdk.on("AuditPushed", (event) => {
-    console.log("Received AuditPushed:", event.farmId);
-  });
+const listener = createGlowEventListener({
+  username: "listener",
+  password: "your-password-here",
+  zoneId: 1,
+  queueName: "my.precreated.queue",
+});
 
-  sdk.on("AuditSlashed", (id) => {
-    console.log("Received AuditSlashed:", id);
-  });
+listener.onEvent("audit.pushed", 1, (event) => {
+  console.log("Received audit.pushed v1:", event.farmId);
+});
 
-  await sdk.startListener();
+listener.onEvent("audit.slashed", 1, (event) => {
+  console.log("Received audit.slashed v1:", event.farmId, event.slasher);
+});
 
-  // To stop listening:
-  // await sdk.stopListener();
-}
+listener.onEvent("audit.pfees.paid", 1, (event) => {
+  console.log(
+    "Received audit.pfees.paid v1:",
+    event.farmId,
+    event.payer,
+    event.amount_12Decimals
+  );
+});
 
-main();
+await listener.start();
+// To stop listening:
+// await listener.stop();
 ```
 
 ### Emit Events (Admin Only)
 
 ```ts
-import { createGlowListener } from "@glowlabs-org/events-sdk";
-
-async function main() {
-  const sdk = await createGlowListener({
-    username: "admin",
-    password: "your-password-here",
-    queueName: "my.precreated.queue", // REQUIRED: must be pre-created and bound by an admin
-    // Optionally specify a custom exchange:
-    // exchange: "glow.audit.v2.exchange",
-  });
-
-  await sdk.emitAuditPushed?.({
+import { createGlowEventEmitter } from "@glowlabs-org/events-sdk";
+
+const emitter = createGlowEventEmitter({
+  username: "admin",
+  password: "your-password-here",
+  zoneId: 1,
+});
+
+await emitter.emit({
+  eventType: "audit.pushed",
+  schemaVersion: 1,
+  payload: {
     farmId: "0x...",
     protocolFeeUSDPrice_12Decimals: "...",
-    tokenPrices: [],
     expectedProduction_12Decimals: "...",
-    glowRewardSplits: [],
-    cashRewardSplits: [],
-  });
+  },
+});
 
-  sdk.emitAuditSlashed?.("0x...");
-}
+await emitter.emit({
+  eventType: "audit.slashed",
+  schemaVersion: 1,
+  payload: {
+    farmId: "0x...",
+    slasher: "0x...",
+  },
+});
+
+await emitter.emit({
+  eventType: "audit.pfees.paid",
+  schemaVersion: 1,
+  payload: {
+    farmId: "0x...",
+    payer: "0x...",
+    amount_12Decimals: "1000000000000",
+  },
+});
 
-main();
+await emitter.disconnect();
 ```
 
----
+### 🌐 Emitting or Listening to All Zones
 
-## 📝 API Reference
+You can emit to or listen to **all zones at once** by passing `zoneId: 0` to the emitter or listener.
 
-### `createGlowListener({ username, password, exchange?, queueName })`
+#### Emit to All Zones
 
-Returns a Promise resolving to an object with:
+```ts
+import { createGlowEventEmitter } from "@glowlabs-org/events-sdk";
 
-- `.on(event, listener)` — Listen to typed events
-- `.off(event, listener)` — Remove a listener
-- `.emitAuditPushed(payload)` — Emit an AuditPushed event (if permitted)
-- `.emitAuditSlashed(id)` — Emit an AuditSlashed event (if permitted)
-- `.startListener()` — Start listening to events
-- `.stopListener()` — Stop listening to events
+const emitter = createGlowEventEmitter({
+  username: "admin",
+  password: "your-password-here",
+  zoneId: 0, // special value for all zones
+});
 
-#### Options
+await emitter.emit({
+  eventType: "audit.pushed",
+  schemaVersion: 1,
+  payload: {
+    farmId: "0x...",
+    protocolFeeUSDPrice_12Decimals: "...",
+    expectedProduction_12Decimals: "...",
+  },
+});
 
-- `username` (string, required)
-- `password` (string, required)
-- `exchange` (string, optional): RabbitMQ exchange name (default: `glow.audit.v1.exchange`)
-- `queueName` (string, required): Use a pre-created queue (must be set up by an admin)
-- **Naming Requirement:** Both `queueName` and `exchange` must be dot-separated (e.g., 'glow.audit.v1.exchange').
+await emitter.emit({
+  eventType: "audit.slashed",
+  schemaVersion: 1,
+  payload: {
+    farmId: "0x...",
+    slasher: "0x...",
+  },
+});
 
----
+await emitter.emit({
+  eventType: "audit.pfees.paid",
+  schemaVersion: 1,
+  payload: {
+    farmId: "0x...",
+    payer: "0x...",
+    amount_12Decimals: "1000000000000",
+  },
+});
 
-## 🔐 Permissions & Credentials
+await emitter.disconnect();
+```
 
-- **Listener credentials:** Can only subscribe to events. Cannot emit events or create new queues.
-- **Admin credentials:** Can subscribe, emit events, and create/bind new queues and exchanges.
+#### Listen to All Zones
 
-If you try to emit with listener credentials, the SDK will throw an error.
+```ts
+import { createGlowEventListener } from "@glowlabs-org/events-sdk";
 
----
+const listener = createGlowEventListener({
+  username: "listener",
+  password: "your-password-here",
+  zoneId: 0, // special value for all zones
+  queueName: "my.precreated.queue",
+});
 
-## 🛠️ Advanced: Admin & Queue Management
+listener.onEvent("audit.pushed", 1, (event) => {
+  console.log("Received audit.pushed v1 from any zone:", event.farmId);
+});
 
-The SDK exposes helpers for programmatically creating, binding, and deleting exchanges and queues (admin credentials required). Use these for pre-creating queues for listeners, bootstrapping environments, or advanced queue management.
+listener.onEvent("audit.slashed", 1, (event) => {
+  console.log(
+    "Received audit.slashed v1 from any zone:",
+    event.farmId,
+    event.slasher
+  );
+});
 
-### `createExchange(options)`
+listener.onEvent("audit.pfees.paid", 1, (event) => {
+  console.log(
+    "Received audit.pfees.paid v1 from any zone:",
+    event.farmId,
+    event.payer,
+    event.amount_12Decimals
+  );
+});
 
-### `bindQueueToExchange(options)`
+await listener.start();
+// To stop listening:
+// await listener.stop();
+```
 
-### `deleteExchange(options)`
+---
 
-### `deleteQueue(options)`
+## 🧪 Validation & Error Handling
 
-See the end of this README for full admin/queue management usage examples.
+- All events are validated at runtime using Zod schemas.
+- If you emit or process an event with a `zoneName` that does not match the `zoneId`, an error is thrown. `zoneId: 0` and `zoneName: "All Zones"` are a valid pairing.
+- If you emit or process an event with a `schemaVersion` for which no schema exists (e.g., `audit.pushed` v2), an error is thrown.
+- If the payload does not match the schema, an error is thrown.
 
 ---
 
-## 📚 More Details
+## 🔐 Permissions & Credentials
 
-### Event Payload Zod Schema
+- **Listener credentials:** Can only subscribe to events. Cannot emit events or create new queues.
+- **Admin credentials:** Can subscribe, emit events, and create/bind new queues and exchanges.
 
-```ts
-import { z } from "zod";
-
-export const AuditPushedDataZ = z
-  .object({
-    farmId: z.string().regex(/^0x[0-9a-fA-F]{64}$/, "bytes32 hex string"),
-    protocolFeeUSDPrice_12Decimals: z
-      .string()
-      .regex(/^[0-9]+$/, "uint256 (decimal) − 12 implied decimals"),
-    tokenPrices: z.array(
-      z.object({
-        token: z.string().regex(/^0x[0-9a-fA-F]{40}$/, "ERC‑20 address"),
-        priceWAD_usd12Decimals: z.string().regex(/^[0-9]+$/),
-      })
-    ),
-    expectedProduction_12Decimals: z.string().regex(/^[0-9]+$/),
-    glowRewardSplits: z.array(
-      z.object({
-        receiver: z.string().regex(/^0x[0-9a-fA-F]{40}$/),
-        percent: z.number().min(0).max(100),
-      })
-    ),
-    cashRewardSplits: z.array(
-      z.object({
-        receiver: z.string().regex(/^0x[0-9a-fA-F]{40}$/),
-        percent: z.number().min(0).max(100),
-      })
-    ),
-  })
-  .strict();
-
-export type AuditPushedData = z.infer<typeof AuditPushedDataZ>;
-```
+If you try to emit with listener credentials, the SDK will throw an error.
 
 ---
 
-## 🏗️ Admin: Exchange and Queue Management
+## 🛠️ Admin & Queue Management
 
 The SDK exposes helpers for programmatically creating, binding, and deleting exchanges and queues (admin credentials required). Use these for pre-creating queues for listeners, bootstrapping environments, or advanced queue management.
 
-### Usage Example
+### `createExchange(options)`
+
+Creates a topic exchange (default: `exchangeType = "topic"`).
+
+### `bindQueueToExchange(options)`
+
+Binds a queue to a topic exchange. You can specify a `routingKey` for fine-grained event filtering:
+
+- `routingKey = "#"` (default): all events
+- `routingKey = "audit.pushed.v1"`: only audit.pushed v1 events
+- `routingKey = "audit.pushed.*"`: all versions of audit.pushed
+
+#### Example
 
 ```ts
 import {
@@ -208,26 +303,15 @@ import {
 await createExchange({
   username: "admin",
   password: "your-password-here",
-  exchange: "glow.audit.v1.exchange",
+  exchange: "glow.zone-1.events",
 });
 
 await bindQueueToExchange({
   username: "admin",
   password: "your-password-here",
-  exchange: "glow.audit.v1.exchange",
-  queue: "glow-listener-queue",
-});
-
-await deleteExchange({
-  username: "admin",
-  password: "your-password-here",
-  exchange: "glow.audit.v1.exchange",
-});
-
-await deleteQueue({
-  username: "admin",
-  password: "your-password-here",
+  exchange: "glow.zone-1.events",
   queue: "glow-listener-queue",
+  routingKey: "audit.pushed.v1", // only audit.pushed v1 events
 });
 ```
 
@@ -240,27 +324,27 @@ If your listener credentials only have `read` permission (no `configure`), you m
 ### 1. Admin: Pre-create and bind the queue
 
 ```ts
-import { createAndBindQueue } from "@glowlabs-org/events-sdk";
+import { bindQueueToExchange } from "@glowlabs-org/events-sdk";
 
-await createAndBindQueue({
+await bindQueueToExchange({
   username: "admin",
   password: "your-admin-password",
-  exchange: "glow.audit.v1.exchange",
+  exchange: "glow.zone-1.events",
   queue: "my.precreated.queue",
+  routingKey: "audit.pushed.v1", // only audit.pushed v1 events
 });
 ```
 
 ### 2. Listener: Consume from the pre-created queue
 
 ```ts
-import { createGlowListener } from "@glowlabs-org/events-sdk";
+import { createGlowEventListener } from "@glowlabs-org/events-sdk";
 
-const sdk = await createGlowListener({
+const listener = createGlowEventListener({
   username: "listener",
   password: "your-listener-password",
+  zoneId: 1,
   queueName: "my.precreated.queue",
-  // Optionally specify a custom exchange:
-  // exchange: "glow.audit.v1.exchange",
 });
 ```
 
@@ -269,9 +353,19 @@ const sdk = await createGlowListener({
 
 ---
 
-## 🧩 Advanced: Multiple Listeners/Producers
+## 🧩 Advanced: Multiple Listeners/Emitters
+
+You can create multiple listeners or emitters in the same process, each with its own configuration (e.g., for different credentials, exchanges, or RabbitMQ URLs). This is useful for multi-tenant, multi-topic, or advanced scenarios. **Every listener receives every event for the bound routing key(s).**
+
+---
+
+## 🧪 Extending Event Types
+
+To add new event types or versions:
 
-You can create multiple listeners or producers in the same process, each with its own configuration (e.g., for different credentials, exchanges, or RabbitMQ URLs). This is useful for multi-tenant, multi-topic, or advanced scenarios. **Every listener receives every event for the bound exchange.**
+1. Create a new schema in `src/schemas/`.
+2. Add the event type and version to `eventTypeRegistry` in `src/event-registry.ts`.
+3. Update the base event type in `src/base-event.ts` if needed.
 
 ---
 

package/dist/admin.d.ts

@@ -7,32 +7,33 @@ export interface CreateAndBindQueueOptions {
     exchangeType?: string;
     queueOptions?: amqp.Options.AssertQueue;
     exchangeOptions?: amqp.Options.AssertExchange;
+    routingKey?: string;
 }
 /**
- * Create a RabbitMQ exchange (admin credentials required).
+ * Create a RabbitMQ topic exchange (admin credentials required).
  *
  * @param options - Connection and exchange options
  * @returns Promise<void>
  */
-export declare function createExchange({ username, password, exchange, exchangeType, exchangeOptions, }: Omit<CreateAndBindQueueOptions, "queue" | "queueOptions">): Promise<void>;
+export declare function createExchange({ username, password, exchange, exchangeType, exchangeOptions, }: Omit<CreateAndBindQueueOptions, "queue" | "queueOptions" | "routingKey">): Promise<void>;
 /**
- * Create a RabbitMQ queue and bind it to an exchange (admin credentials required).
+ * Create a RabbitMQ queue and bind it to a topic exchange (admin credentials required).
  *
  * @param options - Connection, queue, and exchange options
  * @returns Promise<void>
  */
-export declare function bindQueueToExchange({ username, password, exchange, queue, exchangeType, queueOptions, exchangeOptions, }: CreateAndBindQueueOptions): Promise<void>;
+export declare function bindQueueToExchange({ username, password, exchange, queue, exchangeType, queueOptions, exchangeOptions, routingKey, }: CreateAndBindQueueOptions): Promise<void>;
 /**
  * Delete a RabbitMQ exchange (admin credentials required).
  *
  * @param options - Connection and exchange options
  * @returns Promise<void>
  */
-export declare function deleteExchange({ username, password, exchange, }: Omit<CreateAndBindQueueOptions, "queue" | "queueOptions" | "exchangeType" | "exchangeOptions">): Promise<void>;
+export declare function deleteExchange({ username, password, exchange, }: Omit<CreateAndBindQueueOptions, "queue" | "queueOptions" | "exchangeType" | "exchangeOptions" | "routingKey">): Promise<void>;
 /**
  * Delete a RabbitMQ queue (admin credentials required).
  *
  * @param options - Connection and queue options
  * @returns Promise<void>
  */
-export declare function deleteQueue({ username, password, queue, }: Omit<CreateAndBindQueueOptions, "exchange" | "exchangeType" | "exchangeOptions" | "queueOptions">): Promise<void>;
+export declare function deleteQueue({ username, password, queue, }: Omit<CreateAndBindQueueOptions, "exchange" | "exchangeType" | "exchangeOptions" | "queueOptions" | "routingKey">): Promise<void>;

package/dist/admin.js

@@ -12,16 +12,16 @@ function validateName(name, type) {
     // Require at least two segments separated by dots, only alphanumerics, dashes, underscores, and dots
     const pattern = /^[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$/;
     if (!pattern.test(name)) {
-        throw new Error(`${type} name '${name}' is invalid. Must be dot-separated (e.g., 'glow.audit.v1.exchange').`);
+        throw new Error(`${type} name '${name}' is invalid. Must be dot-separated (e.g., 'glow.zone-1.events').`);
     }
 }
 /**
- * Create a RabbitMQ exchange (admin credentials required).
+ * Create a RabbitMQ topic exchange (admin credentials required).
  *
  * @param options - Connection and exchange options
  * @returns Promise<void>
  */
-async function createExchange({ username, password, exchange, exchangeType = "fanout", exchangeOptions = { durable: true }, }) {
+async function createExchange({ username, password, exchange, exchangeType = "topic", exchangeOptions = { durable: true }, }) {
     validateName(exchange, "exchange");
     const url = new URL(`amqp://${username}:${password}@turntable.proxy.rlwy.net:50784`);
     const conn = await amqplib_1.default.connect(url.toString());
@@ -31,12 +31,12 @@ async function createExchange({ username, password, exchange, exchangeType = "fa
     await conn.close();
 }
 /**
- * Create a RabbitMQ queue and bind it to an exchange (admin credentials required).
+ * Create a RabbitMQ queue and bind it to a topic exchange (admin credentials required).
  *
  * @param options - Connection, queue, and exchange options
  * @returns Promise<void>
  */
-async function bindQueueToExchange({ username, password, exchange, queue, exchangeType = "fanout", queueOptions = { durable: false }, exchangeOptions = { durable: true }, }) {
+async function bindQueueToExchange({ username, password, exchange, queue, exchangeType = "topic", queueOptions = { durable: false }, exchangeOptions = { durable: true }, routingKey = "#", }) {
     validateName(exchange, "exchange");
     validateName(queue, "queue");
     const url = new URL(`amqp://${username}:${password}@turntable.proxy.rlwy.net:50784`);
@@ -44,7 +44,7 @@ async function bindQueueToExchange({ username, password, exchange, queue, exchan
     const channel = await conn.createChannel();
     await channel.assertExchange(exchange, exchangeType, exchangeOptions);
     await channel.assertQueue(queue, queueOptions);
-    await channel.bindQueue(queue, exchange, "");
+    await channel.bindQueue(queue, exchange, routingKey);
     await channel.close();
     await conn.close();
 }

package/dist/base-event.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { ZoneName } from "./zones";
+export declare const baseEventZ: z.ZodObject<{
+    id: z.ZodString;
+    zoneId: z.ZodEffects<z.ZodNumber, number, number>;
+    zoneName: z.ZodEnum<[string, ...string[]]>;
+    schemaVersion: z.ZodLiteral<1>;
+    eventType: z.ZodEnum<["audit.pushed", "audit.slashed", "audit.pfees.paid"]>;
+    timeStamp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    zoneId: number;
+    zoneName: string;
+    schemaVersion: 1;
+    eventType: "audit.pushed" | "audit.slashed" | "audit.pfees.paid";
+    timeStamp: number;
+}, {
+    id: string;
+    zoneId: number;
+    zoneName: string;
+    schemaVersion: 1;
+    eventType: "audit.pushed" | "audit.slashed" | "audit.pfees.paid";
+    timeStamp: number;
+}>;
+export interface BaseEvent {
+    id: string;
+    zoneId: number;
+    zoneName: ZoneName;
+    schemaVersion: 1;
+    eventType: "audit.pushed" | "audit.slashed" | "audit.pfees.paid";
+    timeStamp: number;
+}

package/dist/base-event.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseEventZ = void 0;
+const zod_1 = require("zod");
+const zones_1 = require("./zones");
+const zoneIdNumbers = Object.keys(zones_1.zoneMap).map(Number);
+const zoneNames = Object.values(zones_1.zoneMap);
+exports.baseEventZ = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    zoneId: zod_1.z.number().refine((id) => zoneIdNumbers.includes(id), {
+        message: "Invalid zoneId",
+    }),
+    zoneName: zod_1.z.enum(zoneNames),
+    schemaVersion: zod_1.z.literal(1),
+    eventType: zod_1.z.enum(["audit.pushed", "audit.slashed", "audit.pfees.paid"]),
+    timeStamp: zod_1.z.number().int(),
+});

package/dist/emitter.d.ts

@@ -0,0 +1,18 @@
+import { EventPayload, EventType, EventVersion } from "./types";
+interface CreateGlowEventEmitterOptions {
+    username: string;
+    password: string;
+    zoneId: number;
+    exchangePrefix?: string;
+}
+interface EmitEventArgs<T extends EventType, V extends EventVersion<T>> {
+    eventType: T;
+    schemaVersion: V;
+    zoneId: number;
+    payload: EventPayload<T, V>;
+}
+export declare function createGlowEventEmitter({ username, password, zoneId, exchangePrefix, }: CreateGlowEventEmitterOptions): {
+    emit: <T extends EventType, V extends EventVersion<T>>(args: EmitEventArgs<T, V>) => Promise<void>;
+    disconnect: () => Promise<void>;
+};
+export {};