@emanuelepifani/nexo-client 0.1.0

package/README.md

@@ -0,0 +1,219 @@
+# Nexo Client SDK
+
+High-performance TypeScript client for [Nexo Broker](https://github.com/emanuel-epifani/nexo).
+
+## Quick Start
+
+
+### Run NEXO server
+```bash
+docker run -p 7654:7654 -p 8080:8080 emanuelepifani/nexo:latest
+```
+This exposes:
+- Port 7654 (TCP): Main server socket for SDK clients.
+- Port 8080 (HTTP): Web Dashboard with status of all brokers.
+
+### Install SDK
+
+```bash
+npm install @emanuelepifani/nexo-client
+```
+
+### Connection
+```typescript
+const client = await NexoClient.connect({ host: 'localhost', port: 7654 });
+```
+
+### 1. STORE (Key-Value Map)
+
+```typescript
+// SET key
+await client.store.map.set("user:1", { name: "Max", role: "admin" });
+
+// GET key
+const user = await client.store.map.get<User>("user:1");
+
+// DEL key
+await client.store.map.del("user:1");
+```
+
+### 2. QUEUE
+
+```typescript
+// Create queue
+const mailQ = await client.queue<MailJob>("emails").create();
+// Push message
+await mailQ.push({ to: "test@test.com" });
+// Subscribe
+await mailQ.subscribe((msg) => console.log(msg));
+```
+
+<details>
+<summary><strong>Advanced Queue Features (Retry, Delay, Priority, Concurrency)</strong></summary>
+
+```typescript
+// -------------------------------------------------------------
+// 1. CREATION (Default behavior for all messages in this queue)
+// -------------------------------------------------------------
+interface CriticalTask { type: string; payload: any; }
+
+const criticalQueue = await client.queue<CriticalTask>('critical-tasks').create({
+    // RELIABILITY:
+    visibilityTimeoutMs: 10000, // Retry delivery if not ACKed within 10s   (default=30s)
+    maxRetries: 5,              // Move to DLQ after 5 failures             (default=5)
+    ttlMs: 60000,               // Message expires if not consumed in 60s   (default=7days)
+
+    // PERSISTENCE:
+    // - strategy: 'memory'     -> Volatile (Fastest, lost on restart)
+    // - strategy: 'file_sync'  -> Save every message (Safest, Slowest)
+    // - strategy: 'file_async' -> Buffer & flush periodically (Fast & Durable) -> DEFAULT 
+    // DEFAULT: { strategy: 'file_async', flushIntervalMs: 1000 }
+    persistence: {
+        strategy: 'file_async',
+        flushIntervalMs: 100    
+    }
+});
+
+
+// ---------------------------------------------------------
+// 2. PRODUCING (Override specific behaviors per message)
+// ---------------------------------------------------------
+
+// PRIORITY: Higher value (255) delivered before lower values (0)
+// This message jumps ahead of all priority < 255 messages sent previously and still not consumed.
+await criticalQueue.push({ type: 'urgent' }, { priority: 255 });
+
+// SCHEDULING: Delay visibility
+// This message is hidden for 1 hour (default delayMs: 0, instant)
+await criticalQueue.push({ type: 'scheduled' }, { delayMs: 3600000 });
+
+
+
+// ---------------------------------------------------------
+// 3. CONSUMING (Worker Tuning to optimize throughput and latency)
+// ---------------------------------------------------------
+await criticalQueue.subscribe(
+    async (task) => { await processTask(task); },
+    {
+        batchSize: 100,   // Network: Fetch 100 messages in one request
+        concurrency: 10,  // Local: Process 10 messages concurrently (useful for I/O tasks)
+        waitMs: 5000      // Polling: If empty, wait 5s for new messages before retrying
+    }
+);
+```
+</details>
+
+### 3. PUB/SUB 
+
+```typescript
+// Define topic (not need to create, auto-created on first publish)
+const alerts = client.pubsub<AlertMsg>("system-alerts");
+// Subscribe
+await alerts.subscribe((msg) => console.log(msg));
+// Publish
+await alerts.publish({ level: "high" });
+```
+
+<details>
+<summary><strong>Wildcards & Retained Messages</strong></summary>
+
+```typescript
+// WILDCARD SUBSCRIPTIONS
+// ----------------------
+
+// 1. Single-Level Wildcard (+)
+// Matches: 'home/kitchen/light', 'home/garage/light'
+const roomLights = client.pubsub<LightStatus>('home/+/light');
+await roomLights.subscribe((status) => console.log('Light is:', status.state));
+
+// 2. Multi-Level Wildcard (#)
+// Matches all topics under 'sensors/'
+const allSensors = client.pubsub<SensorData>('sensors/#');
+await allSensors.subscribe((data) => console.log('Sensor value:', data.value));
+
+// PUBLISHING (No wildcards allowed!)
+// ---------------------------------
+// You must publish to concrete topics with matching types
+await client.pubsub<LightStatus>('home/kitchen/light').publish({ state: 'ON' });
+await client.pubsub<SensorData>('sensors/kitchen/temp').publish({ value: 22.5, unit: 'C' });
+
+// RETAINED MESSAGES
+// -----------------
+// Last value is stored and immediately sent to new subscribers
+await client.pubsub<string>('config/theme').publish('dark', { retain: true });
+```
+</details>
+
+### 4. STREAM
+
+```typescript
+// Create topic
+const stream = await client.stream<UserEvent>('user-events').create();
+// Publisher
+await stream.publish({ type: 'login', userId: 'u1' });
+// Consumer (must specify group)
+await stream.subscribe('analytics', (msg) => {console.log(`User ${msg.userId} performed ${msg.type}`); });
+```
+
+<details>
+<summary><strong>Consumer Groups & Scaling</strong></summary>
+
+```typescript
+// ---------------------------------------------------------
+// 1. STREAM CREATION & POLICY
+// ---------------------------------------------------------
+const orders = await client.stream<Order>('orders').create({
+    // SCALING
+    partitions: 4,              // Max concurrent consumers per group on same topic (default=8)
+
+    // PERSISTENCE:
+    // - strategy: 'memory'     -> Volatile (Fastest, lost on restart)
+    // - strategy: 'file_sync'  -> Save every message (Safest, Slowest)
+    // - strategy: 'file_async' -> Buffer & flush periodically (Fast & Durable) -> DEFAULT 
+    // DEFAULT: { strategy: 'file_async', flushIntervalMs: 1000 }
+    persistence: {
+        strategy: 'file_async',
+        flushIntervalMs: 100    
+    }
+});
+
+// ---------------------------------------------------------
+// 2. CONSUMING (Scaling & Broadcast patterns)
+// ---------------------------------------------------------
+
+// SCALING (Microservices Replicas / K8s Pods)
+// Same Group ('workers') -> Automatic Load Balancing & Rebalancing
+// Partitions are distributed among workers.
+await orders.subscribe('workers', (order) => process(order));
+await orders.subscribe('workers', (order) => process(order));
+
+
+// BROADCAST (Independent Domains)
+// Different Groups -> Each group gets a full copy of the stream.
+// Useful for independent services reacting to the same event.
+await orders.subscribe('analytics', (order) => trackMetrics(order));
+await orders.subscribe('audit-log', (order) => saveAudit(order));
+```
+</details>
+
+
+---
+
+## License
+
+MIT
+
+
+## Links
+
+- **Nexo Broker (Server):** [GitHub Repository](https://github.com/emanuel-epifani/nexo)
+- **Server Docs:** [Nexo Internals & Architecture](https://github.com/emanuel-epifani/nexo/tree/main/docs)
+- **SDK Source:** [sdk/ts](https://github.com/emanuel-epifani/nexo/tree/main/sdk/ts)
+- **Docker Image:** [emanuelepifani/nexo](https://hub.docker.com/r/emanuelepifani/nexo)
+
+## Author
+
+Built by **Emanuel Epifani**.
+
+- [LinkedIn](https://www.linkedin.com/in/emanuel-epifani/)
+- [GitHub](https://github.com/emanuel-epifani)

package/dist/brokers/pubsub.d.ts

@@ -0,0 +1,41 @@
+import { NexoConnection } from '../connection';
+export declare enum PubSubOpcode {
+    PUB = 33,
+    SUB = 34,
+    UNSUB = 35
+}
+export declare const PubSubCommands: {
+    publish: (conn: NexoConnection, topic: string, data: any, options: PublishOptions) => Promise<{
+        status: import("../protocol").ResponseStatus;
+        cursor: import("../codec").Cursor;
+    }>;
+    subscribe: (conn: NexoConnection, topic: string) => Promise<{
+        status: import("../protocol").ResponseStatus;
+        cursor: import("../codec").Cursor;
+    }>;
+    unsubscribe: (conn: NexoConnection, topic: string) => Promise<{
+        status: import("../protocol").ResponseStatus;
+        cursor: import("../codec").Cursor;
+    }>;
+};
+export interface PublishOptions {
+    retain?: boolean;
+}
+export declare class NexoTopic<T = any> {
+    private broker;
+    readonly name: string;
+    constructor(broker: NexoPubSub, name: string);
+    publish(data: T, options?: PublishOptions): Promise<void>;
+    subscribe(cb: (data: T) => void): Promise<void>;
+    unsubscribe(): Promise<void>;
+}
+export declare class NexoPubSub {
+    private conn;
+    private handlers;
+    constructor(conn: NexoConnection);
+    publish(topic: string, data: any, options?: PublishOptions): Promise<void>;
+    subscribe(topic: string, callback: (data: any) => void): Promise<void>;
+    unsubscribe(topic: string): Promise<void>;
+    private dispatch;
+    private matches;
+}

package/dist/brokers/pubsub.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NexoPubSub = exports.NexoTopic = exports.PubSubCommands = exports.PubSubOpcode = void 0;
+const codec_1 = require("../codec");
+var PubSubOpcode;
+(function (PubSubOpcode) {
+    PubSubOpcode[PubSubOpcode["PUB"] = 33] = "PUB";
+    PubSubOpcode[PubSubOpcode["SUB"] = 34] = "SUB";
+    PubSubOpcode[PubSubOpcode["UNSUB"] = 35] = "UNSUB";
+})(PubSubOpcode || (exports.PubSubOpcode = PubSubOpcode = {}));
+exports.PubSubCommands = {
+    publish: (conn, topic, data, options) => conn.send(PubSubOpcode.PUB, codec_1.FrameCodec.string(topic), codec_1.FrameCodec.string(JSON.stringify(options || {})), codec_1.FrameCodec.any(data)),
+    subscribe: (conn, topic) => conn.send(PubSubOpcode.SUB, codec_1.FrameCodec.string(topic)),
+    unsubscribe: (conn, topic) => conn.send(PubSubOpcode.UNSUB, codec_1.FrameCodec.string(topic)),
+};
+class NexoTopic {
+    constructor(broker, name) {
+        this.broker = broker;
+        this.name = name;
+    }
+    async publish(data, options) { return this.broker.publish(this.name, data, options); }
+    async subscribe(cb) { return this.broker.subscribe(this.name, cb); }
+    async unsubscribe() { return this.broker.unsubscribe(this.name); }
+}
+exports.NexoTopic = NexoTopic;
+class NexoPubSub {
+    constructor(conn) {
+        this.conn = conn;
+        this.handlers = new Map();
+        conn.onPush = (topic, data) => this.dispatch(topic, data);
+    }
+    async publish(topic, data, options) {
+        await exports.PubSubCommands.publish(this.conn, topic, data, options || {});
+    }
+    async subscribe(topic, callback) {
+        if (!this.handlers.has(topic))
+            this.handlers.set(topic, []);
+        this.handlers.get(topic).push(callback);
+        if (this.handlers.get(topic).length === 1) {
+            await exports.PubSubCommands.subscribe(this.conn, topic);
+        }
+    }
+    async unsubscribe(topic) {
+        if (this.handlers.has(topic)) {
+            this.handlers.delete(topic);
+            await exports.PubSubCommands.unsubscribe(this.conn, topic);
+        }
+    }
+    dispatch(topic, data) {
+        this.handlers.get(topic)?.forEach(cb => { try {
+            cb(data);
+        }
+        catch (e) {
+            console.error(e);
+        } });
+        for (const [pattern, cbs] of this.handlers) {
+            if (pattern === topic)
+                continue;
+            if (this.matches(pattern, topic)) {
+                cbs.forEach(cb => { try {
+                    cb(data);
+                }
+                catch (e) {
+                    console.error(e);
+                } });
+            }
+        }
+    }
+    matches(pattern, topic) {
+        const pParts = pattern.split('/');
+        const tParts = topic.split('/');
+        for (let i = 0; i < pParts.length; i++) {
+            if (pParts[i] === '#')
+                return true;
+            if (i >= tParts.length || (pParts[i] !== '+' && pParts[i] !== tParts[i]))
+                return false;
+        }
+        return pParts.length === tParts.length;
+    }
+}
+exports.NexoPubSub = NexoPubSub;

package/dist/brokers/queue.d.ts

@@ -0,0 +1,66 @@
+import { NexoConnection } from '../connection';
+import { Cursor } from '../codec';
+export declare enum QueueOpcode {
+    Q_CREATE = 16,
+    Q_PUSH = 17,
+    Q_CONSUME = 18,
+    Q_ACK = 19,
+    Q_EXISTS = 20
+}
+export declare const QueueCommands: {
+    create: (conn: NexoConnection, name: string, config: QueueConfig) => Promise<{
+        status: import("../protocol").ResponseStatus;
+        cursor: Cursor;
+    }>;
+    exists: (conn: NexoConnection, name: string) => Promise<boolean>;
+    push: (conn: NexoConnection, name: string, data: any, options: QueuePushOptions) => Promise<{
+        status: import("../protocol").ResponseStatus;
+        cursor: Cursor;
+    }>;
+    consume: <T>(conn: NexoConnection, name: string, batchSize: number, waitMs: number) => Promise<{
+        id: string;
+        data: T;
+    }[]>;
+    ack: (conn: NexoConnection, name: string, id: string) => Promise<{
+        status: import("../protocol").ResponseStatus;
+        cursor: Cursor;
+    }>;
+};
+export type PersistenceStrategy = 'memory' | 'file_sync' | 'file_async';
+export type PersistenceOptions = {
+    strategy: 'memory';
+} | {
+    strategy: 'file_sync';
+} | {
+    strategy: 'file_async';
+    flushIntervalMs?: number;
+};
+export interface QueueConfig {
+    visibilityTimeoutMs?: number;
+    maxRetries?: number;
+    ttlMs?: number;
+    persistence?: PersistenceOptions;
+}
+export interface QueueSubscribeOptions {
+    batchSize?: number;
+    waitMs?: number;
+    concurrency?: number;
+}
+export interface QueuePushOptions {
+    priority?: number;
+    delayMs?: number;
+}
+export declare class NexoQueue<T = any> {
+    private conn;
+    readonly name: string;
+    private _config?;
+    private isSubscribed;
+    constructor(conn: NexoConnection, name: string, _config?: QueueConfig | undefined);
+    create(config?: QueueConfig): Promise<this>;
+    exists(): Promise<boolean>;
+    push(data: T, options?: QueuePushOptions): Promise<void>;
+    subscribe(callback: (data: T) => Promise<any> | any, options?: QueueSubscribeOptions): Promise<{
+        stop: () => void;
+    }>;
+    private ack;
+}

package/dist/brokers/queue.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NexoQueue = exports.QueueCommands = exports.QueueOpcode = void 0;
+const codec_1 = require("../codec");
+const logger_1 = require("../utils/logger");
+var QueueOpcode;
+(function (QueueOpcode) {
+    QueueOpcode[QueueOpcode["Q_CREATE"] = 16] = "Q_CREATE";
+    QueueOpcode[QueueOpcode["Q_PUSH"] = 17] = "Q_PUSH";
+    QueueOpcode[QueueOpcode["Q_CONSUME"] = 18] = "Q_CONSUME";
+    QueueOpcode[QueueOpcode["Q_ACK"] = 19] = "Q_ACK";
+    QueueOpcode[QueueOpcode["Q_EXISTS"] = 20] = "Q_EXISTS";
+})(QueueOpcode || (exports.QueueOpcode = QueueOpcode = {}));
+exports.QueueCommands = {
+    create: (conn, name, config) => conn.send(QueueOpcode.Q_CREATE, codec_1.FrameCodec.string(name), codec_1.FrameCodec.string(JSON.stringify(config || {}))),
+    exists: async (conn, name) => {
+        try {
+            const res = await conn.send(QueueOpcode.Q_EXISTS, codec_1.FrameCodec.string(name));
+            return res.status === 0x00;
+        }
+        catch {
+            return false;
+        }
+    },
+    push: (conn, name, data, options) => conn.send(QueueOpcode.Q_PUSH, codec_1.FrameCodec.string(name), codec_1.FrameCodec.string(JSON.stringify(options || {})), codec_1.FrameCodec.any(data)),
+    consume: async (conn, name, batchSize, waitMs) => {
+        const res = await conn.send(QueueOpcode.Q_CONSUME, codec_1.FrameCodec.string(name), codec_1.FrameCodec.string(JSON.stringify({ batchSize, waitMs })));
+        const count = res.cursor.readU32();
+        if (count === 0)
+            return [];
+        const messages = [];
+        for (let i = 0; i < count; i++) {
+            const idHex = res.cursor.readUUID();
+            const payloadLen = res.cursor.readU32();
+            const payloadBuf = res.cursor.readBuffer(payloadLen);
+            const data = codec_1.FrameCodec.decodeAny(new codec_1.Cursor(payloadBuf));
+            messages.push({ id: idHex, data });
+        }
+        return messages;
+    },
+    ack: (conn, name, id) => conn.send(QueueOpcode.Q_ACK, codec_1.FrameCodec.uuid(id), codec_1.FrameCodec.string(name)),
+};
+async function runConcurrent(items, concurrency, fn) {
+    if (concurrency === 1) {
+        for (const item of items)
+            await fn(item);
+        return;
+    }
+    const queue = [...items];
+    const workers = Array(Math.min(concurrency, items.length)).fill(null).map(async () => {
+        while (queue.length)
+            await fn(queue.shift());
+    });
+    await Promise.all(workers);
+}
+class NexoQueue {
+    constructor(conn, name, _config) {
+        this.conn = conn;
+        this.name = name;
+        this._config = _config;
+        this.isSubscribed = false;
+    }
+    async create(config = {}) {
+        await exports.QueueCommands.create(this.conn, this.name, config);
+        return this;
+    }
+    async exists() {
+        return exports.QueueCommands.exists(this.conn, this.name);
+    }
+    async push(data, options = {}) {
+        await exports.QueueCommands.push(this.conn, this.name, data, options);
+    }
+    async subscribe(callback, options = {}) {
+        if (this.isSubscribed)
+            throw new Error(`Queue '${this.name}' already subscribed.`);
+        // Fail Fast: Check existence first
+        if (!(await this.exists())) {
+            throw new Error(`Queue '${this.name}' not found`);
+        }
+        this.isSubscribed = true;
+        const batchSize = options.batchSize ?? 50;
+        const waitMs = options.waitMs ?? 20000;
+        const concurrency = options.concurrency ?? 5;
+        let active = true;
+        const loop = async () => {
+            while (active && this.conn.isConnected) {
+                try {
+                    const messages = await exports.QueueCommands.consume(this.conn, this.name, batchSize, waitMs);
+                    if (messages.length === 0)
+                        continue;
+                    await runConcurrent(messages, concurrency, async (msg) => {
+                        if (!active)
+                            return;
+                        try {
+                            await callback(msg.data);
+                            await this.ack(msg.id);
+                        }
+                        catch (e) {
+                            if (!this.conn.isConnected)
+                                return;
+                            logger_1.logger.error(`Callback error in queue ${this.name}:`, e);
+                        }
+                    });
+                }
+                catch (e) {
+                    if (!active || !this.conn.isConnected)
+                        return;
+                    logger_1.logger.error(`Queue consume error in ${this.name}:`, e);
+                    await new Promise(r => setTimeout(r, 1000));
+                }
+            }
+            this.isSubscribed = false;
+        };
+        loop();
+        return { stop: () => { active = false; } };
+    }
+    async ack(id) {
+        await exports.QueueCommands.ack(this.conn, this.name, id);
+    }
+}
+exports.NexoQueue = NexoQueue;

package/dist/brokers/store.d.ts

@@ -0,0 +1,32 @@
+import { NexoConnection } from '../connection';
+import { ResponseStatus } from '../protocol';
+export declare enum StoreOpcode {
+    MAP_SET = 2,
+    MAP_GET = 3,
+    MAP_DEL = 4
+}
+export declare const StoreCommands: {
+    mapSet: (conn: NexoConnection, key: string, value: any, options: MapSetOptions) => Promise<{
+        status: ResponseStatus;
+        cursor: import("../codec").Cursor;
+    }>;
+    mapGet: (conn: NexoConnection, key: string) => Promise<any>;
+    mapDel: (conn: NexoConnection, key: string) => Promise<{
+        status: ResponseStatus;
+        cursor: import("../codec").Cursor;
+    }>;
+};
+export interface MapSetOptions {
+    ttl?: number;
+}
+export declare class NexoMap {
+    private conn;
+    constructor(conn: NexoConnection);
+    set(key: string, value: any, options?: MapSetOptions): Promise<void>;
+    get<T = any>(key: string): Promise<T | null>;
+    del(key: string): Promise<void>;
+}
+export declare class NexoStore {
+    readonly map: NexoMap;
+    constructor(conn: NexoConnection);
+}

package/dist/brokers/store.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NexoStore = exports.NexoMap = exports.StoreCommands = exports.StoreOpcode = void 0;
+const protocol_1 = require("../protocol");
+const codec_1 = require("../codec");
+var StoreOpcode;
+(function (StoreOpcode) {
+    StoreOpcode[StoreOpcode["MAP_SET"] = 2] = "MAP_SET";
+    StoreOpcode[StoreOpcode["MAP_GET"] = 3] = "MAP_GET";
+    StoreOpcode[StoreOpcode["MAP_DEL"] = 4] = "MAP_DEL";
+})(StoreOpcode || (exports.StoreOpcode = StoreOpcode = {}));
+exports.StoreCommands = {
+    mapSet: (conn, key, value, options) => conn.send(StoreOpcode.MAP_SET, codec_1.FrameCodec.string(key), codec_1.FrameCodec.string(JSON.stringify(options || {})), codec_1.FrameCodec.any(value)),
+    mapGet: async (conn, key) => {
+        const res = await conn.send(StoreOpcode.MAP_GET, codec_1.FrameCodec.string(key));
+        if (res.status === protocol_1.ResponseStatus.NULL)
+            return null;
+        return codec_1.FrameCodec.decodeAny(res.cursor);
+    },
+    mapDel: (conn, key) => conn.send(StoreOpcode.MAP_DEL, codec_1.FrameCodec.string(key)),
+};
+class NexoMap {
+    constructor(conn) {
+        this.conn = conn;
+    }
+    async set(key, value, options = {}) {
+        await exports.StoreCommands.mapSet(this.conn, key, value, options);
+    }
+    async get(key) {
+        return exports.StoreCommands.mapGet(this.conn, key);
+    }
+    async del(key) {
+        await exports.StoreCommands.mapDel(this.conn, key);
+    }
+}
+exports.NexoMap = NexoMap;
+class NexoStore {
+    constructor(conn) {
+        this.map = new NexoMap(conn);
+    }
+}
+exports.NexoStore = NexoStore;

package/dist/brokers/stream.d.ts

@@ -0,0 +1,66 @@
+import { NexoConnection } from '../connection';
+import { Cursor } from '../codec';
+export declare enum StreamOpcode {
+    S_CREATE = 48,
+    S_PUB = 49,
+    S_FETCH = 50,
+    S_JOIN = 51,
+    S_COMMIT = 52,
+    S_EXISTS = 53
+}
+export type PersistenceStrategy = 'memory' | 'file_sync' | 'file_async';
+export type PersistenceOptions = {
+    strategy: 'memory';
+} | {
+    strategy: 'file_sync';
+} | {
+    strategy: 'file_async';
+    flushIntervalMs?: number;
+};
+export interface StreamCreateOptions {
+    partitions?: number;
+    persistence?: PersistenceOptions;
+}
+export interface StreamPublishOptions {
+    key?: string;
+}
+export declare const StreamCommands: {
+    create: (conn: NexoConnection, name: string, options: StreamCreateOptions) => Promise<{
+        status: import("../protocol").ResponseStatus;
+        cursor: Cursor;
+    }>;
+    exists: (conn: NexoConnection, name: string) => Promise<boolean>;
+    publish: (conn: NexoConnection, name: string, data: any, options: StreamPublishOptions) => Promise<{
+        status: import("../protocol").ResponseStatus;
+        cursor: Cursor;
+    }>;
+    join: (conn: NexoConnection, stream: string, group: string) => Promise<{
+        generationId: bigint;
+        partitions: {
+            id: number;
+            offset: bigint;
+        }[];
+    }>;
+    fetch: <T>(conn: NexoConnection, stream: string, group: string, partition: number, offset: bigint, generationId: bigint, batchSize: number) => Promise<{
+        offset: bigint;
+        data: T;
+    }[]>;
+    commit: (conn: NexoConnection, stream: string, group: string, partition: number, offset: bigint, generationId: bigint) => Promise<{
+        status: import("../protocol").ResponseStatus;
+        cursor: Cursor;
+    }>;
+};
+export interface StreamSubscribeOptions {
+    batchSize?: number;
+}
+export declare class NexoStream<T = any> {
+    private conn;
+    readonly name: string;
+    constructor(conn: NexoConnection, name: string);
+    create(options?: StreamCreateOptions): Promise<this>;
+    exists(): Promise<boolean>;
+    publish(data: T, options?: StreamPublishOptions): Promise<void>;
+    subscribe(group: string, callback: (data: T) => Promise<any> | any, options?: StreamSubscribeOptions): Promise<{
+        stop: () => void;
+    }>;
+}