case-editor-tools 1.0.0-beta.3 → 1.0.0-beta.30

package/surveys/responseTypeGenerators/optionGroupComponents.js

@@ -0,0 +1,125 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var surveys_surveyEditor_componentEditor = require('../survey-editor/component-editor.js');
+var surveys_utils_simpleGenerators = require('../utils/simple-generators.js');
+require('../utils/randomKeyGenerator.js');
+
+const optionDefToItemComponent = (optionDef) => {
+    const isGroup = optionDef.items && optionDef.items.length > 0;
+    const optEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+        key: optionDef.key,
+        role: optionDef.role,
+        isGroup: isGroup
+    });
+    if (isGroup) {
+        optEditor.setOrder({
+            name: 'sequential'
+        });
+    }
+    if (optionDef.content) {
+        optEditor.setContent(surveys_utils_simpleGenerators.generateLocStrings(optionDef.content));
+    }
+    if (optionDef.description) {
+        optEditor.setDescription(surveys_utils_simpleGenerators.generateLocStrings(optionDef.description));
+    }
+    switch (optionDef.role) {
+        case 'date':
+            optEditor.setDType('date');
+            break;
+        case 'numberInput':
+            optEditor.setDType('number');
+            break;
+    }
+    if (optionDef.displayCondition) {
+        optEditor.setDisplayCondition(optionDef.displayCondition);
+    }
+    if (optionDef.disabled) {
+        optEditor.setDisabled(optionDef.disabled);
+    }
+    if (optionDef.style) {
+        optEditor.setStyles(optionDef.style);
+    }
+    if (optionDef.optionProps) {
+        if (typeof (optionDef.optionProps.min) === 'number') {
+            optionDef.optionProps.min = { dtype: 'num', num: optionDef.optionProps.min };
+        }
+        if (typeof (optionDef.optionProps.max) === 'number') {
+            optionDef.optionProps.max = { dtype: 'num', num: optionDef.optionProps.max };
+        }
+        if (typeof (optionDef.optionProps.stepSize) === 'number') {
+            optionDef.optionProps.stepSize = { dtype: 'num', num: optionDef.optionProps.stepSize };
+        }
+        optEditor.setProperties(optionDef.optionProps);
+    }
+    if (optionDef.items) {
+        if (optionDef.role === 'text') {
+            optionDef.items.forEach((item, index) => {
+                const textItem = item;
+                optEditor.addItemComponent({
+                    key: index.toFixed(),
+                    role: 'text',
+                    content: surveys_utils_simpleGenerators.generateLocStrings(textItem.content),
+                    style: textItem.className ? [{ key: 'className', value: textItem.className }] : undefined
+                });
+            });
+        }
+        else {
+            optionDef.items.forEach((item) => {
+                const clozeItem = item;
+                const comp = optionDefToItemComponent(clozeItem);
+                optEditor.addItemComponent(comp);
+            });
+        }
+    }
+    return optEditor.getComponent();
+};
+const initResponseGroup = (type, key, optionItems, order, groupDisabled, groupContent, groupDescription) => {
+    // init group
+    const groupEdit = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+        key: key,
+        isGroup: true,
+        role: type,
+    });
+    groupEdit.setOrder(order ? order : {
+        name: 'sequential'
+    });
+    if (groupDisabled) {
+        groupEdit.setDisabled(groupDisabled);
+    }
+    if (groupContent) {
+        groupEdit.setContent(groupContent);
+    }
+    if (groupDescription) {
+        groupEdit.setDescription(groupDescription);
+    }
+    // add option items
+    optionItems.forEach(optionDef => {
+        groupEdit.addItemComponent(optionDefToItemComponent(optionDef));
+    });
+    return groupEdit.getComponent();
+};
+const initSingleChoiceGroup = (key, optionItems, order) => {
+    // init group
+    return initResponseGroup('singleChoiceGroup', key, optionItems, order);
+};
+const initMultipleChoiceGroup = (key, optionItems, order) => {
+    // init group
+    return initResponseGroup('multipleChoiceGroup', key, optionItems, order);
+};
+const initDropdownGroup = (key, optionItems, order, groupDisabled, groupContent, groupDescription) => {
+    // init group
+    return initResponseGroup('dropDownGroup', key, optionItems, order, groupDisabled, groupContent ? surveys_utils_simpleGenerators.generateLocStrings(groupContent) : undefined, groupDescription ? surveys_utils_simpleGenerators.generateLocStrings(groupDescription) : undefined);
+};
+const initSliderCategoricalGroup = (key, optionItems, order, groupDisabled) => {
+    // init group
+    return initResponseGroup('sliderCategorical', key, optionItems, order, groupDisabled);
+};
+
+exports.initDropdownGroup = initDropdownGroup;
+exports.initMultipleChoiceGroup = initMultipleChoiceGroup;
+exports.initSingleChoiceGroup = initSingleChoiceGroup;
+exports.initSliderCategoricalGroup = initSliderCategoricalGroup;
+exports.optionDefToItemComponent = optionDefToItemComponent;
+//# sourceMappingURL=optionGroupComponents.js.map

