@hotmeshio/hotmesh 0.0.3 → 0.0.5

package/build/esm/services/activities/activity.js

@@ -0,0 +1,411 @@
+import { GetStateError } from '../../modules/errors';
+import { formatISODate, getValueByPath, restoreHierarchy } from '../../modules/utils';
+import { CollatorService } from '../collator';
+import { DimensionService } from '../dimension';
+import { MapperService } from '../mapper';
+import { Pipe } from '../pipe';
+import { MDATA_SYMBOLS } from '../serializer';
+import { StoreSignaler } from '../signaler/store';
+import { TelemetryService } from '../telemetry';
+import { StreamDataType, StreamStatus } from '../../types/stream';
+/**
+ * The base class for all activities
+ */
+class Activity {
+    constructor(config, data, metadata, hook, engine, context) {
+        this.status = StreamStatus.SUCCESS;
+        this.code = 200;
+        this.adjacentIndex = 0; //can be updated by leg2 using 'as' metadata hincrby output
+        this.config = config;
+        this.data = data;
+        this.metadata = metadata;
+        this.hook = hook;
+        this.engine = engine;
+        this.context = context || { data: {}, metadata: {} };
+        this.logger = engine.logger;
+        this.store = engine.store;
+    }
+    //********  INITIAL ENTRY POINT (A)  ********//
+    async process() {
+        this.logger.debug('activity-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+        let telemetry;
+        try {
+            this.setLeg(1);
+            await CollatorService.notarizeEntry(this);
+            await this.getState();
+            telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+            telemetry.startActivitySpan(this.leg);
+            let multiResponse;
+            const multi = this.store.getMulti();
+            if (this.doesHook()) {
+                //sleep and wait to awaken upon a signal
+                await this.registerHook(multi);
+                this.mapJobData();
+                await this.setState(multi);
+                await CollatorService.authorizeReentry(this, multi);
+                await this.setStatus(0, multi);
+                await multi.exec();
+                telemetry.mapActivityAttributes();
+            }
+            else {
+                //end the activity and transition to its children
+                this.adjacencyList = await this.filterAdjacent();
+                this.mapJobData();
+                await this.setState(multi);
+                await CollatorService.notarizeEarlyCompletion(this, multi);
+                await this.setStatus(this.adjacencyList.length - 1, multi);
+                multiResponse = await multi.exec();
+                telemetry.mapActivityAttributes();
+                const jobStatus = this.resolveStatus(multiResponse);
+                const attrs = { 'app.job.jss': jobStatus };
+                const messageIds = await this.transition(this.adjacencyList, jobStatus);
+                if (messageIds.length) {
+                    attrs['app.activity.mids'] = messageIds.join(',');
+                }
+                telemetry.setActivityAttributes(attrs);
+            }
+            return this.context.metadata.aid;
+        }
+        catch (error) {
+            if (error instanceof GetStateError) {
+                this.logger.error('activity-get-state-error', error);
+            }
+            else {
+                this.logger.error('activity-process-error', error);
+            }
+            telemetry.setActivityError(error.message);
+            throw error;
+        }
+        finally {
+            telemetry.endActivitySpan();
+            this.logger.debug('activity-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+        }
+    }
+    setLeg(leg) {
+        this.leg = leg;
+    }
+    //********  SIGNALER RE-ENTRY POINT (B)  ********//
+    doesHook() {
+        return !!(this.config.hook?.topic || this.config.sleep);
+    }
+    async registerHook(multi) {
+        if (this.config.hook?.topic) {
+            const signaler = new StoreSignaler(this.store, this.logger);
+            return await signaler.registerWebHook(this.config.hook.topic, this.context, multi);
+        }
+        else if (this.config.sleep) {
+            const durationInSeconds = Pipe.resolve(this.config.sleep, this.context);
+            const jobId = this.context.metadata.jid;
+            const activityId = this.metadata.aid;
+            const dId = this.metadata.dad;
+            await this.engine.task.registerTimeHook(jobId, `${activityId}${dId || ''}`, 'sleep', durationInSeconds);
+            return jobId;
+        }
+    }
+    async processWebHookEvent() {
+        this.logger.debug('engine-process-web-hook-event', {
+            topic: this.config.hook.topic,
+            aid: this.metadata.aid
+        });
+        const signaler = new StoreSignaler(this.store, this.logger);
+        const data = { ...this.data };
+        const jobId = await signaler.processWebHookSignal(this.config.hook.topic, data);
+        if (jobId) {
+            await this.processHookEvent(jobId);
+            await signaler.deleteWebHookSignal(this.config.hook.topic, data);
+        } //else => already resolved
+    }
+    async processTimeHookEvent(jobId) {
+        this.logger.debug('engine-process-time-hook-event', {
+            jid: jobId,
+            aid: this.metadata.aid
+        });
+        return await this.processHookEvent(jobId);
+    }
+    //todo: hooks are currently singletons. but they can support
+    //      dimensional threads like `await` and `worker` do.
+    //      Copy code from those activities to support cyclical
+    //      timehook and eventhook inputs by adding a 'pending'
+    //      flag to hooks that allows for repeated signals
+    async processHookEvent(jobId) {
+        this.logger.debug('activity-process-hook-event', { jobId });
+        let telemetry;
+        try {
+            this.setLeg(2);
+            await this.getState(jobId);
+            const aState = await CollatorService.notarizeReentry(this);
+            this.adjacentIndex = CollatorService.getDimensionalIndex(aState);
+            telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+            telemetry.startActivitySpan(this.leg);
+            this.bindActivityData('hook');
+            this.mapJobData();
+            this.adjacencyList = await this.filterAdjacent();
+            const multi = this.engine.store.getMulti();
+            await this.setState(multi);
+            await CollatorService.notarizeCompletion(this, multi);
+            await this.setStatus(this.adjacencyList.length - 1, multi);
+            const multiResponse = await multi.exec();
+            telemetry.mapActivityAttributes();
+            const jobStatus = this.resolveStatus(multiResponse);
+            const attrs = { 'app.job.jss': jobStatus };
+            const messageIds = await this.transition(this.adjacencyList, jobStatus);
+            if (messageIds.length) {
+                attrs['app.activity.mids'] = messageIds.join(',');
+            }
+            telemetry.setActivityAttributes(attrs);
+            return jobStatus;
+        }
+        catch (error) {
+            console.error('this error?', error);
+            this.logger.error('engine-process-hook-event-error', error);
+            telemetry.setActivityError(error.message);
+            throw error;
+        }
+        finally {
+            telemetry.endActivitySpan();
+        }
+    }
+    resolveStatus(multiResponse) {
+        const activityStatus = multiResponse[multiResponse.length - 1];
+        if (Array.isArray(activityStatus)) {
+            return Number(activityStatus[1]);
+        }
+        else {
+            return Number(activityStatus);
+        }
+    }
+    mapJobData() {
+        if (this.config.job?.maps) {
+            const mapper = new MapperService(this.config.job.maps, this.context);
+            this.context.data = mapper.mapRules();
+        }
+    }
+    mapInputData() {
+        if (this.config.input?.maps) {
+            const mapper = new MapperService(this.config.input.maps, this.context);
+            this.context.data = mapper.mapRules();
+        }
+    }
+    async registerTimeout() {
+        //set timeout in support of hook and/or duplex
+    }
+    bindActivityError(data) {
+        //todo: map activity error data into the job error (if defined)
+        //      map job status via: (500: [3**, 4**, 5**], 202: [$pending])
+        this.context.metadata.err = JSON.stringify(data);
+    }
+    async getTriggerConfig() {
+        return await this.store.getSchema(this.config.trigger, await this.engine.getVID());
+    }
+    getJobStatus() {
+        return null;
+    }
+    async setStatus(amount, multi) {
+        const { id: appId } = await this.engine.getVID();
+        await this.store.setStatus(amount, this.context.metadata.jid, appId, multi);
+    }
+    authorizeEntry(state) {
+        //pre-authorize activity state to allow entry for adjacent activities
+        return this.adjacencyList?.map((streamData) => {
+            const { metadata: { aid } } = streamData;
+            state[`${aid}/output/metadata/as`] = CollatorService.getSeed();
+            return aid;
+        }) ?? [];
+    }
+    bindDimensionalAddress(state) {
+        const dad = this.resolveDad();
+        state[`${this.metadata.aid}/output/metadata/dad`] = dad;
+    }
+    async setState(multi) {
+        const jobId = this.context.metadata.jid;
+        this.bindJobMetadata();
+        this.bindActivityMetadata();
+        let state = {};
+        await this.bindJobState(state);
+        const presets = this.authorizeEntry(state);
+        this.bindDimensionalAddress(state);
+        this.bindActivityState(state);
+        //symbolNames holds symkeys
+        const symbolNames = [
+            `$${this.config.subscribes}`,
+            this.metadata.aid,
+            ...presets
+        ];
+        const dIds = CollatorService.getDimensionsById([...this.config.ancestors, this.metadata.aid], this.resolveDad());
+        return await this.store.setState(state, this.getJobStatus(), jobId, symbolNames, dIds, multi);
+    }
+    bindJobMetadata() {
+        //both legs of the most recently run activity (1 and 2) modify ju (job_updated)
+        this.context.metadata.ju = formatISODate(new Date());
+    }
+    bindActivityMetadata() {
+        const self = this.context['$self'];
+        if (!self.output.metadata) {
+            self.output.metadata = {};
+        }
+        if (this.status === StreamStatus.ERROR) {
+            self.output.metadata.err = JSON.stringify(this.data);
+        }
+        //todo: verify leg2 never overwrites leg1 `ac`
+        self.output.metadata.ac =
+            self.output.metadata.au = formatISODate(new Date());
+        self.output.metadata.atp = this.config.type;
+        if (this.config.subtype) {
+            self.output.metadata.stp = this.config.subtype;
+        }
+        self.output.metadata.aid = this.metadata.aid;
+    }
+    async bindJobState(state) {
+        const triggerConfig = await this.getTriggerConfig();
+        const PRODUCES = [
+            ...(triggerConfig.PRODUCES || []),
+            ...this.bindJobMetadataPaths()
+        ];
+        for (const path of PRODUCES) {
+            const value = getValueByPath(this.context, path);
+            if (value !== undefined) {
+                state[path] = value;
+            }
+        }
+        TelemetryService.bindJobTelemetryToState(state, this.config, this.context);
+    }
+    bindActivityState(state) {
+        const produces = [
+            ...this.config.produces,
+            ...this.bindActivityMetadataPaths()
+        ];
+        for (const path of produces) {
+            const prefixedPath = `${this.metadata.aid}/${path}`;
+            const value = getValueByPath(this.context, prefixedPath);
+            if (value !== undefined) {
+                state[prefixedPath] = value;
+            }
+        }
+        TelemetryService.bindActivityTelemetryToState(state, this.config, this.metadata, this.context, this.leg);
+    }
+    bindJobMetadataPaths() {
+        return MDATA_SYMBOLS.JOB_UPDATE.KEYS.map((key) => `metadata/${key}`);
+    }
+    bindActivityMetadataPaths() {
+        const keys_to_save = this.leg === 1 ? 'ACTIVITY' : 'ACTIVITY_UPDATE';
+        return MDATA_SYMBOLS[keys_to_save].KEYS.map((key) => `output/metadata/${key}`);
+    }
+    async getState(jobId) {
+        //assemble list of paths necessary to create 'job state' from the 'symbol hash'
+        const jobSymbolHashName = `$${this.config.subscribes}`;
+        const consumes = {
+            [jobSymbolHashName]: MDATA_SYMBOLS.JOB.KEYS.map((key) => `metadata/${key}`)
+        };
+        for (let [activityId, paths] of Object.entries(this.config.consumes)) {
+            if (activityId === '$job') {
+                for (const path of paths) {
+                    consumes[jobSymbolHashName].push(path);
+                }
+            }
+            else {
+                if (activityId === '$self') {
+                    activityId = this.metadata.aid;
+                }
+                if (!consumes[activityId]) {
+                    consumes[activityId] = [];
+                }
+                for (const path of paths) {
+                    consumes[activityId].push(`${activityId}/${path}`);
+                }
+            }
+        }
+        TelemetryService.addTargetTelemetryPaths(consumes, this.config, this.metadata, this.leg);
+        let { dad, jid } = this.context.metadata;
+        jobId = jobId || jid;
+        //`state` is a flat hash
+        const dIds = CollatorService.getDimensionsById([...this.config.ancestors, this.metadata.aid], dad);
+        const [state, status] = await this.store.getState(jobId, consumes, dIds);
+        //`context` is a tree
+        this.context = restoreHierarchy(state);
+        this.initDimensionalAddress(dad);
+        this.initSelf(this.context);
+        this.initPolicies(this.context);
+    }
+    initDimensionalAddress(dad) {
+        this.metadata.dad = dad;
+    }
+    initSelf(context) {
+        const activityId = this.metadata.aid;
+        if (!context[activityId]) {
+            context[activityId] = {};
+        }
+        const self = context[activityId];
+        if (!self.output) {
+            self.output = {};
+        }
+        if (!self.input) {
+            self.input = {};
+        }
+        if (!self.hook) {
+            self.hook = {};
+        }
+        context['$self'] = self;
+        context['$job'] = context; //NEVER call STRINGIFY! (circular)
+        return context;
+    }
+    initPolicies(context) {
+        context.metadata.expire = this.config.expire;
+    }
+    bindActivityData(type) {
+        this.context[this.metadata.aid][type].data = this.data;
+    }
+    resolveDad() {
+        let dad = this.metadata.dad;
+        if (this.adjacentIndex > 0) {
+            //if adjacent index > 0 the activity is cycling; replace last index with cycle index
+            dad = `${dad.substring(0, dad.lastIndexOf(','))},${this.adjacentIndex}`;
+        }
+        return dad;
+    }
+    resolveAdjacentDad() {
+        //concat self and child dimension (all children (leg 1) begin life at 0)
+        return `${this.resolveDad()}${DimensionService.getSeed(0)}`;
+    }
+    ;
+    async filterAdjacent() {
+        const adjacencyList = [];
+        const transitions = await this.store.getTransitions(await this.engine.getVID());
+        const transition = transitions[`.${this.metadata.aid}`];
+        //resolve the dimensional address for adjacent children
+        const adjacentDad = this.resolveAdjacentDad();
+        if (transition) {
+            for (const toActivityId in transition) {
+                const transitionRule = transition[toActivityId];
+                if (MapperService.evaluate(transitionRule, this.context, this.code)) {
+                    adjacencyList.push({
+                        metadata: {
+                            jid: this.context.metadata.jid,
+                            dad: adjacentDad,
+                            aid: toActivityId,
+                            spn: this.context['$self'].output.metadata?.l2s,
+                            trc: this.context.metadata.trc,
+                        },
+                        type: StreamDataType.TRANSITION,
+                        data: {}
+                    });
+                }
+            }
+        }
+        return adjacencyList;
+    }
+    async transition(adjacencyList, jobStatus) {
+        let mIds = [];
+        if (adjacencyList.length) {
+            const multi = this.store.getMulti();
+            for (const execSignal of adjacencyList) {
+                await this.engine.streamSignaler?.publishMessage(null, execSignal, multi);
+            }
+            mIds = (await multi.exec());
+        }
+        else if (jobStatus <= 0) {
+            await this.engine.runJobCompletionTasks(this.context);
+        }
+        return mIds;
+    }
+}
+export { Activity };

package/build/esm/services/activities/await.d.ts

@@ -0,0 +1,16 @@
+import { Activity } from './activity';
+import { EngineService } from '../engine';
+import { ActivityData, ActivityMetadata, AwaitActivity, ActivityType } from '../../types/activity';
+import { JobState } from '../../types/job';
+import { MultiResponseFlags } from '../../types/redis';
+import { StreamCode, StreamData, StreamStatus } from '../../types/stream';
+declare class Await extends Activity {
+    config: AwaitActivity;
+    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
+    process(): Promise<string>;
+    execActivity(): Promise<string>;
+    processEvent(status?: StreamStatus, code?: StreamCode): Promise<void>;
+    processSuccess(adjacencyList: StreamData[]): Promise<MultiResponseFlags>;
+    processError(adjacencyList: StreamData[]): Promise<MultiResponseFlags>;
+}
+export { Await };

package/build/esm/services/activities/await.js

@@ -0,0 +1,140 @@
+import { GetStateError } from '../../modules/errors';
+import { Activity } from './activity';
+import { StreamDataType, StreamStatus } from '../../types/stream';
+import { TelemetryService } from '../telemetry';
+import { CollatorService } from '../collator';
+class Await extends Activity {
+    constructor(config, data, metadata, hook, engine, context) {
+        super(config, data, metadata, hook, engine, context);
+    }
+    //********  INITIAL ENTRY POINT (A)  ********//
+    async process() {
+        this.logger.debug('await-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+        let telemetry;
+        try {
+            this.setLeg(1);
+            await CollatorService.notarizeEntry(this);
+            await this.getState();
+            telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+            telemetry.startActivitySpan(this.leg);
+            this.mapInputData();
+            const multi = this.store.getMulti();
+            //await this.registerTimeout();
+            await CollatorService.authorizeReentry(this, multi);
+            await this.setState(multi);
+            await this.setStatus(0, multi);
+            const multiResponse = await multi.exec();
+            telemetry.mapActivityAttributes();
+            const jobStatus = this.resolveStatus(multiResponse);
+            const messageId = await this.execActivity();
+            telemetry.setActivityAttributes({
+                'app.activity.mid': messageId,
+                'app.job.jss': jobStatus
+            });
+            return this.context.metadata.aid;
+        }
+        catch (error) {
+            telemetry.setActivityError(error.message);
+            if (error instanceof GetStateError) {
+                this.logger.error('await-get-state-error', error);
+            }
+            else {
+                this.logger.error('await-process-error', error);
+            }
+            throw error;
+        }
+        finally {
+            telemetry.endActivitySpan();
+            this.logger.debug('await-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+        }
+    }
+    async execActivity() {
+        const streamData = {
+            metadata: {
+                jid: this.context.metadata.jid,
+                dad: this.metadata.dad,
+                aid: this.metadata.aid,
+                topic: this.config.subtype,
+                spn: this.context['$self'].output.metadata?.l1s,
+                trc: this.context.metadata.trc,
+            },
+            type: StreamDataType.AWAIT,
+            data: this.context.data
+        };
+        if (this.config.retry) {
+            streamData.policies = {
+                retry: this.config.retry
+            };
+        }
+        return (await this.engine.streamSignaler?.publishMessage(null, streamData));
+    }
+    //********  `RESOLVE` ENTRY POINT (B)  ********//
+    //this method is invoked when the job spawned by this job ends;
+    //`this.data` is the job data produced by the spawned job
+    async processEvent(status = StreamStatus.SUCCESS, code = 200) {
+        this.setLeg(2);
+        const jid = this.context.metadata.jid;
+        const aid = this.metadata.aid;
+        if (!jid) {
+            throw new Error('await-process-event-error');
+        }
+        this.logger.debug('await-resolve-await', { jid, aid, status, code });
+        this.status = status;
+        this.code = code;
+        let telemetry;
+        try {
+            await this.getState();
+            const aState = await CollatorService.notarizeReentry(this);
+            this.adjacentIndex = CollatorService.getDimensionalIndex(aState);
+            telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+            telemetry.startActivitySpan(this.leg);
+            let multiResponse = [];
+            if (status === StreamStatus.SUCCESS) {
+                this.bindActivityData('output');
+                this.adjacencyList = await this.filterAdjacent();
+                multiResponse = await this.processSuccess(this.adjacencyList);
+            }
+            else {
+                this.bindActivityError(this.data);
+                this.adjacencyList = await this.filterAdjacent();
+                multiResponse = await this.processError(this.adjacencyList);
+            }
+            telemetry.mapActivityAttributes();
+            const jobStatus = this.resolveStatus(multiResponse);
+            const attrs = { 'app.job.jss': jobStatus };
+            const messageIds = await this.transition(this.adjacencyList, jobStatus);
+            if (messageIds.length) {
+                attrs['app.activity.mids'] = messageIds.join(',');
+            }
+            telemetry.setActivityAttributes(attrs);
+        }
+        catch (error) {
+            this.logger.error('await-resolve-await-error', error);
+            telemetry.setActivityError(error.message);
+            throw error;
+        }
+        finally {
+            telemetry.endActivitySpan();
+            this.logger.debug('await-resolve-await-end', { jid, aid, status, code });
+        }
+    }
+    async processSuccess(adjacencyList) {
+        this.mapJobData();
+        const multi = this.store.getMulti();
+        await this.setState(multi);
+        await CollatorService.notarizeCompletion(this, multi);
+        await this.setStatus(adjacencyList.length - 1, multi);
+        return await multi.exec();
+    }
+    async processError(adjacencyList) {
+        //todo: if adjacencyList.length == 0, then map to the job output
+        //      this method would be added to Base activity class 
+        //this.mapJobData();
+        const multi = this.store.getMulti();
+        await this.setState(multi);
+        await CollatorService.notarizeCompletion(this, multi);
+        await this.setStatus(adjacencyList.length - 1, multi);
+        return await multi.exec();
+    }
+}
+export { Await };

package/build/esm/services/activities/emit.d.ts

@@ -0,0 +1,9 @@
+import { EngineService } from '../engine';
+import { Activity, ActivityType } from './activity';
+import { ActivityData, ActivityMetadata, EmitActivity } from '../../types/activity';
+declare class Emit extends Activity {
+    config: EmitActivity;
+    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService);
+    mapInputData(): Promise<void>;
+}
+export { Emit };

package/build/esm/services/activities/emit.js

@@ -0,0 +1,10 @@
+import { Activity } from './activity';
+class Emit extends Activity {
+    constructor(config, data, metadata, hook, engine) {
+        super(config, data, metadata, hook, engine);
+    }
+    async mapInputData() {
+        this.logger.info('emit-map-input-data');
+    }
+}
+export { Emit };

package/build/esm/services/activities/index.d.ts

@@ -0,0 +1,15 @@
+import { Activity } from './activity';
+import { Await } from './await';
+import { Worker } from './worker';
+import { Iterate } from './iterate';
+import { Emit } from './emit';
+import { Trigger } from './trigger';
+declare const _default: {
+    activity: typeof Activity;
+    await: typeof Await;
+    iterate: typeof Iterate;
+    emit: typeof Emit;
+    trigger: typeof Trigger;
+    worker: typeof Worker;
+};
+export default _default;

package/build/esm/services/activities/index.js

@@ -0,0 +1,14 @@
+import { Activity } from './activity';
+import { Await } from './await';
+import { Worker } from './worker';
+import { Iterate } from './iterate';
+import { Emit } from './emit';
+import { Trigger } from './trigger';
+export default {
+    activity: Activity,
+    await: Await,
+    iterate: Iterate,
+    emit: Emit,
+    trigger: Trigger,
+    worker: Worker,
+};

package/build/esm/services/activities/iterate.d.ts

@@ -0,0 +1,9 @@
+import { EngineService } from '../engine';
+import { Activity, ActivityType } from './activity';
+import { ActivityData, ActivityMetadata, IterateActivity } from '../../types/activity';
+declare class Iterate extends Activity {
+    config: IterateActivity;
+    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService);
+    mapInputData(): Promise<void>;
+}
+export { Iterate };

package/build/esm/services/activities/iterate.js

@@ -0,0 +1,10 @@
+import { Activity } from './activity';
+class Iterate extends Activity {
+    constructor(config, data, metadata, hook, engine) {
+        super(config, data, metadata, hook, engine);
+    }
+    async mapInputData() {
+        this.logger.info('iterate-map-input-data');
+    }
+}
+export { Iterate };

package/build/esm/services/activities/trigger.d.ts

@@ -0,0 +1,22 @@
+import { Activity } from './activity';
+import { EngineService } from '../engine';
+import { ActivityData, ActivityMetadata, ActivityType, TriggerActivity } from '../../types/activity';
+import { JobState } from '../../types/job';
+import { RedisMulti } from '../../types/redis';
+declare class Trigger extends Activity {
+    config: TriggerActivity;
+    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
+    process(): Promise<string>;
+    setStatus(amount: number): Promise<void>;
+    createInputContext(): Partial<JobState>;
+    getState(): Promise<void>;
+    bindJobMetadataPaths(): string[];
+    bindActivityMetadataPaths(): string[];
+    resolveGranularity(): string;
+    getJobStatus(): number;
+    resolveJobId(context: Partial<JobState>): string;
+    resolveJobKey(context: Partial<JobState>): string;
+    setStateNX(): Promise<void>;
+    setStats(multi?: RedisMulti): Promise<void>;
+}
+export { Trigger };