@hotmeshio/hotmesh 0.0.1

package/build/services/store/cache.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The Cache is a key/value store and used to store commonly accessed Redis metadata
+ * (mainly the execution rules for the app) to save time accessing them as they
+ * are immutable per verison. The only time the rules are ejected are when
+ * a new version is deployed to the quorum and the cache is invalidated/cleared.
+ */
+import { ActivityType } from "../../types/activity";
+import { HookRule } from "../../types/hook";
+import { HotMeshApp, HotMeshSettings } from "../../types/hotmesh";
+import { Symbols } from "../../types/serializer";
+import { Transitions } from "../../types/transition";
+declare class Cache {
+    settings: HotMeshSettings;
+    appId: string;
+    apps: Record<string, HotMeshApp>;
+    schemas: Record<string, ActivityType>;
+    subscriptions: Record<string, Record<string, string>>;
+    symbols: Record<string, Symbols>;
+    symvals: Record<string, Symbols>;
+    transitions: Record<string, Record<string, unknown>>;
+    hookRules: Record<string, Record<string, HookRule[]>>;
+    workItems: Record<string, string>;
+    /**
+     * The cache is ALWAYS initialized with HotMeshSettings. The other parameters are optional.
+     * @param settings
+     * @param apps
+     * @param schemas
+     * @param subscriptions
+     * @param transitions
+     * @param hookRules
+     */
+    constructor(appId: string, settings: HotMeshSettings, apps?: Record<string, HotMeshApp>, schemas?: Record<string, ActivityType>, subscriptions?: Record<string, Record<string, string>>, symbols?: Record<string, Symbols>, symvals?: Record<string, Symbols>, transitions?: Record<string, Record<string, unknown>>, hookRules?: Record<string, Record<string, HookRule[]>>, workItems?: Record<string, string>);
+    /**
+     * invalidate the cache; settings are not invalidated!
+     */
+    invalidate(): void;
+    getSettings(): HotMeshSettings;
+    setSettings(settings: HotMeshSettings): void;
+    getApps(): Record<string, HotMeshApp>;
+    getApp(appId: string): HotMeshApp;
+    setApps(apps: Record<string, HotMeshApp>): void;
+    setApp(appId: string, app: HotMeshApp): void;
+    getSchemas(appId: string, version: string): Record<string, ActivityType>;
+    getSchema(appId: string, version: string, activityId: string): ActivityType;
+    setSchemas(appId: string, version: string, schemas: Record<string, ActivityType>): void;
+    setSchema(appId: string, version: string, activityId: string, schema: ActivityType): void;
+    getSubscriptions(appId: string, version: string): Record<string, string>;
+    getSubscription(appId: string, version: string, topic: string): unknown;
+    setSubscriptions(appId: string, version: string, subscriptions: Record<string, string>): void;
+    getSymbols(appId: string, targetEntityId: string): Symbols;
+    setSymbols(appId: string, targetEntityId: string, symbols: Symbols): void;
+    deleteSymbols(appId: string, targetEntityId: string): void;
+    getSymbolValues(appId: string): Symbols;
+    setSymbolValues(appId: string, symvals: Symbols): void;
+    deleteSymbolValues(appId: string): void;
+    getTransitions(appId: string, version: string): Transitions;
+    setTransitions(appId: string, version: string, transitions: Transitions): void;
+    getHookRules(appId: string): Record<string, HookRule[]>;
+    setHookRules(appId: string, hookRules: Record<string, HookRule[]>): void;
+    getSignals(appId: string, version: string): Record<string, unknown>;
+    setSignals(appId: string, version: string): Record<string, unknown>;
+    getActiveTaskQueue(appId: string): string;
+    setWorkItem(appId: string, workItem: string): void;
+    removeWorkItem(appId: string): void;
+}
+export { Cache };

