@mulingai-npm/redis 2.3.1 → 2.5.0

package/dist/managers/mulingstream-listener-manager.js

@@ -1,169 +1,169 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MulingstreamListenerManager = void 0;
-const uuid_1 = require("uuid");
-const EXPIRATION = 24 * 60 * 60; // 24 hours in seconds
-class MulingstreamListenerManager {
-    constructor(redisClient) {
-        this.redisClient = redisClient;
-    }
-    parseHashData(data) {
-        return {
-            listenerId: data.listenerId,
-            roomId: data.roomId,
-            socketId: data.socketId || '',
-            token: data.token,
-            name: data.name || '',
-            firstJoined: parseInt(data.firstJoined, 10),
-            language: data.language || '',
-            isActive: data.isActive === 'true'
-        };
-    }
-    // Creates a new listener.
-    // -Generates a unique listenerId and adds it to the room's set.
-    // -Stores the listener data in a Redis hash under `listener:{listenerId}`.
-    async addListener(listenerData) {
-        var _a, _b, _c;
-        // You can combine roomId + uuid, or just a uuid, up to you:
-        const listenerId = `[${listenerData.roomId}]-[${(0, uuid_1.v4)()}]`;
-        // Add listenerId to the set for that room
-        await this.redisClient.sadd(`room:${listenerData.roomId}:listeners`, listenerId);
-        // Store listener data in a hash
-        await this.redisClient.hset(`listener:${listenerId}`, {
-            listenerId,
-            roomId: listenerData.roomId,
-            socketId: (_a = listenerData.socketId) !== null && _a !== void 0 ? _a : '',
-            token: listenerData.token,
-            name: (_b = listenerData.name) !== null && _b !== void 0 ? _b : '',
-            firstJoined: listenerData.firstJoined.toString(),
-            language: (_c = listenerData.language) !== null && _c !== void 0 ? _c : '',
-            isActive: 'true'
-        });
-        // expire listener
-        await this.redisClient.expire(`listener:${listenerId}`, EXPIRATION);
-        return listenerId;
-    }
-    async getAllListeners() {
-        // get all keys that match 'listener:*'
-        // TODO: if we have many keys, consider using SCAN instead of KEYS to avoid performance issues.
-        const keys = await this.redisClient.keys('listener:*');
-        if (!keys || keys.length === 0) {
-            return [];
-        }
-        // fetch each hash with HGETALL
-        const listeners = [];
-        for (const key of keys) {
-            const data = await this.redisClient.hgetall(key);
-            listeners.push(this.parseHashData(data));
-        }
-        return listeners;
-    }
-    async getListenersByRoom(roomId) {
-        // get the set of listener IDs
-        const listenerIds = await this.redisClient.smembers(`room:${roomId}:listeners`);
-        if (!listenerIds || listenerIds.length === 0) {
-            return [];
-        }
-        const listeners = [];
-        for (const id of listenerIds) {
-            // get hash data
-            const data = await this.redisClient.hgetall(`listener:${id}`);
-            // if the hash doesn't exist, it may have expired, so remove from the set
-            if (!data || Object.keys(data).length === 0) {
-                await this.redisClient.srem(`room:${roomId}:listeners`, id);
-                continue;
-            }
-            // otherwise, parse and keep it
-            listeners.push(this.parseHashData(data));
-        }
-        return listeners;
-    }
-    async getListener(listenerIdOrToken) {
-        // try direct lookup by listenerId:
-        const directData = await this.redisClient.hgetall(`listener:${listenerIdOrToken}`);
-        if (directData && directData.listenerId) {
-            return this.parseHashData(directData);
-        }
-        // if not found by listenerId, treat 'listenerIdOrToken' as a token and scan all listeners
-        const keys = await this.redisClient.keys('listener:*');
-        if (!keys || keys.length === 0) {
-            return null;
-        }
-        for (const key of keys) {
-            const data = await this.redisClient.hgetall(key);
-            if (data && data.token === listenerIdOrToken) {
-                return this.parseHashData(data);
-            }
-        }
-        return null;
-    }
-    async removeListenerByToken(token) {
-        // find the listener by token
-        const listener = await this.getListener(token);
-        if (!listener) {
-            return false;
-        }
-        // remove the listener ID from the room's set
-        await this.redisClient.srem(`room:${listener.roomId}:listeners`, listener.listenerId);
-        // remove the listener data (the hash)
-        await this.redisClient.del(`listener:${listener.listenerId}`);
-        return true;
-    }
-    async updateNameLanguage(listenerIdOrToken, name, language) {
-        const listener = await this.getListener(listenerIdOrToken);
-        if (!listener) {
-            return false;
-        }
-        // Update the name/language on the listener’s hash key
-        await this.redisClient.hset(`listener:${listener.listenerId}`, {
-            name,
-            language
-        });
-        return true;
-    }
-    async updateSocketId(listenerIdOrToken, socketId) {
-        const listener = await this.getListener(listenerIdOrToken);
-        if (!listener) {
-            return false;
-        }
-        // Update the name/language on the listener’s hash key
-        await this.redisClient.hset(`listener:${listener.listenerId}`, {
-            socketId
-        });
-        return true;
-    }
-    async getTargetSocketIdsByRoomLanguage(roomId, language) {
-        const listeners = await this.getListenersByRoom(roomId);
-        const filteredListeners = listeners.filter((listener) => {
-            return listener.isActive === true && listener.language === language && listener.socketId && listener.socketId.trim() !== '';
-        });
-        return filteredListeners.map((listener) => listener.socketId);
-    }
-    /**
-     * Returns an array of unique languages for the given room, from highest frequency to lowest.
-     * If a listener has no language (empty string / undefined), it is ignored.
-     */
-    async getUniqueLanguagesByRoom(roomId) {
-        // 1) Fetch all listeners for the room.
-        //    (This includes inactive ones, but feel free to filter out isActive === false if you only want active ones.)
-        const listeners = await this.getListenersByRoom(roomId);
-        // if I wanted to get only active listeners
-        // const listeners = (await this.getListenersByRoom(roomId)).filter(l => l.isActive);
-        // 2) Count how many times each language appears.
-        const languageCountMap = {};
-        for (const listener of listeners) {
-            // skip blank/unset language
-            if (!listener.language || !listener.language.trim()) {
-                continue;
-            }
-            // increment count
-            const lang = listener.language;
-            languageCountMap[lang] = (languageCountMap[lang] || 0) + 1;
-        }
-        // 3) Sort by frequency descending: highest count first
-        const sortedEntries = Object.entries(languageCountMap).sort(([, countA], [, countB]) => countB - countA);
-        // 4) Map back to just the language strings in order
-        return sortedEntries.map(([language]) => language);
-    }
-}
-exports.MulingstreamListenerManager = MulingstreamListenerManager;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulingstreamListenerManager = void 0;
+const uuid_1 = require("uuid");
+const EXPIRATION = 24 * 60 * 60; // 24 hours in seconds
+class MulingstreamListenerManager {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+    parseHashData(data) {
+        return {
+            listenerId: data.listenerId,
+            roomId: data.roomId,
+            socketId: data.socketId || '',
+            token: data.token,
+            name: data.name || '',
+            firstJoined: parseInt(data.firstJoined, 10),
+            language: data.language || '',
+            isActive: data.isActive === 'true'
+        };
+    }
+    // Creates a new listener.
+    // -Generates a unique listenerId and adds it to the room's set.
+    // -Stores the listener data in a Redis hash under `listener:{listenerId}`.
+    async addListener(listenerData) {
+        var _a, _b, _c;
+        // You can combine roomId + uuid, or just a uuid, up to you:
+        const listenerId = `[${listenerData.roomId}]-[${(0, uuid_1.v4)()}]`;
+        // Add listenerId to the set for that room
+        await this.redisClient.sadd(`room:${listenerData.roomId}:listeners`, listenerId);
+        // Store listener data in a hash
+        await this.redisClient.hset(`listener:${listenerId}`, {
+            listenerId,
+            roomId: listenerData.roomId,
+            socketId: (_a = listenerData.socketId) !== null && _a !== void 0 ? _a : '',
+            token: listenerData.token,
+            name: (_b = listenerData.name) !== null && _b !== void 0 ? _b : '',
+            firstJoined: listenerData.firstJoined.toString(),
+            language: (_c = listenerData.language) !== null && _c !== void 0 ? _c : '',
+            isActive: 'true'
+        });
+        // expire listener
+        await this.redisClient.expire(`listener:${listenerId}`, EXPIRATION);
+        return listenerId;
+    }
+    async getAllListeners() {
+        // get all keys that match 'listener:*'
+        // TODO: if we have many keys, consider using SCAN instead of KEYS to avoid performance issues.
+        const keys = await this.redisClient.keys('listener:*');
+        if (!keys || keys.length === 0) {
+            return [];
+        }
+        // fetch each hash with HGETALL
+        const listeners = [];
+        for (const key of keys) {
+            const data = await this.redisClient.hgetall(key);
+            listeners.push(this.parseHashData(data));
+        }
+        return listeners;
+    }
+    async getListenersByRoom(roomId) {
+        // get the set of listener IDs
+        const listenerIds = await this.redisClient.smembers(`room:${roomId}:listeners`);
+        if (!listenerIds || listenerIds.length === 0) {
+            return [];
+        }
+        const listeners = [];
+        for (const id of listenerIds) {
+            // get hash data
+            const data = await this.redisClient.hgetall(`listener:${id}`);
+            // if the hash doesn't exist, it may have expired, so remove from the set
+            if (!data || Object.keys(data).length === 0) {
+                await this.redisClient.srem(`room:${roomId}:listeners`, id);
+                continue;
+            }
+            // otherwise, parse and keep it
+            listeners.push(this.parseHashData(data));
+        }
+        return listeners;
+    }
+    async getListener(listenerIdOrToken) {
+        // try direct lookup by listenerId:
+        const directData = await this.redisClient.hgetall(`listener:${listenerIdOrToken}`);
+        if (directData && directData.listenerId) {
+            return this.parseHashData(directData);
+        }
+        // if not found by listenerId, treat 'listenerIdOrToken' as a token and scan all listeners
+        const keys = await this.redisClient.keys('listener:*');
+        if (!keys || keys.length === 0) {
+            return null;
+        }
+        for (const key of keys) {
+            const data = await this.redisClient.hgetall(key);
+            if (data && data.token === listenerIdOrToken) {
+                return this.parseHashData(data);
+            }
+        }
+        return null;
+    }
+    async removeListenerByToken(token) {
+        // find the listener by token
+        const listener = await this.getListener(token);
+        if (!listener) {
+            return false;
+        }
+        // remove the listener ID from the room's set
+        await this.redisClient.srem(`room:${listener.roomId}:listeners`, listener.listenerId);
+        // remove the listener data (the hash)
+        await this.redisClient.del(`listener:${listener.listenerId}`);
+        return true;
+    }
+    async updateNameLanguage(listenerIdOrToken, name, language) {
+        const listener = await this.getListener(listenerIdOrToken);
+        if (!listener) {
+            return false;
+        }
+        // Update the name/language on the listener’s hash key
+        await this.redisClient.hset(`listener:${listener.listenerId}`, {
+            name,
+            language
+        });
+        return true;
+    }
+    async updateSocketId(listenerIdOrToken, socketId) {
+        const listener = await this.getListener(listenerIdOrToken);
+        if (!listener) {
+            return false;
+        }
+        // Update the name/language on the listener’s hash key
+        await this.redisClient.hset(`listener:${listener.listenerId}`, {
+            socketId
+        });
+        return true;
+    }
+    async getTargetSocketIdsByRoomLanguage(roomId, language) {
+        const listeners = await this.getListenersByRoom(roomId);
+        const filteredListeners = listeners.filter((listener) => {
+            return listener.isActive === true && listener.language === language && listener.socketId && listener.socketId.trim() !== '';
+        });
+        return filteredListeners.map((listener) => listener.socketId);
+    }
+    /**
+     * Returns an array of unique languages for the given room, from highest frequency to lowest.
+     * If a listener has no language (empty string / undefined), it is ignored.
+     */
+    async getUniqueLanguagesByRoom(roomId) {
+        // 1) Fetch all listeners for the room.
+        //    (This includes inactive ones, but feel free to filter out isActive === false if you only want active ones.)
+        const listeners = await this.getListenersByRoom(roomId);
+        // if I wanted to get only active listeners
+        // const listeners = (await this.getListenersByRoom(roomId)).filter(l => l.isActive);
+        // 2) Count how many times each language appears.
+        const languageCountMap = {};
+        for (const listener of listeners) {
+            // skip blank/unset language
+            if (!listener.language || !listener.language.trim()) {
+                continue;
+            }
+            // increment count
+            const lang = listener.language;
+            languageCountMap[lang] = (languageCountMap[lang] || 0) + 1;
+        }
+        // 3) Sort by frequency descending: highest count first
+        const sortedEntries = Object.entries(languageCountMap).sort(([, countA], [, countB]) => countB - countA);
+        // 4) Map back to just the language strings in order
+        return sortedEntries.map(([language]) => language);
+    }
+}
+exports.MulingstreamListenerManager = MulingstreamListenerManager;

