@f1studio/form-spec 5.0.0-alpha.110 → 5.0.0-alpha.112

package/src/FormSpec.FS/Integrations/Adapters/CorEMR/CorEMRStepsBuilder.ts

@@ -0,0 +1,26 @@
+import { empty, FSharpList, map, mapIndexed } from "@fable-org/fable-library-js/List.js";
+import { mapToFormField } from "./CorEMRFieldTypeMapper.js";
+import { defaultArg } from "@fable-org/fable-library-js/Option.js";
+import { FSharpMap, tryFind } from "@fable-org/fable-library-js/Map.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { CoreMRItem, CoreMRChoice } from "../../CorEMR/CoreMRTypes.js";
+import { Spec_FormStep$1, Spec_FieldType_$union, Spec_FormField$1 } from "../../../FormSpec.js";
+import { isNullOrWhiteSpace } from "@fable-org/fable-library-js/String.js";
+import { detectHeadings, groupItemsByHeadings, Section } from "./CorEMRSectioning.js";
+
+/**
+ * Create FormSpec Steps from CoreMR items
+ */
+export function createSteps(formCode: string, items: FSharpList<CoreMRItem>, choicesByItem: FSharpMap<int32, FSharpList<CoreMRChoice>>): FSharpList<Spec_FormStep$1<Spec_FieldType_$union>> {
+    return mapIndexed<Section, Spec_FormStep$1<Spec_FieldType_$union>>((index: int32, section: Section): Spec_FormStep$1<Spec_FieldType_$union> => (new Spec_FormStep$1(index + 1, section.HeadingLabel, map<CoreMRItem, Spec_FormField$1<Spec_FieldType_$union>>((item: CoreMRItem): Spec_FormField$1<Spec_FieldType_$union> => {
+        const field: Spec_FormField$1<Spec_FieldType_$union> = mapToFormField(formCode, index + 1, item, defaultArg(tryFind<int32, FSharpList<CoreMRChoice>>(item.ItemId, choicesByItem), empty<CoreMRChoice>()));
+        if (isNullOrWhiteSpace(field.Label)) {
+            return new Spec_FormField$1(field.FieldOrder, field.FieldKey, "_(blank)_", field.Notes, field.DependsOn, field.IsOptional, field.IsDeprecated, field.NeedsDocumentation, field.Documentation, field.FieldType, field.Value);
+        }
+        else {
+            return field;
+        }
+    }, section.Items))), groupItemsByHeadings(detectHeadings(items), items));
+}
+
+//# sourceMappingURL=CorEMRStepsBuilder.ts.map

package/src/FormSpec.FS/Integrations/Adapters/CorEMR/CorEMRTemplateToFormSpec.ts