package/surveys/responseTypeGenerators/optionGroupComponents.js.map

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

package/{build → surveys}/survey-editor/component-editor.d.ts

@@ -1,4 +1,4 @@
-import { ItemComponent, Expression, LocalizedObject, ComponentProperties } from "survey-engine/lib/data_types";
+import { ItemComponent, Expression, LocalizedObject, ComponentProperties } from "survey-engine/data_types";
 import { NewComponentProps } from "./data-types";
 interface ComponentEditorInt {
     getComponent: () => ItemComponent;

package/{build → surveys}/survey-editor/data-types.d.ts

@@ -1,4 +1,4 @@
-import { SurveyItemTypes } from "survey-engine/lib/data_types";
+import { SurveyItemTypes } from "survey-engine/data_types";
 export interface NewItemProps {
     itemKey?: string;
     isGroup?: boolean;

package/{build → surveys}/survey-editor/item-editor.d.ts

@@ -1,4 +1,4 @@
-import { SurveyItem, SurveyItemTypes, Expression, Validation, ItemComponent, ItemGroupComponent } from "survey-engine/lib/data_types";
+import { SurveyItem, SurveyItemTypes, Expression, Validation, ItemComponent, ItemGroupComponent } from "survey-engine/data_types";
 import { NewItemProps, NewComponentProps } from "./data-types";
 interface ItemEditorInt {
     getItem: () => SurveyItem;

package/{build → surveys}/survey-editor/item-editor.js

@@ -2,11 +2,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var surveyEditor_itemEditor = require('../item-editor-8fd24b61.js');
+var surveys_surveyEditor_itemEditor = require('../../item-editor-c6933791.js');
 require('./component-editor.js');
 require('../utils/randomKeyGenerator.js');
+require('../../logger/logger.js');
 
 
 
-exports.ItemEditor = surveyEditor_itemEditor.ItemEditor;
+exports.ItemEditor = surveys_surveyEditor_itemEditor.ItemEditor;
 //# sourceMappingURL=item-editor.js.map

package/{build → surveys}/survey-editor/item-editor.js.map

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

package/{build → surveys}/survey-editor/survey-editor.d.ts

@@ -1,4 +1,5 @@
-import { Survey, LocalizedString, SurveyItem, SurveyContextDef, Expression } from "survey-engine/lib/data_types";
+import { Survey, LocalizedString, SurveyItem, SurveyContextDef, Expression } from "survey-engine/data_types";
+import { SurveyAvailableFor } from "../types";
 import { NewItemProps } from "./data-types";
 interface SurveyEditorInt {
     setSurveyName: (name: Array<LocalizedString>) => void;
@@ -6,6 +7,8 @@ interface SurveyEditorInt {
     setSurveyDuration: (duration: Array<LocalizedString>) => void;
     setSurveyContextRules: (contextRules: SurveyContextDef) => void;
     setPrefillRules: (rules: Expression[]) => void;
+    setAvailableFor: (value?: SurveyAvailableFor) => void;
+    setRequireLoginBeforeSubmission: (value?: boolean) => void;
     changeItemKey: (oldKey: string, newKey: string) => void;
     addNewSurveyItem: (itemProps: NewItemProps, parentKey?: string, atPosition?: number) => SurveyItem | undefined;
     updateSurveyItem: (item: SurveyItem) => void;
@@ -26,6 +29,8 @@ export declare class SurveyEditor implements SurveyEditorInt {
         small: number;
         large: number;
     }): void;
+    setAvailableFor(value?: SurveyAvailableFor | undefined): void;
+    setRequireLoginBeforeSubmission(value?: boolean | undefined): void;
     setSurveyContextRules(contextRules: SurveyContextDef): void;
     setPrefillRules(rules: Expression[]): void;
     addNewSurveyItem(newItem: NewItemProps, parentKey?: string, atPosition?: number): SurveyItem | undefined;

package/{build → surveys}/survey-editor/survey-editor.js

@@ -2,7 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var surveyEditor_itemEditor = require('../item-editor-8fd24b61.js');
+var surveys_surveyEditor_itemEditor = require('../../item-editor-c6933791.js');
+var logger_logger = require('../../logger/logger.js');
 require('./component-editor.js');
 require('../utils/randomKeyGenerator.js');
 
@@ -51,6 +52,12 @@ class SurveyEditor {
     setMaxItemPerPage(itemLimits) {
         this.survey.maxItemsPerPage = itemLimits;
     }
+    setAvailableFor(value) {
+        this.survey.availableFor = value;
+    }
+    setRequireLoginBeforeSubmission(value) {
+        this.survey.requireLoginBeforeSubmission = value;
+    }
     setSurveyContextRules(contextRules) {
         this.survey.contextRules = Object.assign({}, contextRules);
     }
@@ -63,10 +70,10 @@ class SurveyEditor {
         if (!parentKey) {
             newItem.itemKey = this.surveyKey + '.' + newItem.itemKey;
             if (this.survey.current.surveyDefinition.items.find(it => newItem.itemKey === it.key)) {
-                console.error('item already exists with key: ', newItem.itemKey);
+                logger_logger.Logger.criticalError('Duplicate key in survey: ' + newItem.itemKey);
                 return undefined;
             }
-            const item = (new surveyEditor_itemEditor.ItemEditor(undefined, newItem)).getItem();
+            const item = (new surveys_surveyEditor_itemEditor.ItemEditor(undefined, newItem)).getItem();
             if (atPosition !== undefined) {
                 this.survey.current.surveyDefinition.items.splice(atPosition, 0, item);
             }
@@ -82,10 +89,10 @@ class SurveyEditor {
         }
         newItem.itemKey = parentKey + '.' + newItem.itemKey;
         if (obj.items.find(it => newItem.itemKey === it.key)) {
-            console.error('item already exists with key: ', newItem.itemKey);
+            logger_logger.Logger.criticalError('Duplicate key in survey: ' + newItem.itemKey);
             return undefined;
         }
-        const item = (new surveyEditor_itemEditor.ItemEditor(undefined, newItem)).getItem();
+        const item = (new surveys_surveyEditor_itemEditor.ItemEditor(undefined, newItem)).getItem();
         if (atPosition !== undefined) {
             obj.items.splice(atPosition, 0, item);
         }
@@ -101,7 +108,7 @@ class SurveyEditor {
             return;
         }
         if (parent.items.find(it => surveyItem.key === it.key)) {
-            console.error('item already exists with key: ', surveyItem.key);
+            logger_logger.Logger.criticalError('Duplicate key in survey: ' + surveyItem.key);
             return undefined;
         }
         if (atPosition !== undefined) {
@@ -175,7 +182,7 @@ class SurveyEditor {
                 obj = this.survey.current.surveyDefinition;
                 continue;
             }
-            if (!surveyEditor_itemEditor.data_types.isSurveyGroupItem(obj)) {
+            if (!surveys_surveyEditor_itemEditor.isSurveyGroupItem(obj)) {
                 console.warn('survey item is not a group: ', obj.key);
                 return;
             }
@@ -215,7 +222,7 @@ class SurveyEditor {
     }
     changeItemKeyForSubtree(currentItem, newKey) {
         currentItem = Object.assign({}, currentItem);
-        if (surveyEditor_itemEditor.data_types.isSurveyGroupItem(currentItem)) {
+        if (surveys_surveyEditor_itemEditor.isSurveyGroupItem(currentItem)) {
             currentItem.items = currentItem.items.map(item => {
                 const newSubkey = newKey + '.' + item.key.slice(item.key.lastIndexOf('.') + 1);
                 return this.changeItemKeyForSubtree(item, newSubkey);

package/{build → surveys}/survey-editor/survey-editor.js.map

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

package/{build/expression-utils/surveyEngineExpressions.d.ts → surveys/survey-engine-expressions.d.ts}

@@ -1,4 +1,4 @@
-import { Expression } from "survey-engine/lib/data_types";
+import { Expression } from "survey-engine/data_types";
 import { Duration } from "../types/duration";
 export declare const NativeSurveyEngineExpressions: {
     getters: {
@@ -22,6 +22,7 @@ export declare const NativeSurveyEngineExpressions: {
     isDefined: (arg: Expression) => Expression;
     hasResponse: (itemKey: string, responseKey: string) => Expression;
     getResponseItem: (itemKey: string, responseKey: string) => Expression;
+    parseValueAsNum: (valueRef: Expression) => Expression;
     getResponseValueAsNum: (itemKey: string, responseKey: string) => Expression;
     getResponseValueAsStr: (itemKey: string, responseKey: string) => Expression;
     checkResponseValueWithRegex: (itemKey: string, responseKey: string, regexPattern: string) => Expression;
@@ -72,7 +73,12 @@ export declare const SurveyEngine: {
     datePicker: {
         get: (itemKey: string) => Expression;
     };
-    hasParticipantFlag: (key: string, value: string) => Expression;
+    participantFlags: {
+        hasKey: (key: string) => Expression;
+        hasKeyAndValue: (key: string, value: string) => Expression;
+        getAsNum: (key: string) => Expression;
+    };
+    isLoggedIn: () => Expression;
     getters: {
         getContext: () => Expression;
         getResponses: () => Expression;
@@ -94,6 +100,7 @@ export declare const SurveyEngine: {
     isDefined: (arg: Expression) => Expression;
     hasResponse: (itemKey: string, responseKey: string) => Expression;
     getResponseItem: (itemKey: string, responseKey: string) => Expression;
+    parseValueAsNum: (valueRef: Expression) => Expression;
     getResponseValueAsNum: (itemKey: string, responseKey: string) => Expression;
     getResponseValueAsStr: (itemKey: string, responseKey: string) => Expression;
     checkResponseValueWithRegex: (itemKey: string, responseKey: string, regexPattern: string) => Expression;

package/{build/expression-utils/surveyEngineExpressions.js → surveys/survey-engine-expressions.js}

@@ -4,7 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var constants_keyDefinitions = require('../constants/key-definitions.js');
 var types_duration = require('../types/duration.js');
-var expressionUtils_expressionGen = require('./expressionGen.js');
+var expressionUtils_expressionGen = require('../expression-utils/expressionGen.js');
 
 /**
  * Logical OR expression
@@ -61,6 +61,14 @@ const gte = (val1, val2) => expressionUtils_expressionGen.generateExpression('gt
  * @returns
  */
 const timestampWithOffset = (delta, reference) => expressionUtils_expressionGen.generateExpression('timestampWithOffset', undefined, types_duration.durationObjectToSeconds(delta), reference ? reference : undefined);
+/**
+ * Parse the result of an expression as a number
+ * @param valueRef expression that returns a string with the value that should be parsed
+ * @returns expression that returns the value or undefined
+ */
+const parseValueAsNum = (valueRef) => {
+    return expressionUtils_expressionGen.generateExpression('parseValueAsNum', 'float', valueRef);
+};
 /**
  * Extract value from a response if exits parsed as a number
  * @param itemKey full key of the survey item (e.g. SURVEY.GROUP.QUESTIONKEY)
@@ -286,15 +294,34 @@ const getSurveyItemValidation = (itemKey, validationKey) => {
 const dateResponseDiffFromNow = (itemKey, responseKey, unit, ignoreSign) => {
     return expressionUtils_expressionGen.generateExpression('dateResponseDiffFromNow', undefined, itemKey, responseKey, unit, ignoreSign ? 1 : undefined);
 };
+/**
+ * Check participant flags object if contains the specified key value pair
+ * @param key retrieve participant flag's value for this key
+ * @returns
+ */
+const parseParticipantFlagAsNum = (key) => {
+    return parseValueAsNum(getAttribute(getAttribute(getContext(), 'participantFlags'), key));
+};
+/**
+ * Check participant flags object if contains the specified key value pair
+ * @param key retrieve participant flag's value for this key
+ * @returns
+ */
+const hasParticipantFlagKey = (key) => {
+    return isDefined(getAttribute(getAttribute(getContext(), 'participantFlags'), key));
+};
 /**
  * Check participant flags object if contains the specified key value pair
  * @param key retrieve participant flag's value for this key
  * @param value string value to be checked for a match
  * @returns
  */
-const hasParticipantFlag = (key, value) => {
+const hasParticipantFlagKeyAndValue = (key, value) => {
     return eq(getAttribute(getAttribute(getContext(), 'participantFlags'), key), value);
 };
+const isLoggedIn = () => {
+    return getAttribute(getContext(), 'isLoggedIn');
+};
 /**
  * Counts the number of selected options in a multiple choice question
  * @param itemKey full key of the survey item (e.g. SURVEY.GROUP.QUESTIONKEY)
@@ -355,6 +382,7 @@ const NativeSurveyEngineExpressions = {
     isDefined,
     hasResponse,
     getResponseItem,
+    parseValueAsNum,
     getResponseValueAsNum,
     getResponseValueAsStr,
     checkResponseValueWithRegex,
@@ -400,8 +428,12 @@ const SurveyEngine = Object.assign(Object.assign({}, NativeSurveyEngineExpressio
         regexCheck: multilineTextInputRegexCheck,
     }, datePicker: {
         get: getDatePickerResponseValue,
-    }, hasParticipantFlag });
+    }, participantFlags: {
+        hasKey: hasParticipantFlagKey,
+        hasKeyAndValue: hasParticipantFlagKeyAndValue,
+        getAsNum: parseParticipantFlagAsNum,
+    }, isLoggedIn });
 
 exports.NativeSurveyEngineExpressions = NativeSurveyEngineExpressions;
 exports.SurveyEngine = SurveyEngine;
-//# sourceMappingURL=surveyEngineExpressions.js.map
+//# sourceMappingURL=survey-engine-expressions.js.map

package/{build/expression-utils/surveyEngineExpressions.js.map → surveys/survey-engine-expressions.js.map}

@@ -1 +1 @@
-{"version":3,"file":"surveyEngineExpressions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"survey-engine-expressions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/surveys/survey-items.d.ts

@@ -0,0 +1,66 @@
+import { ItemGroupComponent, Expression, ItemComponent, SurveyItem, ExpressionArg, ResponseComponent } from "survey-engine/data_types";
+import { ClozeQuestionProps, DateInputQuestionProps, GenericQuestionProps, MultiLineTextInput, NumericInputQuestionProps, OptionDef, ResponsiveBipolarLikertArrayQuestionProps, ResponsiveSingleChoiceArrayQuestionProps, TextInputQuestionProps } from "./types/item-properties";
+import { LikertGroupRow } from "./responseTypeGenerators/likertGroupComponents";
+interface OptionQuestionProps extends GenericQuestionProps {
+    responseOptions: Array<OptionDef>;
+}
+interface LikertGroupQuestionProps extends GenericQuestionProps {
+    rows: Array<LikertGroupRow>;
+    scaleOptions: Array<{
+        key: string;
+        className?: string;
+        content: Map<string, string>;
+    }>;
+    stackOnSmallScreen?: boolean;
+}
+interface NumericSliderProps extends GenericQuestionProps {
+    sliderLabel: Map<string, string>;
+    noResponseLabel: Map<string, string>;
+    min?: number | ExpressionArg;
+    max?: number | ExpressionArg;
+    stepSize?: number | ExpressionArg;
+}
+interface CustomResponseItem extends ResponseComponent {
+    mapToRole?: 'singleChoiceGroup' | 'multipleChoiceGroup' | 'input';
+    items?: ItemComponent[];
+}
+interface CustomQuestionProps extends GenericQuestionProps {
+    responseItemDefs: CustomResponseItem[];
+}
+interface DisplayProps {
+    parentKey: string;
+    itemKey: string;
+    content: Array<ItemComponent>;
+    condition?: Expression;
+}
+interface EQ5DHealthSliderProps {
+    role: 'eq5d-health-indicator';
+    key: string;
+    displayCondition?: Expression;
+    disabled?: Expression;
+    instructionText: Map<string, string>;
+    valueBoxText: Map<string, string>;
+    maxHealthText: Map<string, string>;
+    minHealthText: Map<string, string>;
+}
+export declare const initEQ5DHealthIndicatorQuestion: (props: EQ5DHealthSliderProps) => ItemGroupComponent;
+export declare const SurveyItems: {
+    singleChoice: (props: OptionQuestionProps) => SurveyItem;
+    responsiveSingleChoiceArray: (props: ResponsiveSingleChoiceArrayQuestionProps) => SurveyItem;
+    responsiveBipolarLikertArray: (props: ResponsiveBipolarLikertArrayQuestionProps) => SurveyItem;
+    multipleChoice: (props: OptionQuestionProps) => SurveyItem;
+    dateInput: (props: DateInputQuestionProps) => SurveyItem;
+    textInput: (props: TextInputQuestionProps) => SurveyItem;
+    clozeQuestion: (props: ClozeQuestionProps) => SurveyItem;
+    numericInput: (props: NumericInputQuestionProps) => SurveyItem;
+    multilineTextInput: (props: MultiLineTextInput) => SurveyItem;
+    dropDown: (props: OptionQuestionProps) => SurveyItem;
+    numericSlider: (props: NumericSliderProps) => SurveyItem;
+    display: (props: DisplayProps) => SurveyItem;
+    surveyEnd: (parentKey: string, content: Map<string, string>, condition?: Expression | undefined) => SurveyItem;
+    customQuestion: (props: CustomQuestionProps) => SurveyItem;
+    old: {
+        simpleLikertGroup: (props: LikertGroupQuestionProps) => SurveyItem;
+    };
+};
+export {};