@aehrc/smart-forms-renderer 0.21.2 → 0.22.1

package/lib/utils/validateQuestionnaire.d.ts

@@ -1,11 +1,50 @@
-import type { Questionnaire, QuestionnaireResponse } from 'fhir/r4';
+import type { OperationOutcome, Questionnaire, QuestionnaireItem, QuestionnaireResponse } from 'fhir/r4';
 import type { EnableWhenExpressions, EnableWhenItems } from '../interfaces';
 import type { RegexValidation } from '../interfaces/regex.interface';
-export type InvalidType = 'regex' | 'minLength' | 'maxLength' | 'required';
+export declare enum ValidationResult {
+    unknown = "unknown",
+    questionnaireNotFound = "questionnaireNotFound",
+    questionnaireInactive = "questionnaireInactive",
+    questionnaireDraft = "questionnaireDraft",
+    questionnaireRetired = "questionnaireRetired",
+    invalidLinkId = "invalidLinkId",
+    invalidType = "invalidType",
+    invalidAnswerType = "invalidAnswerType",
+    invalidAnswerOption = "invalidAnswerOption",
+    exclusiveAnswerOption = "exclusiveAnswerOption",
+    invalidUrlValue = "invalidUrlValue",
+    groupShouldNotHaveAnswers = "groupShouldNotHaveAnswers",
+    required = "required",
+    invariant = "invariant",
+    invariantExecution = "invariantExecution",
+    repeats = "repeats",
+    minCount = "minCount",
+    maxCount = "maxCount",
+    minValue = "minValue",
+    maxValue = "maxValue",
+    maxDecimalPlaces = "maxDecimalPlaces",
+    minLength = "minLength",
+    maxLength = "maxLength",
+    invalidNewLine = "invalidNewLine",
+    invalidCoding = "invalidCoding",
+    tsError = "tsError",
+    maxAttachmentSize = "maxAttachmentSize",
+    attachmentSizeInconsistent = "attachmentSizeInconsistent",
+    invalidAttachmentType = "invalidAttachmentType",
+    displayAnswer = "displayAnswer",
+    regex = "regex",
+    regexTimeout = "regexTimeout",
+    invalidRefValue = "invalidRefValue",
+    invalidRefResourceType = "invalidRefResourceType",
+    invalidRefResourceTypeRestriction = "invalidRefResourceTypeRestriction",
+    minValueIncompatUnits = "minValueIncompatUnits",
+    maxValueIncompatUnits = "maxValueIncompatUnits",
+    invalidUnit = "invalidUnit",
+    invalidUnitValueSet = "invalidUnitValueSet"
+}
 interface ValidateQuestionnaireParams {
     questionnaire: Questionnaire;
     questionnaireResponse: QuestionnaireResponse;
-    invalidItems: Record<string, InvalidType>;
     enableWhenIsActivated: boolean;
     enableWhenItems: EnableWhenItems;
     enableWhenExpressions: EnableWhenExpressions;
@@ -16,6 +55,16 @@ interface ValidateQuestionnaireParams {
  *
  * @author Sean Fong
  */
-export declare function validateQuestionnaire(params: ValidateQuestionnaireParams): Record<string, InvalidType>;
-export declare function getInputInvalidType(input: string, regexValidation: RegexValidation | null, minLength: number | null, maxLength: number | null): InvalidType | null;
+export declare function validateQuestionnaire(params: ValidateQuestionnaireParams): Record<string, OperationOutcome>;
+interface GetInputInvalidTypeParams {
+    qItem: QuestionnaireItem;
+    input: string;
+    regexValidation?: RegexValidation;
+    minLength?: number;
+    maxLength?: number;
+    maxDecimalPlaces?: number;
+    minValue?: string | number;
+    maxValue?: string | number;
+}
+export declare function getInputInvalidType(getInputInvalidTypeParams: GetInputInvalidTypeParams): ValidationResult | null;
 export {};

package/lib/utils/validateQuestionnaire.js

@@ -16,8 +16,52 @@
  */
 import { getQrItemsIndex, mapQItemsIndex } from './mapItem';
 import { isHiddenByEnableWhen } from './qItem';
-import { getRegexValidation } from './itemControl';
+import { getDecimalPrecision, getMaxValue, getMinValue, getRegexString, getRegexValidation, getShortText } from './itemControl';
 import { structuredDataCapture } from 'fhir-sdc-helpers';
+import { parseDecimalStringToFloat } from './parseInputs';
+import dayjs from 'dayjs';
+export var ValidationResult;
+(function (ValidationResult) {
+    ValidationResult["unknown"] = "unknown";
+    ValidationResult["questionnaireNotFound"] = "questionnaireNotFound";
+    ValidationResult["questionnaireInactive"] = "questionnaireInactive";
+    ValidationResult["questionnaireDraft"] = "questionnaireDraft";
+    ValidationResult["questionnaireRetired"] = "questionnaireRetired";
+    ValidationResult["invalidLinkId"] = "invalidLinkId";
+    ValidationResult["invalidType"] = "invalidType";
+    ValidationResult["invalidAnswerType"] = "invalidAnswerType";
+    ValidationResult["invalidAnswerOption"] = "invalidAnswerOption";
+    ValidationResult["exclusiveAnswerOption"] = "exclusiveAnswerOption";
+    ValidationResult["invalidUrlValue"] = "invalidUrlValue";
+    ValidationResult["groupShouldNotHaveAnswers"] = "groupShouldNotHaveAnswers";
+    ValidationResult["required"] = "required";
+    ValidationResult["invariant"] = "invariant";
+    ValidationResult["invariantExecution"] = "invariantExecution";
+    ValidationResult["repeats"] = "repeats";
+    ValidationResult["minCount"] = "minCount";
+    ValidationResult["maxCount"] = "maxCount";
+    ValidationResult["minValue"] = "minValue";
+    ValidationResult["maxValue"] = "maxValue";
+    ValidationResult["maxDecimalPlaces"] = "maxDecimalPlaces";
+    ValidationResult["minLength"] = "minLength";
+    ValidationResult["maxLength"] = "maxLength";
+    ValidationResult["invalidNewLine"] = "invalidNewLine";
+    ValidationResult["invalidCoding"] = "invalidCoding";
+    ValidationResult["tsError"] = "tsError";
+    ValidationResult["maxAttachmentSize"] = "maxAttachmentSize";
+    ValidationResult["attachmentSizeInconsistent"] = "attachmentSizeInconsistent";
+    ValidationResult["invalidAttachmentType"] = "invalidAttachmentType";
+    ValidationResult["displayAnswer"] = "displayAnswer";
+    ValidationResult["regex"] = "regex";
+    ValidationResult["regexTimeout"] = "regexTimeout";
+    ValidationResult["invalidRefValue"] = "invalidRefValue";
+    ValidationResult["invalidRefResourceType"] = "invalidRefResourceType";
+    ValidationResult["invalidRefResourceTypeRestriction"] = "invalidRefResourceTypeRestriction";
+    ValidationResult["minValueIncompatUnits"] = "minValueIncompatUnits";
+    ValidationResult["maxValueIncompatUnits"] = "maxValueIncompatUnits";
+    ValidationResult["invalidUnit"] = "invalidUnit";
+    ValidationResult["invalidUnitValueSet"] = "invalidUnitValueSet"; // The unit provided was not in the provided valueset
+})(ValidationResult || (ValidationResult = {}));
 /**
  * Recursively go through the questionnaireResponse and check for un-filled required qItems
  * At the moment item.required for group items are not checked
@@ -26,41 +70,61 @@ import { structuredDataCapture } from 'fhir-sdc-helpers';
  */
 export function validateQuestionnaire(params) {
     var _a;
-    const { questionnaire, questionnaireResponse, invalidItems, enableWhenIsActivated, enableWhenItems, enableWhenExpressions } = params;
+    const { questionnaire, questionnaireResponse, enableWhenIsActivated, enableWhenItems, enableWhenExpressions } = params;
     if (!questionnaire.item ||
         questionnaire.item.length === 0 ||
         !questionnaireResponse.item ||
         questionnaireResponse.item.length === 0) {
-        return invalidItems;
+        return {};
     }
     const qItemsIndexMap = mapQItemsIndex(questionnaire);
     const topLevelQRItemsByIndex = getQrItemsIndex(questionnaire.item, questionnaireResponse.item, qItemsIndexMap);
+    const invalidItems = {};
+    let qrItemIndex = 0;
     for (const [index, topLevelQItem] of questionnaire.item.entries()) {
+        let repeatGroupInstances = null;
         let topLevelQRItem = (_a = topLevelQRItemsByIndex[index]) !== null && _a !== void 0 ? _a : {
             linkId: topLevelQItem.linkId,
             text: topLevelQItem.text
         };
+        // topLevelQRItem being an array means this item is a repeat group
+        const isRepeatGroup = Array.isArray(topLevelQRItem);
         if (Array.isArray(topLevelQRItem)) {
+            repeatGroupInstances = topLevelQRItem.length;
             topLevelQRItem = {
                 linkId: topLevelQItem.linkId,
                 text: topLevelQItem.text,
                 item: topLevelQRItem
             };
         }
+        const locationExpression = `QuestionnaireResponse.item`;
         validateItemRecursive({
             qItem: topLevelQItem,
             qrItem: topLevelQRItem,
-            invalidItems: invalidItems,
+            qrItemIndex,
+            locationExpression,
+            invalidItems,
             enableWhenIsActivated,
             enableWhenItems,
-            enableWhenExpressions
+            enableWhenExpressions,
+            isRepeatGroupInstance: false
         });
+        // Increment qrItemIndex
+        // If it's a repeat group, increment by the number of instances so qrItemIndex is correct once we reach the next item
+        if (isRepeatGroup && typeof repeatGroupInstances === 'number') {
+            qrItemIndex += repeatGroupInstances;
+        }
+        else {
+            qrItemIndex++;
+        }
     }
     return invalidItems;
 }
 function validateItemRecursive(params) {
-    var _a, _b;
-    const { qItem, qrItem, invalidItems, enableWhenIsActivated, enableWhenItems, enableWhenExpressions } = params;
+    var _a, _b, _c;
+    const { qItem, qrItem, qrItemIndex, invalidItems, enableWhenIsActivated, enableWhenItems, enableWhenExpressions, isRepeatGroupInstance } = params;
+    let { locationExpression } = params;
+    // If item is hidden by enableWhen, skip validation
     if (isHiddenByEnableWhen({
         linkId: qItem.linkId,
         enableWhenIsActivated,
@@ -69,22 +133,40 @@ function validateItemRecursive(params) {
     })) {
         return;
     }
-    // FIXME repeat groups not working
+    // Validate repeat groups
     if (qItem.type === 'group' && qItem.repeats) {
-        return;
+        if (!isRepeatGroupInstance) {
+            validateRepeatGroupRecursive({
+                qItem,
+                qrItem,
+                qrItemIndex,
+                locationExpression,
+                invalidItems,
+                enableWhenIsActivated,
+                enableWhenItems,
+                enableWhenExpressions,
+                isRepeatGroupInstance: false
+            });
+            return;
+        }
     }
+    locationExpression = `${locationExpression}[${qrItemIndex}]`;
+    // Recursively validate groups with child items
     const childQItems = qItem.item;
     if (childQItems && childQItems.length > 0) {
         const childQrItems = (_a = qrItem === null || qrItem === void 0 ? void 0 : qrItem.item) !== null && _a !== void 0 ? _a : [];
         const indexMap = mapQItemsIndex(qItem);
         const qrItemsByIndex = getQrItemsIndex(childQItems, childQrItems, indexMap);
+        // Check if group is required and has no answers
         if (qItem.type === 'group' && qItem.required) {
             if (!qrItem || qrItemsByIndex.length === 0) {
-                invalidItems[qItem.linkId] = 'required';
+                invalidItems[qItem.linkId] = createValidationOperationOutcome(ValidationResult.required, qItem, qrItem, null, locationExpression, (_b = invalidItems[qItem.linkId]) === null || _b === void 0 ? void 0 : _b.issue);
             }
         }
+        // Loop through child items
         for (const [index, childQItem] of childQItems.entries()) {
-            let childQRItem = (_b = qrItemsByIndex[index]) !== null && _b !== void 0 ? _b : {
+            const childLocationExpression = `${locationExpression}.item`;
+            let childQRItem = (_c = qrItemsByIndex[index]) !== null && _c !== void 0 ? _c : {
                 linkId: childQItem.linkId,
                 text: childQItem.text
             };
@@ -98,56 +180,79 @@ function validateItemRecursive(params) {
             validateItemRecursive({
                 qItem: childQItem,
                 qrItem: childQRItem,
+                qrItemIndex: index,
+                locationExpression: childLocationExpression,
                 invalidItems: invalidItems,
                 enableWhenIsActivated,
                 enableWhenItems,
-                enableWhenExpressions
+                enableWhenExpressions,
+                isRepeatGroupInstance: false
             });
         }
     }
-    validateSingleItem(qItem, qrItem, invalidItems);
+    // Validate the item, note that this can be either a group or a non-group
+    validateSingleItem(qItem, qrItem, invalidItems, locationExpression);
 }
-function validateSingleItem(qItem, qrItem, invalidItems) {
+function validateRepeatGroupRecursive(params) {
+    var _a;
+    const { qItem, qrItem, qrItemIndex, locationExpression, invalidItems, enableWhenIsActivated, enableWhenItems, enableWhenExpressions } = params;
+    if (!qItem.item || qItem.item.length === 0 || !qrItem.item || qrItem.item.length === 0) {
+        return;
+    }
+    // Get repeat group answers
+    const repeatGroupAnswers = (_a = qrItem.item) !== null && _a !== void 0 ? _a : [];
+    for (const [index, repeatGroupAnswer] of repeatGroupAnswers.entries()) {
+        // Because the item is a repeat group and might have multiple answer instances, we need to increment the qItemIndex by the instanceIndex
+        const updatedQrItemIndex = qrItemIndex + index;
+        validateItemRecursive({
+            qItem: qItem,
+            qrItem: repeatGroupAnswer,
+            qrItemIndex: updatedQrItemIndex,
+            locationExpression: locationExpression,
+            invalidItems: invalidItems,
+            enableWhenIsActivated,
+            enableWhenItems,
+            enableWhenExpressions,
+            isRepeatGroupInstance: true
+        });
+    }
+}
+function validateSingleItem(qItem, qrItem, invalidItems, locationExpression) {
     var _a, _b;
-    // Validate item.required
+    // Validate item.required first before every other validation check
     if (qItem.type !== 'display') {
         if (qItem.required && !qrItem.answer) {
-            invalidItems[qItem.linkId] = 'required';
+            invalidItems[qItem.linkId] = createValidationOperationOutcome(ValidationResult.required, qItem, qrItem, null, locationExpression, (_a = invalidItems[qItem.linkId]) === null || _a === void 0 ? void 0 : _a.issue);
             return invalidItems;
         }
     }
     // Validate regex, maxLength and minLength
     if (qrItem.answer) {
-        for (const answer of qrItem.answer) {
+        for (const [i, answer] of qrItem.answer.entries()) {
+            // Your code here, you can use 'index' and 'answer' as needed
             if (answer.valueString || answer.valueInteger || answer.valueDecimal || answer.valueUri) {
-                const invalidInputType = getInputInvalidType(getInputInString(answer), getRegexValidation(qItem), (_a = structuredDataCapture.getMinLength(qItem)) !== null && _a !== void 0 ? _a : null, (_b = qItem.maxLength) !== null && _b !== void 0 ? _b : null);
-                if (!invalidInputType) {
-                    continue;
+                const invalidInputType = getInputInvalidType({
+                    qItem,
+                    input: getInputInString(answer),
+                    regexValidation: getRegexValidation(qItem),
+                    minLength: structuredDataCapture.getMinLength(qItem),
+                    maxLength: qItem.maxLength,
+                    maxDecimalPlaces: structuredDataCapture.getMaxDecimalPlaces(qItem),
+                    minValue: getMinValue(qItem),
+                    maxValue: getMaxValue(qItem)
+                });
+                if (invalidInputType) {
+                    invalidItems[qItem.linkId] = createValidationOperationOutcome(invalidInputType, qItem, qrItem, i, locationExpression, (_b = invalidItems[qItem.linkId]) === null || _b === void 0 ? void 0 : _b.issue);
                 }
-                // Assign invalid type and break - stop checking other answers if is a repeat item
-                switch (invalidInputType) {
-                    case 'regex':
-                        invalidItems[qItem.linkId] = 'regex';
-                        break;
-                    case 'minLength':
-                        invalidItems[qItem.linkId] = 'minLength';
-                        break;
-                    case 'maxLength':
-                        invalidItems[qItem.linkId] = 'maxLength';
-                        break;
-                }
-                break;
             }
         }
-        // Reached the end of the loop and no invalid input type found
-        // If a required item is filled, remove the required invalid type
-        if (qItem.required && invalidItems[qItem.linkId] && invalidItems[qItem.linkId] === 'required') {
-            delete invalidItems[qItem.linkId];
-        }
     }
     return invalidItems;
 }
 function getInputInString(answer) {
+    if (!answer) {
+        return '';
+    }
     if (answer.valueString) {
         return answer.valueString;
     }
@@ -162,18 +267,289 @@ function getInputInString(answer) {
     }
     return '';
 }
-export function getInputInvalidType(input, regexValidation, minLength, maxLength) {
+export function getInputInvalidType(getInputInvalidTypeParams) {
+    var _a, _b;
+    const { qItem, input, regexValidation, minLength, maxLength, maxDecimalPlaces, minValue, maxValue } = getInputInvalidTypeParams;
     if (input) {
         if (regexValidation && !regexValidation.expression.test(input)) {
-            return 'regex';
+            return ValidationResult.regex;
         }
         if (minLength && input.length < minLength) {
-            return 'minLength';
+            return ValidationResult.minLength;
         }
         if (maxLength && input.length > maxLength) {
-            return 'maxLength';
+            return ValidationResult.maxLength;
+        }
+        if (maxDecimalPlaces) {
+            const decimalPlaces = (_b = (_a = input.split('.')[1]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+            if (decimalPlaces > maxDecimalPlaces) {
+                return ValidationResult.maxDecimalPlaces;
+            }
+        }
+        if (minValue) {
+            const minValueError = checkMinValue(qItem, input, minValue);
+            if (minValueError !== null) {
+                return ValidationResult.minValue;
+            }
+        }
+        if (maxValue) {
+            const maxValueError = checkMaxValue(qItem, input, maxValue);
+            if (maxValueError !== null) {
+                return ValidationResult.maxValue;
+            }
         }
     }
     return null;
 }
+function checkMinValue(qItem, input, minValue) {
+    switch (qItem.type) {
+        case 'integer':
+            if (typeof minValue === 'number') {
+                if (parseInt(input) < minValue) {
+                    return ValidationResult.minValue;
+                }
+            }
+            break;
+        case 'decimal': {
+            const precision = getDecimalPrecision(qItem);
+            const decimalValue = precision
+                ? parseDecimalStringToFloat(input, precision)
+                : parseFloat(input);
+            if (typeof minValue === 'number') {
+                if (decimalValue < minValue) {
+                    return ValidationResult.minValue;
+                }
+            }
+            break;
+        }
+        case 'date':
+            if (typeof minValue === 'string') {
+                if (new Date(input) < new Date(minValue)) {
+                    return ValidationResult.minValue;
+                }
+            }
+            break;
+        case 'dateTime':
+            if (typeof minValue === 'string') {
+                if (dayjs(input).isBefore(dayjs(minValue))) {
+                    return ValidationResult.minValue;
+                }
+            }
+            break;
+        default:
+            return null;
+    }
+    return null;
+}
+function checkMaxValue(qItem, input, maxValue) {
+    switch (qItem.type) {
+        case 'integer':
+            if (typeof maxValue === 'number') {
+                if (parseInt(input) > maxValue) {
+                    return ValidationResult.maxValue;
+                }
+            }
+            break;
+        case 'decimal': {
+            const precision = getDecimalPrecision(qItem);
+            const decimalValue = precision
+                ? parseDecimalStringToFloat(input, precision)
+                : parseFloat(input);
+            if (typeof maxValue === 'number') {
+                if (decimalValue > maxValue) {
+                    return ValidationResult.maxValue;
+                }
+            }
+            break;
+        }
+        case 'date':
+            if (typeof maxValue === 'string') {
+                if (new Date(input) > new Date(maxValue)) {
+                    return ValidationResult.maxValue;
+                }
+            }
+            break;
+        case 'dateTime':
+            if (typeof maxValue === 'string') {
+                if (dayjs(input).isAfter(dayjs(maxValue))) {
+                    return ValidationResult.maxValue;
+                }
+            }
+            break;
+        default:
+            return null;
+    }
+    return null;
+}
+function createValidationOperationOutcome(error, qItem, qrItem, answerIndex, locationExpression, existingOperationOutcomeIssues = []) {
+    return {
+        resourceType: 'OperationOutcome',
+        issue: existingOperationOutcomeIssues.concat(createValidationOperationOutcomeIssue(error, qItem, qrItem, answerIndex, locationExpression))
+    };
+}
+function createValidationOperationOutcomeIssue(error, qItem, qrItem, answerIndex, locationExpression) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    const errorCodeSystem = 'http://fhir.forms-lab.com/CodeSystem/errors';
+    let detailsText = '';
+    let fieldDisplayText = (_d = (_c = (_b = (_a = qrItem === null || qrItem === void 0 ? void 0 : qrItem.text) !== null && _a !== void 0 ? _a : getShortText(qItem)) !== null && _b !== void 0 ? _b : qItem === null || qItem === void 0 ? void 0 : qItem.text) !== null && _c !== void 0 ? _c : qItem.linkId) !== null && _d !== void 0 ? _d : qrItem.linkId;
+    if (!fieldDisplayText && fieldDisplayText.endsWith(':')) {
+        fieldDisplayText = fieldDisplayText.substring(0, fieldDisplayText.length - 1);
+    }
+    answerIndex = answerIndex !== null && answerIndex !== void 0 ? answerIndex : 0;
+    // create operationOutcomeIssue based on error
+    switch (error) {
+        case ValidationResult.required: {
+            if (qItem.type === 'group') {
+                detailsText = `${fieldDisplayText}: Mandatory group does not have answer(s)`;
+            }
+            else {
+                detailsText = `${fieldDisplayText}: Mandatory field does not have an answer`;
+            }
+            return {
+                severity: 'error',
+                code: 'required',
+                expression: [locationExpression],
+                details: {
+                    coding: [
+                        {
+                            system: errorCodeSystem,
+                            code: error,
+                            display: 'Required'
+                        }
+                    ],
+                    text: detailsText
+                }
+            };
+        }
+        case ValidationResult.regex: {
+            detailsText = `${fieldDisplayText}: The value '${getInputInString((_e = qrItem.answer) === null || _e === void 0 ? void 0 : _e[answerIndex])}' does not match the defined format.`;
+            if (structuredDataCapture.getEntryFormat(qItem)) {
+                detailsText += ` ${structuredDataCapture.getEntryFormat(qItem)}`;
+            }
+            return {
+                severity: 'error',
+                code: 'invalid',
+                expression: [locationExpression],
+                details: {
+                    coding: [
+                        {
+                            system: errorCodeSystem,
+                            code: error,
+                            display: 'Invalid format'
+                        }
+                    ],
+                    text: detailsText
+                },
+                diagnostics: (_f = getRegexString(qItem)) !== null && _f !== void 0 ? _f : undefined
+            };
+        }
+        case ValidationResult.minLength: {
+            detailsText = `${fieldDisplayText}: Expected the minimum value ${structuredDataCapture.getMinLength(qItem)} characters, received '${getInputInString((_g = qrItem.answer) === null || _g === void 0 ? void 0 : _g[answerIndex])}'`;
+            return {
+                severity: 'error',
+                code: 'business-rule',
+                expression: [locationExpression],
+                details: {
+                    coding: [
+                        {
+                            system: errorCodeSystem,
+                            code: error,
+                            display: 'Too short'
+                        }
+                    ],
+                    text: detailsText
+                }
+            };
+        }
+        case ValidationResult.maxLength: {
+            detailsText = `${fieldDisplayText}: Exceeded maximum of  ${qItem.maxLength} characters, received '${getInputInString((_h = qrItem.answer) === null || _h === void 0 ? void 0 : _h[answerIndex])}'`;
+            return {
+                severity: 'error',
+                code: 'business-rule',
+                expression: [locationExpression],
+                details: {
+                    coding: [
+                        {
+                            system: errorCodeSystem,
+                            code: error,
+                            display: 'Too long'
+                        }
+                    ],
+                    text: detailsText
+                }
+            };
+        }
+        case ValidationResult.maxDecimalPlaces: {
+            detailsText = `${fieldDisplayText}: Exceeded maximum decimal places ${structuredDataCapture.getMaxDecimalPlaces(qItem)}, received '${getInputInString((_j = qrItem.answer) === null || _j === void 0 ? void 0 : _j[answerIndex])}'`;
+            return {
+                severity: 'error',
+                code: 'business-rule',
+                expression: [locationExpression],
+                details: {
+                    coding: [
+                        {
+                            system: errorCodeSystem,
+                            code: error,
+                            display: 'Too precise'
+                        }
+                    ],
+                    text: detailsText
+                }
+            };
+        }
+        case ValidationResult.minValue: {
+            detailsText = `${fieldDisplayText}: Expected the minimum value ${getMinValue(qItem)}, received '${getInputInString((_k = qrItem.answer) === null || _k === void 0 ? void 0 : _k[answerIndex])}'`;
+            return {
+                severity: 'error',
+                code: 'business-rule',
+                expression: [locationExpression],
+                details: {
+                    coding: [
+                        {
+                            system: errorCodeSystem,
+                            code: error,
+                            display: 'Too small'
+                        }
+                    ],
+                    text: detailsText
+                }
+            };
+        }
+        case ValidationResult.maxValue: {
+            detailsText = `${fieldDisplayText}: Exceeded the maximum value ${getMaxValue(qItem)}, received '${getInputInString((_l = qrItem.answer) === null || _l === void 0 ? void 0 : _l[answerIndex])}'`;
+            return {
+                severity: 'error',
+                code: 'business-rule',
+                expression: [locationExpression],
+                details: {
+                    coding: [
+                        {
+                            system: errorCodeSystem,
+                            code: error,
+                            display: 'Too big'
+                        }
+                    ],
+                    text: detailsText
+                }
+            };
+        }
+        // mark unknown issues as fatal
+        default: {
+            return {
+                severity: 'error',
+                code: 'unknown',
+                expression: [locationExpression],
+                details: {
+                    coding: [
+                        {
+                            system: errorCodeSystem,
+                            code: 'unknown',
+                            display: 'Unknown'
+                        }
+                    ]
+                }
+            };
+        }
+    }
+}
 //# sourceMappingURL=validateQuestionnaire.js.map