@glowlabs-org/events-sdk 0.1.0 → 1.0.0

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 {};

package/dist/emitter.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGlowEventEmitter = createGlowEventEmitter;
+const amqplib_1 = __importDefault(require("amqplib"));
+const utils_1 = require("./utils");
+const uuid_1 = require("uuid");
+const zones_1 = require("./zones");
+function createGlowEventEmitter({ username, password, zoneId, exchangePrefix = "glow.zone-", }) {
+    let amqpConnection = null;
+    let amqpChannel = null;
+    // Use a special exchange for all zones if zoneId is 0
+    const exchangeName = `${exchangePrefix}${zoneId}.events`;
+    function buildAmqpUrl() {
+        const url = new URL(`amqp://${username}:${password}@turntable.proxy.rlwy.net:50784`);
+        return url.toString();
+    }
+    async function connectIfNeeded() {
+        if (!amqpConnection) {
+            amqpConnection = (await amqplib_1.default.connect(buildAmqpUrl()));
+            amqpChannel = (await amqpConnection.createChannel());
+        }
+        if (amqpChannel) {
+            await amqpChannel.assertExchange(exchangeName, "topic", {
+                durable: true,
+            });
+        }
+    }
+    async function emit(args) {
+        const { eventType, schemaVersion, zoneId, payload } = args;
+        const zoneName = zones_1.zoneMap[String(zoneId)];
+        if (!zoneName)
+            throw new Error(`Invalid zoneId: ${zoneId}`);
+        const event = {
+            id: (0, uuid_1.v4)(),
+            eventType,
+            schemaVersion,
+            zoneId,
+            zoneName,
+            timeStamp: Date.now(),
+            payload,
+        };
+        (0, utils_1.validateZoneNameAndId)(event.zoneId, event.zoneName);
+        (0, utils_1.validateEventPayload)(event.eventType, event.schemaVersion, event);
+        const routingKey = `${event.eventType}.v${event.schemaVersion}`;
+        await connectIfNeeded();
+        amqpChannel.publish(exchangeName, routingKey, Buffer.from(JSON.stringify(event)), { persistent: true });
+    }
+    async function disconnect() {
+        if (amqpConnection) {
+            await amqpConnection.close();
+            amqpConnection = null;
+            amqpChannel = null;
+        }
+    }
+    return { emit, disconnect };
+}

package/dist/event-registry.d.ts

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare function getEventSchema(eventType: string, version: number): z.ZodTypeAny;

package/dist/event-registry.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEventSchema = getEventSchema;
+const audit_pushed_v1_1 = require("./schemas/audit-pushed.v1");
+const audit_slashed_v1_1 = require("./schemas/audit-slashed.v1");
+const audit_pfees_paid_v1_1 = require("./schemas/audit-pfees-paid.v1");
+const base_event_1 = require("./base-event");
+const eventTypeRegistry = {
+    "audit.pushed:v1": base_event_1.baseEventZ.extend({ payload: audit_pushed_v1_1.auditPushedV1PayloadZ }),
+    "audit.slashed:v1": base_event_1.baseEventZ.extend({ payload: audit_slashed_v1_1.auditSlashedV1PayloadZ }),
+    "audit.pfees.paid:v1": base_event_1.baseEventZ.extend({
+        payload: audit_pfees_paid_v1_1.auditPfeesPaidV1PayloadZ,
+    }),
+    // Add more event types/versions here
+};
+function getEventSchema(eventType, version) {
+    const key = `${eventType}:v${version}`;
+    return eventTypeRegistry[key];
+}

package/dist/index.d.ts

@@ -1,6 +1,3 @@
-export * from "./producer";
-export * from "./consumer";
-export * from "./schemas/auditPushed";
-export * from "./glow-listener";
-export * from "./types";
+export * from "./emitter";
+export * from "./listener";
 export * from "./admin";

package/dist/index.js