package/dist/managers/mulingstream-speaker-manager.d.ts

@@ -0,0 +1,36 @@
+import { RedisClient } from '../redis-client';
+export type MulingstreamSpeakerData = {
+    speakerId: string;
+    userId: string;
+    roomId: string;
+    socketId: string;
+    sourceLanguage: string;
+    theme: string;
+    prompts: string;
+    recordingsDuration: number;
+    targetLanguages: string[];
+    timestamp: string;
+};
+export declare class MulingstreamSpeakerManager {
+    private redisClient;
+    constructor(redisClient: RedisClient);
+    private parseHash;
+    private serialize;
+    private buildId;
+    private buildKey;
+    addSpeaker(payload: Omit<MulingstreamSpeakerData, 'speakerId' | 'timestamp'>): Promise<string>;
+    removeSpeakerBySocketId(socketId: string): Promise<boolean>;
+    removeSpeakersByUserId(userId: string): Promise<number>;
+    removeSpeakersByRoomId(roomId: string): Promise<number>;
+    /** internal: remove hash + all index references */
+    private removeSpeakerById;
+    getSpeakerBySpeakerId(speakerId: string): Promise<MulingstreamSpeakerData | null>;
+    getSpeakerBySocketId(socketId: string): Promise<MulingstreamSpeakerData | null>;
+    getSpeakersByRoomId(roomId: string): Promise<MulingstreamSpeakerData[]>;
+    getSpeakersByUserId(userId: string): Promise<MulingstreamSpeakerData[]>;
+    getSpeakerByUserRoom(roomId: string, userId: string): Promise<MulingstreamSpeakerData | null>;
+    updateSourceLanguage(socketId: string, newLang: string): Promise<boolean>;
+    updateTargetLanguages(socketId: string, languages: string[]): Promise<boolean>;
+    increaseRecordingDuration(socketId: string, delta: number): Promise<number>;
+    private cleanIndexes;
+}

