case-editor-tools 1.0.0-beta.15 → 1.0.0-beta.19

package/surveys/responseTypeGenerators/matrixGroupComponent.d.ts

@@ -0,0 +1,49 @@
+import { ComponentProperties, Expression, ItemGroupComponent } from "survey-engine/data_types";
+interface HeaderRow {
+    role: 'headerRow';
+    key: string;
+    displayCondition?: Expression;
+    disabled?: Expression;
+    cells: Array<{
+        role: 'text';
+        key: string;
+        content?: Map<string, string>;
+        description?: Map<string, string>;
+    }>;
+}
+interface RadioRow {
+    role: 'radioRow';
+    key: string;
+    displayCondition?: Expression;
+    disabled?: Expression;
+    cells: Array<{
+        role: 'label' | 'option';
+        key: string;
+        content?: Map<string, string>;
+        description?: Map<string, string>;
+    }>;
+}
+export interface ResponseRowCell {
+    role: 'label' | 'check' | 'input' | 'numberInput' | 'dropDownGroup';
+    key: string;
+    content?: Map<string, string>;
+    description?: Map<string, string>;
+    properties?: ComponentProperties;
+    items?: Array<{
+        role: 'option';
+        key: string;
+        content?: Map<string, string>;
+        disabled?: Expression;
+        displayCondition?: Expression;
+    }>;
+}
+interface ResponseRow {
+    role: 'responseRow';
+    key: string;
+    displayCondition?: Expression;
+    disabled?: Expression;
+    cells: Array<ResponseRowCell>;
+}
+declare type MatrixRow = HeaderRow | RadioRow | ResponseRow;
+export declare const initMatrixQuestion: (key: string, rows: Array<MatrixRow>, order?: Expression | undefined) => ItemGroupComponent;
+export {};

package/surveys/responseTypeGenerators/matrixGroupComponent.js

@@ -0,0 +1,99 @@
+'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 initMatrixQuestion = (key, rows, order) => {
+    // init group
+    const groupEdit = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+        key: key,
+        isGroup: true,
+        role: 'matrix',
+    });
+    groupEdit.setOrder(order ? order : {
+        name: 'sequential'
+    });
+    // init rows
+    rows.forEach(rowDef => {
+        const rowEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+            key: rowDef.key,
+            role: rowDef.role,
+        });
+        if (rowDef.displayCondition) {
+            rowEditor.setDisplayCondition(rowDef.displayCondition);
+        }
+        if (rowDef.disabled) {
+            rowEditor.setDisabled(rowDef.disabled);
+        }
+        switch (rowDef.role) {
+            case 'headerRow':
+                rowDef.cells.forEach(cell => {
+                    const cellEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+                        key: cell.key,
+                        role: cell.role,
+                    });
+                    if (cell.content) {
+                        cellEditor.setContent(surveys_utils_simpleGenerators.generateLocStrings(cell.content));
+                    }
+                    if (cell.description) {
+                        cellEditor.setDescription(surveys_utils_simpleGenerators.generateLocStrings(cell.description));
+                    }
+                    rowEditor.addItemComponent(cellEditor.getComponent());
+                });
+                break;
+            case 'radioRow':
+                rowDef.cells.forEach(cell => {
+                    const cellEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+                        key: cell.key,
+                        role: cell.role,
+                    });
+                    if (cell.content) {
+                        cellEditor.setContent(surveys_utils_simpleGenerators.generateLocStrings(cell.content));
+                    }
+                    if (cell.description) {
+                        cellEditor.setDescription(surveys_utils_simpleGenerators.generateLocStrings(cell.description));
+                    }
+                    rowEditor.addItemComponent(cellEditor.getComponent());
+                });
+                break;
+            case 'responseRow':
+                rowDef.cells.forEach(cell => {
+                    const cellEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+                        key: cell.key,
+                        role: cell.role,
+                    });
+                    if (cell.content) {
+                        cellEditor.setContent(surveys_utils_simpleGenerators.generateLocStrings(cell.content));
+                    }
+                    if (cell.description) {
+                        cellEditor.setDescription(surveys_utils_simpleGenerators.generateLocStrings(cell.description));
+                    }
+                    cellEditor.setProperties(cell.properties);
+                    if (cell.items) {
+                        cell.items.forEach(opt => {
+                            const cellOptionEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+                                key: opt.key,
+                                role: opt.role,
+                            });
+                            if (opt.content) {
+                                cellOptionEditor.setContent(surveys_utils_simpleGenerators.generateLocStrings(opt.content));
+                            }
+                            cellOptionEditor.setDisabled(opt.disabled);
+                            cellOptionEditor.setDisplayCondition(opt.displayCondition);
+                            cellEditor.addItemComponent(cellOptionEditor.getComponent());
+                        });
+                    }
+                    rowEditor.addItemComponent(cellEditor.getComponent());
+                });
+                break;
+        }
+        groupEdit.addItemComponent(rowEditor.getComponent());
+    });
+    return groupEdit.getComponent();
+};
+
+exports.initMatrixQuestion = initMatrixQuestion;
+//# sourceMappingURL=matrixGroupComponent.js.map