@@ -14,9 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./producer"), exports);
-__exportStar(require("./consumer"), exports);
-__exportStar(require("./schemas/auditPushed"), exports);
-__exportStar(require("./glow-listener"), exports);
-__exportStar(require("./types"), exports);
+__exportStar(require("./emitter"), exports);
+__exportStar(require("./listener"), exports);
 __exportStar(require("./admin"), exports);

package/dist/listener.d.ts

@@ -0,0 +1,14 @@
+import type { EventType, EventVersion, EventPayload, GlowEvent } from "./types";
+interface CreateGlowEventListenerOptions {
+    username: string;
+    password: string;
+    zoneId: number;
+    queueName?: string;
+    exchangePrefix?: string;
+}
+export declare function createGlowEventListener({ username, password, zoneId, queueName, exchangePrefix, }: CreateGlowEventListenerOptions): {
+    onEvent: <T extends EventType, V extends EventVersion<T>>(eventType: T, schemaVersion: V, handler: (event: GlowEvent<EventPayload<T, V>>) => void) => void;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+};
+export {};

package/dist/listener.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGlowEventListener = createGlowEventListener;
+const amqplib_1 = __importDefault(require("amqplib"));
+const event_registry_1 = require("./event-registry");
+const utils_1 = require("./utils");
+function createGlowEventListener({ username, password, zoneId, queueName, exchangePrefix = "glow.zone-", }) {
+    let amqpConnection = null;
+    let amqpChannel = null;
+    let internalQueueName;
+    let consumerTag = null;
+    // Use a special exchange for all zones if zoneId is 0
+    const exchangeName = `${exchangePrefix}${zoneId}.events`;
+    const eventHandlers = [];
+    function buildAmqpUrl() {
+        const url = new URL(`amqp://${username}:${password}@turntable.proxy.rlwy.net:50784`);
+        return url.toString();
+    }
+    async function connectIfNeeded(bindingPattern) {
+        if (!amqpConnection) {
+            amqpConnection = (await amqplib_1.default.connect(buildAmqpUrl()));
+            amqpChannel = (await amqpConnection.createChannel());
+        }
+        if (amqpChannel) {
+            if (queueName) {
+                internalQueueName = queueName;
+            }
+            else {
+                await amqpChannel.assertExchange(exchangeName, "topic", {
+                    durable: true,
+                });
+                const q = await amqpChannel.assertQueue("", { exclusive: true });
+                internalQueueName = q.queue;
+                await amqpChannel.bindQueue(internalQueueName, exchangeName, bindingPattern);
+            }
+        }
+    }
+    function onEvent(eventType, schemaVersion, handler) {
+        const bindingPattern = `${String(eventType)}.v${String(schemaVersion)}`;
+        eventHandlers.push({
+            bindingPattern,
+            handler: (event, meta) => handler(event),
+        });
+    }
+    async function start() {
+        for (const { bindingPattern } of eventHandlers) {
+            await connectIfNeeded(bindingPattern);
+        }
+        if (!internalQueueName)
+            throw new Error("Queue not initialized");
+        consumerTag = (await amqpChannel.consume(internalQueueName, (msg) => {
+            if (msg) {
+                try {
+                    const decoded = JSON.parse(msg.content.toString());
+                    const [eventType, versionStr] = msg.fields.routingKey.split(".v");
+                    const schemaVersion = Number(versionStr);
+                    (0, utils_1.validateZoneNameAndId)(decoded.zoneId, decoded.zoneName);
+                    (0, utils_1.validateEventPayload)(eventType, schemaVersion, decoded);
+                    const event = (0, event_registry_1.getEventSchema)(eventType, schemaVersion).parse(decoded);
+                    const handlerEntry = eventHandlers.find((h) => h.bindingPattern === `${eventType}.v${schemaVersion}`);
+                    if (handlerEntry)
+                        handlerEntry.handler(event, { eventType, schemaVersion });
+                    amqpChannel.ack(msg);
+                }
+                catch (error) {
+                    console.error("Failed to process event:", error);
+                    amqpChannel.nack(msg, false, false);
+                }
+            }
+        }, { noAck: false })).consumerTag;
+    }
+    async function stop() {
+        if (amqpChannel && consumerTag && internalQueueName) {
+            await amqpChannel.cancel(consumerTag);
+            consumerTag = null;
+        }
+        if (amqpConnection) {
+            await amqpConnection.close();
+            amqpConnection = null;
+            amqpChannel = null;
+            internalQueueName = undefined;
+        }
+    }
+    return { onEvent, start, stop };
+}

