@f1studio/form-spec 5.0.0-alpha.101

package/src/Interop/FormSpec.Api.Helpers.ts

@@ -0,0 +1,872 @@
+import { map as map_3, some, value as value_11, unwrap, defaultArgWith as defaultArgWith_1, Option, defaultArg as defaultArg_1 } from "@fable-org/fable-library-js/Option.js";
+import { tryPick, singleton, exists, filter, map as map_2, ofArray as ofArray_1, ofSeq, empty, collect, tryFind, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { join, printf, toConsole } from "@fable-org/fable-library-js/String.js";
+import { Auto_generateBoxedEncoder_437914C6, toString } from "../fable_modules/Thoth.Json.10.4.1/Encode.fs.js";
+import { array_type, string_type, union_type, TypeInfo, obj_type } from "@fable-org/fable-library-js/Reflection.js";
+import { Auto_generateBoxedDecoder_Z6670B51, fromString } from "../fable_modules/Thoth.Json.10.4.1/Decode.fs.js";
+import { equals, compare, IDisposable, disposeSafe, IEnumerator, getEnumerator, IMap, isArrayLike, uncurry2 } from "@fable-org/fable-library-js/Util.js";
+import { ClinicalPathway_StateType_$union, ClinicalPathway_TaskPriority_$union, ClinicalPathway_AlertSeverity_$union, ClinicalPathway_ReferralUrgency_$union, ClinicalPathway_ActionInfo_$union, ClinicalPathway_NavigateToFormAction, ClinicalPathway_ProblemAction, ClinicalPathway_AlertAction, ClinicalPathway_EducationAction, ClinicalPathway_ProcedureAction, ClinicalPathway_TestAction, ClinicalPathway_DocumentationAction, ClinicalPathway_FieldValueSource_$union, ClinicalPathway_SetFieldValueAction, ClinicalPathway_PrescriptionAction, ClinicalPathway_MedicationAction, ClinicalPathway_ReferralAction, ClinicalPathway_ClinicalPathwaySpec, ClinicalPathway_PathRequirement, ClinicalPathway_ConstraintDefinition, ClinicalPathway_PathwayExecutionMode_SinglePathway, ClinicalPathway_SinglePathwayConfig, ClinicalPathway_SelectionStrategy_HighestPriority, ClinicalPathway_TransitionDefinition, ClinicalPathway_TransitionCondition_FieldCondition, Shared_ConditionValue_Single, ClinicalPathway_FieldEvaluator_Equals, Shared_TransitionKey, ClinicalPathway_StateType_Terminal, ClinicalPathway_TerminalInfo, ClinicalPathway_StateDefinition, ClinicalPathway_StateType_Action, ClinicalPathway_ActionInfo_Task, ClinicalPathway_TaskAction, ClinicalPathway_DueDate_Today, ClinicalPathway_TaskPriority_Medium, ClinicalPathway_TaskPriority_Low, ClinicalPathway_TaskPriority_High, Shared_StateKey, Spec_FieldType_PluginField, Spec_PluginFieldConfig, Spec_FieldType_Matrix, Spec_MatrixInfo, Spec_FieldType_Text, Spec_TextInfo, Spec_FieldType_CheckboxList, Spec_MultiChoiceInfo, Shared_FieldOptionKey, Spec_FieldType_Checkbox, Spec_BooleanInfo, Shared_FieldKey, Values_StepOrder, Values_FieldDetails$1, Shared_FieldOption, Shared_FieldValue_Single, Shared_FieldValue_PluginData, Shared_PluginDataProperty, Shared_PluginPropertyKey, Shared_FieldValue_Matrix, Shared_MatrixAnswer, Shared_MatrixItemKey, Shared_FieldValue_Multiple, Shared_FieldAnswer, Values_DynamicFormSpecDetails, Values_Signature, Values_FormStatus_Pending, Spec_FormStep$1, Spec_FormField$1, Values_DynamicFormResultData$1, Values_DynamicFormResultData$1_$reflection, Spec_FieldType_$union, Spec_FormSpec$1, Spec_FormSpec$1_$reflection, Spec_FieldType_$reflection } from "../FormSpec.js";
+import { FSharpResult$2_$union } from "@fable-org/fable-library-js/Result.js";
+import { Union } from "@fable-org/fable-library-js/Types.js";
+import { IOptionalGetter, array as array_4, IGetters, dict, string, IRequiredGetter, object, fromString as fromString_1 } from "../fable_modules/Thoth.Json.10.4.1/Decode.fs.js";
+import { ErrorReason_$union } from "../fable_modules/Thoth.Json.10.4.1/Types.fs.js";
+import { toSeq, tryFind as tryFind_1, ofList, ofSeq as ofSeq_1, FSharpMap } from "@fable-org/fable-library-js/Map.js";
+import { addToDict } from "@fable-org/fable-library-js/MapUtil.js";
+import { mapIndexed, map as map_1, choose } from "@fable-org/fable-library-js/Seq.js";
+import { ofArray } from "@fable-org/fable-library-js/Set.js";
+import { map } from "@fable-org/fable-library-js/Array.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { newGuid, parse } from "@fable-org/fable-library-js/Guid.js";
+import { now } from "@fable-org/fable-library-js/DateOffset.js";
+import { initializeExecution } from "../PathwayExecutor.js";
+
+/**
+ * Get value from Option or return default (SAFE - recommended)
+ * TypeScript: <T>(opt: Option<T>, defaultValue: T) => T
+ * Usage: Api.defaultArg(formSpec.Code, "unknown")
+ */
+export function defaultArg<T>(opt: Option<T>, defaultValue: T): T {
+    return defaultArg_1(opt, defaultValue);
+}
+
+/**
+ * Get value from Option or compute default using function (SAFE - recommended)
+ * TypeScript: <T>(opt: Option<T>, defThunk: () => T) => T
+ * Usage: Api.defaultArgWith(formSpec.Code, () => "unknown")
+ */
+export function defaultArgWith<T>(opt: Option<T>, defThunk: (() => T)): T {
+    return defaultArgWith_1<T>(opt, defThunk);
+}
+
+/**
+ * Check if Option is Some
+ * TypeScript: <T>(opt: Option<T>) => boolean
+ * Usage: if (Api.isSome(formSpec.Code)) { ... }
+ */
+export function isSome<T>(opt: Option<T>): boolean {
+    return opt != null;
+}
+
+/**
+ * Check if Option is None
+ * TypeScript: <T>(opt: Option<T>) => boolean
+ * Usage: if (Api.isNone(formSpec.Code)) { ... }
+ */
+export function isNone<T>(opt: Option<T>): boolean {
+    return opt == null;
+}
+
+export function listToArray<T>(list: FSharpList<T>): T[] {
+    return Array.from(list);
+}
+
+export function serializeFormSpec(formSpec: any): string {
+    toConsole(printf("[API.Helpers] Serializing FormSpec!!"));
+    toConsole(`[API.Helpers] FormSpec: ${formSpec}`);
+    return toString(0, Auto_generateBoxedEncoder_437914C6(obj_type, undefined, undefined, undefined)(formSpec));
+}
+
+export function deserializeFormSpec(json: string): Option<Spec_FormSpec$1<Spec_FieldType_$union>> {
+    toConsole(printf("[API.Helpers] Deserializing FormSpec"));
+    const matchValue: FSharpResult$2_$union<Spec_FormSpec$1<Spec_FieldType_$union>, string> = fromString<Spec_FormSpec$1<Spec_FieldType_$union>>(uncurry2(Auto_generateBoxedDecoder_Z6670B51(Spec_FormSpec$1_$reflection(Spec_FieldType_$reflection()), undefined, undefined)), json);
+    if (matchValue.tag === /* Error */ 1) {
+        throw new Error(`[API.Helpers] Deserialization failed: ${matchValue.fields[0]}`);
+    }
+    else {
+        return matchValue.fields[0];
+    }
+}
+
+export function serializeDynamicFormResultData(data: Values_DynamicFormResultData$1<Spec_FieldType_$union>): string {
+    toConsole(printf("[API.Helpers] Serializing DynamicFormResultData"));
+    return toString(0, Auto_generateBoxedEncoder_437914C6(Values_DynamicFormResultData$1_$reflection(Spec_FieldType_$reflection()), undefined, undefined, undefined)(data));
+}
+
+export function deserializeDynamicFormResultData(json: string): Option<Values_DynamicFormResultData$1<Spec_FieldType_$union>> {
+    const matchValue: FSharpResult$2_$union<Values_DynamicFormResultData$1<Spec_FieldType_$union>, string> = fromString<Values_DynamicFormResultData$1<Spec_FieldType_$union>>(uncurry2(Auto_generateBoxedDecoder_Z6670B51(Values_DynamicFormResultData$1_$reflection(Spec_FieldType_$reflection()), undefined, undefined)), json);
+    if (matchValue.tag === /* Error */ 1) {
+        return undefined;
+    }
+    else {
+        return matchValue.fields[0];
+    }
+}
+
+/**
+ * Find FormField by its FieldKey string representation
+ */
+export function findFieldByKey(spec: Spec_FormSpec$1<Spec_FieldType_$union>, fieldKeyString: string): Option<Spec_FormField$1<Spec_FieldType_$union>> {
+    return tryFind<Spec_FormField$1<Spec_FieldType_$union>>((field: Spec_FormField$1<Spec_FieldType_$union>): boolean => (field.FieldKey.fields[0] === fieldKeyString), 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, spec.Steps));
+}
+
+export type ExpectedFieldValueType_$union = 
+    | ExpectedFieldValueType<0>
+    | ExpectedFieldValueType<1>
+    | ExpectedFieldValueType<2>
+    | ExpectedFieldValueType<3>
+
+export type ExpectedFieldValueType_$cases = {
+    0: ["SingleValue", []],
+    1: ["MultipleValues", []],
+    2: ["MatrixValue", []],
+    3: ["PluginDataValue", []]
+}
+
+export function ExpectedFieldValueType_SingleValue() {
+    return new ExpectedFieldValueType<0>(0, []);
+}
+
+export function ExpectedFieldValueType_MultipleValues() {
+    return new ExpectedFieldValueType<1>(1, []);
+}
+
+export function ExpectedFieldValueType_MatrixValue() {
+    return new ExpectedFieldValueType<2>(2, []);
+}
+
+export function ExpectedFieldValueType_PluginDataValue() {
+    return new ExpectedFieldValueType<3>(3, []);
+}
+
+export class ExpectedFieldValueType<Tag extends keyof ExpectedFieldValueType_$cases> extends Union<Tag, ExpectedFieldValueType_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ExpectedFieldValueType_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["SingleValue", "MultipleValues", "MatrixValue", "PluginDataValue"];
+    }
+}
+
+export function ExpectedFieldValueType_$reflection(): TypeInfo {
+    return union_type("FormSpec.Interop.Helpers.ExpectedFieldValueType", [], ExpectedFieldValueType, () => [[], [], [], []]);
+}
+
+export function getExpectedFieldValueType(fieldType: Spec_FieldType_$union): ExpectedFieldValueType_$union {
+    switch (fieldType.tag) {
+        case /* TextArea */ 1:
+            return ExpectedFieldValueType_SingleValue();
+        case /* Email */ 2:
+            return ExpectedFieldValueType_SingleValue();
+        case /* Password */ 3:
+            return ExpectedFieldValueType_SingleValue();
+        case /* Search */ 4:
+            return ExpectedFieldValueType_SingleValue();
+        case /* Color */ 5:
+            return ExpectedFieldValueType_SingleValue();
+        case /* Number */ 6:
+            return ExpectedFieldValueType_SingleValue();
+        case /* Tel */ 7:
+            return ExpectedFieldValueType_SingleValue();
+        case /* Date */ 8:
+            return ExpectedFieldValueType_SingleValue();
+        case /* DateTimeLocal */ 9:
+            return ExpectedFieldValueType_SingleValue();
+        case /* Time */ 10:
+            return ExpectedFieldValueType_SingleValue();
+        case /* Checkbox */ 11:
+            return ExpectedFieldValueType_SingleValue();
+        case /* Radio */ 12:
+            return ExpectedFieldValueType_SingleValue();
+        case /* SingleChoice */ 13:
+            return ExpectedFieldValueType_SingleValue();
+        case /* Dropdown */ 14:
+            return ExpectedFieldValueType_SingleValue();
+        case /* TextAutoComplete */ 18:
+            return ExpectedFieldValueType_SingleValue();
+        case /* Signature */ 20:
+            return ExpectedFieldValueType_SingleValue();
+        case /* Message */ 21:
+            return ExpectedFieldValueType_SingleValue();
+        case /* CheckboxList */ 16:
+            return ExpectedFieldValueType_MultipleValues();
+        case /* MultiChoice */ 15:
+            return ExpectedFieldValueType_MultipleValues();
+        case /* TagList */ 17:
+            return ExpectedFieldValueType_MultipleValues();
+        case /* Matrix */ 19:
+            return ExpectedFieldValueType_MatrixValue();
+        case /* PluginField */ 22:
+            return ExpectedFieldValueType_PluginDataValue();
+        default:
+            return ExpectedFieldValueType_SingleValue();
+    }
+}
+
+export function decodeAsString(fieldKey: string, obj: any): string {
+    let matchValue: FSharpResult$2_$union<string, string>;
+    const json: string = toString(0, Auto_generateBoxedEncoder_437914C6(obj_type, undefined, undefined, undefined)(obj));
+    matchValue = fromString<string>(uncurry2(Auto_generateBoxedDecoder_Z6670B51(string_type, undefined, undefined)), json);
+    if (matchValue.tag === /* Error */ 1) {
+        if (typeof obj === "string") {
+            const str = obj as string;
+            return str;
+        }
+        else {
+            throw new Error(`Field ${fieldKey}: Expected string value, got ${"Object"}`);
+        }
+    }
+    else {
+        return matchValue.fields[0];
+    }
+}
+
+export function decodeAsStringArray(fieldKey: string, obj: any): string[] {
+    if (isArrayLike(obj)) {
+        return obj;
+    }
+    else if (isArrayLike(obj)) {
+        const resizeArray: string[] = obj;
+        return resizeArray.slice();
+    }
+    else if (typeof obj === "string") {
+        return [obj];
+    }
+    else {
+        try {
+            let matchValue: FSharpResult$2_$union<string[], string>;
+            const json: string = toString(0, Auto_generateBoxedEncoder_437914C6(obj_type, undefined, undefined, undefined)(obj));
+            matchValue = fromString<string[]>(uncurry2(Auto_generateBoxedDecoder_Z6670B51(array_type(string_type), undefined, undefined)), json);
+            if (matchValue.tag === /* Error */ 1) {
+                throw new Error(`Field ${fieldKey}: Expected string array, got ${"Object"}`);
+            }
+            else {
+                return matchValue.fields[0];
+            }
+        }
+        catch (ex: any) {
+            throw new Error(`Field ${fieldKey}: Expected string array, got ${"Object"}`);
+        }
+    }
+}
+
+export function decodeAsMatrixValue(fieldKey: string, obj: any): { description: string, values: IMap<string, string> } {
+    let str: string;
+    const objAsString: string = (typeof obj === "string") ? ((str = (obj as string), str)) : toString(0, Auto_generateBoxedEncoder_437914C6(obj_type, undefined, undefined, undefined)(obj));
+    try {
+        const matchValue: FSharpResult$2_$union<{ description: string, values: IMap<string, string> }, string> = fromString_1<{ description: string, values: IMap<string, string> }>((path_2: string, v: any): FSharpResult$2_$union<{ description: string, values: IMap<string, string> }, [string, ErrorReason_$union]> => object<{ description: string, values: IMap<string, string> }>((get$: IGetters): { description: string, values: IMap<string, string> } => {
+            let description: string;
+            const objectArg: IRequiredGetter = get$.Required;
+            description = objectArg.Field<string>("description", string);
+            let valuesMap: FSharpMap<string, string>;
+            const arg_3: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, string>, [string, ErrorReason_$union]>)) = dict<string>(string);
+            const objectArg_1: IRequiredGetter = get$.Required;
+            valuesMap = objectArg_1.Field<FSharpMap<string, string>>("values", uncurry2(arg_3));
+            const valuesDict: IMap<string, string> = new Map<string, string>([]);
+            const enumerator: IEnumerator<[string, string]> = getEnumerator(valuesMap);
+            try {
+                while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                    const kvp: [string, string] = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    addToDict(valuesDict, kvp[0], kvp[1]);
+                }
+            }
+            finally {
+                disposeSafe(enumerator as IDisposable);
+            }
+            return {
+                description: description,
+                values: valuesDict,
+            };
+        }, path_2, v), objAsString);
+        if (matchValue.tag === /* Error */ 1) {
+            throw new Error(`Field ${fieldKey}: Invalid matrix data format - ${matchValue.fields[0]}`);
+        }
+        else {
+            return matchValue.fields[0];
+        }
+    }
+    catch (ex: any) {
+        throw new Error(`Field ${fieldKey}: Failed to decode matrix value - ${ex.message}`);
+    }
+}
+
+export function decodeAsPluginDataArray(fieldKey: string, obj: any): { dataType: string, description?: string, displayName?: string, name: string, propertyKey: string, unit?: string, value: string }[] {
+    let str: string;
+    const objAsString: string = (typeof obj === "string") ? ((str = (obj as string), str)) : toString(0, Auto_generateBoxedEncoder_437914C6(obj_type, undefined, undefined, undefined)(obj));
+    try {
+        const matchValue: FSharpResult$2_$union<{ dataType: string, description?: string, displayName?: string, name: string, propertyKey: string, unit?: string, value: string }[], string> = fromString_1<{ dataType: string, description?: string, displayName?: string, name: string, propertyKey: string, unit?: string, value: string }[]>((path_8: string, value_10: any): FSharpResult$2_$union<{ dataType: string, description?: string, displayName?: string, name: string, propertyKey: string, unit?: string, value: string }[], [string, ErrorReason_$union]> => array_4<{ dataType: string, description?: string, displayName?: string, name: string, propertyKey: string, unit?: string, value: string }>((path_7: string, v: any): FSharpResult$2_$union<{ dataType: string, description?: string, displayName?: string, name: string, propertyKey: string, unit?: string, value: string }, [string, ErrorReason_$union]> => object<{ dataType: string, description?: string, displayName?: string, name: string, propertyKey: string, unit?: string, value: string }>((get$: IGetters): { dataType: string, description?: string, displayName?: string, name: string, propertyKey: string, unit?: string, value: string } => {
+            let objectArg_6: IOptionalGetter;
+            let propertyKey: string;
+            const objectArg: IRequiredGetter = get$.Required;
+            propertyKey = objectArg.Field<string>("propertyKey", string);
+            let name: string;
+            const objectArg_1: IRequiredGetter = get$.Required;
+            name = objectArg_1.Field<string>("name", string);
+            let dataType: string;
+            const objectArg_2: IRequiredGetter = get$.Required;
+            dataType = objectArg_2.Field<string>("dataType", string);
+            let value_6: string;
+            const objectArg_3: IRequiredGetter = get$.Required;
+            value_6 = objectArg_3.Field<string>("value", string);
+            let displayName: Option<string>;
+            const objectArg_4: IOptionalGetter = get$.Optional;
+            displayName = objectArg_4.Field<string>("displayName", string);
+            let unit: Option<string>;
+            const objectArg_5: IOptionalGetter = get$.Optional;
+            unit = objectArg_5.Field<string>("unit", string);
+            return {
+                dataType: dataType,
+                description: unwrap((objectArg_6 = get$.Optional, objectArg_6.Field<string>("description", string))),
+                displayName: unwrap(displayName),
+                name: name,
+                propertyKey: propertyKey,
+                unit: unwrap(unit),
+                value: value_6,
+            };
+        }, path_7, v), path_8, value_10), objAsString);
+        if (matchValue.tag === /* Error */ 1) {
+            throw new Error(`Field ${fieldKey}: Invalid plugin data format - ${matchValue.fields[0]}`);
+        }
+        else {
+            return matchValue.fields[0];
+        }
+    }
+    catch (ex: any) {
+        throw new Error(`Field ${fieldKey}: Failed to decode plugin data - ${ex.message}`);
+    }
+}
+
+export function createFormFieldData(fieldKey: string, objectValue: any): { fieldKey: string, objectValue: any } {
+    return {
+        fieldKey: fieldKey,
+        objectValue: objectValue,
+    };
+}
+
+/**
+ * Build DynamicFormResultData from FormSpec with comprehensive type validation
+ * TypeScript: (formSpec: FormSpec, fieldData: FieldInput[]) => DynamicFormResultData
+ * Where FieldInput = SingleValueInput | MultipleValueInput | MatrixValueInput | PluginValueInput
+ */
+export function buildDynamicFormResultData(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>, fieldData: { fieldKey: string, objectValue: any }[]): Values_DynamicFormResultData$1<Spec_FieldType_$union> {
+    const resultFormSpecDetails: Values_DynamicFormSpecDetails = new Values_DynamicFormSpecDetails(formSpec.Id, formSpec.Code, formSpec.FormSpecVersion, formSpec.FormSpecVersion, formSpec.Score, Values_FormStatus_Pending(), empty<Values_Signature>());
+    const allFieldDetails: FSharpList<[Spec_FormField$1<Spec_FieldType_$union>, Values_FieldDetails$1<Spec_FieldType_$union>]> = ofSeq<[Spec_FormField$1<Spec_FieldType_$union>, Values_FieldDetails$1<Spec_FieldType_$union>]>(choose<{ fieldKey: string, objectValue: any }, [Spec_FormField$1<Spec_FieldType_$union>, Values_FieldDetails$1<Spec_FieldType_$union>]>((input: { fieldKey: string, objectValue: any }): Option<[Spec_FormField$1<Spec_FieldType_$union>, Values_FieldDetails$1<Spec_FieldType_$union>]> => {
+        let matchValue_1: ExpectedFieldValueType_$union, matrixData: { description: string, values: IMap<string, string> }, matchValue_2: Spec_FieldType_$union;
+        const matchValue: Option<Spec_FormField$1<Spec_FieldType_$union>> = findFieldByKey(formSpec, input.fieldKey);
+        if (matchValue == null) {
+            toConsole(`Warning: Field ${input.fieldKey} not found in FormSpec`);
+            return undefined;
+        }
+        else {
+            const field: Spec_FormField$1<Spec_FieldType_$union> = value_11(matchValue);
+            try {
+                return [field, new Values_FieldDetails$1(field.FieldOrder, field.FieldKey, field.Label, (matchValue_1 = getExpectedFieldValueType(field.FieldType), (matchValue_1.tag === /* MultipleValues */ 1) ? Shared_FieldValue_Multiple(ofArray<Shared_FieldAnswer>(map<string, Shared_FieldAnswer>((value: string): Shared_FieldAnswer => (new Shared_FieldAnswer(field.FieldKey, field.Label, value)), decodeAsStringArray(input.fieldKey, input.objectValue)), {
+                    Compare: compare,
+                })) : ((matchValue_1.tag === /* MatrixValue */ 2) ? ((matrixData = decodeAsMatrixValue(input.fieldKey, input.objectValue), Shared_FieldValue_Matrix(new Shared_MatrixAnswer(field.FieldKey, matrixData.description, ofSeq_1<Shared_MatrixItemKey, string>(map_1<[string, string], [Shared_MatrixItemKey, string]>((kvp: [string, string]): [Shared_MatrixItemKey, string] => ([new Shared_MatrixItemKey(parse(kvp[0])), kvp[1]] as [Shared_MatrixItemKey, string]), matrixData.values), {
+                    Compare: compare,
+                }))))) : ((matchValue_1.tag === /* PluginDataValue */ 3) ? Shared_FieldValue_PluginData(ofArray_1<Shared_PluginDataProperty>(map<{ dataType: string, description?: string, displayName?: string, name: string, propertyKey: string, unit?: string, value: string }, Shared_PluginDataProperty>((prop: { dataType: string, description?: string, displayName?: string, name: string, propertyKey: string, unit?: string, value: string }): Shared_PluginDataProperty => (new Shared_PluginDataProperty(new Shared_PluginPropertyKey(parse(prop.propertyKey)), prop.name, prop.dataType, prop.value, prop.displayName, prop.unit, prop.description)), decodeAsPluginDataArray(input.fieldKey, input.objectValue)))) : Shared_FieldValue_Single(new Shared_FieldAnswer(field.FieldKey, field.Label, decodeAsString(input.fieldKey, input.objectValue)))))), field.FieldType, (matchValue_2 = field.FieldType, (matchValue_2.tag === /* Radio */ 12) ? matchValue_2.fields[0].Options : ((matchValue_2.tag === /* SingleChoice */ 13) ? matchValue_2.fields[0].Options : ((matchValue_2.tag === /* Dropdown */ 14) ? matchValue_2.fields[0].Options : ((matchValue_2.tag === /* MultiChoice */ 15) ? matchValue_2.fields[0].Options : ((matchValue_2.tag === /* CheckboxList */ 16) ? matchValue_2.fields[0].Options : ((matchValue_2.tag === /* TagList */ 17) ? matchValue_2.fields[0].Options : ((matchValue_2.tag === /* TextAutoComplete */ 18) ? matchValue_2.fields[0].Options : ((matchValue_2.tag === /* Matrix */ 19) ? matchValue_2.fields[0].Options : empty<Shared_FieldOption>())))))))))] as [Spec_FormField$1<Spec_FieldType_$union>, Values_FieldDetails$1<Spec_FieldType_$union>];
+            }
+            catch (ex: any) {
+                toConsole(`Error processing field ${input.fieldKey}: ${ex.message}`);
+                return undefined;
+            }
+        }
+    }, fieldData));
+    return new Values_DynamicFormResultData$1(resultFormSpecDetails, ofList<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>(map_2<Spec_FormStep$1<Spec_FieldType_$union>, [Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]>((step: Spec_FormStep$1<Spec_FieldType_$union>): [Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>] => ([new Values_StepOrder(step.StepOrder), ofList<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>(map_2<[Spec_FormField$1<Spec_FieldType_$union>, Values_FieldDetails$1<Spec_FieldType_$union>], [Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>((tupledArg_1: [Spec_FormField$1<Spec_FieldType_$union>, Values_FieldDetails$1<Spec_FieldType_$union>]): [Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>] => {
+        const fieldDetails_1: Values_FieldDetails$1<Spec_FieldType_$union> = tupledArg_1[1];
+        return [fieldDetails_1.Key, fieldDetails_1] as [Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>];
+    }, filter<[Spec_FormField$1<Spec_FieldType_$union>, Values_FieldDetails$1<Spec_FieldType_$union>]>((tupledArg: [Spec_FormField$1<Spec_FieldType_$union>, Values_FieldDetails$1<Spec_FieldType_$union>]): boolean => exists<Spec_FormField$1<Spec_FieldType_$union>>((stepField: Spec_FormField$1<Spec_FieldType_$union>): boolean => equals(stepField.FieldKey, tupledArg[0].FieldKey), step.Fields), allFieldDetails)), {
+        Compare: compare,
+    })] as [Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]), formSpec.Steps), {
+        Compare: compare,
+    }));
+}
+
+/**
+ * Create a checkbox field with the given parameters
+ * TypeScript: createCheckboxField(fieldKey: string, label: string, isOptional: boolean)
+ */
+export function createCheckboxField(fieldKeyString: string, label: string, isOptional: boolean): Spec_FormField$1<Spec_FieldType_$union> {
+    return new Spec_FormField$1(1, new Shared_FieldKey(parse(fieldKeyString)), label, undefined, undefined, isOptional, false, Spec_FieldType_Checkbox(new Spec_BooleanInfo(undefined, undefined)));
+}
+
+/**
+ * Create a checkbox list field with options
+ * TypeScript: createCheckboxListField(fieldKey: string, label: string, options: {value: string, description: string, optionKey: string}[])
+ */
+export function createCheckboxListField(fieldKeyString: string, label: string, options: { description: string, optionKey: string, value: string }[]): Spec_FormField$1<Spec_FieldType_$union> {
+    const fieldOptions: FSharpList<Shared_FieldOption> = ofSeq<Shared_FieldOption>(mapIndexed<{ description: string, optionKey: string, value: string }, Shared_FieldOption>((_arg: int32, opt: { description: string, optionKey: string, value: string }): Shared_FieldOption => (new Shared_FieldOption(opt.description, opt.value, new Shared_FieldOptionKey(parse(opt.optionKey)))), options));
+    return new Spec_FormField$1(1, new Shared_FieldKey(parse(fieldKeyString)), label, undefined, undefined, false, false, Spec_FieldType_CheckboxList(new Spec_MultiChoiceInfo(fieldOptions)));
+}
+
+/**
+ * Create a text field
+ * TypeScript: createTextField(fieldKey: string, label: string, isOptional: boolean)
+ */
+export function createTextField(fieldKeyString: string, label: string, isOptional: boolean): Spec_FormField$1<Spec_FieldType_$union> {
+    return new Spec_FormField$1(1, new Shared_FieldKey(parse(fieldKeyString)), label, undefined, undefined, isOptional, false, Spec_FieldType_Text(new Spec_TextInfo(undefined)));
+}
+
+/**
+ * Create a form step with fields
+ * TypeScript: createFormStep(stepOrder: number, stepLabel: string, fields: FormField[])
+ */
+export function createFormStep(stepOrder: int32, stepLabel: string, fields: Spec_FormField$1<Spec_FieldType_$union>[]): Spec_FormStep$1<Spec_FieldType_$union> {
+    return new Spec_FormStep$1(stepOrder, stepLabel, ofSeq<Spec_FormField$1<Spec_FieldType_$union>>(mapIndexed<Spec_FormField$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>>((index: int32, field: Spec_FormField$1<Spec_FieldType_$union>): Spec_FormField$1<Spec_FieldType_$union> => (new Spec_FormField$1(index + 1, field.FieldKey, field.Label, field.Notes, field.DependsOn, field.IsOptional, field.IsDeprecated, field.FieldType)), fields)));
+}
+
+/**
+ * Create a FormSpec with basic information
+ * TypeScript: createFormSpec(id: string, title: string, steps: FormStep[])
+ */
+export function createFormSpec(idString: string, title: string, steps: Spec_FormStep$1<Spec_FieldType_$union>[]): Spec_FormSpec$1<Spec_FieldType_$union> {
+    return new Spec_FormSpec$1(parse(idString), "DYN", title, "Dynamically created FormSpec", "1.0.0", "2.0.5", ofSeq<Spec_FormStep$1<Spec_FieldType_$union>>(steps), empty<string>(), undefined, empty<string>(), false, false, undefined);
+}
+
+/**
+ * Create a field option
+ * TypeScript: createFieldOption(description: string, value: string, optionKey: string)
+ */
+export function createFieldOption(description: string, value: string, optionKeyString: string): Shared_FieldOption {
+    return new Shared_FieldOption(description, value, new Shared_FieldOptionKey(parse(optionKeyString)));
+}
+
+/**
+ * Create a matrix field
+ * TypeScript: createMatrixField(fieldKey: string, label: string, items: FieldOption[], options: FieldOption[])
+ */
+export function createMatrixField(fieldKeyString: string, label: string, items: Shared_FieldOption[], options: Shared_FieldOption[]): Spec_FormField$1<Spec_FieldType_$union> {
+    return new Spec_FormField$1(1, new Shared_FieldKey(parse(fieldKeyString)), label, undefined, undefined, false, false, Spec_FieldType_Matrix(new Spec_MatrixInfo(ofSeq<Shared_FieldOption>(items), ofSeq<Shared_FieldOption>(options))));
+}
+
+/**
+ * Create a plugin field
+ * TypeScript: createPluginField(fieldKey: string, label: string, config: {pluginId: string, fieldName: string})
+ */
+export function createPluginField(fieldKeyString: string, label: string, config: { fieldName: string, pluginId: string }): Spec_FormField$1<Spec_FieldType_$union> {
+    return new Spec_FormField$1(1, new Shared_FieldKey(parse(fieldKeyString)), label, undefined, undefined, false, false, Spec_FieldType_PluginField(new Spec_PluginFieldConfig(config.pluginId, config.fieldName)));
+}
+
+/**
+ * Create an action state that executes a task
+ * TypeScript: createActionState(stateKey: string, label: string, taskDescription: string, priority?: string)
+ */
+export function createActionState(stateKeyString: string, label: string, taskDescription: string, priority: Option<string>): ClinicalPathway_StateDefinition {
+    return new ClinicalPathway_StateDefinition(new Shared_StateKey(parse(stateKeyString)), label, 1, ClinicalPathway_StateType_Action(ClinicalPathway_ActionInfo_Task(new ClinicalPathway_TaskAction("Clinical", taskDescription, (priority != null) ? ((value_11(priority) === "High") ? ClinicalPathway_TaskPriority_High() : ((value_11(priority) === "Low") ? ClinicalPathway_TaskPriority_Low() : ClinicalPathway_TaskPriority_Medium())) : ClinicalPathway_TaskPriority_Medium(), ClinicalPathway_DueDate_Today(), "Clinical Staff", undefined))), undefined);
+}
+
+/**
+ * Create a terminal state that ends the pathway
+ * TypeScript: createTerminalState(stateKey: string, outcome: string)
+ */
+export function createTerminalState(stateKeyString: string, outcome: string): ClinicalPathway_StateDefinition {
+    return new ClinicalPathway_StateDefinition(new Shared_StateKey(parse(stateKeyString)), outcome, 1, ClinicalPathway_StateType_Terminal(new ClinicalPathway_TerminalInfo("Complete", outcome, undefined)), undefined);
+}
+
+/**
+ * Create a transition between states based on field condition
+ * TypeScript: createTransition(transitionKey: string, fromState: string, toState: string, fieldKey: string, expectedValue: string)
+ */
+export function createTransition(transitionKeyString: string, fromStateString: string, toStateString: string, fieldKeyString: string, expectedValue: string): ClinicalPathway_TransitionDefinition {
+    return new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(parse(transitionKeyString)), new Shared_StateKey(parse(fromStateString)), new Shared_StateKey(parse(toStateString)), ClinicalPathway_TransitionCondition_FieldCondition(new Shared_FieldKey(parse(fieldKeyString)), ClinicalPathway_FieldEvaluator_Equals(), Shared_ConditionValue_Single(expectedValue)), undefined);
+}
+
+/**
+ * Create a clinical pathway with states and transitions
+ * TypeScript: createClinicalPathway(name: string, states: StateDefinition[], transitions: TransitionDefinition[])
+ */
+export function createClinicalPathway(name: string, states: ClinicalPathway_StateDefinition[], transitions: ClinicalPathway_TransitionDefinition[]): ClinicalPathway_ClinicalPathwaySpec {
+    let copyOfStruct: string;
+    const statesWithOrder: FSharpList<ClinicalPathway_StateDefinition> = ofSeq<ClinicalPathway_StateDefinition>(mapIndexed<ClinicalPathway_StateDefinition, ClinicalPathway_StateDefinition>((index: int32, state: ClinicalPathway_StateDefinition): ClinicalPathway_StateDefinition => (new ClinicalPathway_StateDefinition(state.StateKey, state.StateLabel, index + 1, state.StateType, state.DependsOn)), states));
+    return new ClinicalPathway_ClinicalPathwaySpec((copyOfStruct = newGuid(), copyOfStruct), name, "1.0.0", "Dynamic Builder", ClinicalPathway_PathwayExecutionMode_SinglePathway(new ClinicalPathway_SinglePathwayConfig(ClinicalPathway_SelectionStrategy_HighestPriority(), true)), new Shared_StateKey("00000000-0000-0000-0000-000000000001"), statesWithOrder, ofSeq<ClinicalPathway_TransitionDefinition>(transitions), empty<ClinicalPathway_ConstraintDefinition>(), empty<ClinicalPathway_PathRequirement>(), now(), undefined, undefined, undefined);
+}
+
+/**
+ * Add a clinical pathway to an existing FormSpec
+ * TypeScript: addPathwayToFormSpec(formSpec: FormSpec, pathway: ClinicalPathwaySpec)
+ */
+export function addPathwayToFormSpec(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>, pathway: ClinicalPathway_ClinicalPathwaySpec): Spec_FormSpec$1<Spec_FieldType_$union> {
+    return new Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, formSpec.Steps, formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, pathway);
+}
+
+/**
+ * Extract form field data from DynamicFormResultData in TypeScript-friendly format
+ * TypeScript: getFieldDataFromFormResult(formData: DynamicFormResultData, stepOrder: number, fieldKey: string)
+ */
+export function getFieldDataFromFormResult(formData: Values_DynamicFormResultData$1<Spec_FieldType_$union>, stepOrder: int32, fieldKeyString: string): Option<any> {
+    const fieldKey: Shared_FieldKey = new Shared_FieldKey(parse(fieldKeyString));
+    const matchValue: Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>> = tryFind_1<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>(new Values_StepOrder(stepOrder), formData.ResultSteps);
+    if (matchValue == null) {
+        return undefined;
+    }
+    else {
+        const matchValue_1: Option<Values_FieldDetails$1<Spec_FieldType_$union>> = tryFind_1<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>(fieldKey, value_11(matchValue));
+        if (matchValue_1 == null) {
+            return undefined;
+        }
+        else {
+            const fieldDetails: Values_FieldDetails$1<Spec_FieldType_$union> = value_11(matchValue_1);
+            return some({
+                FieldOrder: fieldDetails.FieldOrder,
+                FieldType: fieldDetails.FieldType,
+                FieldValue: fieldDetails.FieldValue,
+                Key: fieldKeyString,
+                Label: fieldDetails.Label,
+            });
+        }
+    }
+}
+
+/**
+ * Get all step orders from DynamicFormResultData
+ * TypeScript: getFormResultStepOrders(formData: DynamicFormResultData)
+ */
+export function getFormResultStepOrders(formData: Values_DynamicFormResultData$1<Spec_FieldType_$union>): int32[] {
+    const collection: Iterable<int32> = map_1<[Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>], int32>((tupledArg: [Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]): int32 => tupledArg[0].fields[0], toSeq<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>(formData.ResultSteps));
+    return Array.from(collection);
+}
+
+/**
+ * Get all field keys for a specific step from DynamicFormResultData
+ * TypeScript: getFormResultFieldKeys(formData: DynamicFormResultData, stepOrder: number)
+ */
+export function getFormResultFieldKeys(formData: Values_DynamicFormResultData$1<Spec_FieldType_$union>, stepOrder: int32): string[] {
+    const matchValue: Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>> = tryFind_1<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>(new Values_StepOrder(stepOrder), formData.ResultSteps);
+    if (matchValue == null) {
+        return [];
+    }
+    else {
+        const collection: Iterable<string> = map_1<Shared_FieldKey, string>((_arg: Shared_FieldKey): string => _arg.fields[0], map_1<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>], Shared_FieldKey>((tuple: [Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]): Shared_FieldKey => tuple[0], toSeq<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>(value_11(matchValue))));
+        return Array.from(collection);
+    }
+}
+
+/**
+ * Get the ResultSteps as a TypeScript-friendly structure
+ * TypeScript: getResultSteps(formResult: DynamicFormResultData)
+ */
+export function getResultSteps(formData: Values_DynamicFormResultData$1<Spec_FieldType_$union>): any {
+    return formData.ResultSteps;
+}
+
+/**
+ * Get a specific field value from the result
+ * TypeScript: getFieldValue(formResult: DynamicFormResultData, stepOrder: number, fieldKey: string)
+ */
+export function getFieldValue(formData: Values_DynamicFormResultData$1<Spec_FieldType_$union>, stepOrder: int32, fieldKeyString: string): Option<any> {
+    const fieldKey: Shared_FieldKey = new Shared_FieldKey(parse(fieldKeyString));
+    const matchValue: Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>> = tryFind_1<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>(new Values_StepOrder(stepOrder), formData.ResultSteps);
+    if (matchValue == null) {
+        return undefined;
+    }
+    else {
+        const matchValue_1: Option<Values_FieldDetails$1<Spec_FieldType_$union>> = tryFind_1<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>(fieldKey, value_11(matchValue));
+        if (matchValue_1 == null) {
+            return undefined;
+        }
+        else {
+            return some(value_11(matchValue_1).FieldValue);
+        }
+    }
+}
+
+/**
+ * Get complete field details from the result
+ * TypeScript: getFieldDetails(formResult: DynamicFormResultData, stepOrder: number, fieldKey: string)
+ */
+export function getFieldDetails(formData: Values_DynamicFormResultData$1<Spec_FieldType_$union>, stepOrder: int32, fieldKeyString: string): Option<any> {
+    const fieldKey: Shared_FieldKey = new Shared_FieldKey(parse(fieldKeyString));
+    const matchValue: Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>> = tryFind_1<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>(new Values_StepOrder(stepOrder), formData.ResultSteps);
+    if (matchValue == null) {
+        return undefined;
+    }
+    else {
+        const matchValue_1: Option<Values_FieldDetails$1<Spec_FieldType_$union>> = tryFind_1<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>(fieldKey, value_11(matchValue));
+        if (matchValue_1 == null) {
+            return undefined;
+        }
+        else {
+            return some(value_11(matchValue_1));
+        }
+    }
+}
+
+/**
+ * Create a complete test FormSpec for buildDynamicFormResultData testing
+ * TypeScript: createTestFormSpec()
+ */
+export function createTestFormSpec(): Spec_FormSpec$1<Spec_FieldType_$union> {
+    const option1: Shared_FieldOption = new Shared_FieldOption("Option 1", "opt1", new Shared_FieldOptionKey(newGuid()));
+    const option2: Shared_FieldOption = new Shared_FieldOption("Option 2", "opt2", new Shared_FieldOptionKey(newGuid()));
+    const testStep: Spec_FormStep$1<Spec_FieldType_$union> = new Spec_FormStep$1(1, "Test Step", ofArray_1([new Spec_FormField$1(1, new Shared_FieldKey("11111111-1111-1111-1111-111111111111"), "Test Text Field", undefined, undefined, false, false, Spec_FieldType_Text(new Spec_TextInfo(undefined))), new Spec_FormField$1(2, new Shared_FieldKey("22222222-2222-2222-2222-222222222222"), "Test Checkbox List", undefined, undefined, false, false, Spec_FieldType_CheckboxList(new Spec_MultiChoiceInfo(ofArray_1([option1, option2])))), new Spec_FormField$1(3, new Shared_FieldKey("33333333-3333-3333-3333-333333333333"), "Test Matrix", undefined, undefined, false, false, Spec_FieldType_Matrix(new Spec_MatrixInfo(ofArray_1([option1, option2]), ofArray_1([new Shared_FieldOption("Scale 1", "1", new Shared_FieldOptionKey(newGuid())), new Shared_FieldOption("Scale 2", "2", new Shared_FieldOptionKey(newGuid()))])))), new Spec_FormField$1(4, new Shared_FieldKey("44444444-4444-4444-4444-444444444444"), "Test Plugin Field", undefined, undefined, false, false, Spec_FieldType_PluginField(new Spec_PluginFieldConfig("test.plugin", "Test Plugin")))]));
+    return new Spec_FormSpec$1(newGuid(), "TEST-001", "Test Form", "Test form for buildDynamicFormResultData", "1.0.0", "5.0.0", singleton(testStep), empty<string>(), undefined, empty<string>(), false, false, undefined);
+}
+
+/**
+ * Safe pathway execution initialization wrapper
+ * TypeScript: initializePathwayExecution(formSpec: FormSpec, pathway: ClinicalPathwaySpec, formData: DynamicFormResultData)
+ */
+export function initializePathwayExecution(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>, pathway: ClinicalPathway_ClinicalPathwaySpec, formData: Values_DynamicFormResultData$1<Spec_FieldType_$union>): any {
+    try {
+        return initializeExecution<Spec_FieldType_$union>(formSpec, formData);
+    }
+    catch (ex: any) {
+        return {
+            ErrorMessage: ex.message,
+            ErrorType: "Exception",
+            IsError: true,
+        };
+    }
+}
+
+/**
+ * Get field type information in TypeScript-friendly format
+ * TypeScript: getFieldTypeInfo(field: FormField) => {typeName: string, isRequired: boolean}
+ */
+export function getFieldTypeInfo(field: Spec_FormField$1<Spec_FieldType_$union>): { isRequired: boolean, typeName: string } {
+    let matchValue: Spec_FieldType_$union;
+    return {
+        isRequired: !field.IsOptional,
+        typeName: (matchValue = field.FieldType, (matchValue.tag === /* TextArea */ 1) ? "TextArea" : ((matchValue.tag === /* Email */ 2) ? "Email" : ((matchValue.tag === /* Password */ 3) ? "Password" : ((matchValue.tag === /* Search */ 4) ? "Search" : ((matchValue.tag === /* Color */ 5) ? "Color" : ((matchValue.tag === /* Number */ 6) ? "Number" : ((matchValue.tag === /* Tel */ 7) ? "Tel" : ((matchValue.tag === /* Date */ 8) ? "Date" : ((matchValue.tag === /* DateTimeLocal */ 9) ? "DateTimeLocal" : ((matchValue.tag === /* Time */ 10) ? "Time" : ((matchValue.tag === /* Checkbox */ 11) ? "Checkbox" : ((matchValue.tag === /* Radio */ 12) ? "Radio" : ((matchValue.tag === /* SingleChoice */ 13) ? "SingleChoice" : ((matchValue.tag === /* Dropdown */ 14) ? "Dropdown" : ((matchValue.tag === /* TextAutoComplete */ 18) ? "TextAutoComplete" : ((matchValue.tag === /* MultiChoice */ 15) ? "MultiChoice" : ((matchValue.tag === /* CheckboxList */ 16) ? "CheckboxList" : ((matchValue.tag === /* TagList */ 17) ? "TagList" : ((matchValue.tag === /* Matrix */ 19) ? "Matrix" : ((matchValue.tag === /* Signature */ 20) ? "Signature" : ((matchValue.tag === /* Message */ 21) ? "Message" : ((matchValue.tag === /* PluginField */ 22) ? "PluginField" : "Text")))))))))))))))))))))),
+    };
+}
+
+/**
+ * Extract choice options from fields that support them
+ * TypeScript: getFieldChoiceOptions(field: FormField) => {key: string, label: string, value: string}[] | null
+ */
+export function getFieldChoiceOptions(field: Spec_FormField$1<Spec_FieldType_$union>): Option<{ key: string, label: string, value: string }[]> {
+    let collection: FSharpList<{ key: string, label: string, value: string }>, collection_1: FSharpList<{ key: string, label: string, value: string }>, collection_2: FSharpList<{ key: string, label: string, value: string }>, collection_3: FSharpList<{ key: string, label: string, value: string }>, collection_4: FSharpList<{ key: string, label: string, value: string }>, collection_5: FSharpList<{ key: string, label: string, value: string }>, collection_6: FSharpList<{ key: string, label: string, value: string }>;
+    const matchValue: Spec_FieldType_$union = field.FieldType;
+    switch (matchValue.tag) {
+        case /* Radio */ 12:
+            return (collection = map_2<Shared_FieldOption, { key: string, label: string, value: string }>((opt: Shared_FieldOption): { key: string, label: string, value: string } => ({
+                key: opt.OptionKey.fields[0],
+                label: opt.Description,
+                value: opt.Value,
+            }), matchValue.fields[0].Options), Array.from(collection));
+        case /* SingleChoice */ 13:
+            return (collection_1 = map_2<Shared_FieldOption, { key: string, label: string, value: string }>((opt_1: Shared_FieldOption): { key: string, label: string, value: string } => ({
+                key: opt_1.OptionKey.fields[0],
+                label: opt_1.Description,
+                value: opt_1.Value,
+            }), matchValue.fields[0].Options), Array.from(collection_1));
+        case /* Dropdown */ 14:
+            return (collection_2 = map_2<Shared_FieldOption, { key: string, label: string, value: string }>((opt_2: Shared_FieldOption): { key: string, label: string, value: string } => ({
+                key: opt_2.OptionKey.fields[0],
+                label: opt_2.Description,
+                value: opt_2.Value,
+            }), matchValue.fields[0].Options), Array.from(collection_2));
+        case /* MultiChoice */ 15:
+            return (collection_3 = map_2<Shared_FieldOption, { key: string, label: string, value: string }>((opt_3: Shared_FieldOption): { key: string, label: string, value: string } => ({
+                key: opt_3.OptionKey.fields[0],
+                label: opt_3.Description,
+                value: opt_3.Value,
+            }), matchValue.fields[0].Options), Array.from(collection_3));
+        case /* CheckboxList */ 16:
+            return (collection_4 = map_2<Shared_FieldOption, { key: string, label: string, value: string }>((opt_4: Shared_FieldOption): { key: string, label: string, value: string } => ({
+                key: opt_4.OptionKey.fields[0],
+                label: opt_4.Description,
+                value: opt_4.Value,
+            }), matchValue.fields[0].Options), Array.from(collection_4));
+        case /* TagList */ 17:
+            return (collection_5 = map_2<Shared_FieldOption, { key: string, label: string, value: string }>((opt_5: Shared_FieldOption): { key: string, label: string, value: string } => ({
+                key: opt_5.OptionKey.fields[0],
+                label: opt_5.Description,
+                value: opt_5.Value,
+            }), matchValue.fields[0].Options), Array.from(collection_5));
+        case /* TextAutoComplete */ 18:
+            return (collection_6 = map_2<Shared_FieldOption, { key: string, label: string, value: string }>((opt_6: Shared_FieldOption): { key: string, label: string, value: string } => ({
+                key: opt_6.OptionKey.fields[0],
+                label: opt_6.Description,
+                value: opt_6.Value,
+            }), matchValue.fields[0].Options), Array.from(collection_6));
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Extract matrix field structure (items and options)
+ * TypeScript: getFieldMatrixInfo(field: FormField) => {items: {key: string, label: string}[], options: {key: string, description: string, value: string}[]} | null
+ */
+export function getFieldMatrixInfo(field: Spec_FormField$1<Spec_FieldType_$union>): Option<{ items: { key: string, label: string }[], options: { description: string, key: string, value: string }[] }> {
+    let collection: FSharpList<{ key: string, label: string }>, collection_1: FSharpList<{ description: string, key: string, value: string }>;
+    const matchValue: Spec_FieldType_$union = field.FieldType;
+    if (matchValue.tag === /* Matrix */ 19) {
+        const matrixInfo: Spec_MatrixInfo = matchValue.fields[0];
+        return {
+            items: (collection = map_2<Shared_FieldOption, { key: string, label: string }>((item: Shared_FieldOption): { key: string, label: string } => ({
+                key: item.OptionKey.fields[0],
+                label: item.Description,
+            }), matrixInfo.Items), Array.from(collection)),
+            options: (collection_1 = map_2<Shared_FieldOption, { description: string, key: string, value: string }>((opt: Shared_FieldOption): { description: string, key: string, value: string } => ({
+                description: opt.Description,
+                key: opt.OptionKey.fields[0],
+                value: opt.Value,
+            }), matrixInfo.Options), Array.from(collection_1)),
+        };
+    }
+    else {
+        return undefined;
+    }
+}
+
+/**
+ * Extract GUID string from FieldKey (single-case DU)
+ * TypeScript: getFieldKeyString(fieldKey: FieldKey) => string
+ */
+export function getFieldKeyString(fieldKey: Shared_FieldKey): string {
+    return fieldKey.fields[0];
+}
+
+/**
+ * Convert ClinicalPathway ActionInfo to TypeScript-friendly objects
+ * TypeScript: convertActionInfo(action: ActionInfo) => {type: string, description: string, ...}
+ */
+export function convertActionInfo(action: ClinicalPathway_ActionInfo_$union): any {
+    let matchValue_1: ClinicalPathway_ReferralUrgency_$union, matchValue_3: ClinicalPathway_AlertSeverity_$union, matchValue: ClinicalPathway_TaskPriority_$union;
+    switch (action.tag) {
+        case /* Referral */ 2: {
+            const referral: ClinicalPathway_ReferralAction = action.fields[0];
+            return {
+                description: `Refer to ${referral.Target}`,
+                reason: referral.Reason,
+                type: "referral",
+                urgency: (matchValue_1 = referral.Urgency, (matchValue_1.tag === /* Routine */ 1) ? (`routine-${matchValue_1.fields[0]}`) : ((matchValue_1.tag === /* AsNeeded */ 2) ? "asNeeded" : "immediate")),
+            };
+        }
+        case /* Medication */ 0: {
+            const med: ClinicalPathway_MedicationAction = action.fields[0];
+            return {
+                description: `${med.Name} - ${med.Dose} ${med.Route}`,
+                dose: med.Dose,
+                duration: med.Duration,
+                frequency: med.Frequency,
+                medicationName: med.Name,
+                route: med.Route,
+                type: "medication",
+            };
+        }
+        case /* Prescription */ 9: {
+            const presc: ClinicalPathway_PrescriptionAction = action.fields[0];
+            return {
+                description: `${presc.Medication} - ${presc.Dose} ${presc.Route}`,
+                dose: presc.Dose,
+                duration: presc.Duration,
+                frequency: presc.Frequency,
+                medication: presc.Medication,
+                quantity: presc.Quantity,
+                route: presc.Route,
+                type: "prescription",
+            };
+        }
+        case /* SetFieldValue */ 10: {
+            const setField: ClinicalPathway_SetFieldValueAction = action.fields[0];
+            let valueStr: string;
+            const matchValue_2: ClinicalPathway_FieldValueSource_$union = setField.Value;
+            valueStr = ((matchValue_2.tag === /* FieldReference */ 1) ? (`Reference to ${matchValue_2.fields[0].fields[0]}`) : ((matchValue_2.tag === /* OptionKey */ 2) ? (`Option ${matchValue_2.fields[0].fields[0]}`) : matchValue_2.fields[0]));
+            const fieldGuid: string = setField.TargetField.fields[0];
+            return {
+                description: `Set field ${fieldGuid} to ${valueStr}`,
+                fieldKey: fieldGuid,
+                type: "setFieldValue",
+                value: valueStr,
+            };
+        }
+        case /* Documentation */ 5: {
+            const doc: ClinicalPathway_DocumentationAction = action.fields[0];
+            return {
+                description: `Document: ${doc.FormName}`,
+                formName: doc.FormName,
+                purpose: doc.Purpose,
+                required: doc.Required,
+                type: "documentation",
+            };
+        }
+        case /* Test */ 1: {
+            const test: ClinicalPathway_TestAction = action.fields[0];
+            return {
+                description: `${test.TestName} (${test.TestType})`,
+                testName: test.TestName,
+                testType: test.TestType,
+                type: "test",
+            };
+        }
+        case /* Procedure */ 4: {
+            const proc: ClinicalPathway_ProcedureAction = action.fields[0];
+            return {
+                description: `${proc.Name}: ${proc.Description}`,
+                procedureDescription: proc.Description,
+                procedureName: proc.Name,
+                type: "procedure",
+            };
+        }
+        case /* Education */ 3: {
+            const edu: ClinicalPathway_EducationAction = action.fields[0];
+            return {
+                description: `Education: ${join(", ", edu.Topics)}`,
+                topics: edu.Topics,
+                type: "education",
+            };
+        }
+        case /* Alert */ 7: {
+            const alert: ClinicalPathway_AlertAction = action.fields[0];
+            return {
+                category: alert.Category,
+                description: alert.Message,
+                severity: (matchValue_3 = alert.Severity, (matchValue_3.tag === /* High */ 2) ? "high" : ((matchValue_3.tag === /* Medium */ 1) ? "medium" : ((matchValue_3.tag === /* Low */ 0) ? "low" : "critical"))),
+                type: "alert",
+            };
+        }
+        case /* Problem */ 8: {
+            const prob: ClinicalPathway_ProblemAction = action.fields[0];
+            return {
+                description: `${prob.ProblemName}${defaultArg_1(map_3<string, string>((code: string): string => (` (ICD: ${code})`), prob.IcdCode), "")}`,
+                icdCode: unwrap(prob.IcdCode),
+                problemName: prob.ProblemName,
+                type: "problem",
+            };
+        }
+        case /* NavigateToForm */ 11: {
+            const nav: ClinicalPathway_NavigateToFormAction = action.fields[0];
+            const formCode: string = defaultArg_1(nav.FormCode, nav.FormId);
+            return {
+                description: `Navigate to form: ${formCode}`,
+                formCode: formCode,
+                type: "navigateToForm",
+            };
+        }
+        default: {
+            const task: ClinicalPathway_TaskAction = action.fields[0];
+            return {
+                category: task.Category,
+                description: task.Description,
+                priority: (matchValue = task.Priority, (matchValue.tag === /* Medium */ 1) ? "medium" : ((matchValue.tag === /* Low */ 2) ? "low" : "high")),
+                type: "task",
+            };
+        }
+    }
+}
+
+/**
+ * Find the StateKey for a given ActionInfo in a ClinicalPathwaySpec
+ * TypeScript: stateKeyForAction(pathway: ClinicalPathwaySpec, action: ActionInfo) => string | null
+ */
+export function stateKeyForAction(pathway: ClinicalPathway_ClinicalPathwaySpec, action: ClinicalPathway_ActionInfo_$union): Option<string> {
+    toConsole(printf("PathwayId: %A"))(pathway.PathwayId);
+    toConsole(printf("Finding state key for action: %A"))(action);
+    return tryPick<ClinicalPathway_StateDefinition, string>((state: ClinicalPathway_StateDefinition): Option<string> => {
+        const matchValue: ClinicalPathway_StateType_$union = state.StateType;
+        let matchResult: int32, actionInfo_1: ClinicalPathway_ActionInfo_$union;
+        if (matchValue.tag === /* Action */ 2) {
+            if (equals(matchValue.fields[0], action)) {
+                matchResult = 0;
+                actionInfo_1 = matchValue.fields[0];
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return state.StateKey.fields[0];
+            default:
+                return undefined;
+        }
+    }, pathway.States);
+}
+
+//# sourceMappingURL=FormSpec.Api.Helpers.ts.map