@f1studio/form-spec 5.0.0-alpha.111 → 5.0.0-alpha.113

package/FormSpec.TS/FormSpec.FS/Integrations/Adapters/CorEMR/CorEMRFormSpecValidator.js

@@ -0,0 +1,801 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get FormSpecValidator_calculateExpectedMaxScore () {
+        return FormSpecValidator_calculateExpectedMaxScore;
+    },
+    get FormSpecValidator_countHeadings () {
+        return FormSpecValidator_countHeadings;
+    },
+    get FormSpecValidator_countNonHeadingItems () {
+        return FormSpecValidator_countNonHeadingItems;
+    },
+    get FormSpecValidator_countTotalFields () {
+        return FormSpecValidator_countTotalFields;
+    },
+    get FormSpecValidator_createSummary () {
+        return FormSpecValidator_createSummary;
+    },
+    get FormSpecValidator_getChoicesPerItem () {
+        return FormSpecValidator_getChoicesPerItem;
+    },
+    get FormSpecValidator_validateChoices () {
+        return FormSpecValidator_validateChoices;
+    },
+    get FormSpecValidator_validateConversion () {
+        return FormSpecValidator_validateConversion;
+    },
+    get FormSpecValidator_validateCounts () {
+        return FormSpecValidator_validateCounts;
+    },
+    get FormSpecValidator_validateMetadata () {
+        return FormSpecValidator_validateMetadata;
+    },
+    get FormSpecValidator_validatePathways () {
+        return FormSpecValidator_validatePathways;
+    },
+    get FormSpecValidator_validateRequiredFields () {
+        return FormSpecValidator_validateRequiredFields;
+    },
+    get FormSpecValidator_validateScoring () {
+        return FormSpecValidator_validateScoring;
+    },
+    get FormSpecValidator_validateTags () {
+        return FormSpecValidator_validateTags;
+    },
+    get ValidationError () {
+        return ValidationError;
+    },
+    get ValidationError_$reflection () {
+        return ValidationError_$reflection;
+    },
+    get ValidationError_ChoiceCountMismatch () {
+        return ValidationError_ChoiceCountMismatch;
+    },
+    get ValidationError_FieldCountMismatch () {
+        return ValidationError_FieldCountMismatch;
+    },
+    get ValidationError_HeadingNotConverted () {
+        return ValidationError_HeadingNotConverted;
+    },
+    get ValidationError_InvalidFieldType () {
+        return ValidationError_InvalidFieldType;
+    },
+    get ValidationError_ItemCountMismatch () {
+        return ValidationError_ItemCountMismatch;
+    },
+    get ValidationError_MetadataMismatch () {
+        return ValidationError_MetadataMismatch;
+    },
+    get ValidationError_MissingChoices () {
+        return ValidationError_MissingChoices;
+    },
+    get ValidationError_MissingStep () {
+        return ValidationError_MissingStep;
+    },
+    get ValidationError_PathwayMissing () {
+        return ValidationError_PathwayMissing;
+    },
+    get ValidationError_PathwayStateCountInvalid () {
+        return ValidationError_PathwayStateCountInvalid;
+    },
+    get ValidationError_PathwayTransitionCountInvalid () {
+        return ValidationError_PathwayTransitionCountInvalid;
+    },
+    get ValidationError_RequiredFieldMismatch () {
+        return ValidationError_RequiredFieldMismatch;
+    },
+    get ValidationError_ScoreMismatch () {
+        return ValidationError_ScoreMismatch;
+    },
+    get ValidationError_StepCountMismatch () {
+        return ValidationError_StepCountMismatch;
+    },
+    get ValidationError_TagCountMismatch () {
+        return ValidationError_TagCountMismatch;
+    },
+    get ValidationError_TriggerConditionCountMismatch () {
+        return ValidationError_TriggerConditionCountMismatch;
+    },
+    get ValidationError_TriggerEventCountMismatch () {
+        return ValidationError_TriggerEventCountMismatch;
+    },
+    get ValidationResult () {
+        return ValidationResult;
+    },
+    get ValidationResult_$reflection () {
+        return ValidationResult_$reflection;
+    },
+    get ValidationSummary () {
+        return ValidationSummary;
+    },
+    get ValidationSummary_$reflection () {
+        return ValidationSummary_$reflection;
+    }
+});
+const _Types = require("@fable-org/fable-library-js/Types.js");
+const _Option = require("@fable-org/fable-library-js/Option.js");
+const _Reflection = require("@fable-org/fable-library-js/Reflection.js");
+const _List = require("@fable-org/fable-library-js/List.js");
+const _Util = require("@fable-org/fable-library-js/Util.js");
+const _CorEMRSectioning = require("./CorEMRSectioning.js");
+const _Map = require("@fable-org/fable-library-js/Map.js");
+const _Seq2 = require("@fable-org/fable-library-js/Seq2.js");
+const _Seq = require("@fable-org/fable-library-js/Seq.js");
+const _CorEMRElementTypeMap = require("./CorEMRElementTypeMap.js");
+const _Result = require("@fable-org/fable-library-js/Result.js");
+function ValidationError_ItemCountMismatch(expected, actual) {
+    return new ValidationError(0, [
+        expected,
+        actual
+    ]);
+}
+function ValidationError_StepCountMismatch(expected, actual) {
+    return new ValidationError(1, [
+        expected,
+        actual
+    ]);
+}
+function ValidationError_FieldCountMismatch(step, expected, actual) {
+    return new ValidationError(2, [
+        step,
+        expected,
+        actual
+    ]);
+}
+function ValidationError_MetadataMismatch(field, expected, actual) {
+    return new ValidationError(3, [
+        field,
+        expected,
+        actual
+    ]);
+}
+function ValidationError_MissingChoices(itemId, itemLabel) {
+    return new ValidationError(4, [
+        itemId,
+        itemLabel
+    ]);
+}
+function ValidationError_InvalidFieldType(itemId, itemType, reason) {
+    return new ValidationError(5, [
+        itemId,
+        itemType,
+        reason
+    ]);
+}
+function ValidationError_HeadingNotConverted(itemId, heading) {
+    return new ValidationError(6, [
+        itemId,
+        heading
+    ]);
+}
+function ValidationError_MissingStep(heading) {
+    return new ValidationError(7, [
+        heading
+    ]);
+}
+function ValidationError_ChoiceCountMismatch(itemId, itemLabel, expected, actual) {
+    return new ValidationError(8, [
+        itemId,
+        itemLabel,
+        expected,
+        actual
+    ]);
+}
+function ValidationError_RequiredFieldMismatch(itemId, itemLabel, expected, actual) {
+    return new ValidationError(9, [
+        itemId,
+        itemLabel,
+        expected,
+        actual
+    ]);
+}
+function ValidationError_ScoreMismatch(expected, actual) {
+    return new ValidationError(10, [
+        expected,
+        actual
+    ]);
+}
+function ValidationError_TagCountMismatch(expected, actual) {
+    return new ValidationError(11, [
+        expected,
+        actual
+    ]);
+}
+function ValidationError_PathwayMissing(triggerCount) {
+    return new ValidationError(12, [
+        triggerCount
+    ]);
+}
+function ValidationError_PathwayStateCountInvalid(pathwayId, expected, actual) {
+    return new ValidationError(13, [
+        pathwayId,
+        expected,
+        actual
+    ]);
+}
+function ValidationError_PathwayTransitionCountInvalid(pathwayId, expected, actual) {
+    return new ValidationError(14, [
+        pathwayId,
+        expected,
+        actual
+    ]);
+}
+function ValidationError_TriggerConditionCountMismatch(triggerId, expected, actual) {
+    return new ValidationError(15, [
+        triggerId,
+        expected,
+        actual
+    ]);
+}
+function ValidationError_TriggerEventCountMismatch(triggerId, expected, actual) {
+    return new ValidationError(16, [
+        triggerId,
+        expected,
+        actual
+    ]);
+}
+class ValidationError extends _Types.Union {
+    cases() {
+        return [
+            "ItemCountMismatch",
+            "StepCountMismatch",
+            "FieldCountMismatch",
+            "MetadataMismatch",
+            "MissingChoices",
+            "InvalidFieldType",
+            "HeadingNotConverted",
+            "MissingStep",
+            "ChoiceCountMismatch",
+            "RequiredFieldMismatch",
+            "ScoreMismatch",
+            "TagCountMismatch",
+            "PathwayMissing",
+            "PathwayStateCountInvalid",
+            "PathwayTransitionCountInvalid",
+            "TriggerConditionCountMismatch",
+            "TriggerEventCountMismatch"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function ValidationError_$reflection() {
+    return (0, _Reflection.union_type)("FormSpec.Integrations.CorEMR.CorEMRFormSpecValidator.ValidationError", [], ValidationError, ()=>[
+            [
+                [
+                    "expected",
+                    _Reflection.int32_type
+                ],
+                [
+                    "actual",
+                    _Reflection.int32_type
+                ]
+            ],
+            [
+                [
+                    "expected",
+                    _Reflection.int32_type
+                ],
+                [
+                    "actual",
+                    _Reflection.int32_type
+                ]
+            ],
+            [
+                [
+                    "step",
+                    _Reflection.string_type
+                ],
+                [
+                    "expected",
+                    _Reflection.int32_type
+                ],
+                [
+                    "actual",
+                    _Reflection.int32_type
+                ]
+            ],
+            [
+                [
+                    "field",
+                    _Reflection.string_type
+                ],
+                [
+                    "expected",
+                    _Reflection.string_type
+                ],
+                [
+                    "actual",
+                    _Reflection.string_type
+                ]
+            ],
+            [
+                [
+                    "itemId",
+                    _Reflection.int32_type
+                ],
+                [
+                    "itemLabel",
+                    _Reflection.string_type
+                ]
+            ],
+            [
+                [
+                    "itemId",
+                    _Reflection.int32_type
+                ],
+                [
+                    "itemType",
+                    _Reflection.string_type
+                ],
+                [
+                    "reason",
+                    _Reflection.string_type
+                ]
+            ],
+            [
+                [
+                    "itemId",
+                    _Reflection.int32_type
+                ],
+                [
+                    "heading",
+                    _Reflection.string_type
+                ]
+            ],
+            [
+                [
+                    "heading",
+                    _Reflection.string_type
+                ]
+            ],
+            [
+                [
+                    "itemId",
+                    _Reflection.int32_type
+                ],
+                [
+                    "itemLabel",
+                    _Reflection.string_type
+                ],
+                [
+                    "expected",
+                    _Reflection.int32_type
+                ],
+                [
+                    "actual",
+                    _Reflection.int32_type
+                ]
+            ],
+            [
+                [
+                    "itemId",
+                    _Reflection.int32_type
+                ],
+                [
+                    "itemLabel",
+                    _Reflection.string_type
+                ],
+                [
+                    "expected",
+                    _Reflection.bool_type
+                ],
+                [
+                    "actual",
+                    _Reflection.bool_type
+                ]
+            ],
+            [
+                [
+                    "expected",
+                    _Reflection.int32_type
+                ],
+                [
+                    "actual",
+                    (0, _Reflection.option_type)(_Reflection.int32_type)
+                ]
+            ],
+            [
+                [
+                    "expected",
+                    _Reflection.int32_type
+                ],
+                [
+                    "actual",
+                    _Reflection.int32_type
+                ]
+            ],
+            [
+                [
+                    "triggerCount",
+                    _Reflection.int32_type
+                ]
+            ],
+            [
+                [
+                    "pathwayId",
+                    _Reflection.string_type
+                ],
+                [
+                    "expected",
+                    _Reflection.int32_type
+                ],
+                [
+                    "actual",
+                    _Reflection.int32_type
+                ]
+            ],
+            [
+                [
+                    "pathwayId",
+                    _Reflection.string_type
+                ],
+                [
+                    "expected",
+                    _Reflection.int32_type
+                ],
+                [
+                    "actual",
+                    _Reflection.int32_type
+                ]
+            ],
+            [
+                [
+                    "triggerId",
+                    _Reflection.int32_type
+                ],
+                [
+                    "expected",
+                    _Reflection.int32_type
+                ],
+                [
+                    "actual",
+                    _Reflection.int32_type
+                ]
+            ],
+            [
+                [
+                    "triggerId",
+                    _Reflection.int32_type
+                ],
+                [
+                    "expected",
+                    _Reflection.int32_type
+                ],
+                [
+                    "actual",
+                    _Reflection.int32_type
+                ]
+            ]
+        ]);
+}
+class ValidationResult extends _Types.Record {
+    constructor(IsValid, Errors, Warnings, Summary){
+        super();
+        this.IsValid = IsValid;
+        this.Errors = Errors;
+        this.Warnings = Warnings;
+        this.Summary = Summary;
+    }
+}
+function ValidationResult_$reflection() {
+    return (0, _Reflection.record_type)("FormSpec.Integrations.CorEMR.CorEMRFormSpecValidator.ValidationResult", [], ValidationResult, ()=>[
+            [
+                "IsValid",
+                _Reflection.bool_type
+            ],
+            [
+                "Errors",
+                (0, _Reflection.list_type)(ValidationError_$reflection())
+            ],
+            [
+                "Warnings",
+                (0, _Reflection.list_type)(ValidationError_$reflection())
+            ],
+            [
+                "Summary",
+                ValidationSummary_$reflection()
+            ]
+        ]);
+}
+class ValidationSummary extends _Types.Record {
+    constructor(TotalItems, ConvertedFields, HeadingsDetected, StepsCreated, ChoicesProcessed, TriggersFound, TagsMapped){
+        super();
+        this.TotalItems = TotalItems | 0;
+        this.ConvertedFields = ConvertedFields | 0;
+        this.HeadingsDetected = HeadingsDetected | 0;
+        this.StepsCreated = StepsCreated | 0;
+        this.ChoicesProcessed = ChoicesProcessed | 0;
+        this.TriggersFound = TriggersFound | 0;
+        this.TagsMapped = TagsMapped | 0;
+    }
+}
+function ValidationSummary_$reflection() {
+    return (0, _Reflection.record_type)("FormSpec.Integrations.CorEMR.CorEMRFormSpecValidator.ValidationSummary", [], ValidationSummary, ()=>[
+            [
+                "TotalItems",
+                _Reflection.int32_type
+            ],
+            [
+                "ConvertedFields",
+                _Reflection.int32_type
+            ],
+            [
+                "HeadingsDetected",
+                _Reflection.int32_type
+            ],
+            [
+                "StepsCreated",
+                _Reflection.int32_type
+            ],
+            [
+                "ChoicesProcessed",
+                _Reflection.int32_type
+            ],
+            [
+                "TriggersFound",
+                _Reflection.int32_type
+            ],
+            [
+                "TagsMapped",
+                _Reflection.int32_type
+            ]
+        ]);
+}
+function FormSpecValidator_countNonHeadingItems(items) {
+    const headings = (0, _CorEMRSectioning.detectHeadings)(items);
+    return (0, _List.length)(items) - (0, _List.length)(headings) | 0;
+}
+function FormSpecValidator_countHeadings(items) {
+    return (0, _List.length)((0, _CorEMRSectioning.detectHeadings)(items));
+}
+function FormSpecValidator_countTotalFields(steps) {
+    return (0, _List.sumBy)((s)=>(0, _List.length)(s.Fields), steps, {
+        GetZero: ()=>0,
+        Add: (x, y)=>x + y
+    });
+}
+function FormSpecValidator_getChoicesPerItem(choices) {
+    return (0, _Map.ofList)((0, _List.map)((tupledArg)=>[
+            tupledArg[0],
+            (0, _List.length)(tupledArg[1])
+        ], (0, _Seq2.List_groupBy)((c)=>c.ItemId, choices, {
+        Equals: (x, y)=>x === y,
+        GetHashCode: _Util.numberHash
+    })), {
+        Compare: _Util.comparePrimitives
+    });
+}
+function FormSpecValidator_calculateExpectedMaxScore(choices) {
+    return (0, _List.sumBy)((c)=>c.Score, choices, {
+        GetZero: ()=>0,
+        Add: (x, y)=>x + y
+    });
+}
+function FormSpecValidator_validateMetadata(coreMR, formSpec) {
+    return (0, _Seq.toList)((0, _Seq.delay)(()=>(0, _Seq.append)(formSpec.Title !== coreMR.FormName ? (0, _Seq.singleton)(ValidationError_MetadataMismatch("title", coreMR.FormName, formSpec.Title)) : (0, _Seq.empty)(), (0, _Seq.delay)(()=>(0, _Seq.append)(formSpec.Version !== (0, _Util.int32ToString)(coreMR.VersionNumber) ? (0, _Seq.singleton)(ValidationError_MetadataMismatch("version", (0, _Util.int32ToString)(coreMR.VersionNumber), formSpec.Version)) : (0, _Seq.empty)(), (0, _Seq.delay)(()=>formSpec.RequiresReview !== coreMR.RequiresSignature ? (0, _Seq.singleton)(ValidationError_MetadataMismatch("requiresReview", (0, _Types.toString)(coreMR.RequiresSignature), (0, _Types.toString)(formSpec.RequiresReview))) : (0, _Seq.empty)()))))));
+}
+function FormSpecValidator_validateCounts(coreMR, formSpec) {
+    const expectedFields = FormSpecValidator_countNonHeadingItems(coreMR.Items) | 0;
+    const actualFields = FormSpecValidator_countTotalFields(formSpec.Steps) | 0;
+    const expectedSteps = FormSpecValidator_countHeadings(coreMR.Items) | 0;
+    const actualSteps = (0, _List.length)(formSpec.Steps) | 0;
+    return (0, _Seq.toList)((0, _Seq.delay)(()=>(0, _Seq.append)(expectedFields !== actualFields ? (0, _Seq.singleton)(ValidationError_ItemCountMismatch(expectedFields, actualFields)) : (0, _Seq.empty)(), (0, _Seq.delay)(()=>expectedSteps > 0 && expectedSteps !== actualSteps ? (0, _Seq.singleton)(ValidationError_StepCountMismatch(expectedSteps, actualSteps)) : (0, _Seq.empty)()))));
+}
+function FormSpecValidator_validateChoices(coreMR, formSpec) {
+    const choicesPerItem = FormSpecValidator_getChoicesPerItem(coreMR.Choices);
+    const errors = [];
+    const sequenceToFieldKey = (0, _Map.ofList)((0, _List.map)((f)=>[
+            f.FieldOrder,
+            f.FieldKey
+        ], (0, _List.collect)((s)=>s.Fields, formSpec.Steps)), {
+        Compare: _Util.comparePrimitives
+    });
+    const fieldKeyToItemId = (0, _Map.ofList)((0, _List.choose)((item)=>(0, _Option.map)((fieldKey)=>[
+                fieldKey,
+                item.ItemId
+            ], (0, _Map.tryFind)(item.Sequence, sequenceToFieldKey)), coreMR.Items), {
+        Compare: _Util.compare
+    });
+    const itemsById = (0, _Map.ofList)((0, _List.map)((i)=>[
+            i.ItemId,
+            i
+        ], coreMR.Items), {
+        Compare: _Util.comparePrimitives
+    });
+    const enumerator = (0, _Util.getEnumerator)(formSpec.Steps);
+    try {
+        while(enumerator["System.Collections.IEnumerator.MoveNext"]()){
+            const enumerator_1 = (0, _Util.getEnumerator)(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]().Fields);
+            try {
+                while(enumerator_1["System.Collections.IEnumerator.MoveNext"]()){
+                    const field = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const matchValue = field.FieldType;
+                    switch(matchValue.tag){
+                        case /* MultiChoice */ 15:
+                            {
+                                const info = matchValue.fields[0];
+                                const matchValue_1 = (0, _Map.tryFind)(field.FieldKey, fieldKeyToItemId);
+                                if (matchValue_1 == null) {} else {
+                                    const itemId = (0, _Option.value)(matchValue_1) | 0;
+                                    const matchValue_2 = (0, _Map.tryFind)(itemId, itemsById);
+                                    if (matchValue_2 == null) {} else {
+                                        const item_1 = (0, _Option.value)(matchValue_2);
+                                        const expectedCount = (0, _Option.defaultArg)((0, _Map.tryFind)(itemId, choicesPerItem), 0) | 0;
+                                        const actualCount = (0, _List.length)(info.Options) | 0;
+                                        if (!(0, _CorEMRElementTypeMap.getElementTypeInfo)(item_1.ItemTypeId).IsScaffold) {
+                                            if (expectedCount > 0 && expectedCount !== actualCount) {
+                                                void errors.push(ValidationError_ChoiceCountMismatch(itemId, item_1.Label, expectedCount, actualCount));
+                                            } else if (expectedCount === 0) {
+                                                void errors.push(ValidationError_MissingChoices(itemId, item_1.Label));
+                                            }
+                                        }
+                                    }
+                                }
+                                break;
+                            }
+                        case /* Dropdown */ 14:
+                            {
+                                const info_1 = matchValue.fields[0];
+                                const matchValue_3 = (0, _Map.tryFind)(field.FieldKey, fieldKeyToItemId);
+                                if (matchValue_3 == null) {} else {
+                                    const itemId_1 = (0, _Option.value)(matchValue_3) | 0;
+                                    const matchValue_4 = (0, _Map.tryFind)(itemId_1, itemsById);
+                                    if (matchValue_4 == null) {} else {
+                                        const item_2 = (0, _Option.value)(matchValue_4);
+                                        const expectedCount_1 = (0, _Option.defaultArg)((0, _Map.tryFind)(itemId_1, choicesPerItem), 0) | 0;
+                                        const actualCount_1 = (0, _List.length)(info_1.Options) | 0;
+                                        if (!(0, _CorEMRElementTypeMap.getElementTypeInfo)(item_2.ItemTypeId).IsScaffold) {
+                                            if (expectedCount_1 > 0 && expectedCount_1 !== actualCount_1) {
+                                                void errors.push(ValidationError_ChoiceCountMismatch(itemId_1, item_2.Label, expectedCount_1, actualCount_1));
+                                            } else if (expectedCount_1 === 0) {
+                                                void errors.push(ValidationError_MissingChoices(itemId_1, item_2.Label));
+                                            }
+                                        }
+                                    }
+                                }
+                                break;
+                            }
+                        case /* CheckboxList */ 16:
+                            {
+                                const info_2 = matchValue.fields[0];
+                                const matchValue_5 = (0, _Map.tryFind)(field.FieldKey, fieldKeyToItemId);
+                                if (matchValue_5 == null) {} else {
+                                    const itemId_2 = (0, _Option.value)(matchValue_5) | 0;
+                                    const matchValue_6 = (0, _Map.tryFind)(itemId_2, itemsById);
+                                    if (matchValue_6 == null) {} else {
+                                        const item_3 = (0, _Option.value)(matchValue_6);
+                                        const expectedCount_2 = (0, _Option.defaultArg)((0, _Map.tryFind)(itemId_2, choicesPerItem), 0) | 0;
+                                        const actualCount_2 = (0, _List.length)(info_2.Options) | 0;
+                                        if (!(0, _CorEMRElementTypeMap.getElementTypeInfo)(item_3.ItemTypeId).IsScaffold) {
+                                            if (expectedCount_2 > 0 && expectedCount_2 !== actualCount_2) {
+                                                void errors.push(ValidationError_ChoiceCountMismatch(itemId_2, item_3.Label, expectedCount_2, actualCount_2));
+                                            } else if (expectedCount_2 === 0) {
+                                                void errors.push(ValidationError_MissingChoices(itemId_2, item_3.Label));
+                                            }
+                                        }
+                                    }
+                                }
+                                break;
+                            }
+                        default:
+                            undefined;
+                    }
+                }
+            } finally{
+                (0, _Util.disposeSafe)(enumerator_1);
+            }
+        }
+    } finally{
+        (0, _Util.disposeSafe)(enumerator);
+    }
+    return (0, _List.ofSeq)(errors);
+}
+function FormSpecValidator_validateRequiredFields(coreMR, formSpec) {
+    const errors = [];
+    const itemsByLabel = (0, _Map.ofList)((0, _List.map)((i)=>[
+            i.Label,
+            i
+        ], coreMR.Items), {
+        Compare: _Util.comparePrimitives
+    });
+    const enumerator = (0, _Util.getEnumerator)(formSpec.Steps);
+    try {
+        while(enumerator["System.Collections.IEnumerator.MoveNext"]()){
+            const enumerator_1 = (0, _Util.getEnumerator)(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]().Fields);
+            try {
+                while(enumerator_1["System.Collections.IEnumerator.MoveNext"]()){
+                    const field = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const matchValue = (0, _Map.tryFind)(field.Label, itemsByLabel);
+                    if (matchValue == null) {} else {
+                        const item = (0, _Option.value)(matchValue);
+                        const expectedOptional = !item.IsRequired;
+                        if (field.IsOptional !== expectedOptional) {
+                            void errors.push(ValidationError_RequiredFieldMismatch(item.ItemId, item.Label, expectedOptional, field.IsOptional));
+                        }
+                    }
+                }
+            } finally{
+                (0, _Util.disposeSafe)(enumerator_1);
+            }
+        }
+    } finally{
+        (0, _Util.disposeSafe)(enumerator);
+    }
+    return (0, _List.ofSeq)(errors);
+}
+function FormSpecValidator_validateScoring(coreMR, formSpec) {
+    const expectedScore = FormSpecValidator_calculateExpectedMaxScore(coreMR.Choices) | 0;
+    if (expectedScore > 0) {
+        const matchValue = formSpec.Score;
+        if (matchValue == null) {
+            return (0, _List.singleton)(ValidationError_ScoreMismatch(expectedScore, undefined));
+        } else {
+            const score = (0, _Option.value)(matchValue);
+            if (score.MaxScore !== expectedScore) {
+                return (0, _List.singleton)(ValidationError_ScoreMismatch(expectedScore, score.MaxScore));
+            } else {
+                return (0, _List.empty)();
+            }
+        }
+    } else {
+        return (0, _List.empty)();
+    }
+}
+function FormSpecValidator_validateTags(coreMR, formSpec) {
+    const expectedCount = (0, _List.length)(coreMR.Tags) | 0;
+    const actualCount = (0, _List.length)(formSpec.CategoryTags) | 0;
+    if (expectedCount !== actualCount) {
+        return (0, _List.singleton)(ValidationError_TagCountMismatch(expectedCount, actualCount));
+    } else {
+        return (0, _List.empty)();
+    }
+}
+function FormSpecValidator_createSummary(coreMR, formSpec) {
+    return new ValidationSummary((0, _List.length)(coreMR.Items), FormSpecValidator_countTotalFields(formSpec.Steps), FormSpecValidator_countHeadings(coreMR.Items), (0, _List.length)(formSpec.Steps), (0, _List.length)(coreMR.Choices), (0, _List.length)(coreMR.Triggers), (0, _List.length)(formSpec.CategoryTags));
+}
+function FormSpecValidator_validatePathways(triggers, pathway) {
+    const activeTriggers = (0, _List.filter)((t)=>{
+        if (t.Active) {
+            return !(0, _List.isEmpty)(t.Events);
+        } else {
+            return false;
+        }
+    }, triggers);
+    let matchResult;
+    if (pathway == null) {
+        if ((0, _List.length)(activeTriggers) > 0) {
+            matchResult = 0;
+        } else {
+            matchResult = 1;
+        }
+    } else {
+        matchResult = 1;
+    }
+    switch(matchResult){
+        case 0:
+            return (0, _List.singleton)(ValidationError_PathwayMissing((0, _List.length)(activeTriggers)));
+        default:
+            return (0, _List.empty)();
+    }
+}
+function FormSpecValidator_validateConversion(coreMR, formSpec) {
+    try {
+        const allErrors = (0, _Seq.toList)((0, _Seq.delay)(()=>(0, _Seq.append)(FormSpecValidator_validateMetadata(coreMR.Metadata, formSpec), (0, _Seq.delay)(()=>(0, _Seq.append)(FormSpecValidator_validateCounts(coreMR, formSpec), (0, _Seq.delay)(()=>(0, _Seq.append)(FormSpecValidator_validateChoices(coreMR, formSpec), (0, _Seq.delay)(()=>(0, _Seq.append)(FormSpecValidator_validateRequiredFields(coreMR, formSpec), (0, _Seq.delay)(()=>(0, _Seq.append)(FormSpecValidator_validateScoring(coreMR, formSpec), (0, _Seq.delay)(()=>(0, _Seq.append)(FormSpecValidator_validateTags(coreMR, formSpec), (0, _Seq.delay)(()=>FormSpecValidator_validatePathways(coreMR.Triggers, formSpec.ClinicalPathway)))))))))))))));
+        return (0, _Result.FSharpResult$2_Ok)(new ValidationResult((0, _List.isEmpty)(allErrors), allErrors, (0, _List.empty)(), FormSpecValidator_createSummary(coreMR, formSpec)));
+    } catch (ex) {
+        return (0, _Result.FSharpResult$2_Error)(`Validation failed: ${ex.message}`);
+    }
+} //# sourceMappingURL=CorEMRFormSpecValidator.ts.map
+
+//# sourceMappingURL=CorEMRFormSpecValidator.js.map