@@ -0,0 +1,161 @@
+import { Helpers_generateDeterministicGuidRaw, Helpers_canonicalizeFieldKey } from "../../../Helpers.js";
+import { tryFind, FSharpMap, ofList } from "@fable-org/fable-library-js/Map.js";
+import { empty, isEmpty, collect, ofArray, sumBy, FSharpList, map } from "@fable-org/fable-library-js/List.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { CoreMRFormData, CoreMRTag, CoreMRItem, CoreMRChoice } from "../../CorEMR/CoreMRTypes.js";
+import { numberHash, comparePrimitives } from "@fable-org/fable-library-js/Util.js";
+import { Spec_FormSpec$1_$reflection, Spec_FieldType_$reflection, Spec_FormSpec$1, Spec_FormLifecycle_Blueprint, ClinicalPathway_ClinicalPathwaySpec, Spec_FormField$1, Shared_FieldKey, Spec_FieldType_$union, Spec_FormStep$1, Spec_Score, Spec_ScoreColor_Danger, Spec_ScoreColor_Warning, Spec_ScoreRange, Spec_ScoreColor_Success } from "../../../FormSpec.js";
+import { defaultArg, Option } from "@fable-org/fable-library-js/Option.js";
+import { toConsoleError, printf, toText, substring } from "@fable-org/fable-library-js/String.js";
+import { createSteps } from "./CorEMRStepsBuilder.js";
+import { List_groupBy } from "@fable-org/fable-library-js/Seq2.js";
+import { generateNamespacedFieldKey } from "./CorEMRFieldTypeMapper.js";
+import { nonHeadingItems } from "./CorEMRSectioning.js";
+import { convertTriggersToSinglePathway } from "./CorEMRTriggerConverter.js";
+import { Auto_generateBoxedEncoder_437914C6, toString } from "../../../../fable_modules/Thoth.Json.10.4.1/Encode.fs.js";
+import { FSharpResult$2_Ok, FSharpResult$2_$union, FSharpResult$2_Error } from "@fable-org/fable-library-js/Result.js";
+import { FormSpecValidator_validateConversion, ValidationResult } from "./CorEMRFormSpecValidator.js";
+import { buildReport } from "./CorEMRSemanticReportBuilder.js";
+
+/**
+ * Use FormSpec's single source of truth for canonicalization
+ */
+export function canonicalizeFieldKey(input: string): string {
+    return Helpers_canonicalizeFieldKey(input);
+}
+
+/**
+ * Generate deterministic GUID using FormSpec's single source of truth
+ */
+export function generateStableDeterministicGuid(name: string): string {
+    return Helpers_generateDeterministicGuidRaw(`coremr:formspec:${name}`);
+}
+
+/**
+ * Create mapping from choice ID to actual text value
+ */
+export function createChoiceIdToTextMap(choices: FSharpList<CoreMRChoice>): FSharpMap<int32, string> {
+    return ofList<int32, string>(map<CoreMRChoice, [int32, string]>((c: CoreMRChoice): [int32, string] => ([c.ChoiceId, c.Text] as [int32, string]), choices), {
+        Compare: comparePrimitives,
+    });
+}
+
+/**
+ * Calculate scoring from choice scores
+ */
+export function calculateScore(choices: FSharpList<CoreMRChoice>, formName: string): Option<Spec_Score> {
+    const maxScore: int32 = sumBy<CoreMRChoice, int32>((c: CoreMRChoice): int32 => c.Score, choices, {
+        GetZero: (): int32 => 0,
+        Add: (x: int32, y: int32): int32 => (x + y),
+    }) | 0;
+    if (maxScore > 0) {
+        return new Spec_Score(maxScore, ofArray([new Spec_ScoreRange(generateStableDeterministicGuid(`score_range_${formName}_low`), 0, ~~(maxScore / 3), "Low Risk", Spec_ScoreColor_Success()), new Spec_ScoreRange(generateStableDeterministicGuid(`score_range_${formName}_medium`), ~~(maxScore / 3) + 1, ~~((maxScore * 2) / 3), "Medium Risk", Spec_ScoreColor_Warning()), new Spec_ScoreRange(generateStableDeterministicGuid(`score_range_${formName}_high`), ~~((maxScore * 2) / 3) + 1, maxScore, "High Risk", Spec_ScoreColor_Danger())]));
+    }
+    else {
+        return undefined;
+    }
+}
+
+/**
+ * Extract form code from form name using patterns:
+ * 1. If ends with (CODE) - extract CODE
+ * 2. If contains ' - ' - take everything after last dash
+ * 3. Otherwise use CORE-{id}
+ */
+export function extractFormCode(formName: string, formId: int32): string {
+    const trimmed: string = formName.trim();
+    if (trimmed.endsWith(")") && (trimmed.indexOf("(") >= 0)) {
+        const lastOpenParen: int32 = trimmed.lastIndexOf("(") | 0;
+        const lastCloseParen: int32 = trimmed.lastIndexOf(")") | 0;
+        if (lastOpenParen < lastCloseParen) {
+            return substring(trimmed, lastOpenParen + 1, (lastCloseParen - lastOpenParen) - 1).trim();
+        }
+        else {
+            return `CORE-${formId}`;
+        }
+    }
+    else if (trimmed.indexOf(" - ") >= 0) {
+        const lastDashIndex: int32 = trimmed.lastIndexOf(" - ") | 0;
+        return substring(trimmed, lastDashIndex + 3).trim();
+    }
+    else {
+        return `CORE-${formId}`;
+    }
+}
+
+/**
+ * Convert CoreMR form data to FormSpec
+ */
+export function convertToFormSpec(formData: CoreMRFormData): Spec_FormSpec$1<Spec_FieldType_$union> {
+    const formCode: string = extractFormCode(formData.Metadata.FormName, formData.Metadata.FormId);
+    const steps: FSharpList<Spec_FormStep$1<Spec_FieldType_$union>> = createSteps(formCode, formData.Items, ofList<int32, FSharpList<CoreMRChoice>>(List_groupBy<CoreMRChoice, int32>((c: CoreMRChoice): int32 => c.ItemId, formData.Choices, {
+        Equals: (x: int32, y: int32): boolean => (x === y),
+        GetHashCode: numberHash,
+    }), {
+        Compare: comparePrimitives,
+    }));
+    const score: Option<Spec_Score> = calculateScore(formData.Choices, formData.Metadata.FormName);
+    const fieldKeyBySequence: FSharpMap<int32, Shared_FieldKey> = ofList<int32, Shared_FieldKey>(map<Spec_FormField$1<Spec_FieldType_$union>, [int32, Shared_FieldKey]>((field: Spec_FormField$1<Spec_FieldType_$union>): [int32, Shared_FieldKey] => ([field.FieldOrder, field.FieldKey] as [int32, Shared_FieldKey]), collect<Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>>((step: Spec_FormStep$1<Spec_FieldType_$union>): FSharpList<Spec_FormField$1<Spec_FieldType_$union>> => step.Fields, steps)), {
+        Compare: comparePrimitives,
+    });
+    const itemIdToFieldKeyMap: FSharpMap<int32, Shared_FieldKey> = ofList<int32, Shared_FieldKey>(map<CoreMRItem, [int32, Shared_FieldKey]>((item: CoreMRItem): [int32, Shared_FieldKey] => ([item.ItemId, defaultArg(tryFind<int32, Shared_FieldKey>(item.Sequence, fieldKeyBySequence), generateNamespacedFieldKey(formCode, 1, item))] as [int32, Shared_FieldKey]), nonHeadingItems(formData.Items)), {
+        Compare: comparePrimitives,
+    });
+    const clinicalPathway: Option<ClinicalPathway_ClinicalPathwaySpec> = isEmpty(formData.Triggers) ? undefined : convertTriggersToSinglePathway(formData.Triggers, (itemId: int32): Shared_FieldKey => defaultArg(tryFind<int32, Shared_FieldKey>(itemId, itemIdToFieldKeyMap), new Shared_FieldKey(generateStableDeterministicGuid(`unknown_item_${itemId}`))), createChoiceIdToTextMap(formData.Choices), formData.Metadata, formData.Items);
+    return new Spec_FormSpec$1(generateStableDeterministicGuid(`form_${formData.Metadata.FormId}_${formData.Metadata.FormName}`), formCode, formData.Metadata.FormName, defaultArg(formData.Metadata.Description, ""), toText(printf("1.0.0-CoreEMRv%d"))(formData.Metadata.VersionNumber), "5.0.0", steps, map<CoreMRTag, string>((t: CoreMRTag): string => t.TagName, formData.Tags), score, empty<string>(), formData.Metadata.RequiresSignature, false, undefined, Spec_FormLifecycle_Blueprint(), undefined, undefined, undefined);
+}
+
+/**
+ * Serialize FormSpec to JSON
+ * Note: The JSON serialization may have issues with ConditionValue discriminated union.
+ * This is a known limitation - the MCP enhancement server and YAML conversion
+ * handle the FormSpec directly without relying on JSON serialization.
+ */
+export function serializeFormSpec(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): string {
+    try {
+        return toString(2, Auto_generateBoxedEncoder_437914C6(Spec_FormSpec$1_$reflection(Spec_FieldType_$reflection()), undefined, undefined, undefined)(formSpec));
+    }
+    catch (ex: any) {
+        toConsoleError(`JSON serialization failed for FormSpec '${formSpec.Title}' (ID: ${formSpec.Id}): ${ex.message}`);
+        toConsoleError(`Stack trace: ${ex.stack}`);
+        toConsoleError(printf("The FormSpec object is still valid for MCP enhancement"));
+        const errorResponse: { error: string, formId: string, formTitle: string, message: string, supportedAlternatives: string[] } = {
+            error: "JSON serialization not fully supported for ConditionValue types",
+            formId: formSpec.Id,
+            formTitle: formSpec.Title,
+            message: "Use FormSpec object directly or export to YAML",
+            supportedAlternatives: ["MCP Enhancement Server", "YAML Export", "Direct FormSpec Usage"],
+        };
+        return "Legacy JSON export is deprecated. Use MCP Enhancement Server or YAML export instead.";
+    }
+}
+
+/**
+ * Main conversion function
+ */
+export function convertForm(formData: CoreMRFormData): Spec_FormSpec$1<Spec_FieldType_$union> {
+    return convertToFormSpec(formData);
+}
+
+/**
+ * Convert form with validation
+ */
+export function convertFormWithValidation(formData: CoreMRFormData): FSharpResult$2_$union<[Spec_FormSpec$1<Spec_FieldType_$union>, ValidationResult], string> {
+    try {
+        const formSpec: Spec_FormSpec$1<Spec_FieldType_$union> = convertToFormSpec(formData);
+        const matchValue: FSharpResult$2_$union<ValidationResult, string> = FormSpecValidator_validateConversion(formData, formSpec);
+        return (matchValue.tag === /* Error */ 1) ? FSharpResult$2_Error<[Spec_FormSpec$1<Spec_FieldType_$union>, ValidationResult], string>(matchValue.fields[0]) : FSharpResult$2_Ok<[Spec_FormSpec$1<Spec_FieldType_$union>, ValidationResult], string>([formSpec, matchValue.fields[0]] as [Spec_FormSpec$1<Spec_FieldType_$union>, ValidationResult]);
+    }
+    catch (ex: any) {
+        return FSharpResult$2_Error<[Spec_FormSpec$1<Spec_FieldType_$union>, ValidationResult], string>(`Conversion failed: ${ex.message}`);
+    }
+}
+
+/**
+ * Convert form with semantic analysis
+ */
+export function convertFormWithSemantics(formData: CoreMRFormData): [Spec_FormSpec$1<Spec_FieldType_$union>, string] {
+    return [convertToFormSpec(formData), buildReport(formData)] as [Spec_FormSpec$1<Spec_FieldType_$union>, string];
+}
+
+//# sourceMappingURL=CorEMRTemplateToFormSpec.ts.map

