@f1studio/form-spec 5.0.0-alpha.149 → 5.0.0-alpha.152

package/src/FormSpec.FS/Integrations/CorEMR/ItemTriggerConverter.ts

@@ -0,0 +1,545 @@
+import { Helpers_generateDeterministicGuidRaw } from "../../Helpers.js";
+import { ClinicalPathway_PathwayExecutionMode_MultiPathway, ClinicalPathway_MultiPathwayConfig, ClinicalPathway_ConflictResolution_CombineActions, ClinicalPathway_CombinationStrategy_AllMatching, ClinicalPathway_ClinicalPathwaySpec, ClinicalPathway_PathRequirement, ClinicalPathway_ConstraintDefinition, ClinicalPathway_PathwayExecutionMode_TriggerBased, ClinicalPathway_TriggerBasedConfig, ClinicalPathway_TransitionDefinition, Shared_TransitionKey, ClinicalPathway_StateType_Terminal, ClinicalPathway_TerminalInfo, ClinicalPathway_StateType_Action, ClinicalPathway_StateType_CompoundAction, ClinicalPathway_StateDefinition, ClinicalPathway_StateType_Evaluation, ClinicalPathway_EvaluationInfo, Shared_StateKey, ClinicalPathway_ActionInfo_$union, ClinicalPathway_ActionInfo_Documentation, ClinicalPathway_DocumentationAction, ClinicalPathway_ActionInfo_Problem, ClinicalPathway_ProblemAction, ClinicalPathway_ProblemStatus_Active, ClinicalPathway_ActionInfo_Medication, ClinicalPathway_MedicationAction, ClinicalPathway_ActionInfo_Task, ClinicalPathway_TaskAction, ClinicalPathway_ActionInfo_Alert, ClinicalPathway_AlertAction, ClinicalPathway_AlertSeverity_High, ClinicalPathway_TransitionCondition_Always, ClinicalPathway_TransitionCondition_CompositeCondition, ClinicalPathway_LogicalOp_And, ClinicalPathway_LogicalOp_Or, ClinicalPathway_TransitionCondition_$union, ClinicalPathway_TransitionCondition_FieldCondition, ClinicalPathway_TransitionCondition_PluginPropertyCondition, Shared_PluginPropertyKey, Shared_ConditionValue_Single, Shared_ConditionValue_Multiple, Shared_ConditionValue_$union, Shared_FieldKey, ClinicalPathway_RecurrencePattern, ClinicalPathway_RecurrenceEnd_AfterOccurrences, ClinicalPathway_RecurrenceEnd_OnDate, ClinicalPathway_RecurrenceEnd_$union, ClinicalPathway_DueDate_$union, ClinicalPathway_DueDate_DaysFromNow, ClinicalPathway_DueDate_Tomorrow, ClinicalPathway_DueDate_Today, ClinicalPathway_TaskPriority_$union, ClinicalPathway_TaskPriority_Medium, ClinicalPathway_TaskPriority_Low, ClinicalPathway_TaskPriority_High, ClinicalPathway_TriggerTiming_$union, ClinicalPathway_TriggerTiming_OnFormLoad, ClinicalPathway_TriggerTiming_OnFormSubmit, ClinicalPathway_TriggerTiming_OnFormSave, ClinicalPathway_FieldEvaluator_$union, ClinicalPathway_FieldEvaluator_MatchesPattern, ClinicalPathway_FieldEvaluator_NotInSet, ClinicalPathway_FieldEvaluator_ContainsAll, ClinicalPathway_FieldEvaluator_LessOrEqual, ClinicalPathway_FieldEvaluator_LessThan, ClinicalPathway_FieldEvaluator_GreaterOrEqual, ClinicalPathway_FieldEvaluator_GreaterThan, ClinicalPathway_FieldEvaluator_NotEquals, ClinicalPathway_FieldEvaluator_Equals, ClinicalPathway_FieldEvaluator_InSet } from "../../FormSpec.js";
+import { bind, map as map_1, defaultArgWith, Option, value as value_1, defaultArg } from "@fable-org/fable-library-js/Option.js";
+import { sortByDescending, append, indexed, singleton, collect, filter, empty, ofArray, length, tryFind as tryFind_1, map, tail, head, isEmpty, FSharpList, tryHead } from "@fable-org/fable-library-js/List.js";
+import { tryParse, int32 } from "@fable-org/fable-library-js/Int32.js";
+import { substring, join, isNullOrEmpty, split, replace } from "@fable-org/fable-library-js/String.js";
+import { FSharpRef } from "@fable-org/fable-library-js/Types.js";
+import { utcNow, addDays } from "@fable-org/fable-library-js/DateOffset.js";
+import { fromDays } from "@fable-org/fable-library-js/TimeSpan.js";
+import { toList, FSharpMap, tryFind } from "@fable-org/fable-library-js/Map.js";
+import { ofList } from "@fable-org/fable-library-js/Set.js";
+import { IDisposable, disposeSafe, IEnumerator, getEnumerator, numberHash, stringHash, int32ToString, comparePrimitives } from "@fable-org/fable-library-js/Util.js";
+import { TemplateForm, ItemTrigger, TemplateItem, TriggerAction, TriggerCondition } from "./TemplateManifestDecoder.js";
+import { item as item_1 } from "@fable-org/fable-library-js/Array.js";
+import { List_countBy, List_distinctBy, List_distinct } from "@fable-org/fable-library-js/Seq2.js";
+
+function stableGuid(name: string): string {
+    return Helpers_generateDeterministicGuidRaw(`coremr:item_trigger:${name}`);
+}
+
+export function convertOperator(operator: string, values: FSharpList<string>): ClinicalPathway_FieldEvaluator_$union {
+    const matchValue: string = operator.toLowerCase();
+    switch (matchValue) {
+        case "any":
+            return ClinicalPathway_FieldEvaluator_InSet(values);
+        case "equals":
+            return ClinicalPathway_FieldEvaluator_Equals();
+        case "not_equals":
+            return ClinicalPathway_FieldEvaluator_NotEquals();
+        case "greater":
+            return ClinicalPathway_FieldEvaluator_GreaterThan();
+        case "greater_equals":
+            return ClinicalPathway_FieldEvaluator_GreaterOrEqual();
+        case "less":
+            return ClinicalPathway_FieldEvaluator_LessThan();
+        case "less_equals":
+            return ClinicalPathway_FieldEvaluator_LessOrEqual();
+        case "all":
+            return ClinicalPathway_FieldEvaluator_ContainsAll(values);
+        case "none":
+            return ClinicalPathway_FieldEvaluator_NotInSet(values);
+        case "regex":
+            return ClinicalPathway_FieldEvaluator_MatchesPattern(defaultArg(tryHead<string>(values), ".*"));
+        default:
+            throw new Error(`ItemTriggerConverter: unknown operator '${matchValue}'`);
+    }
+}
+
+export function convertTiming(eventName: string): ClinicalPathway_TriggerTiming_$union {
+    const matchValue: string = eventName.toLowerCase();
+    switch (matchValue) {
+        case "save":
+            return ClinicalPathway_TriggerTiming_OnFormSave();
+        case "lock":
+            return ClinicalPathway_TriggerTiming_OnFormSubmit();
+        case "open_first_time":
+            return ClinicalPathway_TriggerTiming_OnFormLoad();
+        default:
+            return ClinicalPathway_TriggerTiming_OnFormSave();
+    }
+}
+
+function convertPriority(priorityStr: string): ClinicalPathway_TaskPriority_$union {
+    switch (priorityStr) {
+        case "1":
+            return ClinicalPathway_TaskPriority_High();
+        case "3":
+            return ClinicalPathway_TaskPriority_Low();
+        default:
+            return ClinicalPathway_TaskPriority_Medium();
+    }
+}
+
+function parseDueDate(dateStr: string): ClinicalPathway_DueDate_$union {
+    const matchValue: string = dateStr.trim().toLowerCase();
+    let matchResult: int32;
+    switch (matchValue) {
+        case "today":
+        case "": {
+            matchResult = 0;
+            break;
+        }
+        case "tomorrow": {
+            matchResult = 1;
+            break;
+        }
+        default:
+            if (matchValue.startsWith("+")) {
+                matchResult = 2;
+            }
+            else {
+                matchResult = 3;
+            }
+    }
+    switch (matchResult) {
+        case 0:
+            return ClinicalPathway_DueDate_Today();
+        case 1:
+            return ClinicalPathway_DueDate_Tomorrow();
+        case 2: {
+            let matchValue_1: [boolean, int32];
+            let outArg = 0;
+            matchValue_1 = ([tryParse(replace(replace(replace(matchValue, "+", ""), "days", ""), "day", "").trim(), 511, false, 32, new FSharpRef<int32>((): int32 => outArg, (v: int32): void => {
+                outArg = (v | 0);
+            })), outArg] as [boolean, int32]);
+            if (matchValue_1[0]) {
+                return ClinicalPathway_DueDate_DaysFromNow(matchValue_1[1]);
+            }
+            else {
+                return ClinicalPathway_DueDate_Today();
+            }
+        }
+        default:
+            return ClinicalPathway_DueDate_Today();
+    }
+}
+
+function parseRecurrence(endStr: Option<string>): Option<ClinicalPathway_RecurrencePattern> {
+    let matchResult: int32, s: string;
+    if (endStr != null) {
+        if (value_1(endStr) === "") {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+            s = value_1(endStr);
+        }
+    }
+    else {
+        matchResult = 0;
+    }
+    switch (matchResult) {
+        case 0:
+            return undefined;
+        default: {
+            const dueDate: ClinicalPathway_DueDate_$union = parseDueDate(s!);
+            let until: ClinicalPathway_RecurrenceEnd_$union;
+            if (dueDate.tag === /* DaysFromNow */ 2) {
+                const days: int32 = dueDate.fields[0] | 0;
+                until = ClinicalPathway_RecurrenceEnd_OnDate(addDays(utcNow(), days));
+            }
+            else {
+                until = ClinicalPathway_RecurrenceEnd_AfterOccurrences(7);
+            }
+            return new ClinicalPathway_RecurrencePattern(fromDays(1), until);
+        }
+    }
+}
+
+export function convertCondition(cond: TriggerCondition, itemFieldKeyMap: FSharpMap<int32, Shared_FieldKey>): ClinicalPathway_TransitionCondition_$union {
+    const fieldKey: Shared_FieldKey = defaultArgWith<Shared_FieldKey>(tryFind<int32, Shared_FieldKey>(cond.SourceFieldId, itemFieldKeyMap), (): Shared_FieldKey => (new Shared_FieldKey(stableGuid(`field_${cond.SourceFieldId}`))));
+    const evaluator: ClinicalPathway_FieldEvaluator_$union = convertOperator(cond.Operator, cond.Values);
+    let condValue: Shared_ConditionValue_$union;
+    const matchValue: string = cond.Operator.toLowerCase();
+    switch (matchValue) {
+        case "any":
+        case "all":
+        case "none": {
+            condValue = Shared_ConditionValue_Multiple(ofList<string>(cond.Values, {
+                Compare: comparePrimitives,
+            }));
+            break;
+        }
+        default: {
+            const matchValue_1: FSharpList<string> = cond.Values;
+            if (isEmpty(matchValue_1)) {
+                const matchValue_2: FSharpList<int32> = cond.RawChoiceIds;
+                condValue = (isEmpty(matchValue_2) ? Shared_ConditionValue_Single("") : Shared_ConditionValue_Single(int32ToString(head(matchValue_2))));
+            }
+            else {
+                condValue = Shared_ConditionValue_Single(head(matchValue_1));
+            }
+        }
+    }
+    const matchValue_3: string = cond.Source.toLowerCase();
+    switch (matchValue_3) {
+        case "flow_bp_sys":
+            return ClinicalPathway_TransitionCondition_PluginPropertyCondition(fieldKey, new Shared_PluginPropertyKey(stableGuid("bp_systolic")), evaluator, condValue);
+        case "flow_bp_dia":
+            return ClinicalPathway_TransitionCondition_PluginPropertyCondition(fieldKey, new Shared_PluginPropertyKey(stableGuid("bp_diastolic")), evaluator, condValue);
+        default:
+            return ClinicalPathway_TransitionCondition_FieldCondition(fieldKey, evaluator, condValue);
+    }
+}
+
+/**
+ * Combine multiple conditions respecting booleanOperator
+ */
+export function combineConditions(conditions: FSharpList<TriggerCondition>, itemFieldKeyMap: FSharpMap<int32, Shared_FieldKey>): ClinicalPathway_TransitionCondition_$union {
+    let matchValue: Option<string>;
+    if (!isEmpty(conditions)) {
+        if (isEmpty(tail(conditions))) {
+            return convertCondition(head(conditions), itemFieldKeyMap);
+        }
+        else {
+            const converted: FSharpList<ClinicalPathway_TransitionCondition_$union> = map<TriggerCondition, ClinicalPathway_TransitionCondition_$union>((c: TriggerCondition): ClinicalPathway_TransitionCondition_$union => convertCondition(c, itemFieldKeyMap), conditions);
+            return ClinicalPathway_TransitionCondition_CompositeCondition((matchValue = map_1<TriggerCondition, string>((c_1: TriggerCondition): string => c_1.BooleanOperator, tryHead<TriggerCondition>(conditions)), (matchValue != null) ? ((value_1(matchValue) === "||") ? ClinicalPathway_LogicalOp_Or() : ClinicalPathway_LogicalOp_And()) : ClinicalPathway_LogicalOp_And()), converted);
+        }
+    }
+    else {
+        return ClinicalPathway_TransitionCondition_Always();
+    }
+}
+
+function param(key: string, action: TriggerAction): string {
+    return defaultArg(tryFind<string, string>(key, action.Params), "");
+}
+
+export function convertAction(action: TriggerAction): ClinicalPathway_ActionInfo_$union {
+    let s: string, s_1: string;
+    const matchValue: string = action.ActionType.toLowerCase();
+    switch (matchValue) {
+        case "alert": {
+            const categoryName: string = param("category_name", action);
+            return ClinicalPathway_ActionInfo_Alert(new ClinicalPathway_AlertAction(categoryName, `Alert: ${categoryName}`, ClinicalPathway_AlertSeverity_High(), undefined));
+        }
+        case "task": {
+            const category: string = param("category_name", action);
+            let assignee: string;
+            const parts: string[] = split(category, ["-"], undefined, 0);
+            assignee = ((parts.length > 0) ? item_1(0, parts).trim() : "Staff");
+            return ClinicalPathway_ActionInfo_Task(new ClinicalPathway_TaskAction(category, param("description", action), convertPriority(param("priority", action)), parseDueDate(param("start", action)), assignee, undefined));
+        }
+        case "recurring_task": {
+            const category_1: string = param("category_name", action);
+            let assignee_1: string;
+            const parts_1: string[] = split(category_1, ["-"], undefined, 0);
+            assignee_1 = ((parts_1.length > 0) ? item_1(0, parts_1).trim() : "Staff");
+            return ClinicalPathway_ActionInfo_Task(new ClinicalPathway_TaskAction(category_1, param("description", action), convertPriority(param("priority", action)), parseDueDate(param("start", action)), assignee_1, parseRecurrence(tryFind<string, string>("end", action.Params))));
+        }
+        case "medset":
+            return ClinicalPathway_ActionInfo_Medication(new ClinicalPathway_MedicationAction(param("medset_name", action), "", "", "", "", false));
+        case "problem":
+            return ClinicalPathway_ActionInfo_Problem(new ClinicalPathway_ProblemAction((s = param("category_name", action), isNullOrEmpty(s) ? "Problem" : s), undefined, utcNow(), ClinicalPathway_ProblemStatus_Active(), undefined));
+        case "treatment":
+            return ClinicalPathway_ActionInfo_Medication(new ClinicalPathway_MedicationAction((s_1 = param("category_name", action), isNullOrEmpty(s_1) ? "Treatment" : s_1), "", "", "", "", false));
+        case "taskcomplete":
+            return ClinicalPathway_ActionInfo_Task(new ClinicalPathway_TaskAction(`Complete: ${param("category_name", action)}`, "Mark task as complete", ClinicalPathway_TaskPriority_Medium(), ClinicalPathway_DueDate_Today(), "Staff", undefined));
+        case "approval":
+            return ClinicalPathway_ActionInfo_Task(new ClinicalPathway_TaskAction("Approval Required", param("description", action), ClinicalPathway_TaskPriority_High(), ClinicalPathway_DueDate_Today(), "Supervisor", undefined));
+        case "groups":
+            return ClinicalPathway_ActionInfo_Documentation(new ClinicalPathway_DocumentationAction("Group Assignment", param("category_name", action), false));
+        default:
+            return ClinicalPathway_ActionInfo_Task(new ClinicalPathway_TaskAction(`Unknown action: ${matchValue}`, join("; ", map<[string, string], string>((tupledArg: [string, string]): string => (`${tupledArg[0]}=${tupledArg[1]}`), toList<string, string>(action.Params))), ClinicalPathway_TaskPriority_Medium(), ClinicalPathway_DueDate_Today(), "Staff", undefined));
+    }
+}
+
+export function generateEvaluationLabel(trigger: ItemTrigger, items: FSharpList<TemplateItem>): string {
+    let fieldLabel: string;
+    const s: string = defaultArg(bind<TriggerCondition, string>((c: TriggerCondition): Option<string> => map_1<TemplateItem, string>((i_1: TemplateItem): string => i_1.Text, tryFind_1<TemplateItem>((i: TemplateItem): boolean => (i.ItemId === c.SourceFieldId), items)), tryHead<TriggerCondition>(trigger.Conditions)), "field");
+    fieldLabel = ((s.length > 50) ? (substring(s, 0, 47) + "...") : s);
+    const matchValue: FSharpList<TriggerCondition> = trigger.Conditions;
+    if (!isEmpty(matchValue)) {
+        if (isEmpty(tail(matchValue))) {
+            const matchValue_1: string = head(matchValue).Operator.toLowerCase();
+            const matchValue_2: FSharpList<string> = head(matchValue).Values;
+            let matchResult: int32, v: string, vals_2: FSharpList<string>, vals_3: FSharpList<string>, v_1: string, v_2: string, v_3: string, v_4: string, v_5: string, v_6: string, vals_4: FSharpList<string>, op: string;
+            switch (matchValue_1) {
+                case "any": {
+                    if (!isEmpty(matchValue_2)) {
+                        if (isEmpty(tail(matchValue_2))) {
+                            matchResult = 0;
+                            v = head(matchValue_2);
+                        }
+                        else if (length(matchValue_2) <= 3) {
+                            matchResult = 1;
+                            vals_2 = matchValue_2;
+                        }
+                        else {
+                            matchResult = 2;
+                            vals_3 = matchValue_2;
+                        }
+                    }
+                    else if (length(matchValue_2) <= 3) {
+                        matchResult = 1;
+                        vals_2 = matchValue_2;
+                    }
+                    else {
+                        matchResult = 2;
+                        vals_3 = matchValue_2;
+                    }
+                    break;
+                }
+                case "equals": {
+                    if (!isEmpty(matchValue_2)) {
+                        if (isEmpty(tail(matchValue_2))) {
+                            matchResult = 3;
+                            v_1 = head(matchValue_2);
+                        }
+                        else {
+                            matchResult = 10;
+                            op = matchValue_1;
+                        }
+                    }
+                    else {
+                        matchResult = 10;
+                        op = matchValue_1;
+                    }
+                    break;
+                }
+                case "not_equals": {
+                    if (!isEmpty(matchValue_2)) {
+                        if (isEmpty(tail(matchValue_2))) {
+                            matchResult = 4;
+                            v_2 = head(matchValue_2);
+                        }
+                        else {
+                            matchResult = 10;
+                            op = matchValue_1;
+                        }
+                    }
+                    else {
+                        matchResult = 10;
+                        op = matchValue_1;
+                    }
+                    break;
+                }
+                case "greater_equals": {
+                    if (!isEmpty(matchValue_2)) {
+                        if (isEmpty(tail(matchValue_2))) {
+                            matchResult = 5;
+                            v_3 = head(matchValue_2);
+                        }
+                        else {
+                            matchResult = 10;
+                            op = matchValue_1;
+                        }
+                    }
+                    else {
+                        matchResult = 10;
+                        op = matchValue_1;
+                    }
+                    break;
+                }
+                case "greater": {
+                    if (!isEmpty(matchValue_2)) {
+                        if (isEmpty(tail(matchValue_2))) {
+                            matchResult = 6;
+                            v_4 = head(matchValue_2);
+                        }
+                        else {
+                            matchResult = 10;
+                            op = matchValue_1;
+                        }
+                    }
+                    else {
+                        matchResult = 10;
+                        op = matchValue_1;
+                    }
+                    break;
+                }
+                case "less_equals": {
+                    if (!isEmpty(matchValue_2)) {
+                        if (isEmpty(tail(matchValue_2))) {
+                            matchResult = 7;
+                            v_5 = head(matchValue_2);
+                        }
+                        else {
+                            matchResult = 10;
+                            op = matchValue_1;
+                        }
+                    }
+                    else {
+                        matchResult = 10;
+                        op = matchValue_1;
+                    }
+                    break;
+                }
+                case "less": {
+                    if (!isEmpty(matchValue_2)) {
+                        if (isEmpty(tail(matchValue_2))) {
+                            matchResult = 8;
+                            v_6 = head(matchValue_2);
+                        }
+                        else {
+                            matchResult = 10;
+                            op = matchValue_1;
+                        }
+                    }
+                    else {
+                        matchResult = 10;
+                        op = matchValue_1;
+                    }
+                    break;
+                }
+                case "all": {
+                    matchResult = 9;
+                    vals_4 = matchValue_2;
+                    break;
+                }
+                default: {
+                    matchResult = 10;
+                    op = matchValue_1;
+                }
+            }
+            switch (matchResult) {
+                case 0:
+                    return `When ${fieldLabel} = ${v!}`;
+                case 1:
+                    return `When ${fieldLabel} is ${join(" or ", vals_2!)}`;
+                case 2:
+                    return `When ${fieldLabel} is any of ${length(vals_3!)} values`;
+                case 3:
+                    return `When ${fieldLabel} = ${v_1!}`;
+                case 4:
+                    return `When ${fieldLabel} ≠ ${v_2!}`;
+                case 5:
+                    return `When ${fieldLabel} ≥ ${v_3!}`;
+                case 6:
+                    return `When ${fieldLabel} > ${v_4!}`;
+                case 7:
+                    return `When ${fieldLabel} ≤ ${v_5!}`;
+                case 8:
+                    return `When ${fieldLabel} < ${v_6!}`;
+                case 9:
+                    return `When ${fieldLabel} has all of: ${join(", ", vals_4!)}`;
+                default:
+                    return `When ${fieldLabel} ${op!}`;
+            }
+        }
+        else {
+            return `When ${fieldLabel} (${length(matchValue)} conditions)`;
+        }
+    }
+    else {
+        return `When ${fieldLabel} (always)`;
+    }
+}
+
+export function generateActionLabel(trigger: ItemTrigger): string {
+    const matchValue: FSharpList<TriggerAction> = trigger.Actions;
+    if (!isEmpty(matchValue)) {
+        if (isEmpty(tail(matchValue))) {
+            const matchValue_1: string = head(matchValue).ActionType.toLowerCase();
+            switch (matchValue_1) {
+                case "alert":
+                    return `Create Alert: ${param("category_name", head(matchValue))}`;
+                case "task": {
+                    const p: string = param("priority", head(matchValue));
+                    return `Create ${(p === "1") ? "High " : ((p === "3") ? "Low " : "")}Task: ${param("category_name", head(matchValue))}`;
+                }
+                case "recurring_task":
+                    return `Schedule: ${param("category_name", head(matchValue))}`;
+                case "medset":
+                    return `Order Medset: ${param("medset_name", head(matchValue))}`;
+                case "problem":
+                    return "Add to Problem List";
+                default:
+                    return `Execute: ${matchValue_1}`;
+            }
+        }
+        else {
+            const joined: string = join(", ", List_distinct<string>(map<TriggerAction, string>((a: TriggerAction): string => a.ActionType, matchValue), {
+                Equals: (x: string, y: string): boolean => (x === y),
+                GetHashCode: stringHash,
+            }));
+            return `Execute ${length(matchValue)} actions: ${joined}`;
+        }
+    }
+    else {
+        return "No actions";
+    }
+}
+
+export function convertTriggerToPathway(trigger: ItemTrigger, parentItemId: int32, items: FSharpList<TemplateItem>, itemFieldKeyMap: FSharpMap<int32, Shared_FieldKey>): ClinicalPathway_ClinicalPathwaySpec {
+    const tid: int32 = trigger.TriggerId | 0;
+    const startKey: Shared_StateKey = new Shared_StateKey(stableGuid(`t${tid}_start`));
+    const evalKey: Shared_StateKey = new Shared_StateKey(stableGuid(`t${tid}_eval`));
+    const actionKey: Shared_StateKey = new Shared_StateKey(stableGuid(`t${tid}_action`));
+    const endKey: Shared_StateKey = new Shared_StateKey(stableGuid(`t${tid}_end`));
+    const evalLabel: string = generateEvaluationLabel(trigger, items);
+    const actionLabel: string = generateActionLabel(trigger);
+    const startState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(startKey, "Start", 0, ClinicalPathway_StateType_Evaluation(new ClinicalPathway_EvaluationInfo("", undefined)), undefined);
+    const evalState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(evalKey, evalLabel, 1, ClinicalPathway_StateType_Evaluation(new ClinicalPathway_EvaluationInfo("", undefined)), undefined);
+    let actionState: ClinicalPathway_StateDefinition;
+    const actions: FSharpList<ClinicalPathway_ActionInfo_$union> = map<TriggerAction, ClinicalPathway_ActionInfo_$union>(convertAction, trigger.Actions);
+    actionState = (new ClinicalPathway_StateDefinition(actionKey, actionLabel, 2, isEmpty(actions) ? ClinicalPathway_StateType_CompoundAction(actions) : (isEmpty(tail(actions)) ? ClinicalPathway_StateType_Action(head(actions)) : ClinicalPathway_StateType_CompoundAction(actions)), undefined));
+    const endState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(endKey, "Complete", 3, ClinicalPathway_StateType_Terminal(new ClinicalPathway_TerminalInfo("Complete", "Trigger evaluation complete", undefined)), undefined);
+    const condition: ClinicalPathway_TransitionCondition_$union = combineConditions(trigger.Conditions, itemFieldKeyMap);
+    const transitions: FSharpList<ClinicalPathway_TransitionDefinition> = ofArray([new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(stableGuid(`t${tid}_start_to_eval`)), startKey, evalKey, ClinicalPathway_TransitionCondition_Always(), undefined), new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(stableGuid(`t${tid}_eval_to_action`)), evalKey, actionKey, condition, 0), new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(stableGuid(`t${tid}_action_to_end`)), actionKey, endKey, ClinicalPathway_TransitionCondition_Always(), undefined)]);
+    return new ClinicalPathway_ClinicalPathwaySpec(`item_trigger_${tid}`, `Trigger ${tid}: ${actionLabel}`, "1.0.0", "CoreMR Conduit - Item Trigger", ClinicalPathway_PathwayExecutionMode_TriggerBased(new ClinicalPathway_TriggerBasedConfig(convertTiming(trigger.EventName), true)), startKey, ofArray([startState, evalState, actionState, endState]), transitions, empty<ClinicalPathway_ConstraintDefinition>(), empty<ClinicalPathway_PathRequirement>(), utcNow(), undefined, undefined, 1);
+}
+
+export function convertFormTriggersToPathway(form: TemplateForm, itemFieldKeyMap: FSharpMap<int32, Shared_FieldKey>): Option<ClinicalPathway_ClinicalPathwaySpec> {
+    const allTriggers: FSharpList<[int32, ItemTrigger]> = filter<[int32, ItemTrigger]>((tupledArg_1: [int32, ItemTrigger]): boolean => {
+        const t_2: ItemTrigger = tupledArg_1[1];
+        if (t_2.Enabled) {
+            return !isEmpty(t_2.Actions);
+        }
+        else {
+            return false;
+        }
+    }, List_distinctBy<[int32, ItemTrigger], int32>((tupledArg: [int32, ItemTrigger]): int32 => tupledArg[1].TriggerId, collect<TemplateItem, [int32, ItemTrigger]>((item: TemplateItem): FSharpList<[int32, ItemTrigger]> => map<ItemTrigger, [int32, ItemTrigger]>((t: ItemTrigger): [int32, ItemTrigger] => ([item.ItemId, t] as [int32, ItemTrigger]), item.Triggers), form.Items), {
+        Equals: (x: int32, y: int32): boolean => (x === y),
+        GetHashCode: numberHash,
+    }));
+    if (!isEmpty(allTriggers)) {
+        if (isEmpty(tail(allTriggers))) {
+            return convertTriggerToPathway(head(allTriggers)[1], head(allTriggers)[0], form.Items, itemFieldKeyMap);
+        }
+        else {
+            const pathwayId = `form_${form.FormId}_pathway`;
+            const startKey: Shared_StateKey = new Shared_StateKey(stableGuid(`${pathwayId}_start`));
+            let allStates: FSharpList<ClinicalPathway_StateDefinition> = singleton(new ClinicalPathway_StateDefinition(startKey, "Start", 0, ClinicalPathway_StateType_Evaluation(new ClinicalPathway_EvaluationInfo("", undefined)), undefined));
+            let allTransitions: FSharpList<ClinicalPathway_TransitionDefinition> = empty<ClinicalPathway_TransitionDefinition>();
+            const enumerator: IEnumerator<[int32, [int32, ItemTrigger]]> = getEnumerator(indexed<[int32, ItemTrigger]>(allTriggers));
+            try {
+                while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                    const forLoopVar: [int32, [int32, ItemTrigger]] = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const trigger: ItemTrigger = forLoopVar[1][1];
+                    const idx: int32 = forLoopVar[0] | 0;
+                    const tid: int32 = trigger.TriggerId | 0;
+                    const evalKey: Shared_StateKey = new Shared_StateKey(stableGuid(`${pathwayId}_eval_${tid}`));
+                    const actionKey: Shared_StateKey = new Shared_StateKey(stableGuid(`${pathwayId}_action_${tid}`));
+                    const endKey: Shared_StateKey = new Shared_StateKey(stableGuid(`${pathwayId}_end_${tid}`));
+                    const evalLabel: string = generateEvaluationLabel(trigger, form.Items);
+                    const actionLabel: string = generateActionLabel(trigger);
+                    const evalState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(evalKey, evalLabel, (idx * 3) + 1, ClinicalPathway_StateType_Evaluation(new ClinicalPathway_EvaluationInfo("", undefined)), undefined);
+                    const actions: FSharpList<ClinicalPathway_ActionInfo_$union> = map<TriggerAction, ClinicalPathway_ActionInfo_$union>(convertAction, trigger.Actions);
+                    const actionState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(actionKey, actionLabel, (idx * 3) + 2, isEmpty(actions) ? ClinicalPathway_StateType_CompoundAction(actions) : (isEmpty(tail(actions)) ? ClinicalPathway_StateType_Action(head(actions)) : ClinicalPathway_StateType_CompoundAction(actions)), undefined);
+                    const endState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(endKey, "Complete", (idx * 3) + 3, ClinicalPathway_StateType_Terminal(new ClinicalPathway_TerminalInfo("Complete", `Trigger ${tid} complete`, undefined)), undefined);
+                    const condition: ClinicalPathway_TransitionCondition_$union = combineConditions(trigger.Conditions, itemFieldKeyMap);
+                    const transitions: FSharpList<ClinicalPathway_TransitionDefinition> = ofArray([new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(stableGuid(`${pathwayId}_start_to_eval_${tid}`)), startKey, evalKey, ClinicalPathway_TransitionCondition_Always(), idx), new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(stableGuid(`${pathwayId}_eval_to_action_${tid}`)), evalKey, actionKey, condition, idx), new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(stableGuid(`${pathwayId}_action_to_end_${tid}`)), actionKey, endKey, ClinicalPathway_TransitionCondition_Always(), undefined)]);
+                    allStates = append(allStates, ofArray([evalState, actionState, endState]));
+                    allTransitions = append(allTransitions, transitions);
+                }
+            }
+            finally {
+                disposeSafe(enumerator as IDisposable);
+            }
+            const primaryTiming: string = defaultArg(map_1<[string, int32], string>((tuple_1: [string, int32]): string => tuple_1[0], tryHead<[string, int32]>(sortByDescending<[string, int32], int32>((tuple: [string, int32]): int32 => tuple[1], List_countBy<string, string>((x_1: string): string => x_1, map<[int32, ItemTrigger], string>((tupledArg_2: [int32, ItemTrigger]): string => tupledArg_2[1].EventName, allTriggers), {
+                Equals: (x_2: string, y_1: string): boolean => (x_2 === y_1),
+                GetHashCode: stringHash,
+            }), {
+                Compare: comparePrimitives,
+            }))), "save");
+            return new ClinicalPathway_ClinicalPathwaySpec(pathwayId, `${form.Name} - Clinical Pathway`, "1.0.0", "CoreMR Conduit - Unified Item Triggers", (length(allTriggers) > 1) ? ClinicalPathway_PathwayExecutionMode_MultiPathway(new ClinicalPathway_MultiPathwayConfig(ClinicalPathway_CombinationStrategy_AllMatching(), ClinicalPathway_ConflictResolution_CombineActions(), undefined)) : ClinicalPathway_PathwayExecutionMode_TriggerBased(new ClinicalPathway_TriggerBasedConfig(convertTiming(primaryTiming), true)), startKey, allStates, allTransitions, empty<ClinicalPathway_ConstraintDefinition>(), empty<ClinicalPathway_PathRequirement>(), utcNow(), undefined, undefined, 1);
+        }
+    }
+    else {
+        return undefined;
+    }
+}
+
+//# sourceMappingURL=ItemTriggerConverter.ts.map