package/surveys/responseTypeGenerators/matrixGroupComponent.js.map

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

package/surveys/responseTypeGenerators/optionGroupComponents.d.ts

@@ -0,0 +1,7 @@
+import { Expression, ItemComponent, ItemGroupComponent } from "survey-engine/data_types";
+import { OptionDef } from "../types";
+export declare const optionDefToItemComponent: (optionDef: OptionDef) => ItemComponent;
+export declare const initSingleChoiceGroup: (key: string, optionItems: OptionDef[], order?: Expression | undefined) => ItemGroupComponent;
+export declare const initMultipleChoiceGroup: (key: string, optionItems: OptionDef[], order?: Expression | undefined) => ItemGroupComponent;
+export declare const initDropdownGroup: (key: string, optionItems: OptionDef[], order?: Expression | undefined, groupDisabled?: Expression | undefined, groupContent?: Map<string, string> | undefined, groupDescription?: Map<string, string> | undefined) => ItemGroupComponent;
+export declare const initSliderCategoricalGroup: (key: string, optionItems: OptionDef[], order?: Expression | undefined, groupDisabled?: Expression | undefined) => ItemGroupComponent;

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/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/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/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/surveys/survey-editor/item-editor.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var surveys_surveyEditor_itemEditor = require('../../item-editor-7f825952.js');
+var surveys_surveyEditor_itemEditor = require('../../item-editor-c6933791.js');
 require('./component-editor.js');
 require('../utils/randomKeyGenerator.js');
 require('../../logger/logger.js');

package/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/surveys/survey-editor/survey-editor.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var surveys_surveyEditor_itemEditor = require('../../item-editor-7f825952.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');
@@ -52,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);
     }
@@ -176,7 +182,7 @@ class SurveyEditor {
                 obj = this.survey.current.surveyDefinition;
                 continue;
             }