package/src/FormSpec.FS/Integrations/Adapters/CorEMR/CorEMRTriggerConverter.ts

@@ -0,0 +1,386 @@
+import { Helpers_generateDeterministicGuidRaw } from "../../../Helpers.js";
+import { ClinicalPathway_PathwayExecutionMode_MultiPathway, ClinicalPathway_MultiPathwayConfig, ClinicalPathway_ConflictResolution_CombineActions, ClinicalPathway_CombinationStrategy_AllMatching, ClinicalPathway_PathwayExecutionMode_$union, ClinicalPathway_ClinicalPathwaySpec, ClinicalPathway_PathRequirement, ClinicalPathway_ConstraintDefinition, ClinicalPathway_PathwayExecutionMode_TriggerBased, ClinicalPathway_TriggerBasedConfig, ClinicalPathway_TransitionDefinition, ClinicalPathway_StateType_Terminal, ClinicalPathway_TerminalInfo, ClinicalPathway_StateType_CompoundAction, ClinicalPathway_StateType_Action, ClinicalPathway_StateDefinition, ClinicalPathway_StateType_Evaluation, ClinicalPathway_EvaluationInfo, Shared_TransitionKey, Shared_StateKey, ClinicalPathway_TransitionCondition_Always, ClinicalPathway_TransitionCondition_CompositeCondition, ClinicalPathway_LogicalOp_And, ClinicalPathway_TransitionCondition_$union, ClinicalPathway_TransitionCondition_FieldCondition, Shared_ConditionValue_Single, Shared_ConditionValue_Multiple, Shared_FieldKey, ClinicalPathway_ActionInfo_$union, ClinicalPathway_ActionInfo_Prescription, ClinicalPathway_PrescriptionAction, ClinicalPathway_ActionInfo_Medication, ClinicalPathway_MedicationAction, ClinicalPathway_ActionInfo_Problem, ClinicalPathway_ProblemAction, ClinicalPathway_ProblemStatus_Active, ClinicalPathway_ActionInfo_Task, ClinicalPathway_TaskAction, ClinicalPathway_ActionInfo_Alert, ClinicalPathway_AlertAction, ClinicalPathway_AlertSeverity_High, ClinicalPathway_RecurrencePattern, ClinicalPathway_RecurrenceEnd_OnDate, ClinicalPathway_RecurrenceEnd_Never, ClinicalPathway_DueDate_$union, ClinicalPathway_DueDate_DaysFromNow, ClinicalPathway_DueDate_Tomorrow, ClinicalPathway_DueDate_Today, ClinicalPathway_TaskPriority_$union, ClinicalPathway_TaskPriority_Low, ClinicalPathway_TaskPriority_Medium, ClinicalPathway_TaskPriority_High, ClinicalPathway_TriggerTiming_$union, ClinicalPathway_TriggerTiming_OnFormLoad, ClinicalPathway_TriggerTiming_OnFormSubmit, ClinicalPathway_TriggerTiming_OnFormSave, ClinicalPathway_FieldEvaluator_$union, 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 { join, trimStart, trim, split, replace, toConsoleError, printf, toFail } from "@fable-org/fable-library-js/String.js";
+import { singleton, tryHead, append, cons, collect, mapIndexed, filter, empty, ofArray, map as map_1, item as item_3, length, tryFind as tryFind_1, head, tail, isEmpty, choose, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { tryParse, int32 } from "@fable-org/fable-library-js/Int32.js";
+import { FSharpRef } from "@fable-org/fable-library-js/Types.js";
+import { item as item_2 } from "@fable-org/fable-library-js/Array.js";
+import { fromDays, fromHours } from "@fable-org/fable-library-js/TimeSpan.js";
+import { map, defaultArg, Option, value as value_7 } from "@fable-org/fable-library-js/Option.js";
+import { addDays, now, add } from "@fable-org/fable-library-js/DateOffset.js";
+import { FSharpMap, tryFind } from "@fable-org/fable-library-js/Map.js";
+import { CoreMRFormMetadata, CoreMRTrigger, CoreMRItem, CoreMRTriggerCondition, CoreMRTriggerEvent } from "../../CorEMR/CoreMRTypes.js";
+import { ofList } from "@fable-org/fable-library-js/Set.js";
+import { safeHash, equals, int32ToString, stringHash, comparePrimitives } from "@fable-org/fable-library-js/Util.js";
+import { List_distinctBy, List_distinct } from "@fable-org/fable-library-js/Seq2.js";
+
+function generateStableDeterministicGuid(name: string): string {
+    return Helpers_generateDeterministicGuidRaw(`coremr:trigger:${name}`);
+}
+
+/**
+ * Convert CoreMR operator to FormSpec FieldEvaluator
+ * Note: answerValues are now actual text values, not IDs
+ */
+export function convertOperator(operator: string, answerValues: FSharpList<string>): ClinicalPathway_FieldEvaluator_$union {
+    const matchValue: string = operator.toLocaleLowerCase();
+    switch (matchValue) {
+        case "any":
+            return ClinicalPathway_FieldEvaluator_InSet(answerValues);
+        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(answerValues);
+        case "none":
+            return ClinicalPathway_FieldEvaluator_NotInSet(answerValues);
+        default:
+            return toFail(printf("Unknown CoreMR operator: %s"))(matchValue);
+    }
+}
+
+/**
+ * Convert CoreMR trigger_on to FormSpec TriggerTiming
+ */
+export function convertTiming(triggerOn: string): ClinicalPathway_TriggerTiming_$union {
+    const matchValue: string = triggerOn.toLocaleLowerCase();
+    switch (matchValue) {
+        case "save":
+            return ClinicalPathway_TriggerTiming_OnFormSave();
+        case "lock":
+            return ClinicalPathway_TriggerTiming_OnFormSubmit();
+        case "open_first_time":
+            return ClinicalPathway_TriggerTiming_OnFormLoad();
+        default: {
+            toConsoleError(printf("Unknown trigger_on value: %s, defaulting to OnFormSave"))(matchValue);
+            return ClinicalPathway_TriggerTiming_OnFormSave();
+        }
+    }
+}
+
+/**
+ * Convert CoreMR priority (1=high, 2=medium, 3=low) to FormSpec TaskPriority
+ */
+export function convertPriority(priority: string): ClinicalPathway_TaskPriority_$union {
+    switch (priority) {
+        case "1":
+            return ClinicalPathway_TaskPriority_High();
+        case "2":
+            return ClinicalPathway_TaskPriority_Medium();
+        default:
+            return ClinicalPathway_TaskPriority_Low();
+    }
+}
+
+/**
+ * Parse CoreMR due date string to FormSpec DueDate
+ */
+export function parseDueDate(dateStr: string): ClinicalPathway_DueDate_$union {
+    let date: string;
+    const matchValue: string = dateStr.toLocaleLowerCase().trim();
+    switch (matchValue) {
+        case "today":
+            return ClinicalPathway_DueDate_Today();
+        case "tomorrow":
+            return ClinicalPathway_DueDate_Tomorrow();
+        default:
+            if ((date = matchValue, date.startsWith("+") && date.endsWith("days"))) {
+                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();
+                }
+            }
+            else if (matchValue.startsWith("+")) {
+                const parts: string[] = split(trim(matchValue, "+").trim(), [" "], undefined, 1);
+                if (parts.length > 0) {
+                    let matchValue_2: [boolean, int32];
+                    let outArg_1 = 0;
+                    matchValue_2 = ([tryParse(item_2(0, parts), 511, false, 32, new FSharpRef<int32>((): int32 => outArg_1, (v_1: int32): void => {
+                        outArg_1 = (v_1 | 0);
+                    })), outArg_1] as [boolean, int32]);
+                    if (matchValue_2[0]) {
+                        return ClinicalPathway_DueDate_DaysFromNow(matchValue_2[1]);
+                    }
+                    else {
+                        return ClinicalPathway_DueDate_Today();
+                    }
+                }
+                else {
+                    return ClinicalPathway_DueDate_Today();
+                }
+            }
+            else {
+                return ClinicalPathway_DueDate_Today();
+            }
+    }
+}
+
+/**
+ * Parse CoreMR recurrence interval (e.g., "+1 day", "+4 hours")
+ */
+export function parseRecurrenceInterval(intervalStr: string): number {
+    const parts: string[] = split(trimStart(intervalStr.toLocaleLowerCase().trim(), "+"), [" "], undefined, 1);
+    if (parts.length >= 2) {
+        const valueStr: string = item_2(0, parts);
+        const unit: string = item_2(1, parts);
+        let matchValue: [boolean, int32];
+        let outArg = 0;
+        matchValue = ([tryParse(valueStr, 511, false, 32, new FSharpRef<int32>((): int32 => outArg, (v: int32): void => {
+            outArg = (v | 0);
+        })), outArg] as [boolean, int32]);
+        if (matchValue[0]) {
+            const value: int32 = matchValue[1] | 0;
+            switch (unit) {
+                case "hour":
+                case "hours":
+                    return fromHours(value);
+                case "day":
+                case "days":
+                    return fromDays(value);
+                case "week":
+                case "weeks":
+                    return fromDays(value * 7);
+                default:
+                    return fromDays(1);
+            }
+        }
+        else {
+            return fromDays(1);
+        }
+    }
+    else {
+        return fromDays(1);
+    }
+}
+
+/**
+ * Parse recurrence pattern from CoreMR event params
+ */
+export function parseRecurrence(recurEvery: Option<string>, recurEnd: Option<string>): Option<ClinicalPathway_RecurrencePattern> {
+    let endStr: string;
+    if (recurEvery != null) {
+        return new ClinicalPathway_RecurrencePattern(parseRecurrenceInterval(value_7(recurEvery)), (recurEnd == null) ? ClinicalPathway_RecurrenceEnd_Never() : ((endStr = value_7(recurEnd), ClinicalPathway_RecurrenceEnd_OnDate(endStr.startsWith("+") ? add(now(), parseRecurrenceInterval(endStr)) : addDays(now(), 7)))));
+    }
+    else {
+        return undefined;
+    }
+}
+
+/**
+ * Convert CoreMR event to FormSpec ActionInfo
+ */
+export function convertEvent(event: CoreMRTriggerEvent): ClinicalPathway_ActionInfo_$union {
+    const matchValue: string = event.EventType.toLocaleLowerCase();
+    switch (matchValue) {
+        case "alert": {
+            const category: string = defaultArg(tryFind<string, string>("category_desc", event.EventParams), "Alert");
+            return ClinicalPathway_ActionInfo_Alert(new ClinicalPathway_AlertAction(category, `Alert: ${category}`, ClinicalPathway_AlertSeverity_High(), undefined));
+        }
+        case "task": {
+            const category_1: string = defaultArg(tryFind<string, string>("cat_desc", event.EventParams), "Task");
+            const description: string = defaultArg(tryFind<string, string>("description", event.EventParams), "");
+            const priorityStr: string = defaultArg(tryFind<string, string>("priority", event.EventParams), "2");
+            const dateStr: string = defaultArg(tryFind<string, string>("date", event.EventParams), "Today");
+            const recurEvery: Option<string> = tryFind<string, string>("recur_every", event.EventParams);
+            const recurEnd: Option<string> = tryFind<string, string>("recur_end", event.EventParams);
+            let assignee: string;
+            const parts: string[] = split(category_1, ["-"], 2);
+            assignee = ((parts.length > 0) ? item_2(0, parts).trim() : "Staff");
+            return ClinicalPathway_ActionInfo_Task(new ClinicalPathway_TaskAction(category_1, description, convertPriority(priorityStr), parseDueDate(dateStr), assignee, parseRecurrence(recurEvery, recurEnd)));
+        }
+        case "problem":
+            return ClinicalPathway_ActionInfo_Problem(new ClinicalPathway_ProblemAction("Problem", undefined, now(), ClinicalPathway_ProblemStatus_Active(), undefined));
+        case "medset":
+            return ClinicalPathway_ActionInfo_Medication(new ClinicalPathway_MedicationAction("Medication Set", "", "", "", "", false));
+        case "prescription":
+            return ClinicalPathway_ActionInfo_Prescription(new ClinicalPathway_PrescriptionAction("", "", "PO", "", "", 30, 0, true, undefined));
+        default:
+            return toFail(printf("Unknown CoreMR event type: %s"))(matchValue);
+    }
+}
+
+/**
+ * Convert CoreMR condition to FormSpec TransitionCondition
+ */
+export function convertCondition(condition: CoreMRTriggerCondition, itemIdToFieldKey: ((arg0: int32) => Shared_FieldKey), choiceIdToText: FSharpMap<int32, string>): ClinicalPathway_TransitionCondition_$union {
+    let matchValue: string;
+    const fieldKey: Shared_FieldKey = itemIdToFieldKey(condition.TriggerId);
+    const answerValues: FSharpList<string> = choose<int32, string>((choiceId: int32): Option<string> => tryFind<int32, string>(choiceId, choiceIdToText), condition.Answers);
+    return ClinicalPathway_TransitionCondition_FieldCondition(fieldKey, convertOperator(condition.Operator, answerValues), (matchValue = condition.Operator.toLocaleLowerCase(), (matchValue === "any") ? Shared_ConditionValue_Multiple(ofList<string>(answerValues, {
+        Compare: comparePrimitives,
+    })) : ((matchValue === "all") ? Shared_ConditionValue_Multiple(ofList<string>(answerValues, {
+        Compare: comparePrimitives,
+    })) : ((matchValue === "none") ? Shared_ConditionValue_Multiple(ofList<string>(answerValues, {
+        Compare: comparePrimitives,
+    })) : (!isEmpty(answerValues) ? (isEmpty(tail(answerValues)) ? Shared_ConditionValue_Single(head(answerValues)) : Shared_ConditionValue_Single(head<string>(answerValues))) : Shared_ConditionValue_Single(""))))));
+}
+
+/**
+ * Combine multiple conditions with AND logic
+ */
+export function combineConditions(conditions: FSharpList<ClinicalPathway_TransitionCondition_$union>): ClinicalPathway_TransitionCondition_$union {
+    if (!isEmpty(conditions)) {
+        if (isEmpty(tail(conditions))) {
+            return head(conditions);
+        }
+        else {
+            return ClinicalPathway_TransitionCondition_CompositeCondition(ClinicalPathway_LogicalOp_And(), conditions);
+        }
+    }
+    else {
+        return ClinicalPathway_TransitionCondition_Always();
+    }
+}
+
+/**
+ * Generate human-readable label for evaluation state based on trigger conditions
+ */
+export function generateEvaluationLabel(trigger: CoreMRTrigger, itemIdToFieldKey: ((arg0: int32) => Shared_FieldKey), choiceIdToText: FSharpMap<int32, string>, items: FSharpList<CoreMRItem>): string {
+    let value: string, matchValue: FSharpList<CoreMRTriggerCondition>, answerValues: FSharpList<string>, matchValue_1: string;
+    return `When ${(value = (`Field ${trigger.TargetItemId}`), defaultArg(map<CoreMRItem, string>((item_1: CoreMRItem): string => item_1.Label, tryFind_1<CoreMRItem>((item: CoreMRItem): boolean => (item.ItemId === trigger.TargetItemId), items)), value))} ${(matchValue = trigger.Conditions, !isEmpty(matchValue) ? (isEmpty(tail(matchValue)) ? ((answerValues = choose<int32, string>((choiceId: int32): Option<string> => tryFind<int32, string>(choiceId, choiceIdToText), head(matchValue).Answers), (matchValue_1 = head(matchValue).Operator.toLocaleLowerCase(), (matchValue_1 === "any") ? ((length(answerValues) === 1) ? (`= ${item_3(0, answerValues)}`) : (`is ${join(" or ", answerValues)}`)) : ((matchValue_1 === "equals") ? ((length(answerValues) > 0) ? (`= ${item_3(0, answerValues)}`) : (`${matchValue_1} ${join(", ", answerValues)}`)) : ((matchValue_1 === "all") ? (`is all of: ${join(", ", answerValues)}`) : ((matchValue_1 === "none") ? (`is none of: ${join(", ", answerValues)}`) : ((matchValue_1 === "greater") ? ((length(answerValues) > 0) ? (`> ${item_3(0, answerValues)}`) : (`${matchValue_1} ${join(", ", answerValues)}`)) : ((matchValue_1 === "greater_equals") ? ((length(answerValues) > 0) ? (`>= ${item_3(0, answerValues)}`) : (`${matchValue_1} ${join(", ", answerValues)}`)) : ((matchValue_1 === "less") ? ((length(answerValues) > 0) ? (`< ${item_3(0, answerValues)}`) : (`${matchValue_1} ${join(", ", answerValues)}`)) : ((matchValue_1 === "less_equals") ? ((length(answerValues) > 0) ? (`<= ${item_3(0, answerValues)}`) : (`${matchValue_1} ${join(", ", answerValues)}`)) : (`${matchValue_1} ${join(", ", answerValues)}`))))))))))) : "multiple conditions") : "always")}`;
+}
+
+/**
+ * Generate human-readable label for action state based on trigger events
+ */
+export function generateActionLabel(trigger: CoreMRTrigger): string {
+    const matchValue: FSharpList<CoreMRTriggerEvent> = trigger.Events;
+    if (!isEmpty(matchValue)) {
+        if (isEmpty(tail(matchValue))) {
+            const matchValue_1: string = head(matchValue).EventType.toLocaleLowerCase();
+            switch (matchValue_1) {
+                case "alert":
+                    return `Create Alert: ${defaultArg(tryFind<string, string>("category_desc", head(matchValue).EventParams), "Alert")}`;
+                case "task": {
+                    const category_1: string = defaultArg(tryFind<string, string>("cat_desc", head(matchValue).EventParams), "Task");
+                    const priority: string = defaultArg(tryFind<string, string>("priority", head(matchValue).EventParams), "2");
+                    return `Create ${`${(priority === "1") ? "High Priority" : ((priority === "2") ? "Medium Priority" : ((priority === "3") ? "Low Priority" : "Priority"))} Task: ${category_1}`}`;
+                }
+                case "problem":
+                    return "Add to Problem List";
+                case "prescription":
+                    return "Create Prescription";
+                case "medset":
+                    return "Add Medication Set";
+                default:
+                    return `Execute ${head(matchValue).EventType}`;
+            }
+        }
+        else {
+            const joined: string = join(", ", List_distinct<string>(map_1<CoreMRTriggerEvent, string>((e: CoreMRTriggerEvent): string => e.EventType, matchValue), {
+                Equals: (x: string, y: string): boolean => (x === y),
+                GetHashCode: stringHash,
+            }));
+            return `Execute ${length(matchValue)} actions: ${joined}`;
+        }
+    }
+    else {
+        return "No actions";
+    }
+}
+
+/**
+ * Convert single CoreMR trigger to complete ClinicalPathwaySpec
+ */
+export function convertTriggerToPathway(trigger: CoreMRTrigger, itemIdToFieldKey: ((arg0: int32) => Shared_FieldKey), choiceIdToText: FSharpMap<int32, string>): ClinicalPathway_ClinicalPathwaySpec {
+    const startKey: Shared_StateKey = new Shared_StateKey(generateStableDeterministicGuid(`trigger_${trigger.TriggerId}_state_start`));
+    const evalKey: Shared_StateKey = new Shared_StateKey(generateStableDeterministicGuid(`trigger_${trigger.TriggerId}_state_evaluate`));
+    const actionKey: Shared_StateKey = new Shared_StateKey(generateStableDeterministicGuid(`trigger_${trigger.TriggerId}_state_action`));
+    const endKey: Shared_StateKey = new Shared_StateKey(generateStableDeterministicGuid(`trigger_${trigger.TriggerId}_state_end`));
+    const transitionKey1: Shared_TransitionKey = new Shared_TransitionKey(generateStableDeterministicGuid(`trigger_${trigger.TriggerId}_transition_start_to_eval`));
+    const transitionKey2: Shared_TransitionKey = new Shared_TransitionKey(generateStableDeterministicGuid(`trigger_${trigger.TriggerId}_transition_eval_to_action`));
+    const transitionKey3: Shared_TransitionKey = new Shared_TransitionKey(generateStableDeterministicGuid(`trigger_${trigger.TriggerId}_transition_action_to_end`));
+    const startState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(startKey, "Start", 0, ClinicalPathway_StateType_Evaluation(new ClinicalPathway_EvaluationInfo("Start", undefined)), undefined);
+    const evalState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(evalKey, "Evaluate Condition", 1, ClinicalPathway_StateType_Evaluation(new ClinicalPathway_EvaluationInfo(`Check Trigger ${trigger.TriggerId}`, undefined)), undefined);
+    let actionState: ClinicalPathway_StateDefinition;
+    const actions: FSharpList<ClinicalPathway_ActionInfo_$union> = map_1<CoreMRTriggerEvent, ClinicalPathway_ActionInfo_$union>(convertEvent, trigger.Events);
+    actionState = (new ClinicalPathway_StateDefinition(actionKey, "Execute Actions", 2, !isEmpty(actions) ? (isEmpty(tail(actions)) ? ClinicalPathway_StateType_Action(head(actions)) : ClinicalPathway_StateType_CompoundAction(actions)) : (() => {
+        throw new Error(`Trigger ${trigger.TriggerId} has no events`);
+    })(), undefined));
+    const endState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(endKey, "End", 3, ClinicalPathway_StateType_Terminal(new ClinicalPathway_TerminalInfo("Complete", "Actions executed", undefined)), undefined);
+    const transitions: FSharpList<ClinicalPathway_TransitionDefinition> = ofArray([new ClinicalPathway_TransitionDefinition(transitionKey1, startKey, evalKey, ClinicalPathway_TransitionCondition_Always(), undefined), new ClinicalPathway_TransitionDefinition(transitionKey2, evalKey, actionKey, combineConditions(map_1<CoreMRTriggerCondition, ClinicalPathway_TransitionCondition_$union>((c: CoreMRTriggerCondition): ClinicalPathway_TransitionCondition_$union => convertCondition(c, itemIdToFieldKey, choiceIdToText), trigger.Conditions)), trigger.TriggerOrder), new ClinicalPathway_TransitionDefinition(transitionKey3, actionKey, endKey, ClinicalPathway_TransitionCondition_Always(), undefined)]);
+    return new ClinicalPathway_ClinicalPathwaySpec(`coremr_trigger_${trigger.TriggerId}`, `CoreMR Trigger ${trigger.TriggerId}`, "1.0.0", "CoreMR Migration", ClinicalPathway_PathwayExecutionMode_TriggerBased(new ClinicalPathway_TriggerBasedConfig(convertTiming(trigger.TriggerOn), true)), startKey, ofArray([startState, evalState, actionState, endState]), transitions, empty<ClinicalPathway_ConstraintDefinition>(), empty<ClinicalPathway_PathRequirement>(), now(), undefined, undefined, 1);
+}
+
+/**
+ * Convert all active triggers for a form to pathways
+ */
+export function convertAllTriggers(triggers: FSharpList<CoreMRTrigger>, itemIdToFieldKey: ((arg0: int32) => Shared_FieldKey), choiceIdToText: FSharpMap<int32, string>): FSharpList<ClinicalPathway_ClinicalPathwaySpec> {
+    return map_1<CoreMRTrigger, ClinicalPathway_ClinicalPathwaySpec>((t_2: CoreMRTrigger): ClinicalPathway_ClinicalPathwaySpec => convertTriggerToPathway(t_2, itemIdToFieldKey, choiceIdToText), filter<CoreMRTrigger>((t_1: CoreMRTrigger): boolean => !isEmpty(t_1.Events), filter<CoreMRTrigger>((t: CoreMRTrigger): boolean => t.Active, triggers)));
+}
+
+/**
+ * Convert all triggers into a SINGLE pathway with one start node and branching logic
+ * This creates the proper structure: Start → Multiple Evaluation branches → Actions
+ */
+export function convertTriggersToSinglePathway(triggers: FSharpList<CoreMRTrigger>, itemIdToFieldKey: ((arg0: int32) => Shared_FieldKey), choiceIdToText: FSharpMap<int32, string>, metadata: CoreMRFormMetadata, items: FSharpList<CoreMRItem>): ClinicalPathway_ClinicalPathwaySpec {
+    const activeTriggers: FSharpList<CoreMRTrigger> = filter<CoreMRTrigger>((t_1: CoreMRTrigger): boolean => !isEmpty(t_1.Events), filter<CoreMRTrigger>((t: CoreMRTrigger): boolean => t.Active, triggers));
+    const pathwayId = `form_${metadata.FormId}_pathway`;
+    const startKey: Shared_StateKey = new Shared_StateKey(generateStableDeterministicGuid(`${pathwayId}_start`));
+    const startState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(startKey, "Start", 0, ClinicalPathway_StateType_Evaluation(new ClinicalPathway_EvaluationInfo("Start", undefined)), undefined);
+    const triggerStates: FSharpList<[CoreMRTrigger, Shared_StateKey, Shared_StateKey, Shared_StateKey, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition]> = mapIndexed<CoreMRTrigger, [CoreMRTrigger, Shared_StateKey, Shared_StateKey, Shared_StateKey, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition]>((idx: int32, trigger: CoreMRTrigger): [CoreMRTrigger, Shared_StateKey, Shared_StateKey, Shared_StateKey, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition] => {
+        const evalKey: Shared_StateKey = new Shared_StateKey(generateStableDeterministicGuid(`${pathwayId}_eval_${trigger.TriggerId}`));
+        const actionKey: Shared_StateKey = new Shared_StateKey(generateStableDeterministicGuid(`${pathwayId}_action_${trigger.TriggerId}`));
+        const endKey: Shared_StateKey = new Shared_StateKey(generateStableDeterministicGuid(`${pathwayId}_end_${trigger.TriggerId}`));
+        const evalLabel: string = generateEvaluationLabel(trigger, itemIdToFieldKey, choiceIdToText, items);
+        const actionLabel: string = generateActionLabel(trigger);
+        const evalState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(evalKey, evalLabel, (idx * 3) + 1, ClinicalPathway_StateType_Evaluation(new ClinicalPathway_EvaluationInfo(evalLabel, undefined)), undefined);
+        const actions: FSharpList<ClinicalPathway_ActionInfo_$union> = map_1<CoreMRTriggerEvent, ClinicalPathway_ActionInfo_$union>(convertEvent, trigger.Events);
+        return [trigger, evalKey, actionKey, endKey, evalState, new ClinicalPathway_StateDefinition(actionKey, actionLabel, (idx * 3) + 2, !isEmpty(actions) ? (isEmpty(tail(actions)) ? ClinicalPathway_StateType_Action(head(actions)) : ClinicalPathway_StateType_CompoundAction(actions)) : ClinicalPathway_StateType_CompoundAction(empty<ClinicalPathway_ActionInfo_$union>()), undefined), new ClinicalPathway_StateDefinition(endKey, "End", (idx * 3) + 3, ClinicalPathway_StateType_Terminal(new ClinicalPathway_TerminalInfo("Complete", "Actions executed", undefined)), undefined)] as [CoreMRTrigger, Shared_StateKey, Shared_StateKey, Shared_StateKey, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition];
+    }, activeTriggers);
+    const allStates: FSharpList<ClinicalPathway_StateDefinition> = cons(startState, collect<[CoreMRTrigger, Shared_StateKey, Shared_StateKey, Shared_StateKey, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition], ClinicalPathway_StateDefinition>((tupledArg: [CoreMRTrigger, Shared_StateKey, Shared_StateKey, Shared_StateKey, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition]): FSharpList<ClinicalPathway_StateDefinition> => ofArray([tupledArg[4], tupledArg[5], tupledArg[6]]), triggerStates));
+    const allTransitions: FSharpList<ClinicalPathway_TransitionDefinition> = append(mapIndexed<[CoreMRTrigger, Shared_StateKey, Shared_StateKey, Shared_StateKey, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition], ClinicalPathway_TransitionDefinition>((idx_1: int32, tupledArg_1: [CoreMRTrigger, Shared_StateKey, Shared_StateKey, Shared_StateKey, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition]): ClinicalPathway_TransitionDefinition => (new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(generateStableDeterministicGuid(`${pathwayId}_start_to_eval_${tupledArg_1[0].TriggerId}`)), startKey, tupledArg_1[1], ClinicalPathway_TransitionCondition_Always(), idx_1)), triggerStates), append(map_1<[CoreMRTrigger, Shared_StateKey, Shared_StateKey, Shared_StateKey, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition], ClinicalPathway_TransitionDefinition>((tupledArg_2: [CoreMRTrigger, Shared_StateKey, Shared_StateKey, Shared_StateKey, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition]): ClinicalPathway_TransitionDefinition => {
+        const trigger_2: CoreMRTrigger = tupledArg_2[0];
+        const transitionCondition: ClinicalPathway_TransitionCondition_$union = combineConditions(map_1<CoreMRTriggerCondition, ClinicalPathway_TransitionCondition_$union>((c: CoreMRTriggerCondition): ClinicalPathway_TransitionCondition_$union => convertCondition(c, itemIdToFieldKey, choiceIdToText), trigger_2.Conditions));
+        return new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(generateStableDeterministicGuid(`${pathwayId}_eval_to_action_${trigger_2.TriggerId}`)), tupledArg_2[1], tupledArg_2[2], transitionCondition, trigger_2.TriggerOrder);
+    }, triggerStates), map_1<[CoreMRTrigger, Shared_StateKey, Shared_StateKey, Shared_StateKey, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition], ClinicalPathway_TransitionDefinition>((tupledArg_3: [CoreMRTrigger, Shared_StateKey, Shared_StateKey, Shared_StateKey, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition]): ClinicalPathway_TransitionDefinition => (new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(generateStableDeterministicGuid(`${pathwayId}_action_to_end_${tupledArg_3[0].TriggerId}`)), tupledArg_3[2], tupledArg_3[3], ClinicalPathway_TransitionCondition_Always(), undefined)), triggerStates)));
+    let executionMode: ClinicalPathway_PathwayExecutionMode_$union;
+    const primaryTiming: ClinicalPathway_TriggerTiming_$union = defaultArg(map<CoreMRTrigger, ClinicalPathway_TriggerTiming_$union>((t_2: CoreMRTrigger): ClinicalPathway_TriggerTiming_$union => convertTiming(t_2.TriggerOn), tryHead<CoreMRTrigger>(activeTriggers)), ClinicalPathway_TriggerTiming_OnFormSave());
+    executionMode = ((length(activeTriggers) > 1) ? ClinicalPathway_PathwayExecutionMode_MultiPathway(new ClinicalPathway_MultiPathwayConfig(ClinicalPathway_CombinationStrategy_AllMatching(), ClinicalPathway_ConflictResolution_CombineActions(), undefined)) : ClinicalPathway_PathwayExecutionMode_TriggerBased(new ClinicalPathway_TriggerBasedConfig(primaryTiming, true)));
+    return new ClinicalPathway_ClinicalPathwaySpec(pathwayId, `${metadata.FormName} - Clinical Pathway`, int32ToString(metadata.VersionNumber), "CoreMR Migration - Unified Pathway", executionMode, startKey, allStates, allTransitions, empty<ClinicalPathway_ConstraintDefinition>(), empty<ClinicalPathway_PathRequirement>(), now(), undefined, undefined, 1);
+}
+
+/**
+ * Create an orchestrator pathway that coordinates multiple sub-pathways
+ */
+export function createOrchestratorPathway(subPathways: FSharpList<ClinicalPathway_ClinicalPathwaySpec>, metadata: CoreMRFormMetadata): ClinicalPathway_ClinicalPathwaySpec {
+    const orchestratorId = `orchestrator_form_${metadata.FormId}`;
+    const startKey: Shared_StateKey = new Shared_StateKey(generateStableDeterministicGuid(`${orchestratorId}_start`));
+    const endKey: Shared_StateKey = new Shared_StateKey(generateStableDeterministicGuid(`${orchestratorId}_end`));
+    const allStates: FSharpList<ClinicalPathway_StateDefinition> = append(singleton(new ClinicalPathway_StateDefinition(startKey, "Orchestrator Start", -1, ClinicalPathway_StateType_Evaluation(new ClinicalPathway_EvaluationInfo("Begin Evaluation", undefined)), undefined)), append(List_distinctBy<ClinicalPathway_StateDefinition, Shared_StateKey>((s: ClinicalPathway_StateDefinition): Shared_StateKey => s.StateKey, collect<ClinicalPathway_ClinicalPathwaySpec, ClinicalPathway_StateDefinition>((p: ClinicalPathway_ClinicalPathwaySpec): FSharpList<ClinicalPathway_StateDefinition> => p.States, subPathways), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    }), singleton(new ClinicalPathway_StateDefinition(endKey, "Orchestrator End", 999999, ClinicalPathway_StateType_Terminal(new ClinicalPathway_TerminalInfo("Complete", "All pathways evaluated", undefined)), undefined))));
+    let allTransitions: FSharpList<ClinicalPathway_TransitionDefinition>;
+    const subTransitions: FSharpList<ClinicalPathway_TransitionDefinition> = List_distinctBy<ClinicalPathway_TransitionDefinition, Shared_TransitionKey>((t: ClinicalPathway_TransitionDefinition): Shared_TransitionKey => t.TransitionKey, collect<ClinicalPathway_ClinicalPathwaySpec, ClinicalPathway_TransitionDefinition>((p_1: ClinicalPathway_ClinicalPathwaySpec): FSharpList<ClinicalPathway_TransitionDefinition> => p_1.Transitions, subPathways), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+    allTransitions = append(mapIndexed<Shared_StateKey, ClinicalPathway_TransitionDefinition>((i: int32, initialState: Shared_StateKey): ClinicalPathway_TransitionDefinition => (new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(generateStableDeterministicGuid(`${orchestratorId}_start_to_${i}`)), startKey, initialState, ClinicalPathway_TransitionCondition_Always(), i)), choose<ClinicalPathway_ClinicalPathwaySpec, Shared_StateKey>((p_2: ClinicalPathway_ClinicalPathwaySpec): Option<Shared_StateKey> => p_2.InitialState, subPathways)), append(subTransitions, mapIndexed<ClinicalPathway_StateDefinition, ClinicalPathway_TransitionDefinition>((i_1: int32, terminal: ClinicalPathway_StateDefinition): ClinicalPathway_TransitionDefinition => (new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(generateStableDeterministicGuid(`${orchestratorId}_terminal_${i_1}_to_end`)), terminal.StateKey, endKey, ClinicalPathway_TransitionCondition_Always(), undefined)), filter<ClinicalPathway_StateDefinition>((s_2: ClinicalPathway_StateDefinition): boolean => !equals(s_2.StateKey, endKey), filter<ClinicalPathway_StateDefinition>((s_1: ClinicalPathway_StateDefinition): boolean => {
+        if (s_1.StateType.tag === /* Terminal */ 5) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }, allStates)))));
+    return new ClinicalPathway_ClinicalPathwaySpec(orchestratorId, `${metadata.FormName} - Orchestrated Pathways`, int32ToString(metadata.VersionNumber), "CoreMR Migration - Multi-Trigger Orchestrator", ClinicalPathway_PathwayExecutionMode_MultiPathway(new ClinicalPathway_MultiPathwayConfig(ClinicalPathway_CombinationStrategy_AllMatching(), ClinicalPathway_ConflictResolution_CombineActions(), undefined)), startKey, allStates, allTransitions, empty<ClinicalPathway_ConstraintDefinition>(), empty<ClinicalPathway_PathRequirement>(), now(), undefined, undefined, 0.9);
+}
+
+//# sourceMappingURL=CorEMRTriggerConverter.ts.map