package/build/services/store/cache.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * The Cache is a key/value store and used to store commonly accessed Redis metadata
+ * (mainly the execution rules for the app) to save time accessing them as they
+ * are immutable per verison. The only time the rules are ejected are when
+ * a new version is deployed to the quorum and the cache is invalidated/cleared.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+class Cache {
+    /**
+     * The cache is ALWAYS initialized with HotMeshSettings. The other parameters are optional.
+     * @param settings
+     * @param apps
+     * @param schemas
+     * @param subscriptions
+     * @param transitions
+     * @param hookRules
+     */
+    constructor(appId, settings, apps = {}, schemas = {}, subscriptions = {}, symbols = {}, symvals = {}, transitions = {}, hookRules = {}, workItems = {}) {
+        this.appId = appId;
+        this.settings = settings;
+        this.apps = apps;
+        this.schemas = schemas;
+        this.subscriptions = subscriptions;
+        this.symbols = symbols;
+        this.symvals = symvals;
+        this.transitions = transitions;
+        this.hookRules = hookRules;
+        this.workItems = workItems;
+    }
+    /**
+     * invalidate the cache; settings are not invalidated!
+     */
+    invalidate() {
+        this.apps = {};
+        this.schemas = {};
+        this.subscriptions = {};
+        this.transitions = {};
+        this.hookRules = {};
+    }
+    getSettings() {
+        return this.settings;
+    }
+    setSettings(settings) {
+        this.settings = settings;
+    }
+    getApps() {
+        return this.apps;
+    }
+    getApp(appId) {
+        return this.apps[appId];
+    }
+    setApps(apps) {
+        this.apps = apps;
+    }
+    setApp(appId, app) {
+        this.apps[appId] = app;
+    }
+    getSchemas(appId, version) {
+        return this.schemas[`${appId}/${version}`];
+    }
+    getSchema(appId, version, activityId) {
+        return this.schemas?.[`${appId}/${version}`]?.[activityId];
+    }
+    setSchemas(appId, version, schemas) {
+        this.schemas[`${appId}/${version}`] = schemas;
+    }
+    setSchema(appId, version, activityId, schema) {
+        this.schemas[`${appId}/${version}`][activityId] = schema;
+    }
+    getSubscriptions(appId, version) {
+        return this.subscriptions[`${appId}/${version}`];
+    }
+    getSubscription(appId, version, topic) {
+        return this.subscriptions?.[`${appId}/${version}`]?.[topic];
+    }
+    setSubscriptions(appId, version, subscriptions) {
+        this.subscriptions[`${appId}/${version}`] = subscriptions;
+    }
+    getSymbols(appId, targetEntityId) {
+        return this.symbols[`${appId}/${targetEntityId}`];
+    }
+    setSymbols(appId, targetEntityId, symbols) {
+        this.symbols[`${appId}/${targetEntityId}`] = symbols;
+    }
+    deleteSymbols(appId, targetEntityId) {
+        delete this.symbols[`${appId}/${targetEntityId}`];
+    }
+    getSymbolValues(appId) {
+        return this.symvals[`${appId}`];
+    }
+    setSymbolValues(appId, symvals) {
+        this.symvals[`${appId}`] = symvals;
+    }
+    deleteSymbolValues(appId) {
+        delete this.symvals[`${appId}`];
+    }
+    getTransitions(appId, version) {
+        return this.transitions[`${appId}/${version}`];
+    }
+    setTransitions(appId, version, transitions) {
+        this.transitions[`${appId}/${version}`] = transitions;
+    }
+    getHookRules(appId) {
+        return this.hookRules[`${appId}`];
+    }
+    setHookRules(appId, hookRules) {
+        this.hookRules[`${appId}`] = hookRules;
+    }
+    getSignals(appId, version) {
+        throw new Error("SIGNAL (getHooks) is not supported");
+    }
+    setSignals(appId, version) {
+        throw new Error("SIGNAL (setHook) is not supported");
+    }
+    getActiveTaskQueue(appId) {
+        return this.workItems[appId];
+    }
+    setWorkItem(appId, workItem) {
+        this.workItems[appId] = workItem;
+    }
+    removeWorkItem(appId) {
+        delete this.workItems[appId];
+    }
+}
+exports.Cache = Cache;

package/build/services/store/clients/ioredis.d.ts