package/dist/schemas/audit-pfees-paid.v1.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const auditPfeesPaidV1PayloadZ: z.ZodObject<{
+    farmId: z.ZodString;
+    payer: z.ZodString;
+    amount_12Decimals: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    farmId: string;
+    payer: string;
+    amount_12Decimals: string;
+}, {
+    farmId: string;
+    payer: string;
+    amount_12Decimals: string;
+}>;
+export type AuditPfeesPaidV1Payload = z.infer<typeof auditPfeesPaidV1PayloadZ>;

package/dist/schemas/audit-pfees-paid.v1.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditPfeesPaidV1PayloadZ = void 0;
+const zod_1 = require("zod");
+const hexBytes32 = /^0x[0-9a-fA-F]{64}$/;
+const ethAddress = /^0x[0-9a-fA-F]{40}$/;
+const uint256 = /^[0-9]+$/;
+exports.auditPfeesPaidV1PayloadZ = zod_1.z.object({
+    farmId: zod_1.z.string().regex(hexBytes32, "bytes32 hex string"),
+    payer: zod_1.z.string().regex(ethAddress, "Ethereum address"),
+    amount_12Decimals: zod_1.z
+        .string()
+        .regex(uint256, "uint256 (decimal) − 12 implied decimals"),
+});

package/dist/schemas/audit-pushed.v1.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const auditPushedV1PayloadZ: z.ZodObject<{
+    farmId: z.ZodString;
+    protocolFeeUSDPrice_12Decimals: z.ZodString;
+    expectedProduction_12Decimals: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    farmId: string;
+    protocolFeeUSDPrice_12Decimals: string;
+    expectedProduction_12Decimals: string;
+}, {
+    farmId: string;
+    protocolFeeUSDPrice_12Decimals: string;
+    expectedProduction_12Decimals: string;
+}>;
+export type AuditPushedV1Payload = z.infer<typeof auditPushedV1PayloadZ>;

package/dist/schemas/audit-pushed.v1.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditPushedV1PayloadZ = void 0;
+const zod_1 = require("zod");
+const hexBytes32 = /^0x[0-9a-fA-F]{64}$/;
+const uint256 = /^[0-9]+$/; // unsigned big‑int as decimal string
+exports.auditPushedV1PayloadZ = zod_1.z.object({
+    farmId: zod_1.z.string().regex(hexBytes32, "bytes32 hex string"),
+    protocolFeeUSDPrice_12Decimals: zod_1.z
+        .string()
+        .regex(uint256, "uint256 (decimal) − 12 implied decimals"),
+    expectedProduction_12Decimals: zod_1.z.string().regex(uint256),
+});

package/dist/schemas/audit-slashed.v1.d.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export declare const auditSlashedV1PayloadZ: z.ZodObject<{
+    farmId: z.ZodString;
+    slasher: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    farmId: string;
+    slasher: string;
+}, {
+    farmId: string;
+    slasher: string;
+}>;
+export type AuditSlashedV1Payload = z.infer<typeof auditSlashedV1PayloadZ>;

package/dist/schemas/audit-slashed.v1.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditSlashedV1PayloadZ = void 0;
+const zod_1 = require("zod");
+const hexBytes32 = /^0x[0-9a-fA-F]{64}$/;
+const ethAddress = /^0x[0-9a-fA-F]{40}$/;
+exports.auditSlashedV1PayloadZ = zod_1.z.object({
+    farmId: zod_1.z.string().regex(hexBytes32, "bytes32 hex string"),
+    slasher: zod_1.z.string().regex(ethAddress, "Ethereum address"),
+});

