@f1studio/form-spec 5.0.0-alpha.102 → 5.0.0-alpha.104

package/src/Interop/FormSpec.Values.Api.Option.ts

@@ -2,15 +2,17 @@ import { FSharpRef, Record } from "@fable-org/fable-library-js/Types.js";
 import { Converters_scoreFromTS, Converters_scoreToTS, Converters_fieldOptionFromTS, Converters_fieldTypeFromTS, Converters_fieldOptionToTS, Converters_fieldTypeToTS, Converters_fieldKeyFromTS, Converters_fieldKeyToTS, Types_ScoreTS_$reflection, Types_ScoreTS, Types_FieldOptionTS_$reflection, Types_FieldTypeTS_$reflection, Types_FieldOptionTS, Types_FieldTypeTS, Types_MatrixItemKeyTS_$reflection, Types_MatrixItemKeyTS, Types_FieldKeyTS_$reflection, Types_FieldKeyTS } from "./FormSpec.Api.Option.js";
 import { uncurry2, comparePrimitives, compare, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
 import { obj_type, bool_type, enum_type, int32_type, option_type, array_type, tuple_type, record_type, string_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
-import { some, map as map_3, value as value_2, Option } from "@fable-org/fable-library-js/Option.js";
+import { bind, defaultArgWith, some, map as map_3, value as value_2, Option } from "@fable-org/fable-library-js/Option.js";
 import { int32 } from "@fable-org/fable-library-js/Int32.js";
-import { Values_DynamicFormResultData$1, Values_DynamicForm$1, Values_StepOrder, Values_DynamicFormSpecDetails, Spec_Score, Values_Signature, Values_SignatureType_Approval, Values_SignatureType_Review, Values_SignatureType_$union, Values_FormStatus_Complete, Values_FormStatus_WaitingForApproval, Values_FormStatus_WaitingForReview, Values_FormStatus_Draft, Values_FormStatus_Pending, Values_FormStatus_$union, Spec_FieldType_$union, Values_FieldDetails$1, Shared_FieldOption, Shared_FieldValue_Matrix, Shared_FieldValue_Multiple, Shared_FieldValue_Single, Shared_FieldValue_$union, Shared_PluginDataProperty, Shared_MatrixAnswer, Shared_MatrixItemKey, Shared_FieldKey, Shared_FieldAnswer } from "../FormSpec.js";
-import { fold as fold_1, reverse, empty as empty_2, cons, FSharpList, map as map_1, toArray } from "@fable-org/fable-library-js/List.js";
+import { Values_DynamicForm$1, Spec_FormSpec$1, Values_StepOrder, Spec_Score, Values_Signature, Values_SignatureType_Approval, Values_SignatureType_Review, Values_SignatureType_$union, Values_FormStatus_Complete, Values_FormStatus_WaitingForApproval, Values_FormStatus_WaitingForReview, Values_FormStatus_Draft, Values_FormStatus_Pending, Values_FormStatus_$union, Spec_FieldType_$union, Shared_FieldOption, Shared_FieldValue_Matrix, Shared_FieldValue_Multiple, Shared_FieldValue_Single, Shared_FieldValue_$union, Shared_PluginDataProperty, Shared_MatrixAnswer, Shared_MatrixItemKey, Shared_FieldKey, Shared_FieldAnswer } from "../FormSpec.js";
+import { fold as fold_1, tryHead, reverse, empty as empty_2, cons, FSharpList, map as map_1, toArray } from "@fable-org/fable-library-js/List.js";
 import { empty, add, FSharpMap, toList } from "@fable-org/fable-library-js/Map.js";
 import { fold, map as map_2 } from "@fable-org/fable-library-js/Array.js";
 import { tryParse } from "@fable-org/fable-library-js/Guid.js";
 import { ofArray, empty as empty_1, add as add_1, FSharpSet, toList as toList_1 } from "@fable-org/fable-library-js/Set.js";
+import { resultStepsMapToFormSpec, formSpecToResultStepsMap, formSpecToMetadata, FormSpecMetadata, FieldDetails$1 } from "../FormSpecValues.js";
 import { tryParse as tryParse_1, minValue, toString } from "@fable-org/fable-library-js/Date.js";
+import { buildFormSpecFromResultStepsMap } from "../FormSpecHelpers.js";
 import { Auto_generateBoxedEncoder_437914C6, toString as toString_1 } from "../fable_modules/Thoth.Json.10.4.1/Encode.fs.js";
 import { FSharpResult$2_$union, Result_ToOption } from "@fable-org/fable-library-js/Result.js";
 import { Auto_generateBoxedDecoder_Z6670B51, fromString } from "../fable_modules/Thoth.Json.10.4.1/Decode.fs.js";
@@ -408,14 +410,14 @@ export function ValuesConverters_fieldValueFromTS(value: ValuesTypes_FieldValueT
 /**
  * Convert F# FieldDetails to TypeScript representation
  */
-export function ValuesConverters_fieldDetailsToTS(details: Values_FieldDetails$1<Spec_FieldType_$union>): ValuesTypes_FieldDetailsTS {
+export function ValuesConverters_fieldDetailsToTS(details: FieldDetails$1<Spec_FieldType_$union>): ValuesTypes_FieldDetailsTS {
     return new ValuesTypes_FieldDetailsTS(details.FieldOrder, Converters_fieldKeyToTS(details.Key), details.Label, ValuesConverters_fieldValueToTS(details.FieldValue), Converters_fieldTypeToTS(details.FieldType), toArray<Types_FieldOptionTS>(map_1<Shared_FieldOption, Types_FieldOptionTS>(Converters_fieldOptionToTS, details.Options)));
 }
 
 /**
  * Convert TypeScript FieldDetails to F# representation
  */
-export function ValuesConverters_fieldDetailsFromTS(details: ValuesTypes_FieldDetailsTS): Option<Values_FieldDetails$1<Spec_FieldType_$union>> {
+export function ValuesConverters_fieldDetailsFromTS(details: ValuesTypes_FieldDetailsTS): Option<FieldDetails$1<Spec_FieldType_$union>> {
     const matchValue: Option<Shared_FieldKey> = Converters_fieldKeyFromTS(details.Key);
     const matchValue_1: Option<Shared_FieldValue_$union> = ValuesConverters_fieldValueFromTS(details.FieldValue);
     const matchValue_2: Option<Spec_FieldType_$union> = Converters_fieldTypeFromTS(details.FieldType);
@@ -467,7 +469,7 @@ export function ValuesConverters_fieldDetailsFromTS(details: ValuesTypes_FieldDe
                 return undefined;
             }
             else {
-                return new Values_FieldDetails$1(details.FieldOrder, key!, details.Label, fieldValue!, fieldType!, reverse<Shared_FieldOption>(value_2(options)));
+                return new FieldDetails$1(details.FieldOrder, key!, details.Label, fieldValue!, fieldType!, reverse<Shared_FieldOption>(value_2(options)));
             }
         }
         default:
@@ -605,20 +607,20 @@ export function ValuesConverters_signatureFromTS(signature: ValuesTypes_Signatur
 }
 
 /**
- * Convert F# DynamicStepValues to TypeScript representation
+ * Convert F# ResultStepValues to TypeScript representation
  */
-export function ValuesConverters_dynamicStepValuesToTS(stepValues: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>): [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][] {
-    return toArray<[Types_FieldKeyTS, ValuesTypes_FieldDetailsTS]>(map_1<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>], [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS]>((tupledArg: [Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]): [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS] => ([Converters_fieldKeyToTS(tupledArg[0]), ValuesConverters_fieldDetailsToTS(tupledArg[1])] as [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS]), toList<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>(stepValues)));
+export function ValuesConverters_dynamicStepValuesToTS(stepValues: FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>): [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][] {
+    return toArray<[Types_FieldKeyTS, ValuesTypes_FieldDetailsTS]>(map_1<[Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>], [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS]>((tupledArg: [Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>]): [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS] => ([Converters_fieldKeyToTS(tupledArg[0]), ValuesConverters_fieldDetailsToTS(tupledArg[1])] as [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS]), toList<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>(stepValues)));
 }
 
 /**
  * Convert TypeScript DynamicStepValues to F# representation
  */
-export function ValuesConverters_dynamicStepValuesFromTS(stepValues: [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]): Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>> {
-    const array_1: Option<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>[] = map_2<[Types_FieldKeyTS, ValuesTypes_FieldDetailsTS], Option<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>>((tupledArg: [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS]): Option<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]> => {
+export function ValuesConverters_dynamicStepValuesFromTS(stepValues: [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]): Option<FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>> {
+    const array_1: Option<[Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>]>[] = map_2<[Types_FieldKeyTS, ValuesTypes_FieldDetailsTS], Option<[Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>]>>((tupledArg: [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS]): Option<[Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>]> => {
         const matchValue: Option<Shared_FieldKey> = Converters_fieldKeyFromTS(tupledArg[0]);
-        const matchValue_1: Option<Values_FieldDetails$1<Spec_FieldType_$union>> = ValuesConverters_fieldDetailsFromTS(tupledArg[1]);
-        let matchResult: int32, details: Values_FieldDetails$1<Spec_FieldType_$union>, key: Shared_FieldKey;
+        const matchValue_1: Option<FieldDetails$1<Spec_FieldType_$union>> = ValuesConverters_fieldDetailsFromTS(tupledArg[1]);
+        let matchResult: int32, details: FieldDetails$1<Spec_FieldType_$union>, key: Shared_FieldKey;
         if (matchValue != null) {
             if (matchValue_1 != null) {
                 matchResult = 0;
@@ -634,13 +636,13 @@ export function ValuesConverters_dynamicStepValuesFromTS(stepValues: [Types_Fiel
         }
         switch (matchResult) {
             case 0:
-                return [key!, details!] as [Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>];
+                return [key!, details!] as [Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>];
             default:
                 return undefined;
         }
     }, stepValues);
-    return fold<Option<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>, Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>>((acc: Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>, item: Option<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>): Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>> => {
-        let matchResult_1: int32, details_1: Values_FieldDetails$1<Spec_FieldType_$union>, key_1: Shared_FieldKey, map: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>;
+    return fold<Option<[Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>]>, Option<FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>>((acc: Option<FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>, item: Option<[Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>]>): Option<FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>> => {
+        let matchResult_1: int32, details_1: FieldDetails$1<Spec_FieldType_$union>, key_1: Shared_FieldKey, map: FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>;
         if (acc != null) {
             if (item != null) {
                 matchResult_1 = 0;
@@ -657,78 +659,34 @@ export function ValuesConverters_dynamicStepValuesFromTS(stepValues: [Types_Fiel
         }
         switch (matchResult_1) {
             case 0:
-                return add<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>(key_1!, details_1!, map!);
+                return add<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>(key_1!, details_1!, map!);
             default:
                 return undefined;
         }
-    }, empty<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>({
+    }, empty<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>({
         Compare: compare,
     }), array_1);
 }
 
 /**
- * Convert F# DynamicFormSpecDetails to TypeScript representation
+ * Convert F# FormSpecMetadata to TypeScript representation (legacy DynamicFormSpecDetails shape)
  */
-export function ValuesConverters_dynamicFormSpecDetailsToTS(details: Values_DynamicFormSpecDetails): ValuesTypes_DynamicFormSpecDetailsTS {
-    return new ValuesTypes_DynamicFormSpecDetailsTS(details.FormSpecId, details.FormSpecCode, details.FormSpecVersion, details.DynamicVersion, map_3<Spec_Score, Types_ScoreTS>(Converters_scoreToTS, details.MaxScore), ValuesConverters_formStatusToTS(details.Status), toArray<ValuesTypes_SignatureTS>(map_1<Values_Signature, ValuesTypes_SignatureTS>(ValuesConverters_signatureToTS, details.Signatures)));
+export function ValuesConverters_dynamicFormSpecDetailsToTS(details: FormSpecMetadata): ValuesTypes_DynamicFormSpecDetailsTS {
+    return new ValuesTypes_DynamicFormSpecDetailsTS(details.FormSpecId, details.FormSpecCode, details.FormSpecVersion, details.DynamicVersion, map_3<Spec_Score, Types_ScoreTS>(Converters_scoreToTS, details.MaxScore), new ValuesTypes_FormStatusTS("Pending", undefined), []);
 }
 
 /**
- * Convert TypeScript DynamicFormSpecDetails to F# representation
+ * Convert TypeScript DynamicFormSpecDetails to F# FormSpecMetadata (for buildFormSpecFromResultStepsMap)
  */
-export function ValuesConverters_dynamicFormSpecDetailsFromTS(details: ValuesTypes_DynamicFormSpecDetailsTS): Option<Values_DynamicFormSpecDetails> {
+export function ValuesConverters_dynamicFormSpecDetailsFromTS(details: ValuesTypes_DynamicFormSpecDetailsTS): Option<FormSpecMetadata> {
+    let matchValue_1: Option<Types_ScoreTS>;
     let matchValue: [boolean, string];
     let outArg = "00000000-0000-0000-0000-000000000000";
     matchValue = ([tryParse(details.FormSpecId, new FSharpRef<string>((): string => outArg, (v: string): void => {
         outArg = v;
     })), outArg] as [boolean, string]);
     if (matchValue[0]) {
-        const statusResult: Option<Values_FormStatus_$union> = ValuesConverters_formStatusFromTS(details.Status);
-        const signaturesResult: Option<FSharpList<Values_Signature>> = fold<Option<Values_Signature>, Option<FSharpList<Values_Signature>>>((acc: Option<FSharpList<Values_Signature>>, sigOpt: Option<Values_Signature>): Option<FSharpList<Values_Signature>> => {
-            let matchResult: int32, item: Values_Signature, list: FSharpList<Values_Signature>;
-            if (acc != null) {
-                if (sigOpt != null) {
-                    matchResult = 0;
-                    item = value_2(sigOpt);
-                    list = value_2(acc);
-                }
-                else {
-                    matchResult = 1;
-                }
-            }
-            else {
-                matchResult = 1;
-            }
-            switch (matchResult) {
-                case 0:
-                    return cons(item!, list!);
-                default:
-                    return undefined;
-            }
-        }, empty_2<Values_Signature>(), map_2<ValuesTypes_SignatureTS, Option<Values_Signature>>(ValuesConverters_signatureFromTS, details.Signatures));
-        let maxScoreResult: Option<Spec_Score>;
-        const matchValue_2: Option<Types_ScoreTS> = details.MaxScore;
-        maxScoreResult = ((matchValue_2 == null) ? undefined : Converters_scoreFromTS(value_2(matchValue_2)));
-        let matchResult_1: int32, signatures: FSharpList<Values_Signature>, status: Values_FormStatus_$union;
-        if (statusResult != null) {
-            if (signaturesResult != null) {
-                matchResult_1 = 0;
-                signatures = value_2(signaturesResult);
-                status = value_2(statusResult);
-            }
-            else {
-                matchResult_1 = 1;
-            }
-        }
-        else {
-            matchResult_1 = 1;
-        }
-        switch (matchResult_1) {
-            case 0:
-                return new Values_DynamicFormSpecDetails(matchValue[1], details.FormSpecCode, details.FormSpecVersion, details.DynamicVersion, maxScoreResult, status!, reverse<Values_Signature>(signatures!));
-            default:
-                return undefined;
-        }
+        return new FormSpecMetadata(matchValue[1], details.FormSpecCode, details.FormSpecVersion, details.DynamicVersion, (matchValue_1 = details.MaxScore, (matchValue_1 == null) ? undefined : Converters_scoreFromTS(value_2(matchValue_1))));
     }
     else {
         return undefined;
@@ -819,10 +777,10 @@ export function ValuesConverters_fableFormModelToTS(model: any): Option<ValuesTy
  * Note: This returns obj as we can't directly construct Fable.Form types
  */
 export function ValuesConverters_fableFormModelFromTS(model: ValuesTypes_FableFormModelTS): Option<any> {
-    const matchValue: Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>> = ValuesConverters_dynamicStepValuesFromTS(model.Values);
+    const matchValue: Option<FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>> = ValuesConverters_dynamicStepValuesFromTS(model.Values);
     const matchValue_1: Option<any> = ValuesConverters_fableFormStateFromTS(model.State);
     const matchValue_2: Option<any> = ValuesConverters_errorTrackingFromTS(model.ErrorTracking);
-    let matchResult: int32, errorTracking: any, state: any, values: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>;
+    let matchResult: int32, errorTracking: any, state: any, values: FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>;
     if (matchValue != null) {
         if (matchValue_1 != null) {
             if (matchValue_2 != null) {
@@ -855,17 +813,27 @@ export function ValuesConverters_fableFormModelFromTS(model: ValuesTypes_FableFo
 }
 
 /**
- * Convert F# DynamicForm to TypeScript representation
+ * Convert F# DynamicForm to TypeScript representation.
+ * Details derived from FormSpec (first step's Values) when DynamicForm has Steps only.
  */
 export function ValuesConverters_dynamicFormToTS<FableFormModel>(form: Values_DynamicForm$1<FableFormModel>): Option<ValuesTypes_DynamicFormTS> {
     try {
-        const detailsTS: ValuesTypes_DynamicFormSpecDetailsTS = ValuesConverters_dynamicFormSpecDetailsToTS(form.DynamicFormSpecDetails);
+        const detailsTS: ValuesTypes_DynamicFormSpecDetailsTS = ValuesConverters_dynamicFormSpecDetailsToTS(formSpecToMetadata<Spec_FieldType_$union>(defaultArgWith<Spec_FormSpec$1<Spec_FieldType_$union>>(bind<[Values_StepOrder, FableFormModel], Spec_FormSpec$1<Spec_FieldType_$union>>((tupledArg: [Values_StepOrder, FableFormModel]): Option<Spec_FormSpec$1<Spec_FieldType_$union>> => {
+            try {
+                return tupledArg[1].Values;
+            }
+            catch (matchValue: any) {
+                return undefined;
+            }
+        }, tryHead<[Values_StepOrder, FableFormModel]>(toList<Values_StepOrder, FableFormModel>(form.Steps))), (): Spec_FormSpec$1<Spec_FieldType_$union> => {
+            throw new Error("dynamicFormToTS: no steps or Values");
+        })));
         const stepsTS: Option<FSharpList<[int32, ValuesTypes_FableFormModelTS]>> = fold_1<Option<[int32, ValuesTypes_FableFormModelTS]>, Option<FSharpList<[int32, ValuesTypes_FableFormModelTS]>>>((acc: Option<FSharpList<[int32, ValuesTypes_FableFormModelTS]>>, item: Option<[int32, ValuesTypes_FableFormModelTS]>): Option<FSharpList<[int32, ValuesTypes_FableFormModelTS]>> => {
-            let matchResult: int32, list_1: FSharpList<[int32, ValuesTypes_FableFormModelTS]>, model_1: ValuesTypes_FableFormModelTS, order: int32;
+            let matchResult: int32, list_2: FSharpList<[int32, ValuesTypes_FableFormModelTS]>, model_1: ValuesTypes_FableFormModelTS, order: int32;
             if (acc != null) {
                 if (item != null) {
                     matchResult = 0;
-                    list_1 = value_2(acc);
+                    list_2 = value_2(acc);
                     model_1 = value_2(item)[1];
                     order = value_2(item)[0];
                 }
@@ -878,23 +846,23 @@ export function ValuesConverters_dynamicFormToTS<FableFormModel>(form: Values_Dy
             }
             switch (matchResult) {
                 case 0:
-                    return cons([order!, model_1!] as [int32, ValuesTypes_FableFormModelTS], list_1!);
+                    return cons([order!, model_1!] as [int32, ValuesTypes_FableFormModelTS], list_2!);
                 default:
                     return undefined;
             }
-        }, empty_2<[int32, ValuesTypes_FableFormModelTS]>(), map_1<[Values_StepOrder, FableFormModel], Option<[int32, ValuesTypes_FableFormModelTS]>>((tupledArg: [Values_StepOrder, FableFormModel]): Option<[int32, ValuesTypes_FableFormModelTS]> => {
-            const stepOrder: int32 = tupledArg[0].fields[0] | 0;
-            const matchValue: Option<ValuesTypes_FableFormModelTS> = ValuesConverters_fableFormModelToTS(tupledArg[1]);
-            if (matchValue == null) {
+        }, empty_2<[int32, ValuesTypes_FableFormModelTS]>(), map_1<[Values_StepOrder, FableFormModel], Option<[int32, ValuesTypes_FableFormModelTS]>>((tupledArg_1: [Values_StepOrder, FableFormModel]): Option<[int32, ValuesTypes_FableFormModelTS]> => {
+            const stepOrder: int32 = tupledArg_1[0].fields[0] | 0;
+            const matchValue_1: Option<ValuesTypes_FableFormModelTS> = ValuesConverters_fableFormModelToTS(tupledArg_1[1]);
+            if (matchValue_1 == null) {
                 return undefined;
             }
             else {
-                return [stepOrder, value_2(matchValue)] as [int32, ValuesTypes_FableFormModelTS];
+                return [stepOrder, value_2(matchValue_1)] as [int32, ValuesTypes_FableFormModelTS];
             }
         }, toList<Values_StepOrder, FableFormModel>(form.Steps)));
         return (stepsTS == null) ? undefined : (new ValuesTypes_DynamicFormTS(detailsTS, toArray<[int32, ValuesTypes_FableFormModelTS]>(reverse<[int32, ValuesTypes_FableFormModelTS]>(value_2(stepsTS)))));
     }
-    catch (matchValue_2: any) {
+    catch (matchValue_3: any) {
         return undefined;
     }
 }
@@ -904,30 +872,90 @@ export function ValuesConverters_dynamicFormToTS<FableFormModel>(form: Values_Dy
  * Note: Returns obj as we can't directly construct generic DynamicForm
  */
 export function ValuesConverters_dynamicFormFromTS(form: ValuesTypes_DynamicFormTS): Option<any> {
-    const matchValue: Option<Values_DynamicFormSpecDetails> = ValuesConverters_dynamicFormSpecDetailsFromTS(form.DynamicFormSpecDetails);
+    let steps: Option<FSharpMap<Values_StepOrder, any>>;
+    const array_1: Option<[Values_StepOrder, any]>[] = map_2<[int32, ValuesTypes_FableFormModelTS], Option<[Values_StepOrder, any]>>((tupledArg: [int32, ValuesTypes_FableFormModelTS]): Option<[Values_StepOrder, any]> => {
+        const matchValue: Option<any> = ValuesConverters_fableFormModelFromTS(tupledArg[1]);
+        if (matchValue == null) {
+            return undefined;
+        }
+        else {
+            return [new Values_StepOrder(tupledArg[0]), value_2(matchValue)] as [Values_StepOrder, any];
+        }
+    }, form.Steps);
+    steps = fold<Option<[Values_StepOrder, any]>, Option<FSharpMap<Values_StepOrder, any>>>((acc: Option<FSharpMap<Values_StepOrder, any>>, item: Option<[Values_StepOrder, any]>): Option<FSharpMap<Values_StepOrder, any>> => {
+        let matchResult: int32, map: FSharpMap<Values_StepOrder, any>, model_1: any, order: Values_StepOrder;
+        if (acc != null) {
+            if (item != null) {
+                matchResult = 0;
+                map = value_2(acc);
+                model_1 = value_2(item)[1];
+                order = value_2(item)[0];
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return add<Values_StepOrder, any>(order!, model_1!, map!);
+            default:
+                return undefined;
+        }
+    }, empty<Values_StepOrder, any>({
+        Compare: compare,
+    }), array_1);
+    if (steps == null) {
+        return undefined;
+    }
+    else {
+        return some({
+            Steps: value_2(steps),
+        });
+    }
+}
+
+/**
+ * Convert F# FormSpec to TypeScript DynamicFormResultData representation (legacy shape).
+ * FormSpec is the single source of truth.
+ */
+export function ValuesConverters_dynamicFormResultDataToTS(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): ValuesTypes_DynamicFormResultDataTS {
+    const metadata: FormSpecMetadata = formSpecToMetadata<Spec_FieldType_$union>(formSpec);
+    const resultStepsMap: FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>> = formSpecToResultStepsMap(formSpec);
+    return new ValuesTypes_DynamicFormResultDataTS(ValuesConverters_dynamicFormSpecDetailsToTS(metadata), toArray<[int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]]>(map_1<[Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>], [int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]]>((tupledArg: [Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>]): [int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]] => ([tupledArg[0].fields[0], ValuesConverters_dynamicStepValuesToTS(tupledArg[1])] as [int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]]), toList<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>(resultStepsMap))));
+}
+
+/**
+ * Convert TypeScript DynamicFormResultData to F# FormSpec.
+ * Requires formSpec to merge values into (structure comes from formSpec).
+ */
+export function ValuesConverters_dynamicFormResultDataFromTS(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>, data: ValuesTypes_DynamicFormResultDataTS): Option<Spec_FormSpec$1<Spec_FieldType_$union>> {
+    const matchValue: Option<FormSpecMetadata> = ValuesConverters_dynamicFormSpecDetailsFromTS(data.ResultFormSpecDetails);
     if (matchValue == null) {
         return undefined;
     }
     else {
-        const details: Values_DynamicFormSpecDetails = value_2(matchValue);
-        let steps: Option<FSharpMap<Values_StepOrder, any>>;
-        const array_1: Option<[Values_StepOrder, any]>[] = map_2<[int32, ValuesTypes_FableFormModelTS], Option<[Values_StepOrder, any]>>((tupledArg: [int32, ValuesTypes_FableFormModelTS]): Option<[Values_StepOrder, any]> => {
-            const matchValue_1: Option<any> = ValuesConverters_fableFormModelFromTS(tupledArg[1]);
+        const _details: FormSpecMetadata = value_2(matchValue);
+        let resultSteps: Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>>;
+        const array_1: Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>]>[] = map_2<[int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]], Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>]>>((tupledArg: [int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]]): Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>]> => {
+            const matchValue_1: Option<FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>> = ValuesConverters_dynamicStepValuesFromTS(tupledArg[1]);
             if (matchValue_1 == null) {
                 return undefined;
             }
             else {
-                return [new Values_StepOrder(tupledArg[0]), value_2(matchValue_1)] as [Values_StepOrder, any];
+                return [new Values_StepOrder(tupledArg[0]), value_2(matchValue_1)] as [Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>];
             }
-        }, form.Steps);
-        steps = fold<Option<[Values_StepOrder, any]>, Option<FSharpMap<Values_StepOrder, any>>>((acc: Option<FSharpMap<Values_StepOrder, any>>, item: Option<[Values_StepOrder, any]>): Option<FSharpMap<Values_StepOrder, any>> => {
-            let matchResult: int32, map: FSharpMap<Values_StepOrder, any>, model_1: any, order: Values_StepOrder;
+        }, data.ResultSteps);
+        resultSteps = fold<Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>]>, Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>>>((acc: Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>>, item: Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>]>): Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>> => {
+            let matchResult: int32, map: FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>, order: Values_StepOrder, values: FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>;
             if (acc != null) {
                 if (item != null) {
                     matchResult = 0;
                     map = value_2(acc);
-                    model_1 = value_2(item)[1];
                     order = value_2(item)[0];
+                    values = value_2(item)[1];
                 }
                 else {
                     matchResult = 1;
@@ -938,54 +966,45 @@ export function ValuesConverters_dynamicFormFromTS(form: ValuesTypes_DynamicForm
             }
             switch (matchResult) {
                 case 0:
-                    return add<Values_StepOrder, any>(order!, model_1!, map!);
+                    return add<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>(order!, values!, map!);
                 default:
                     return undefined;
             }
-        }, empty<Values_StepOrder, any>({
+        }, empty<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>({
             Compare: compare,
         }), array_1);
-        if (steps == null) {
+        if (resultSteps == null) {
             return undefined;
         }
         else {
-            return some({
-                DynamicFormSpecDetails: details,
-                Steps: value_2(steps),
-            });
+            return resultStepsMapToFormSpec<Spec_FieldType_$union>(formSpec, value_2(resultSteps));
         }
     }
 }
 
 /**
- * Convert F# DynamicFormResultData to TypeScript representation
- */
-export function ValuesConverters_dynamicFormResultDataToTS(data: Values_DynamicFormResultData$1<Spec_FieldType_$union>): ValuesTypes_DynamicFormResultDataTS {
-    return new ValuesTypes_DynamicFormResultDataTS(ValuesConverters_dynamicFormSpecDetailsToTS(data.ResultFormSpecDetails), toArray<[int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]]>(map_1<[Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>], [int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]]>((tupledArg: [Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]): [int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]] => ([tupledArg[0].fields[0], ValuesConverters_dynamicStepValuesToTS(tupledArg[1])] as [int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]]), toList<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>(data.ResultSteps))));
-}
-
-/**
- * Convert TypeScript DynamicFormResultData to F# representation
+ * Convert TypeScript DynamicFormResultData to F# FormSpec when formSpec is not available.
+ * Builds minimal FormSpec from TS ResultSteps structure (for backward compatibility).
  */
-export function ValuesConverters_dynamicFormResultDataFromTS(data: ValuesTypes_DynamicFormResultDataTS): Option<Values_DynamicFormResultData$1<Spec_FieldType_$union>> {
-    const matchValue: Option<Values_DynamicFormSpecDetails> = ValuesConverters_dynamicFormSpecDetailsFromTS(data.ResultFormSpecDetails);
+export function ValuesConverters_dynamicFormResultDataFromTSWithoutFormSpec(data: ValuesTypes_DynamicFormResultDataTS): Option<Spec_FormSpec$1<Spec_FieldType_$union>> {
+    const matchValue: Option<FormSpecMetadata> = ValuesConverters_dynamicFormSpecDetailsFromTS(data.ResultFormSpecDetails);
     if (matchValue == null) {
         return undefined;
     }
     else {
-        const details: Values_DynamicFormSpecDetails = value_2(matchValue);
-        let resultSteps: Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>>;
-        const array_1: Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]>[] = map_2<[int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]], Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]>>((tupledArg: [int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]]): Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]> => {
-            const matchValue_1: Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>> = ValuesConverters_dynamicStepValuesFromTS(tupledArg[1]);
+        const details: FormSpecMetadata = value_2(matchValue);
+        let resultSteps: Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>>;
+        const array_1: Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>]>[] = map_2<[int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]], Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>]>>((tupledArg: [int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]]): Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>]> => {
+            const matchValue_1: Option<FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>> = ValuesConverters_dynamicStepValuesFromTS(tupledArg[1]);
             if (matchValue_1 == null) {
                 return undefined;
             }
             else {
-                return [new Values_StepOrder(tupledArg[0]), value_2(matchValue_1)] as [Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>];
+                return [new Values_StepOrder(tupledArg[0]), value_2(matchValue_1)] as [Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>];
             }
         }, data.ResultSteps);
-        resultSteps = fold<Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]>, Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>>>((acc: Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>>, item: Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]>): Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>> => {
-            let matchResult: int32, map: FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>, order: Values_StepOrder, values: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>;
+        resultSteps = fold<Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>]>, Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>>>((acc: Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>>, item: Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>]>): Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>> => {
+            let matchResult: int32, map: FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>, order: Values_StepOrder, values: FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>;
             if (acc != null) {
                 if (item != null) {
                     matchResult = 0;
@@ -1002,18 +1021,19 @@ export function ValuesConverters_dynamicFormResultDataFromTS(data: ValuesTypes_D
             }
             switch (matchResult) {
                 case 0:
-                    return add<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>(order!, values!, map!);
+                    return add<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>(order!, values!, map!);
                 default:
                     return undefined;
             }
-        }, empty<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>({
+        }, empty<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>({
             Compare: compare,
         }), array_1);
         if (resultSteps == null) {
             return undefined;
         }
         else {
-            return new Values_DynamicFormResultData$1(details, value_2(resultSteps));
+            const stepsMap: FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>> = value_2(resultSteps);
+            return resultStepsMapToFormSpec<Spec_FieldType_$union>(buildFormSpecFromResultStepsMap(details, stepsMap), stepsMap);
         }
     }
 }
@@ -1027,15 +1047,15 @@ export function ValuesValidators_validateDynamicFormResultData(input: any): Opti
 }
 
 /**
- * Validate and convert a TypeScript DynamicFormResultData to F# domain type
+ * Validate and convert a TypeScript DynamicFormResultData to F# FormSpec
  */
-export function ValuesValidators_validateAndConvertDynamicFormResultData(input: any): Option<Values_DynamicFormResultData$1<Spec_FieldType_$union>> {
+export function ValuesValidators_validateAndConvertDynamicFormResultData(input: any): Option<Spec_FormSpec$1<Spec_FieldType_$union>> {
     const matchValue: Option<ValuesTypes_DynamicFormResultDataTS> = ValuesValidators_validateDynamicFormResultData(input);
     if (matchValue == null) {
         return undefined;
     }
     else {
-        return ValuesConverters_dynamicFormResultDataFromTS(value_2(matchValue));
+        return ValuesConverters_dynamicFormResultDataFromTSWithoutFormSpec(value_2(matchValue));
     }
 }
 
@@ -1122,7 +1142,7 @@ export function ValuesApi_validateDynamicFormResultData<$a>(): ((arg0: $a) => Op
 /**
  * Validate and convert a DynamicFormResultData to F# domain type
  */
-export function ValuesApi_validateAndConvertDynamicFormResultData<$a>(): ((arg0: $a) => Option<Values_DynamicFormResultData$1<Spec_FieldType_$union>>) {
+export function ValuesApi_validateAndConvertDynamicFormResultData<$a>(): ((arg0: $a) => Option<Spec_FormSpec$1<Spec_FieldType_$union>>) {
     return ValuesValidators_validateAndConvertDynamicFormResultData;
 }
 
@@ -1148,17 +1168,24 @@ export function ValuesApi_validateFieldValue<$a>(): ((arg0: $a) => Option<Values
 }
 
 /**
- * Convert F# DynamicFormResultData to TypeScript representation
+ * Convert F# FormSpec to TypeScript DynamicFormResultData representation (legacy shape)
+ */
+export function ValuesApi_dynamicFormResultDataToTypeScript(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): ValuesTypes_DynamicFormResultDataTS {
+    return ValuesConverters_dynamicFormResultDataToTS(formSpec);
+}
+
+/**
+ * Convert TypeScript DynamicFormResultData to F# FormSpec (when formSpec not available)
  */
-export function ValuesApi_dynamicFormResultDataToTypeScript(data: Values_DynamicFormResultData$1<Spec_FieldType_$union>): ValuesTypes_DynamicFormResultDataTS {
-    return ValuesConverters_dynamicFormResultDataToTS(data);
+export function ValuesApi_dynamicFormResultDataFromTypeScript(data: ValuesTypes_DynamicFormResultDataTS): Option<Spec_FormSpec$1<Spec_FieldType_$union>> {
+    return ValuesConverters_dynamicFormResultDataFromTSWithoutFormSpec(data);
 }
 
 /**
- * Convert TypeScript DynamicFormResultData to F# representation
+ * Convert TypeScript DynamicFormResultData to F# FormSpec with formSpec (preferred when formSpec available)
  */
-export function ValuesApi_dynamicFormResultDataFromTypeScript(data: ValuesTypes_DynamicFormResultDataTS): Option<Values_DynamicFormResultData$1<Spec_FieldType_$union>> {
-    return ValuesConverters_dynamicFormResultDataFromTS(data);
+export function ValuesApi_dynamicFormResultDataFromTypeScriptWithFormSpec(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>, data: ValuesTypes_DynamicFormResultDataTS): Option<Spec_FormSpec$1<Spec_FieldType_$union>> {
+    return ValuesConverters_dynamicFormResultDataFromTS(formSpec, data);
 }
 
 /**

package/src/PathwayDataExtractor.ts

@@ -1,6 +1,6 @@
-import { ClinicalPathway_TerminalInfo, Shared_StateKey, ClinicalPathway_StateType_$union, ClinicalPathway_EvaluationInfo, ClinicalPathway_DecisionInfo, ClinicalPathway_ActionInfo_$union, ClinicalPathway_MedicationAction, ClinicalPathway_FieldValueSource_$union, ClinicalPathway_SetFieldValueAction, ClinicalPathway_NavigateToFormAction, ClinicalPathway_PrescriptionAction, ClinicalPathway_ProblemAction, ClinicalPathway_AlertAction, ClinicalPathway_TaskAction, ClinicalPathway_DocumentationAction, ClinicalPathway_ReferralAction, ClinicalPathway_TestAction, ClinicalPathway_EducationAction, ClinicalPathway_ProcedureAction } from "./FormSpec.js";
+import { ClinicalPathway_TerminalInfo, Shared_StateKey, ClinicalPathway_StateType_$union, ClinicalPathway_EvaluationInfo, ClinicalPathway_ActionInfo_$union, ClinicalPathway_MedicationAction, ClinicalPathway_FieldValueSource_$union, ClinicalPathway_SetFieldValueAction, ClinicalPathway_NavigateToFormAction, ClinicalPathway_PrescriptionAction, ClinicalPathway_ProblemAction, ClinicalPathway_AlertAction, ClinicalPathway_TaskAction, ClinicalPathway_DocumentationAction, ClinicalPathway_ReferralAction, ClinicalPathway_TestAction, ClinicalPathway_EducationAction, ClinicalPathway_ProcedureAction } from "./FormSpec.js";
 import { split, replace, join, isNullOrWhiteSpace, substring, printf, toText } from "@fable-org/fable-library-js/String.js";
-import { singleton, append, map, empty, FSharpList, filter } from "@fable-org/fable-library-js/List.js";
+import { singleton, append, map, FSharpList, empty } from "@fable-org/fable-library-js/List.js";
 import { Option, value } from "@fable-org/fable-library-js/Option.js";
 import { item, map as map_1 } from "@fable-org/fable-library-js/Array.js";
 import { int32 } from "@fable-org/fable-library-js/Int32.js";
@@ -173,20 +173,9 @@ export function extractActionType(action: ClinicalPathway_ActionInfo_$union): st
     }
 }
 
-export function extractDecisionDetails(decision: ClinicalPathway_DecisionInfo): [string, FSharpList<string>] {
-    return [decision.Question, filter<string>((opt: string): boolean => {
-        if ((opt !== "Yes") && (opt !== "No")) {
-            return opt !== "None of the above";
-        }
-        else {
-            return false;
-        }
-    }, decision.Options)] as [string, FSharpList<string>];
-}
-
 export function extractEvaluationDetails(evaluation: ClinicalPathway_EvaluationInfo): [string, FSharpList<string>] {
     let matchValue: Option<FSharpList<string>>;
-    return [evaluation.EvaluationName, (matchValue = evaluation.CriticalFindings, (matchValue == null) ? empty<string>() : value(matchValue))] as [string, FSharpList<string>];
+    return [evaluation.EvaluationName, (matchValue = evaluation.EvaluationNotes, (matchValue == null) ? empty<string>() : value(matchValue))] as [string, FSharpList<string>];
 }
 
 export function extractEvaluationName(evaluation: ClinicalPathway_EvaluationInfo): string {
@@ -195,8 +184,8 @@ export function extractEvaluationName(evaluation: ClinicalPathway_EvaluationInfo
 
 export function stateTypeToString(stateType: ClinicalPathway_StateType_$union): string {
     switch (stateType.tag) {
-        case /* Decision */ 1:
-            return "Decision";
+        case /* Evaluation */ 1:
+            return "Evaluation";
         case /* Action */ 2:
             return "Action";
         case /* CompoundAction */ 3:
@@ -206,7 +195,7 @@ export function stateTypeToString(stateType: ClinicalPathway_StateType_$union):
         case /* Terminal */ 5:
             return "Terminal";
         default:
-            return "Evaluation";
+            throw new Error("Match failure: F1.Studio.ClinicalPathway.StateType");
     }
 }