package/dist/managers/mulingstream-speaker-manager.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulingstreamSpeakerManager = void 0;
+const EXPIRATION = 24 * 60 * 60; // 24h
+class MulingstreamSpeakerManager {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+    /* ------------------------------------------------ helpers */
+    parseHash(hash) {
+        return {
+            speakerId: hash.speakerId,
+            userId: hash.userId,
+            roomId: hash.roomId,
+            socketId: hash.socketId,
+            sourceLanguage: hash.sourceLanguage,
+            theme: hash.theme,
+            prompts: hash.prompts,
+            recordingsDuration: parseInt(hash.recordingsDuration, 10) || 0,
+            targetLanguages: JSON.parse(hash.targetLanguages || '[]'),
+            timestamp: hash.timestamp
+        };
+    }
+    serialize(data) {
+        return {
+            speakerId: data.speakerId,
+            userId: data.userId,
+            roomId: data.roomId,
+            socketId: data.socketId,
+            sourceLanguage: data.sourceLanguage,
+            theme: data.theme,
+            prompts: data.prompts,
+            recordingsDuration: data.recordingsDuration.toString(),
+            targetLanguages: JSON.stringify(data.targetLanguages),
+            timestamp: data.timestamp
+        };
+    }
+    buildId(roomId, userId, socketId) {
+        return `[${roomId}]-[${userId}]-[${socketId}]`;
+    }
+    buildKey(speakerId) {
+        return `speaker:${speakerId}`;
+    }
+    /* ------------------------------------------------ insert */
+    async addSpeaker(payload) {
+        const speakerId = this.buildId(payload.roomId, payload.userId, payload.socketId);
+        const key = this.buildKey(speakerId);
+        const speakerData = {
+            ...payload,
+            speakerId,
+            timestamp: new Date(Date.now()).toISOString()
+        };
+        await this.redisClient.hset(key, this.serialize(speakerData));
+        await this.redisClient.expire(key, EXPIRATION);
+        // index sets / mapping
+        await this.redisClient.sadd(`room:${payload.roomId}:speakers`, speakerId);
+        await this.redisClient.sadd(`user:${payload.userId}:speakers`, speakerId);
+        await this.redisClient.set(`socket:${payload.socketId}:speaker`, speakerId);
+        await this.redisClient.expire(`socket:${payload.socketId}:speaker`, EXPIRATION);
+        return speakerId;
+    }
+    /* ------------------------------------------------ remove helpers */
+    async removeSpeakerBySocketId(socketId) {
+        const speakerId = await this.redisClient.get(`socket:${socketId}:speaker`);
+        if (speakerId === null) {
+            return false;
+        }
+        const removed = await this.removeSpeakerById(speakerId);
+        return removed;
+    }
+    async removeSpeakersByUserId(userId) {
+        const ids = await this.redisClient.smembers(`user:${userId}:speakers`);
+        if (ids.length === 0) {
+            return 0;
+        }
+        let deletedCount = 0;
+        for (const id of ids) {
+            if (await this.removeSpeakerById(id)) {
+                deletedCount += 1;
+            }
+        }
+        return deletedCount;
+    }
+    async removeSpeakersByRoomId(roomId) {
+        const ids = await this.redisClient.smembers(`room:${roomId}:speakers`);
+        if (ids.length === 0) {
+            return 0;
+        }
+        let deletedCount = 0;
+        for (const id of ids) {
+            if (await this.removeSpeakerById(id)) {
+                deletedCount += 1;
+            }
+        }
+        return deletedCount;
+    }
+    /** internal: remove hash + all index references */
+    async removeSpeakerById(speakerId) {
+        const key = this.buildKey(speakerId);
+        const data = await this.redisClient.hgetall(key);
+        if (data === null || Object.keys(data).length === 0) {
+            // already gone; clean indexes anyway
+            await this.cleanIndexes(speakerId);
+            return false;
+        }
+        await this.redisClient.del(key);
+        await this.cleanIndexes(speakerId);
+        return true;
+    }
+    /* ------------------------------------------------ lookup helpers */
+    async getSpeakerBySpeakerId(speakerId) {
+        const key = this.buildKey(speakerId);
+        const hash = await this.redisClient.hgetall(key);
+        if (hash === null || Object.keys(hash).length === 0) {
+            /* the hash has expired or was never there – remove any stray index refs */
+            await this.cleanIndexes(speakerId);
+            return null;
+        }
+        return this.parseHash(hash);
+    }
+    async getSpeakerBySocketId(socketId) {
+        const speakerId = await this.redisClient.get(`socket:${socketId}:speaker`);
+        if (speakerId === null) {
+            return null;
+        }
+        const hash = await this.redisClient.hgetall(this.buildKey(speakerId));
+        if (hash !== null && Object.keys(hash).length > 0) {
+            return this.parseHash(hash);
+        }
+        // hash expired: tidy indexes
+        await this.cleanIndexes(speakerId);
+        return null;
+    }
+    async getSpeakersByRoomId(roomId) {
+        const ids = await this.redisClient.smembers(`room:${roomId}:speakers`);
+        const result = [];
+        for (const id of ids) {
+            const hash = await this.redisClient.hgetall(this.buildKey(id));
+            if (hash !== null && Object.keys(hash).length > 0) {
+                result.push(this.parseHash(hash));
+            }
+            else {
+                await this.cleanIndexes(id);
+            }
+        }
+        return result;
+    }
+    async getSpeakersByUserId(userId) {
+        const ids = await this.redisClient.smembers(`user:${userId}:speakers`);
+        const result = [];
+        for (const id of ids) {
+            const hash = await this.redisClient.hgetall(this.buildKey(id));
+            if (hash !== null && Object.keys(hash).length > 0) {
+                result.push(this.parseHash(hash));
+            }
+            else {
+                await this.cleanIndexes(id);
+            }
+        }
+        return result;
+    }
+    async getSpeakerByUserRoom(roomId, userId) {
+        const ids = await this.redisClient.smembers(`room:${roomId}:speakers`);
+        for (const id of ids) {
+            if (id.includes(`]-[${userId}]-[`)) {
+                const hash = await this.redisClient.hgetall(this.buildKey(id));
+                if (hash !== null && Object.keys(hash).length > 0) {
+                    return this.parseHash(hash);
+                }
+                await this.cleanIndexes(id);
+                return null;
+            }
+        }
+        return null;
+    }
+    /* ------------------------------------------------ update helpers */
+    async updateSourceLanguage(socketId, newLang) {
+        const speaker = await this.getSpeakerBySocketId(socketId);
+        if (speaker === null) {
+            return false;
+        }
+        await this.redisClient.hset(this.buildKey(speaker.speakerId), {
+            sourceLanguage: newLang
+        });
+        return true;
+    }
+    async updateTargetLanguages(socketId, languages) {
+        const speaker = await this.getSpeakerBySocketId(socketId);
+        if (speaker === null) {
+            return false;
+        }
+        await this.redisClient.hset(this.buildKey(speaker.speakerId), {
+            targetLanguages: JSON.stringify(languages)
+        });
+        return true;
+    }
+    async increaseRecordingDuration(socketId, delta) {
+        const speaker = await this.getSpeakerBySocketId(socketId);
+        if (speaker === null) {
+            return -1;
+        }
+        speaker.recordingsDuration += delta;
+        await this.redisClient.hset(this.buildKey(speaker.speakerId), {
+            recordingsDuration: speaker.recordingsDuration.toString()
+        });
+        return speaker.recordingsDuration;
+    }
+    /* ------------------------------------------------ index cleanup */
+    async cleanIndexes(speakerId) {
+        const parts = speakerId
+            .substring(1, speakerId.length - 1) // remove outer [...]
+            .split(']-['); // ['roomId','userId','socketId']
+        if (parts.length !== 3) {
+            return;
+        }
+        const roomId = parts[0];
+        const userId = parts[1];
+        const socketId = parts[2];
+        await this.redisClient.srem(`room:${roomId}:speakers`, speakerId);
+        await this.redisClient.srem(`user:${userId}:speakers`, speakerId);
+        await this.redisClient.del(`socket:${socketId}:speaker`);
+    }
+}
+exports.MulingstreamSpeakerManager = MulingstreamSpeakerManager;