package/dist/types.d.ts

@@ -1,23 +1,21 @@
-import type { AuditPushedData } from "./schemas/auditPushed";
-export type AuditPushedEvent = AuditPushedData;
-export type AuditSlashedId = `0x${string}`;
-export interface GlowEvents {
-    AuditPushed: [AuditPushedEvent];
-    AuditSlashed: [AuditSlashedId];
-    [key: string]: any[];
+import type { BaseEvent } from "./base-event";
+import type { AuditPushedV1Payload } from "./schemas/audit-pushed.v1";
+import type { AuditSlashedV1Payload } from "./schemas/audit-slashed.v1";
+import type { AuditPfeesPaidV1Payload } from "./schemas/audit-pfees-paid.v1";
+export type EventType = BaseEvent["eventType"];
+export type EventVersion<T extends EventType> = T extends "audit.pushed" ? 1 : T extends "audit.slashed" ? 1 : T extends "audit.pfees.paid" ? 1 : never;
+export interface EventPayloadMap {
+    "audit.pushed": {
+        1: AuditPushedV1Payload;
+    };
+    "audit.slashed": {
+        1: AuditSlashedV1Payload;
+    };
+    "audit.pfees.paid": {
+        1: AuditPfeesPaidV1Payload;
+    };
 }
-export type SdkPermission = "listen" | "emit";
-export interface SdkAuthConfig {
-    username: string;
-    password: string;
-    permissions: SdkPermission[];
-}
-export type GlowListenerEvent = "AuditPushed" | "AuditSlashed";
-export interface GlowListener {
-    on: <K extends GlowListenerEvent>(event: K, listener: (...args: GlowEvents[K]) => void) => () => void;
-    off: <K extends GlowListenerEvent>(event: K, listener: (...args: GlowEvents[K]) => void) => void;
-    emitAuditPushed?: (data: AuditPushedEvent) => Promise<void>;
-    emitAuditSlashed?: (id: AuditSlashedId) => void;
-    startListener: () => Promise<void>;
-    stopListener: () => Promise<void>;
+export type EventPayload<T extends EventType, V extends EventVersion<T>> = T extends keyof EventPayloadMap ? V extends keyof EventPayloadMap[T] ? EventPayloadMap[T][V] : never : never;
+export interface GlowEvent<TPayload> extends Omit<BaseEvent, "payload"> {
+    payload: TPayload;
 }

package/dist/utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Validates that the zoneName matches the zoneId using the zoneMap.
+ * Throws an error if the values are inconsistent.
+ */
+export declare function validateZoneNameAndId(zoneId: number, zoneName: string): void;
+/**
+ * Validates the event payload against the schema for the given eventType and schemaVersion.
+ * Throws an error if the schema does not exist or the payload is invalid.
+ */
+export declare function validateEventPayload(eventType: string, schemaVersion: number, payload: any): void;
+/**
+ * Processes a message object as the listener would, validating zone and schema.
+ * Throws if validation fails, returns the parsed event otherwise.
+ */
+export declare function processEventMessage(msg: {
+    content: Buffer;
+    fields: {
+        routingKey: string;
+    };
+}): any;

package/dist/utils.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateZoneNameAndId = validateZoneNameAndId;
+exports.validateEventPayload = validateEventPayload;
+exports.processEventMessage = processEventMessage;
+const event_registry_1 = require("./event-registry");
+const zones_1 = require("./zones");
+/**
+ * Validates that the zoneName matches the zoneId using the zoneMap.
+ * Throws an error if the values are inconsistent.
+ */
+function validateZoneNameAndId(zoneId, zoneName) {
+    if (typeof zoneId === "number" &&
+        String(zoneId) in zones_1.zoneMap &&
+        zoneName !== zones_1.zoneMap[String(zoneId)]) {
+        throw new Error(`zoneName '${zoneName}' does not match zoneId '${zoneId}' (expected '${zones_1.zoneMap[String(zoneId)]}')`);
+    }
+}
+/**
+ * Validates the event payload against the schema for the given eventType and schemaVersion.
+ * Throws an error if the schema does not exist or the payload is invalid.
+ */
+function validateEventPayload(eventType, schemaVersion, payload) {
+    const schema = (0, event_registry_1.getEventSchema)(eventType, schemaVersion);
+    if (!schema)
+        throw new Error(`No schema for event: ${eventType} v${schemaVersion}`);
+    try {
+        schema.parse(payload);
+    }
+    catch (err) {
+        throw new Error(`Payload does not match schema for event: ${eventType} v${schemaVersion}: ${err.message}`);
+    }
+}
+/**
+ * Processes a message object as the listener would, validating zone and schema.
+ * Throws if validation fails, returns the parsed event otherwise.
+ */
+function processEventMessage(msg) {
+    const decoded = JSON.parse(msg.content.toString());
+    const [eventType, versionStr] = msg.fields.routingKey.split(".v");
+    const schemaVersion = Number(versionStr);
+    validateZoneNameAndId(decoded.zoneId, decoded.zoneName);
+    validateEventPayload(eventType, schemaVersion, decoded);
+    return (0, event_registry_1.getEventSchema)(eventType, schemaVersion).parse(decoded);
+}

package/dist/zones.d.ts

@@ -0,0 +1,7 @@
+export declare const zoneMap: {
+    readonly "0": "All Zones";
+    readonly "1": "Clean Grid Project";
+    readonly "2": "Coming Soon Zone ";
+};
+export type ZoneId = keyof typeof zoneMap;
+export type ZoneName = (typeof zoneMap)[ZoneId];

package/dist/zones.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zoneMap = void 0;
+exports.zoneMap = {
+    "0": "All Zones",
+    "1": "Clean Grid Project",
+    "2": "Coming Soon Zone ",
+};

package/package.json

@@ -1,18 +1,15 @@
 {
   "name": "@glowlabs-org/events-sdk",
-  "version": "0.1.0",
-  "description": "Typed event SDK for Glow, powered by Redpanda/Kafka and Zod.",
+  "version": "1.0.0",
+  "description": "Typed event SDK for Glow, powered by RabbitMQ and Zod.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
-  "publishConfig": {
-    "access": "public"
-  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/glowlabs-org/glow-events.git"
+    "url": "https://github.com/glowlabs-org/glow-events"
   },
   "author": "Lironie <julien@glowlabs.org>",
   "license": "MIT",
@@ -25,12 +22,9 @@
     "typescript",
     "glow"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "prepublishOnly": "npm run build"
-  },
   "dependencies": {
     "@kafkajs/confluent-schema-registry": "^3.8.0",
+    "@types/node": "^20.0.0",
     "amqplib": "^0.10.8",
     "json-schema": "^0.4.0",
     "kafkajs": "^2.2.4",
@@ -42,5 +36,8 @@
     "@types/amqplib": "^0.10.7",
     "@types/json-schema": "^7.0.15",
     "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
   }
-}
+}