@@ -0,0 +1,27 @@
+import { KeyType } from '../../../modules/key';
+import { ILogger } from '../../logger';
+import { SerializerService as Serializer } from '../../serializer';
+import { Cache } from '../cache';
+import { StoreService } from '../index';
+import { RedisClientType, RedisMultiType } from '../../../types/ioredisclient';
+import { ReclaimedMessageType } from '../../../types/stream';
+declare class IORedisStoreService extends StoreService<RedisClientType, RedisMultiType> {
+    redisClient: RedisClientType;
+    cache: Cache;
+    namespace: string;
+    appId: string;
+    logger: ILogger;
+    serializer: Serializer;
+    constructor(redisClient: RedisClientType);
+    getMulti(): RedisMultiType;
+    hGetAllResult(result: any): any;
+    addTaskQueues(keys: string[]): Promise<void>;
+    publish(keyType: KeyType.QUORUM, message: Record<string, any>, appId: string, engineId?: string): Promise<boolean>;
+    xgroup(command: 'CREATE', key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): Promise<boolean>;
+    xadd(key: string, id: string, messageId: string, messageValue: string, multi?: RedisMultiType): Promise<string | RedisMultiType>;
+    xpending(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): Promise<[string, string, number, [string, number][]][] | [string, string, number, number] | unknown[]>;
+    xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
+    xack(key: string, group: string, id: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
+    xdel(key: string, id: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
+}
+export { IORedisStoreService };

package/build/services/store/clients/ioredis.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IORedisStoreService = void 0;
+const key_1 = require("../../../modules/key");
+const index_1 = require("../index");
+class IORedisStoreService extends index_1.StoreService {
+    constructor(redisClient) {
+        super(redisClient);
+    }
+    getMulti() {
+        return this.redisClient.multi();
+    }
+    hGetAllResult(result) {
+        //ioredis response signature is [null, {}] or [null, null]
+        return result[1];
+    }
+    async addTaskQueues(keys) {
+        const multi = this.redisClient.multi();
+        const zsetKey = this.mintKey(key_1.KeyType.WORK_ITEMS, { appId: this.appId });
+        for (const key of keys) {
+            multi.zadd(zsetKey, 'NX', Date.now(), key);
+        }
+        await multi.exec();
+    }
+    async publish(keyType, message, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        const status = await this.redisClient.publish(topic, JSON.stringify(message));
+        return status === 1;
+    }
+    async xgroup(command, key, groupName, id, mkStream) {
+        if (mkStream === 'MKSTREAM') {
+            try {
+                return (await this.redisClient.xgroup(command, key, groupName, id, mkStream)) === 'OK';
+            }
+            catch (err) {
+                this.logger.info(`Consumer group not created with MKSTREAM for key: ${key} and group: ${groupName}`);
+                throw err;
+            }
+        }
+        else {
+            try {
+                return (await this.redisClient.xgroup(command, key, groupName, id)) === 'OK';
+            }
+            catch (err) {
+                this.logger.info(`Consumer group not created for key: ${key} and group: ${groupName}`);
+                throw err;
+            }
+        }
+    }
+    async xadd(key, id, messageId, messageValue, multi) {
+        try {
+            return await (multi || this.redisClient).xadd(key, id, messageId, messageValue);
+        }
+        catch (err) {
+            this.logger.error(`Error publishing 'xadd'; key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xpending(key, group, start, end, count, consumer) {
+        try {
+            return await this.redisClient.xpending(key, group, start, end, count, consumer);
+        }
+        catch (err) {
+            this.logger.error(`Error in retrieving pending messages for [stream ${key}], [group ${group}]`, err);
+            throw err;
+        }
+    }
+    async xclaim(key, group, consumer, minIdleTime, id, ...args) {
+        try {
+            return await this.redisClient.xclaim(key, group, consumer, minIdleTime, id, ...args);
+        }
+        catch (err) {
+            this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xack(key, group, id, multi) {
+        try {
+            return await (multi || this.redisClient).xack(key, group, id);
+        }
+        catch (err) {
+            this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xdel(key, id, multi) {
+        try {
+            return await (multi || this.redisClient).xdel(key, id);
+        }
+        catch (err) {
+            this.logger.error(`Error in deleting messages with id: ${id} for key: ${key}`, err);
+            throw err;
+        }
+    }
+}
+exports.IORedisStoreService = IORedisStoreService;

package/build/services/store/clients/redis.d.ts

@@ -0,0 +1,29 @@
+import { KeyType } from '../../../modules/key';
+import { ILogger } from '../../logger';
+import { SerializerService as Serializer } from '../../serializer';
+import { Cache } from '../cache';
+import { StoreService } from '../index';
+import { RedisClientType, RedisMultiType } from '../../../types/redisclient';
+import { ReclaimedMessageType } from '../../../types/stream';
+declare class RedisStoreService extends StoreService<RedisClientType, RedisMultiType> {
+    redisClient: RedisClientType;
+    cache: Cache;
+    namespace: string;
+    appId: string;
+    logger: ILogger;
+    serializer: Serializer;
+    commands: Record<string, string>;
+    constructor(redisClient: RedisClientType);
+    getMulti(): RedisMultiType;
+    publish(keyType: KeyType.QUORUM, message: Record<string, any>, appId: string, engineId?: string): Promise<boolean>;
+    zAdd(key: string, score: number | string, value: string | number, redisMulti?: RedisMultiType): Promise<any>;
+    zRangeByScoreWithScores(key: string, score: number | string, value: string | number): Promise<string | null>;
+    zRangeByScore(key: string, score: number | string, value: string | number): Promise<string | null>;
+    xgroup(command: 'CREATE', key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): Promise<boolean>;
+    xadd(key: string, id: string, ...args: any[]): Promise<string | RedisMultiType>;
+    xpending(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): Promise<[string, string, number, [string, number][]][] | [string, string, number, number]>;
+    xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
+    xack(key: string, group: string, id: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
+    xdel(key: string, id: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
+}
+export { RedisStoreService };

package/build/services/store/clients/redis.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStoreService = void 0;
+const index_1 = require("../index");
+class RedisStoreService extends index_1.StoreService {
+    constructor(redisClient) {
+        super(redisClient);
+        this.commands = {
+            setnx: 'SETNX',
+            del: 'DEL',
+            expire: 'EXPIRE',
+            hset: 'HSET',
+            hsetnx: 'HSETNX',
+            hincrby: 'HINCRBY',
+            hdel: 'HDEL',
+            hget: 'HGET',
+            hmget: 'HMGET',
+            hgetall: 'HGETALL',
+            hincrbyfloat: 'HINCRBYFLOAT',
+            zrange: 'ZRANGE',
+            zrangebyscore_withscores: 'ZRANGEBYSCORE_WITHSCORES',
+            zrangebyscore: 'ZRANGEBYSCORE',
+            zrem: 'ZREM',
+            zadd: 'ZADD',
+            lmove: 'LMOVE',
+            lrange: 'LRANGE',
+            llen: 'LLEN',
+            lpop: 'LPOP',
+            rename: 'RENAME',
+            rpush: 'RPUSH',
+            xack: 'XACK',
+            xdel: 'XDEL',
+        };
+    }
+    getMulti() {
+        const multi = this.redisClient.MULTI();
+        return multi;
+    }
+    async publish(keyType, message, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        const status = await this.redisClient.publish(topic, JSON.stringify(message));
+        return this.isSuccessful(status);
+    }
+    async zAdd(key, score, value, redisMulti) {
+        return await (redisMulti || this.redisClient)[this.commands.zadd](key, { score: score, value: value.toString() });
+    }
+    async zRangeByScoreWithScores(key, score, value) {
+        const result = await this.redisClient[this.commands.zrangebyscore_withscores](key, score, value);
+        if (result?.length > 0) {
+            return result[0];
+        }
+        return null;
+    }
+    async zRangeByScore(key, score, value) {
+        const result = await this.redisClient[this.commands.zrangebyscore](key, score, value);
+        if (result?.length > 0) {
+            return result[0];
+        }
+        return null;
+    }
+    async xgroup(command, key, groupName, id, mkStream) {
+        const args = mkStream === 'MKSTREAM' ? ['MKSTREAM'] : [];
+        try {
+            return (await this.redisClient.sendCommand(['XGROUP', 'CREATE', key, groupName, id, ...args])) === 1;
+        }
+        catch (err) {
+            const streamType = mkStream === 'MKSTREAM' ? 'with MKSTREAM' : 'without MKSTREAM';
+            this.logger.warn(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, err);
+            throw err;
+        }
+    }
+    async xadd(key, id, ...args) {
+        let multi;
+        if (typeof args[args.length - 1] !== 'string') {
+            multi = args.pop();
+        }
+        try {
+            return await (multi || this.redisClient).XADD(key, id, { [args[0]]: args[1] });
+        }
+        catch (err) {
+            this.logger.error(`Error publishing 'xadd'; key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xpending(key, group, start, end, count, consumer) {
+        try {
+            const args = [key, group];
+            if (start)
+                args.push(start);
+            if (end)
+                args.push(end);
+            if (count !== undefined)
+                args.push(count.toString());
+            if (consumer)
+                args.push(consumer);
+            return await this.redisClient.sendCommand(['XPENDING', ...args]);
+        }
+        catch (err) {
+            this.logger.error(`Error in retrieving pending messages for group: ${group} in key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xclaim(key, group, consumer, minIdleTime, id, ...args) {
+        try {
+            return await this.redisClient.sendCommand(['XCLAIM', key, group, consumer, minIdleTime.toString(), id, ...args]);
+        }
+        catch (err) {
+            this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xack(key, group, id, multi) {
+        try {
+            if (multi) {
+                multi[this.commands.xack](key, group, id);
+                return multi;
+            }
+            else {
+                return await this.redisClient[this.commands.xack](key, group, id);
+            }
+        }
+        catch (err) {
+            this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xdel(key, id, multi) {
+        try {
+            if (multi) {
+                multi[this.commands.xdel](key, id);
+                return multi;
+            }
+            else {
+                return await this.redisClient[this.commands.xdel](key, id);
+            }
+        }
+        catch (err) {
+            this.logger.error(`Error in deleting messages with ids: ${id} for key: ${key}`, err);
+            throw err;
+        }
+    }
+}
+exports.RedisStoreService = RedisStoreService;

package/build/services/store/index.d.ts

@@ -0,0 +1,88 @@
+import { KeyStoreParams, KeyType } from '../../modules/key';
+import { ILogger } from '../logger';
+import { SerializerService as Serializer } from '../serializer';
+import { Cache } from './cache';
+import { ActivityType, Consumes } from '../../types/activity';
+import { AppVID } from '../../types/app';
+import { HookRule, HookSignal } from '../../types/hook';
+import { HotMeshApp, HotMeshApps, HotMeshSettings } from '../../types/hotmesh';
+import { SymbolSets, StringStringType, StringAnyType, Symbols } from '../../types/serializer';
+import { IdsData, JobStatsRange, StatsType } from '../../types/stats';
+import { Transitions } from '../../types/transition';
+import { ReclaimedMessageType } from '../../types/stream';
+interface AbstractRedisClient {
+    exec(): any;
+}
+declare abstract class StoreService<T, U extends AbstractRedisClient> {
+    redisClient: T;
+    cache: Cache;
+    serializer: Serializer;
+    namespace: string;
+    appId: string;
+    logger: ILogger;
+    commands: Record<string, string>;
+    abstract getMulti(): U;
+    abstract publish(keyType: KeyType.QUORUM, message: Record<string, any>, appId: string, engineId?: string): Promise<boolean>;
+    abstract xgroup(command: 'CREATE', key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): Promise<boolean>;
+    abstract xadd(key: string, id: string, messageId: string, messageValue: string, multi?: U): Promise<string | U>;
+    abstract xpending(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): Promise<[string, string, number, [string, number][]][] | [string, string, number, number] | unknown[]>;
+    abstract xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
+    abstract xack(key: string, group: string, id: string, multi?: U): Promise<number | U>;
+    abstract xdel(key: string, id: string, multi?: U): Promise<number | U>;
+    constructor(redisClient: T);
+    init(namespace: string, appId: string, logger: ILogger): Promise<HotMeshApps>;
+    isSuccessful(result: any): boolean;
+    zAdd(key: string, score: number | string, value: string | number, redisMulti?: U): Promise<any>;
+    zRangeByScoreWithScores(key: string, score: number | string, value: string | number): Promise<string | null>;
+    zRangeByScore(key: string, score: number | string, value: string | number): Promise<string | null>;
+    mintKey(type: KeyType, params: KeyStoreParams): string;
+    invalidateCache(): void;
+    reserveEngineId(engineId: string): Promise<boolean>;
+    getSettings(bCreate?: boolean): Promise<HotMeshSettings>;
+    setSettings(manifest: HotMeshSettings): Promise<any>;
+    reserveSymbolRange(target: string, size: number, type: 'JOB' | 'ACTIVITY'): Promise<[number, number, Symbols]>;
+    getSymbols(activityId: string): Promise<Symbols>;
+    addSymbols(activityId: string, symbols: Symbols): Promise<boolean>;
+    seedSymbols(target: string, type: 'JOB' | 'ACTIVITY', startIndex: number): StringStringType;
+    seedJobSymbols(startIndex: number): StringStringType;
+    seedActivitySymbols(startIndex: number, activityId: string): StringStringType;
+    getSymbolValues(): Promise<Symbols>;
+    addSymbolValues(symvals: Symbols): Promise<boolean>;
+    getSymbolKeys(symbolNames: string[]): Promise<SymbolSets>;
+    getApp(id: string, refresh?: boolean): Promise<HotMeshApp>;
+    setApp(id: string, version: string): Promise<HotMeshApp>;
+    activateAppVersion(id: string, version: string): Promise<boolean>;
+    registerAppVersion(appId: string, version: string): Promise<any>;
+    setStats(jobKey: string, jobId: string, dateTime: string, stats: StatsType, appVersion: AppVID, multi?: U): Promise<any>;
+    hGetAllResult(result: any): any;
+    getJobStats(jobKeys: string[]): Promise<JobStatsRange>;
+    getJobIds(indexKeys: string[], idRange: [number, number]): Promise<IdsData>;
+    setStatus(collationKeyStatus: number, jobId: string, appId: string, multi?: U): Promise<any>;
+    getStatus(jobId: string, appId: string): Promise<number>;
+    setState({ ...state }: StringAnyType, status: number | null, jobId: string, appId: string, symbolNames: string[], multi?: U): Promise<string>;
+    getState(jobId: string, consumes: Consumes): Promise<[StringAnyType, number] | undefined>;
+    collate(jobId: string, activityId: string, amount: number, multi?: U): Promise<number>;
+    setStateNX(jobId: string, appId: string): Promise<boolean>;
+    getSchema(activityId: string, appVersion: AppVID): Promise<ActivityType>;
+    getSchemas(appVersion: AppVID): Promise<Record<string, ActivityType>>;
+    setSchemas(schemas: Record<string, ActivityType>, appVersion: AppVID): Promise<any>;
+    setSubscriptions(subscriptions: Record<string, any>, appVersion: AppVID): Promise<boolean>;
+    getSubscriptions(appVersion: AppVID): Promise<Record<string, string>>;
+    getSubscription(topic: string, appVersion: AppVID): Promise<string | undefined>;
+    setTransitions(transitions: Record<string, any>, appVersion: AppVID): Promise<any>;
+    getTransitions(appVersion: AppVID): Promise<Transitions>;
+    setHookRules(hookRules: Record<string, HookRule[]>): Promise<any>;
+    getHookRules(): Promise<Record<string, HookRule[]>>;
+    setHookSignal(hook: HookSignal, multi?: U): Promise<any>;
+    getHookSignal(topic: string, resolved: string): Promise<string | undefined>;
+    deleteHookSignal(topic: string, resolved: string): Promise<number | undefined>;
+    addTaskQueues(keys: string[]): Promise<void>;
+    getActiveTaskQueue(): Promise<string | null>;
+    deleteProcessedTaskQueue(workItemKey: string, key: string, processedKey: string): Promise<void>;
+    processTaskQueue(sourceKey: string, destinationKey: string): Promise<any>;
+    expireJob(jobId: string, inSeconds: number): Promise<void>;
+    registerTimeHook(jobId: string, activityId: string, type: 'sleep' | 'expire' | 'cron', deletionTime: number, multi?: U): Promise<void>;
+    getNextTimeJob(listKey?: string): Promise<[listKey: string, jobId: string, activityId: string] | void>;
+    scrub(jobId: string): Promise<void>;
+}
+export { StoreService };