package/dist/redis-client.d.ts

@@ -1,28 +1,28 @@
-export interface RedisConfig {
-    host: string;
-    port: number;
-    password?: string;
-    db: number;
-}
-export declare class RedisClient {
-    private client;
-    constructor(config: RedisConfig);
-    set(key: string, value: string): Promise<void>;
-    get(key: string): Promise<string | null>;
-    del(key: string): Promise<number>;
-    sadd(key: string, ...values: string[]): Promise<number>;
-    srem(key: string, ...values: string[]): Promise<number>;
-    smembers(key: string): Promise<string[]>;
-    keys(pattern: string): Promise<string[]>;
-    hset(key: string, data: Record<string, string>): Promise<number>;
-    hgetall(key: string): Promise<Record<string, string>>;
-    flushAll(): Promise<string>;
-    flushDb(): Promise<string>;
-    expire(key: string, seconds: number): Promise<number>;
-    jsonSet<T>(key: string, path: string, value: T): Promise<string>;
-    jsonGet<T>(key: string, path: string): Promise<T | null>;
-    jsonDel(key: string, path: string): Promise<number>;
-    jsonArrAppend<T>(key: string, path: string, ...values: T[]): Promise<number>;
-    jsonArrLen(key: string, path: string): Promise<number | null>;
-    jsonArrPop(key: string, path: string, index?: number): Promise<any>;
-}
+export interface RedisConfig {
+    host: string;
+    port: number;
+    password?: string;
+    db: number;
+}
+export declare class RedisClient {
+    private client;
+    constructor(config: RedisConfig);
+    set(key: string, value: string): Promise<void>;
+    get(key: string): Promise<string | null>;
+    del(key: string): Promise<number>;
+    sadd(key: string, ...values: string[]): Promise<number>;
+    srem(key: string, ...values: string[]): Promise<number>;
+    smembers(key: string): Promise<string[]>;
+    keys(pattern: string): Promise<string[]>;
+    hset(key: string, data: Record<string, string>): Promise<number>;
+    hgetall(key: string): Promise<Record<string, string>>;
+    flushAll(): Promise<string>;
+    flushDb(): Promise<string>;
+    expire(key: string, seconds: number): Promise<number>;
+    jsonSet<T>(key: string, path: string, value: T): Promise<string>;
+    jsonGet<T>(key: string, path: string): Promise<T | null>;
+    jsonDel(key: string, path: string): Promise<number>;
+    jsonArrAppend<T>(key: string, path: string, ...values: T[]): Promise<number>;
+    jsonArrLen(key: string, path: string): Promise<number | null>;
+    jsonArrPop(key: string, path: string, index?: number): Promise<any>;
+}