package/dist/consumer.d.ts

@@ -1,14 +0,0 @@
-import { AuditPushedDataZ } from "./schemas/auditPushed";
-import { z } from "zod";
-export declare function createAuditPushedConsumer({ username, password, onEvent, skipAssertExchange, queueName, skipAssertQueue, exchange, }: {
-    username: string;
-    password: string;
-    onEvent: (evt: z.infer<typeof AuditPushedDataZ>) => void;
-    skipAssertExchange?: boolean;
-    queueName?: string;
-    skipAssertQueue?: boolean;
-    exchange?: string;
-}): {
-    start: () => Promise<void>;
-    stop: () => Promise<void>;
-};

package/dist/consumer.js

@@ -1,84 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAuditPushedConsumer = createAuditPushedConsumer;
-const amqplib_1 = __importDefault(require("amqplib"));
-const auditPushed_1 = require("./schemas/auditPushed");
-const EXCHANGE = "glow.audit.v1.exchange";
-function createAuditPushedConsumer({ username, password, onEvent, skipAssertExchange = false, queueName, skipAssertQueue = false, exchange = "glow.audit.v1.exchange", }) {
-    // amqplib types are not always compatible with runtime objects, so we use 'as any' as a workaround
-    let connection = null;
-    let channel = null;
-    let internalQueueName;
-    let consumerTag = null;
-    function buildAmqpUrl() {
-        const url = new URL(`amqp://${username}:${password}@turntable.proxy.rlwy.net:50784`);
-        return url.toString();
-    }
-    async function connect() {
-        if (!connection) {
-            connection = (await amqplib_1.default.connect(buildAmqpUrl()));
-            channel = (await connection.createChannel());
-        }
-        if (channel) {
-            // Strict read-only: skip all asserts/binds, just use the provided queueName
-            if (skipAssertQueue) {
-                if (!queueName) {
-                    throw new Error("[Glow SDK] In strict read-only mode (skipAssertQueue: true), you must provide a queueName.");
-                }
-                internalQueueName = queueName;
-                // Do not assert or bind anything
-                return;
-            }
-            // Default pattern: assert exchange, create/bind queue
-            if (!skipAssertExchange) {
-                await channel.assertExchange(exchange, "fanout", { durable: true });
-            }
-            const q = await channel.assertQueue(queueName !== null && queueName !== void 0 ? queueName : "", {
-                exclusive: !queueName,
-            });
-            internalQueueName = q.queue;
-            await channel.bindQueue(internalQueueName, exchange, "");
-        }
-    }
-    async function start() {
-        try {
-            await connect();
-            if (!internalQueueName)
-                throw new Error("Queue not initialized");
-            const { consumerTag: tag } = await channel.consume(internalQueueName, (msg) => {
-                if (msg) {
-                    try {
-                        const decoded = JSON.parse(msg.content.toString());
-                        onEvent(auditPushed_1.AuditPushedDataZ.parse(decoded));
-                        channel.ack(msg);
-                    }
-                    catch (error) {
-                        console.error("Failed to process audit pushed event:", error);
-                        channel.nack(msg, false, false);
-                    }
-                }
-            }, { noAck: false });
-            consumerTag = tag;
-        }
-        catch (error) {
-            console.error("Failed to start audit pushed consumer:", error);
-            throw error;
-        }
-    }
-    async function stop() {
-        if (channel && consumerTag && internalQueueName) {
-            await channel.cancel(consumerTag);
-            consumerTag = null;
-        }
-        if (connection) {
-            await connection.close();
-            connection = null;
-            channel = null;
-            internalQueueName = undefined;
-        }
-    }
-    return { start, stop };
-}

