case-editor-tools 1.0.0-beta.4 → 1.0.0-beta.40

package/{build/constants → constants}/key-definitions.d.ts

@@ -10,4 +10,7 @@ export declare const sliderCategoricalKey = "scc";
 export declare const inputKey = "ic";
 export declare const numericInputKey = "num";
 export declare const datePickerKey = "date";
+export declare const timeInputKey = "time";
 export declare const matrixKey = "mat";
+export declare const clozeKey = "cloze";
+export declare const consentKey = "con";

package/{build/constants → constants}/key-definitions.js

@@ -14,8 +14,13 @@ const sliderCategoricalKey = "scc";
 const inputKey = "ic";
 const numericInputKey = "num";
 const datePickerKey = "date";
-const matrixKey = "mat";
+const timeInputKey = "time";
+const matrixKey = "mat";
+const clozeKey = "cloze";
+const consentKey = "con";
 
+exports.clozeKey = clozeKey;
+exports.consentKey = consentKey;
 exports.datePickerKey = datePickerKey;
 exports.dropDownKey = dropDownKey;
 exports.inputKey = inputKey;
@@ -29,4 +34,5 @@ exports.responsiveBipolarLikertArrayKey = responsiveBipolarLikertArrayKey;
 exports.responsiveSingleChoiceArrayKey = responsiveSingleChoiceArrayKey;
 exports.singleChoiceKey = singleChoiceKey;
 exports.sliderCategoricalKey = sliderCategoricalKey;
+exports.timeInputKey = timeInputKey;
 //# sourceMappingURL=key-definitions.js.map

package/{build/constants → constants}/key-definitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"key-definitions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"key-definitions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/exporter/index.d.ts

@@ -0,0 +1,2 @@
+import { Study } from "../types/study";
+export declare const generateFilesForStudy: (study: Study, pretty?: boolean | undefined) => void;