-            if (!surveys_surveyEditor_itemEditor.data_types.isSurveyGroupItem(obj)) {
+            if (!surveys_surveyEditor_itemEditor.isSurveyGroupItem(obj)) {
                 console.warn('survey item is not a group: ', obj.key);
                 return;
             }
@@ -216,7 +222,7 @@ class SurveyEditor {
     }
     changeItemKeyForSubtree(currentItem, newKey) {
         currentItem = Object.assign({}, currentItem);
-        if (surveys_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/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/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: {

package/surveys/survey-items.d.ts

@@ -1,5 +1,6 @@
-import { ItemGroupComponent, Expression, ComponentProperties, ItemComponent, SurveyItem, ExpressionArg } from "survey-engine/lib/data_types";
-import { DateInputQuestionProps, GenericQuestionProps, MultiLineTextInput, NumericInputQuestionProps, OptionDef, ResponsiveBipolarLikertArrayProps, ResponsiveBipolarLikertArrayQuestionProps, ResponsiveSingleChoiceArrayProps, ResponsiveSingleChoiceArrayQuestionProps, TextInputQuestionProps } from "./types/item-properties";
+import { ItemGroupComponent, Expression, ItemComponent, SurveyItem, ExpressionArg, ResponseItem } 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>;
 }
@@ -19,63 +20,18 @@ interface NumericSliderProps extends GenericQuestionProps {
     max?: number | ExpressionArg;
     stepSize?: number | ExpressionArg;
 }
+interface CustomResponseItem extends ResponseItem {
+    mapToRole?: 'singleChoiceGroup' | 'multipleChoiceGroup' | 'input';
+}
+interface CustomQuestionProps extends GenericQuestionProps {
+    responseItemDef: CustomResponseItem;
+}
 interface DisplayProps {
     parentKey: string;
     itemKey: string;
     content: Array<ItemComponent>;
     condition?: Expression;
 }
-export declare const initSingleChoiceGroup: (key: string, optionItems: OptionDef[], order?: Expression | undefined) => ItemGroupComponent;
-export declare const initMultipleChoiceGroup: (key: string, optionItems: OptionDef[], order?: Expression | undefined) => ItemGroupComponent;
-export declare const initDropdownGroup: (key: string, optionItems: OptionDef[], order?: Expression | undefined, groupDisabled?: Expression | undefined, groupContent?: Map<string, string> | undefined, groupDescription?: Map<string, string> | undefined) => ItemGroupComponent;
-export declare const initSliderCategoricalGroup: (key: string, optionItems: OptionDef[], order?: Expression | undefined, groupDisabled?: Expression | undefined) => ItemGroupComponent;
-interface HeaderRow {
-    role: 'headerRow';
-    key: string;
-    displayCondition?: Expression;
-    disabled?: Expression;
-    cells: Array<{
-        role: 'text';
-        key: string;
-        content?: Map<string, string>;
-        description?: Map<string, string>;
-    }>;
-}
-interface RadioRow {
-    role: 'radioRow';
-    key: string;
-    displayCondition?: Expression;
-    disabled?: Expression;
-    cells: Array<{
-        role: 'label' | 'option';
-        key: string;
-        content?: Map<string, string>;
-        description?: Map<string, string>;
-    }>;
-}
-export interface ResponseRowCell {
-    role: 'label' | 'check' | 'input' | 'numberInput' | 'dropDownGroup';
-    key: string;
-    content?: Map<string, string>;
-    description?: Map<string, string>;
-    properties?: ComponentProperties;
-    items?: Array<{
-        role: 'option';
-        key: string;
-        content?: Map<string, string>;
-        disabled?: Expression;
-        displayCondition?: Expression;
-    }>;
-}
-interface ResponseRow {
-    role: 'responseRow';
-    key: string;
-    displayCondition?: Expression;
-    disabled?: Expression;
-    cells: Array<ResponseRowCell>;
-}
-declare type MatrixRow = HeaderRow | RadioRow | ResponseRow;
-export declare const initMatrixQuestion: (key: string, rows: Array<MatrixRow>, order?: Expression | undefined) => ItemGroupComponent;
 interface EQ5DHealthSliderProps {
     role: 'eq5d-health-indicator';
     key: string;
@@ -87,31 +43,6 @@ interface EQ5DHealthSliderProps {
     minHealthText: Map<string, string>;
 }
 export declare const initEQ5DHealthIndicatorQuestion: (props: EQ5DHealthSliderProps) => ItemGroupComponent;
-interface LikertGroupRow {
-    key: string;
-    content: Map<string, string>;
-    descriptions?: ItemComponent[];
-    hideTopBorder?: boolean;
-    hideLabels?: boolean;
-    optionDisabled?: Array<{
-        optionKey: string;
-        exp: Expression;
-    }>;
-    displayCondition?: Expression;
-}
-export declare const initLikertScaleGroup: (key: string, rows: Array<LikertGroupRow>, scaleOptions: {
-    key: string;
-    className?: string | undefined;
-    content: Map<string, string>;
-}[], stackOnSmallScreen?: boolean | undefined, displayCondition?: Expression | undefined) => ItemGroupComponent;
-export declare const initResponsiveSingleChoiceArray: (rgKey: string, props: ResponsiveSingleChoiceArrayProps, displayCondition?: Expression | undefined) => ItemGroupComponent;
-export declare const initResponsiveBipolarLikertArray: (rgKey: string, props: ResponsiveBipolarLikertArrayProps, displayCondition?: Expression | undefined) => ItemGroupComponent;
-export declare const initLikertScaleItem: (key: string, options: {
-    key: string;
-    className?: string | undefined;
-    content?: Map<string, string> | undefined;
-    disabled?: Expression | undefined;
-}[], stackOnSmallScreen?: boolean | undefined, displayCondition?: Expression | undefined) => ItemGroupComponent;
 export declare const SurveyItems: {
     singleChoice: (props: OptionQuestionProps) => SurveyItem;
     responsiveSingleChoiceArray: (props: ResponsiveSingleChoiceArrayQuestionProps) => SurveyItem;
@@ -119,12 +50,14 @@ export declare const SurveyItems: {
     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;
     };