package/dist/glow-listener.d.ts

@@ -1,31 +0,0 @@
-import type { GlowListener } from "./types";
-/**
- * Options for creating a GlowListener instance.
- *
- * - Use admin credentials to emit events and create/bind queues/exchanges.
- * - Use listener credentials for read-only event consumption (with pre-created queues).
- * - Specify a custom exchange for multi-exchange support.
- */
-interface GlowListenerOptions {
-    /** Username for RabbitMQ authentication (admin or listener) */
-    username: string;
-    /** Password for RabbitMQ authentication */
-    password: string;
-    /**
-     * The pre-created queue to use for the listener. Must be set up by an admin.
-     */
-    queueName: string;
-    /**
-     * The pre-created exchange to use. Must be set up by an admin. Defaults to 'glow.audit.v1.exchange'.
-     */
-    exchange?: string;
-}
-/**
- * Create a GlowListener instance for consuming and emitting typed events on the Glow platform.
- *
- * - Use admin credentials to emit events and manage queues/exchanges.
- * - Use listener credentials for read-only event consumption.
- * - Supports specifying a custom exchange for multi-exchange scenarios.
- */
-export declare function createGlowListener({ username, password, queueName, exchange, }: GlowListenerOptions): Promise<GlowListener>;
-export type { GlowListener } from "./types";