package/exporter/index.js

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fs = require('fs');
+var logger_logger = require('../logger/logger.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+
+const generateFilesForStudy = (study, pretty) => {
+    const outputName = study.outputFolderName ? study.outputFolderName : study.studyKey;
+    const outputRoot = `./output/${outputName}`;
+    logger_logger.Logger.log(`Start generating files for study ${outputName}.`);
+    if (!fs__default["default"].existsSync(outputRoot)) {
+        fs__default["default"].mkdirSync(outputRoot, { recursive: true });
+    }
+    // Surveys:
+    generateSurveyFiles(study, outputRoot, pretty);
+    // Study rules:
+    generateStudyRuleFile(study, outputRoot, pretty);
+    // Custom Study rules: (manually triggered rules)
+    generateCustomStudyRules(study, outputRoot, pretty);
+};
+const generateSurveyFiles = (study, outputPath, pretty) => {
+    if (study.surveys.length > 0) {
+        logger_logger.Logger.log(`\tSurveys:`);
+    }
+    else {
+        logger_logger.Logger.log(`\tNo surveys in the study.`);
+    }
+    const surveyOutPath = `${outputPath}/surveys`;
+    if (!fs__default["default"].existsSync(surveyOutPath)) {
+        fs__default["default"].mkdirSync(surveyOutPath, { recursive: true });
+    }
+    study.surveys.forEach(survey => {
+        const fileName = `${surveyOutPath}/${survey.key}.json`;
+        const outputObject = {
+            studyKey: study.studyKey,
+            survey: survey.getSurvey()
+        };
+        try {
+            fs__default["default"].writeFileSync(fileName, JSON.stringify(outputObject, undefined, pretty ? 2 : undefined));
+        }
+        catch (err) {
+            logger_logger.Logger.error(err);
+            return;
+        }
+        logger_logger.Logger.success(`\t\t${survey.key} saved`);
+    });
+};
+const generateStudyRuleFile = (study, outputPath, pretty) => {
+    if (!study.studyRules) {
+        logger_logger.Logger.log(`\tNo study rules in the study.`);
+        return;
+    }
+    else {
+        logger_logger.Logger.log(`\tStudy rule:`);
+    }
+    const fileName = `${outputPath}/studyRules.json`;
+    const outputObject = study.studyRules.get();
+    try {
+        fs__default["default"].writeFileSync(fileName, JSON.stringify(outputObject, undefined, pretty ? 2 : undefined));
+    }
+    catch (err) {
+        logger_logger.Logger.error(err);
+        return;
+    }
+    logger_logger.Logger.success(`\t\tStudy rules saved`);
+};
+const generateCustomStudyRules = (study, outputPath, pretty) => {
+    if (!study.customStudyRules || study.customStudyRules.length < 0) {
+        logger_logger.Logger.log(`\tNo custom study rules in the study.`);
+        return;
+    }
+    else {
+        logger_logger.Logger.log(`\tCustom study rules:`);
+    }
+    const customRulePath = `${outputPath}/customRules`;
+    if (!fs__default["default"].existsSync(customRulePath)) {
+        fs__default["default"].mkdirSync(customRulePath, { recursive: true });
+    }
+    study.customStudyRules.forEach(studyRule => {
+        const fileName = `${customRulePath}/${studyRule.name}.json`;
+        const outputObject = studyRule.rules;
+        try {
+            fs__default["default"].writeFileSync(fileName, JSON.stringify(outputObject, undefined, pretty ? 2 : undefined));
+        }
+        catch (err) {
+            logger_logger.Logger.error(err);
+            return;
+        }
+        logger_logger.Logger.success(`\t\tRule ${studyRule.name} saved`);
+    });
+};
+
+exports.generateFilesForStudy = generateFilesForStudy;
+//# sourceMappingURL=index.js.map

package/exporter/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/{build/expression-utils → expression-utils}/expressionGen.d.ts

@@ -1,2 +1,2 @@
-import { Expression, ExpressionName } from "survey-engine/lib/data_types";
+import { Expression, ExpressionName } from "survey-engine/data_types";
 export declare const generateExpression: (name: ExpressionName, returnType?: "string" | "float" | undefined, ...args: any[]) => Expression;

package/{build/expression-utils → expression-utils}/studyEngineExpressions.d.ts

@@ -1,12 +1,14 @@
-import { Expression } from "survey-engine/lib/data_types";
+import { Expression } from "survey-engine/data_types";
 import { Duration } from "../types/duration";
 export declare const NativeStudyEngineExpressions: {
-    checkEventType: (equalsType: 'ENTER' | 'SUBMIT' | 'TIMER') => Expression;
+    checkEventType: (equalsType: 'ENTER' | 'SUBMIT' | 'TIMER' | 'MERGE') => Expression;
     checkSurveyResponseKey: (surveyKey: string) => Expression;
     responseHasKeysAny: (itemKey: string, responseSlotKey: string, ...optionKeys: string[]) => Expression;
     responseHasOnlyKeysOtherThan: (itemKey: string, responseSlotKey: string, ...optionKeys: string[]) => Expression;
     getResponseValueAsNum: (itemKey: string, responseKey: string) => Expression;
     getResponseValueAsStr: (itemKey: string, responseKey: string) => Expression;
+    hasResponseKey: (itemKey: string, responseKey: string) => Expression;
+    hasResponseKeyWithValue: (itemKey: string, responseKey: string, value: string) => Expression;
     countResponseItems: (itemKey: string, responseKey: string) => Expression;
     checkConditionForOldResponses: (condition: Expression, checkType?: number | "all" | "any" | undefined, surveyKey?: string | undefined, querySince?: number | Expression | undefined, queryUntil?: number | Expression | undefined) => Expression;
     participantState: {
@@ -15,8 +17,23 @@ export declare const NativeStudyEngineExpressions: {
         getSurveyKeyAssignedFrom: (surveyKey: string) => Expression;
         getSurveyKeyAssignedUntil: (surveyKey: string) => Expression;
         hasStudyStatus: (status: string) => Expression;
-        hasParticipantFlag: (key: string, value: string) => Expression;
+        hasParticipantFlagKeyAndValue: (key: string, value: string) => Expression;
+        hasParticipantFlagKey: (key: string) => Expression;
         lastSubmissionDateOlderThan: (reference: number | Expression, surveyKey?: string | undefined) => Expression;
+        hasMessageTypeAssigned: (messageType: string) => Expression;
+        getMessageNextTime: (messageType: string) => Expression;
+        incomingParticipantState: {
+            getStudyEntryTime: () => Expression;
+            hasSurveyKeyAssigned: (surveyKey: string) => Expression;
+            getSurveyKeyAssignedFrom: (surveyKey: string) => Expression;
+            getSurveyKeyAssignedUntil: (surveyKey: string) => Expression;
+            hasStudyStatus: (status: string) => Expression;
+            hasParticipantFlagKeyAndValue: (key: string, value: string) => Expression;
+            hasParticipantFlagKey: (key: string) => Expression;
+            lastSubmissionDateOlderThan: (reference: number | Expression, surveyKey?: string | undefined) => Expression;
+            hasMessageTypeAssigned: (messageType: string) => Expression;
+            getMessageNextTime: (messageType: string) => Expression;
+        };
     };
     eq: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
     lt: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
@@ -34,17 +51,30 @@ export declare const StudyEngineActions: {
     ifThen: (condition: Expression, ...args: Expression[]) => Expression;
     participantActions: {
         updateStudyStatus: (status: string) => Expression;
-        updateFlag: (key: string, newValue: string) => Expression;
+        updateFlag: (key: string, newValue: string | number | Expression) => Expression;
         removeFlag: (key: string) => Expression;
         assignedSurveys: {
-            add: (surveyKey: string, category: 'prio' | 'normal' | 'optional', activeFrom?: number | Expression | undefined, activeUntil?: number | Expression | undefined) => Expression;
+            add: (surveyKey: string, category: 'immediate' | 'prio' | 'normal' | 'optional', activeFrom?: number | Expression | undefined, activeUntil?: number | Expression | undefined) => Expression;
             removeAll: () => Expression;
             remove: (surveyKey: string, selector: 'first' | 'last' | 'all') => Expression;
         };
         reports: {
-            add: (itemKey: string) => Expression;
+            init: (reportKey: string) => Expression;
+            cancel: (reportKey: string) => Expression;
+            updateData: (reportKey: string, attributeKey: string, value: number | string | Expression, dtype?: "string" | "date" | "float" | "int" | "rawMessage" | undefined) => Expression;
+            removeData: (reportKey: string, attributeKey: string) => Expression;
+            setReportIcon: (reportKey: string, icon: string) => Expression;
+            setReportMessage: (reportKey: string, content: string, asTranslationKey?: boolean | undefined) => Expression;
+            setReportSummary: (reportKey: string, content: string, asTranslationKey?: boolean | undefined) => Expression;
+        };
+        messages: {
+            add: (messageType: string, scheduledFor: number | Expression) => Expression;
+            removeAll: () => Expression;
+            remove: (messageType: string) => Expression;
+        };
+        confidentialResponses: {
+            removeByKey: (key: string) => Expression;
             removeAll: () => Expression;
-            remove: (surveyKey: string, selector: 'first' | 'last' | 'all') => Expression;
         };
         stopParticipation: () => Expression;
         finishParticipation: () => Expression;
@@ -60,37 +90,65 @@ export declare const StudyEngine: {
         none: (itemKey: string, ...optionKeys: string[]) => Expression;
         all: (itemKey: string, ...optionKeys: string[]) => Expression;
     };
+    consent: {
+        accepted: (itemKey: string) => Expression;
+    };
     survey: {
         isActive: (surveyKey: string) => Expression;
         validFromOlderThan: (surveyKey: string, delta: Duration, reference?: number | Expression | undefined) => Expression;
         validUntilSoonerThan: (surveyKey: string, delta: Duration, reference?: number | Expression | undefined) => Expression;
     };
+    prefillRules: {
+        GET_LAST_SURVEY_ITEM: (surveyKey: string, itemKey: string, submittedLaterThan?: Duration | undefined) => Expression;
+    };
+    contextRules: {
+        previousResponses: {
+            LAST_RESPONSES_BY_KEY: (surveyKey: string, limit: number) => Expression;
+            ALL_RESPONSES_SINCE: (sinceTimestamp: number) => Expression;
+            RESPONSES_SINCE_BY_KEY: (sinceTimestamp: number, surveyKey: string) => Expression;
+        };
+    };
     if: (condition: Expression, actionIfTrue: Expression, actionIfFalse?: Expression | undefined) => Expression;
     do: (...args: Expression[]) => Expression;
     ifThen: (condition: Expression, ...args: Expression[]) => Expression;
     participantActions: {
         updateStudyStatus: (status: string) => Expression;
-        updateFlag: (key: string, newValue: string) => Expression;
+        updateFlag: (key: string, newValue: string | number | Expression) => Expression;
         removeFlag: (key: string) => Expression;
         assignedSurveys: {
-            add: (surveyKey: string, category: 'prio' | 'normal' | 'optional', activeFrom?: number | Expression | undefined, activeUntil?: number | Expression | undefined) => Expression;
+            add: (surveyKey: string, category: 'immediate' | 'prio' | 'normal' | 'optional', activeFrom?: number | Expression | undefined, activeUntil?: number | Expression | undefined) => Expression;
             removeAll: () => Expression;
             remove: (surveyKey: string, selector: 'first' | 'last' | 'all') => Expression;
         };
         reports: {
-            add: (itemKey: string) => Expression;
+            init: (reportKey: string) => Expression;
+            cancel: (reportKey: string) => Expression;
+            updateData: (reportKey: string, attributeKey: string, value: number | string | Expression, dtype?: "string" | "date" | "float" | "int" | "rawMessage" | undefined) => Expression;
+            removeData: (reportKey: string, attributeKey: string) => Expression;
+            setReportIcon: (reportKey: string, icon: string) => Expression;
+            setReportMessage: (reportKey: string, content: string, asTranslationKey?: boolean | undefined) => Expression;
+            setReportSummary: (reportKey: string, content: string, asTranslationKey?: boolean | undefined) => Expression;
+        };
+        messages: {
+            add: (messageType: string, scheduledFor: number | Expression) => Expression;
+            removeAll: () => Expression;
+            remove: (messageType: string) => Expression;
+        };
+        confidentialResponses: {
+            removeByKey: (key: string) => Expression;
             removeAll: () => Expression;
-            remove: (surveyKey: string, selector: 'first' | 'last' | 'all') => Expression;
         };
         stopParticipation: () => Expression;
         finishParticipation: () => Expression;
     };
-    checkEventType: (equalsType: 'ENTER' | 'SUBMIT' | 'TIMER') => Expression;
+    checkEventType: (equalsType: 'ENTER' | 'SUBMIT' | 'TIMER' | 'MERGE') => Expression;
     checkSurveyResponseKey: (surveyKey: string) => Expression;
     responseHasKeysAny: (itemKey: string, responseSlotKey: string, ...optionKeys: string[]) => Expression;
     responseHasOnlyKeysOtherThan: (itemKey: string, responseSlotKey: string, ...optionKeys: string[]) => Expression;
     getResponseValueAsNum: (itemKey: string, responseKey: string) => Expression;
     getResponseValueAsStr: (itemKey: string, responseKey: string) => Expression;
+    hasResponseKey: (itemKey: string, responseKey: string) => Expression;
+    hasResponseKeyWithValue: (itemKey: string, responseKey: string, value: string) => Expression;
     countResponseItems: (itemKey: string, responseKey: string) => Expression;
     checkConditionForOldResponses: (condition: Expression, checkType?: number | "all" | "any" | undefined, surveyKey?: string | undefined, querySince?: number | Expression | undefined, queryUntil?: number | Expression | undefined) => Expression;
     participantState: {
@@ -99,8 +157,23 @@ export declare const StudyEngine: {
         getSurveyKeyAssignedFrom: (surveyKey: string) => Expression;
         getSurveyKeyAssignedUntil: (surveyKey: string) => Expression;
         hasStudyStatus: (status: string) => Expression;
-        hasParticipantFlag: (key: string, value: string) => Expression;
+        hasParticipantFlagKeyAndValue: (key: string, value: string) => Expression;
+        hasParticipantFlagKey: (key: string) => Expression;
         lastSubmissionDateOlderThan: (reference: number | Expression, surveyKey?: string | undefined) => Expression;
+        hasMessageTypeAssigned: (messageType: string) => Expression;
+        getMessageNextTime: (messageType: string) => Expression;
+        incomingParticipantState: {
+            getStudyEntryTime: () => Expression;
+            hasSurveyKeyAssigned: (surveyKey: string) => Expression;
+            getSurveyKeyAssignedFrom: (surveyKey: string) => Expression;
+            getSurveyKeyAssignedUntil: (surveyKey: string) => Expression;
+            hasStudyStatus: (status: string) => Expression;
+            hasParticipantFlagKeyAndValue: (key: string, value: string) => Expression;
+            hasParticipantFlagKey: (key: string) => Expression;
+            lastSubmissionDateOlderThan: (reference: number | Expression, surveyKey?: string | undefined) => Expression;
+            hasMessageTypeAssigned: (messageType: string) => Expression;
+            getMessageNextTime: (messageType: string) => Expression;
+        };
     };
     eq: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
     lt: (val1: Expression | string | number, val2: Expression | string | number) => Expression;

package/{build/expression-utils → expression-utils}/studyEngineExpressions.js

@@ -11,7 +11,7 @@ const and = (...args) => expressionUtils_expressionGen.generateExpression('and',
 const not = (arg) => expressionUtils_expressionGen.generateExpression('not', undefined, arg);
 /**
  * Check if the current event has the given type
- * @param equalsType string with the possible values: 'ENTER', 'SUBMIT', 'TIMER
+ * @param equalsType string with the possible values: 'ENTER', 'SUBMIT', 'TIMER', 'MERGE'
  * @returns if event type matches the argument, return true otherwise false
  */
 const checkEventType = (equalsType) => expressionUtils_expressionGen.generateExpression('checkEventType', undefined, equalsType);
@@ -37,6 +37,25 @@ const responseHasKeysAny = (itemKey, responseSlotKey, ...optionKeys) => expressi
  * @returns true if a response key is present, but is not in the list defined by optionKeys. If item or the response group is not found, returns false.
  */
 const responseHasOnlyKeysOtherThan = (itemKey, responseSlotKey, ...optionKeys) => expressionUtils_expressionGen.generateExpression('responseHasOnlyKeysOtherThan', undefined, itemKey, responseSlotKey, ...optionKeys);
+/**
+ *
+ * @param itemKey full key to the survey item, in the form, e.g., <surveyKey>.<groupKey>.<itemKey>
+ * @param responseKey  full key to the response that should exists
+ * @returns if item contains responseKey return true
+ */
+const hasResponseKey = (itemKey, responseKey) => {
+    return expressionUtils_expressionGen.generateExpression('hasResponseKey', undefined, itemKey, responseKey);
+};
+/**
+ *
+ * @param itemKey full key to the survey item, in the form, e.g., <surveyKey>.<groupKey>.<itemKey>
+ * @param responseKey full key to the response that should exists
+ * @param value the response object with the above key should have this value
+ * @returns if the response object exists and has the value return true
+ */
+const hasResponseKeyWithValue = (itemKey, responseKey, value) => {
+    return expressionUtils_expressionGen.generateExpression('hasResponseKeyWithValue', undefined, itemKey, responseKey, value);
+};
 const getResponseValueAsNum = (itemKey, responseKey) => {
     return expressionUtils_expressionGen.generateExpression('getResponseValueAsNum', 'float', itemKey, responseKey);
 };
@@ -61,37 +80,64 @@ const checkConditionForOldResponses = (condition, checkType, surveyKey, querySin
  * @returns timestamp
  */
 const getStudyEntryTime = () => expressionUtils_expressionGen.generateExpression('getStudyEntryTime');
+const getStudyEntryTimeForIncoming = () => expressionUtils_expressionGen.generateExpression('incomingState:getStudyEntryTime');
 /**
  * Determines if a specific survey key is currently assigned to the participant.
  * @param surveyKey - string - key of the survey to check for.
  * @returns true if the participant has a survey with this surveyKey assigned, otherwise false.
  */
 const hasSurveyKeyAssigned = (surveyKey) => expressionUtils_expressionGen.generateExpression('hasSurveyKeyAssigned', undefined, surveyKey);
+const hasSurveyKeyAssignedForIncoming = (surveyKey) => expressionUtils_expressionGen.generateExpression('incomingState:hasSurveyKeyAssigned', undefined, surveyKey);
 /**
  * Method to access the timestamp for a surveyKey is assigned from
  * @param surveyKey - string - key of the survey to check for.
  * @returns timestamp
  */
 const getSurveyKeyAssignedFrom = (surveyKey) => expressionUtils_expressionGen.generateExpression('getSurveyKeyAssignedFrom', undefined, surveyKey);
+const getSurveyKeyAssignedFromForIncoming = (surveyKey) => expressionUtils_expressionGen.generateExpression('incomingState:getSurveyKeyAssignedFrom', undefined, surveyKey);
 /**
  * Method to access the timestamp for a surveyKey is assigned until
  * @param surveyKey - string - key of the survey to check for.
  * @returns timestamp
  */
 const getSurveyKeyAssignedUntil = (surveyKey) => expressionUtils_expressionGen.generateExpression('getSurveyKeyAssignedUntil', undefined, surveyKey);
+const getSurveyKeyAssignedUntilForIncoming = (surveyKey) => expressionUtils_expressionGen.generateExpression('incomingState:getSurveyKeyAssignedUntil', undefined, surveyKey);
 /**
  * Check if a participant has a specific study status
  * @param status - string
  * @returns true/false
  */
 const hasStudyStatus = (status) => expressionUtils_expressionGen.generateExpression('getSurveyKeyAssignedUntil', undefined, status);
+const hasStudyStatusForIncoming = (status) => expressionUtils_expressionGen.generateExpression('incomingState:getSurveyKeyAssignedUntil', undefined, status);
 /**
- * Check if a participant flag is present
+ * Check if a participant flag with specific value is present
  * @param key look up this flag
  * @param value and for this value
  * @returns return true if key - value pair (with case sensitive matching for both key and value) is present. If any of the two is different, or participant flags is empty, it returns false.
  */
-const hasParticipantFlag = (key, value) => expressionUtils_expressionGen.generateExpression('hasParticipantFlag', undefined, key, value);
+const hasParticipantFlagKeyAndValue = (key, value) => expressionUtils_expressionGen.generateExpression('hasParticipantFlag', undefined, key, value);
+const hasParticipantFlagKeyAndValueForIncoming = (key, value) => expressionUtils_expressionGen.generateExpression('incomingState:hasParticipantFlag', undefined, key, value);
+/**
+ * Check if a participant flag is present
+ * @param key look up this flag
+ * @returns return true if key is present. If any of the two is different, or participant flags is empty, it returns false.
+ */
+const hasParticipantFlagKey = (key) => expressionUtils_expressionGen.generateExpression('hasParticipantFlagKey', undefined, key);
+const hasParticipantFlagKeyForIncoming = (key) => expressionUtils_expressionGen.generateExpression('incomingState:hasParticipantFlagKey', undefined, key);
+/**
+ * Checks if the participant has a message type assigned (at least one)
+ * @param messageType
+ * @returns return true if a message with the given message type is assigned
+ */
+const hasMessageTypeAssigned = (messageType) => expressionUtils_expressionGen.generateExpression('hasMessageTypeAssigned', undefined, messageType);
+const hasMessageTypeAssignedForIncoming = (messageType) => expressionUtils_expressionGen.generateExpression('incomingState:hasMessageTypeAssigned', undefined, messageType);
+/**
+ * Retrieve the timestamp (scheduledFor) for a particular message type. Return 0 if not assigned.
+ * @param messageType
+ * @returns timestamp value or zero
+ */
+const getMessageNextTime = (messageType) => expressionUtils_expressionGen.generateExpression('getMessageNextTime', undefined, messageType);
+const getMessageNextTimeForIncoming = (messageType) => expressionUtils_expressionGen.generateExpression('incomingState:getMessageNextTime', undefined, messageType);
 /**
  * Check if the last submission is older than the reference timestamp
  * @param reference look up this flag
@@ -99,6 +145,7 @@ const hasParticipantFlag = (key, value) => expressionUtils_expressionGen.generat
  * @returns boolean
  */
 const lastSubmissionDateOlderThan = (reference, surveyKey) => expressionUtils_expressionGen.generateExpression('lastSubmissionDateOlderThan', undefined, reference, surveyKey);
+const lastSubmissionDateOlderThanForIncoming = (reference, surveyKey) => expressionUtils_expressionGen.generateExpression('incomingState:lastSubmissionDateOlderThan', undefined, reference, surveyKey);
 const eq = (val1, val2) => expressionUtils_expressionGen.generateExpression('eq', undefined, val1, val2);
 const lt = (val1, val2) => expressionUtils_expressionGen.generateExpression('lt', undefined, val1, val2);
 const lte = (val1, val2) => expressionUtils_expressionGen.generateExpression('lte', undefined, val1, val2);
@@ -141,7 +188,7 @@ const UPDATE_STUDY_STATUS = (status) => expressionUtils_expressionGen.generateEx
 /**
  * Add or update a participant flag
  * @param key
- * @param newValue
+ * @param newValue: string, number or expression where result should be written in the flag's value
  * @returns
  */
 const UPDATE_FLAG = (key, newValue) => expressionUtils_expressionGen.generateExpression('UPDATE_FLAG', undefined, key, newValue);
@@ -149,11 +196,23 @@ const REMOVE_FLAG = (key) => expressionUtils_expressionGen.generateExpression('R
 const ADD_NEW_SURVEY = (surveyKey, category, activeFrom, activeUntil) => expressionUtils_expressionGen.generateExpression('ADD_NEW_SURVEY', undefined, surveyKey, activeFrom !== undefined ? activeFrom : 0, activeUntil !== undefined ? activeUntil : 0, category);
 const REMOVE_ALL_SURVEYS = () => expressionUtils_expressionGen.generateExpression('REMOVE_ALL_SURVEYS');
 /**
- * When submitting the response, item response with the given key would be added to the report array
- * @param itemKey find and add this item to the report array
+ * Add participant message
+ * @param messageType message type
+ * @param scheduledFor timestamp or expression returning a timestamp
+ * @returns
+ */
+const ADD_MESSAGE = (messageType, scheduledFor) => expressionUtils_expressionGen.generateExpression('ADD_MESSAGE', undefined, messageType, scheduledFor);
+/**
+ * Remove all messages scheduled for the participant
  * @returns
  */
-const ADD_REPORT = (itemKey) => expressionUtils_expressionGen.generateExpression('ADD_REPORT', undefined, itemKey);
+const REMOVE_ALL_MESSAGES = () => expressionUtils_expressionGen.generateExpression('REMOVE_ALL_MESSAGES', undefined);
+/**
+ * Remove all messages with this message type
+ * @param messageType message type
+ * @returns
+ */
+const REMOVE_MESSAGES_BY_TYPE = (messageType) => expressionUtils_expressionGen.generateExpression('REMOVE_MESSAGES_BY_TYPE', undefined, messageType);
 const REMOVE_SURVEY_BY_KEY = (surveyKey, selector) => {
     if (selector === 'all') {
         return expressionUtils_expressionGen.generateExpression('REMOVE_SURVEYS_BY_KEY', undefined, surveyKey);
@@ -162,14 +221,80 @@ const REMOVE_SURVEY_BY_KEY = (surveyKey, selector) => {
         return expressionUtils_expressionGen.generateExpression('REMOVE_SURVEY_BY_KEY', undefined, surveyKey, selector);
     }
 };
-const REMOVE_ALL_REPORTS = () => expressionUtils_expressionGen.generateExpression('REMOVE_ALL_REPORTS');
-const REMOVE_REPORT_BY_KEY = (surveyKey, selector) => {
-    if (selector === 'all') {
-        return expressionUtils_expressionGen.generateExpression('REMOVE_REPORTS_BY_KEY', undefined, surveyKey);
-    }
-    else {
-        return expressionUtils_expressionGen.generateExpression('REMOVE_REPORT_BY_KEY', undefined, surveyKey, selector);
-    }
+/**
+ * Initialises or resets a report for the current event
+ * @param reportKey key to be used for the report
+ */
+const INIT_REPORT = (reportKey) => {
+    return expressionUtils_expressionGen.generateExpression('INIT_REPORT', undefined, reportKey);
+};
+/**
+ * Remove the report from the list of reports to be added at the end of the event
+ * @param reportKey key of the report that should be removed
+ * @returns
+ */
+const CANCEL_REPORT = (reportKey) => {
+    return expressionUtils_expressionGen.generateExpression('CANCEL_REPORT', undefined, reportKey);
+};
+/**
+ * Remove the confidential responses with this key for the participant
+ * @param key key of the confidential responses that should be removed
+ * @returns
+ */
+const REMOVE_CONFIDENTIAL_RESPONSE_BY_KEY = (key) => {
+    return expressionUtils_expressionGen.generateExpression('REMOVE_CONFIDENTIAL_RESPONSE_BY_KEY', undefined, key);
+};
+/**
+ * Remove all confidential responses for the participant
+ * @returns
+ */
+const REMOVE_ALL_CONFIDENTIAL_RESPONSES = () => {
+    return expressionUtils_expressionGen.generateExpression('REMOVE_ALL_CONFIDENTIAL_RESPONSES', undefined);
+};
+/**
+ * Update one value attribute in a report. If report was not initialized, one will be added to the list.
+ * @param reportKey
+ * @param attributeKey update / create this attribute in the report
+ * @param value this should be the value for the given attribute
+ * @param dtype optional dtype to set info for the app how to render this data.
+ * @returns
+ */
+const UPDATE_REPORT_DATA = (reportKey, attributeKey, value, dtype) => {
+    return expressionUtils_expressionGen.generateExpression('UPDATE_REPORT_DATA', undefined, reportKey, attributeKey, value, dtype);
+};
+/**
+ * Method to remove one attribute (key and value) from the report
+ * @param reportKey
+ * @param attributeKey
+ * @returns
+ */
+const REMOVE_REPORT_DATA = (reportKey, attributeKey) => {
+    return expressionUtils_expressionGen.generateExpression('REMOVE_REPORT_DATA', undefined, reportKey, attributeKey);
+};
+const setReportIcon = (reportKey, icon) => {
+    return UPDATE_REPORT_DATA(reportKey, 'icon', icon);
+};
+const setReportMessage = (reportKey, content, asTranslationKey) => {
+    return UPDATE_REPORT_DATA(reportKey, 'message', content, asTranslationKey ? undefined : 'rawMessage');
+};
+const setReportSummary = (reportKey, content, asTranslationKey) => {
+    return UPDATE_REPORT_DATA(reportKey, 'summary', content, asTranslationKey ? undefined : 'rawMessage');
+};
+// ##################
+// Prefill rule methods:
+const GET_LAST_SURVEY_ITEM = (surveyKey, itemKey, submittedLaterThan) => {
+    return expressionUtils_expressionGen.generateExpression('GET_LAST_SURVEY_ITEM', undefined, surveyKey, itemKey, submittedLaterThan ? types_duration.durationObjectToSeconds(submittedLaterThan) : undefined);
+};
+// ##################
+// Context previous responses methods:
+const LAST_RESPONSES_BY_KEY = (surveyKey, limit) => {
+    return expressionUtils_expressionGen.generateExpression('LAST_RESPONSES_BY_KEY', undefined, surveyKey, limit);
+};
+const ALL_RESPONSES_SINCE = (sinceTimestamp) => {
+    return expressionUtils_expressionGen.generateExpression('ALL_RESPONSES_SINCE', undefined, sinceTimestamp);
+};
+const RESPONSES_SINCE_BY_KEY = (sinceTimestamp, surveyKey) => {
+    return expressionUtils_expressionGen.generateExpression('RESPONSES_SINCE_BY_KEY', undefined, sinceTimestamp, surveyKey);
 };
 // ##################
 // Extra methods:
@@ -178,6 +303,9 @@ const multipleChoiceOptionsSelected = (itemKey, ...optionKeys) => expressionUtil
 const multipleChoiceAllOfTheseSelected = (itemKey, ...optionKeys) => and(...optionKeys.map(option => expressionUtils_expressionGen.generateExpression('responseHasKeysAny', undefined, itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.multipleChoiceKey].join('.'), option)));
 const multipleChoiceOnlyOtherKeysSelected = (itemKey, ...optionKeys) => expressionUtils_expressionGen.generateExpression('responseHasOnlyKeysOtherThan', undefined, itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.multipleChoiceKey].join('.'), ...optionKeys);
 const singleChoiceOnlyOtherOptionSelected = (itemKey, ...optionKeys) => expressionUtils_expressionGen.generateExpression('responseHasOnlyKeysOtherThan', undefined, itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.singleChoiceKey].join('.'), ...optionKeys);
+const consentAcceptedCondition = (itemKey) => {
+    return hasResponseKey(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.consentKey].join('.'));
+};
 const stopParticipation = () => UPDATE_STUDY_STATUS('inactive');
 const finishParticipation = () => UPDATE_STUDY_STATUS('finished');
 /**
@@ -216,6 +344,8 @@ const NativeStudyEngineExpressions = {
     responseHasOnlyKeysOtherThan,
     getResponseValueAsNum,
     getResponseValueAsStr,
+    hasResponseKey,
+    hasResponseKeyWithValue,
     countResponseItems,
     // Old responses
     checkConditionForOldResponses,
@@ -226,8 +356,24 @@ const NativeStudyEngineExpressions = {
         getSurveyKeyAssignedFrom,
         getSurveyKeyAssignedUntil,
         hasStudyStatus,
-        hasParticipantFlag,
+        hasParticipantFlagKeyAndValue,
+        hasParticipantFlagKey,
         lastSubmissionDateOlderThan,
+        hasMessageTypeAssigned,
+        getMessageNextTime,
+        incomingParticipantState: {
+            // for merge event
+            getStudyEntryTime: getStudyEntryTimeForIncoming,
+            hasSurveyKeyAssigned: hasSurveyKeyAssignedForIncoming,
+            getSurveyKeyAssignedFrom: getSurveyKeyAssignedFromForIncoming,
+            getSurveyKeyAssignedUntil: getSurveyKeyAssignedUntilForIncoming,
+            hasStudyStatus: hasStudyStatusForIncoming,
+            hasParticipantFlagKeyAndValue: hasParticipantFlagKeyAndValueForIncoming,
+            hasParticipantFlagKey: hasParticipantFlagKeyForIncoming,
+            lastSubmissionDateOlderThan: lastSubmissionDateOlderThanForIncoming,
+            hasMessageTypeAssigned: hasMessageTypeAssignedForIncoming,
+            getMessageNextTime: getMessageNextTimeForIncoming,
+        }
     },
     // logical and comparision
     eq,
@@ -255,9 +401,23 @@ const StudyEngineActions = {
             remove: REMOVE_SURVEY_BY_KEY,
         },
         reports: {
-            add: ADD_REPORT,
-            removeAll: REMOVE_ALL_REPORTS,
-            remove: REMOVE_REPORT_BY_KEY,
+            init: INIT_REPORT,
+            cancel: CANCEL_REPORT,
+            updateData: UPDATE_REPORT_DATA,
+            removeData: REMOVE_REPORT_DATA,
+            // Extra methods:
+            setReportIcon,
+            setReportMessage,
+            setReportSummary,
+        },
+        messages: {
+            add: ADD_MESSAGE,
+            removeAll: REMOVE_ALL_MESSAGES,
+            remove: REMOVE_MESSAGES_BY_TYPE,
+        },
+        confidentialResponses: {
+            removeByKey: REMOVE_CONFIDENTIAL_RESPONSE_BY_KEY,
+            removeAll: REMOVE_ALL_CONFIDENTIAL_RESPONSES,
         },
         // Extra methods:
         stopParticipation,
@@ -271,10 +431,20 @@ const StudyEngine = Object.assign(Object.assign(Object.assign({}, NativeStudyEng
         any: multipleChoiceOptionsSelected,
         none: multipleChoiceOnlyOtherKeysSelected,
         all: multipleChoiceAllOfTheseSelected,
+    }, consent: {
+        accepted: consentAcceptedCondition,
     }, survey: {
         isActive: hasSurveyKeyActive,
         validFromOlderThan: hasSurveyKeyValidFromOlderThan,
         validUntilSoonerThan: hasSurveyKeyValidUntilSoonerThan,
+    }, prefillRules: {
+        GET_LAST_SURVEY_ITEM,
+    }, contextRules: {
+        previousResponses: {
+            LAST_RESPONSES_BY_KEY,
+            ALL_RESPONSES_SINCE,
+            RESPONSES_SINCE_BY_KEY,
+        }
     } });
 
 exports.NativeStudyEngineExpressions = NativeStudyEngineExpressions;