@f1studio/form-spec 5.0.0-alpha.101

package/src/Helpers.ts

@@ -0,0 +1,765 @@
+import { Values_StepOrder, Shared_FieldValue_Multiple, Shared_FieldValue_Single, Shared_FieldAnswer, Shared_FieldValue_$union, Values_FieldDetails$1, Shared_FieldOption, Spec_FieldType_$union, Spec_FieldType, Spec_FormSpec$1, Spec_FormField$1, Spec_FormStep$1, Shared_FieldKey } from "./FormSpec.js";
+import { arrayToGuid, parse } from "@fable-org/fable-library-js/Guid.js";
+import { toConsole, isNullOrEmpty, trimEnd, trim, isNullOrWhiteSpace } from "@fable-org/fable-library-js/String.js";
+import { replace } from "@fable-org/fable-library-js/RegExp.js";
+import { compare, safeHash, comparePrimitives, equals, stringHash } from "@fable-org/fable-library-js/Util.js";
+import { uint8, int32 } from "@fable-org/fable-library-js/Int32.js";
+import { item, setItem, fill } from "@fable-org/fable-library-js/Array.js";
+import { value as value_1, Option, map, defaultArg } from "@fable-org/fable-library-js/Option.js";
+import { splitAt, tryFindIndex, forAll, sortBy, find, insertAt, mapIndexed, singleton, append, head, tail, isEmpty, collect, empty, tryFind, FSharpList, filter, map as map_1 } from "@fable-org/fable-library-js/List.js";
+import { Result_Map, FSharpResult$2_$union, FSharpResult$2_Error, FSharpResult$2_Ok } from "@fable-org/fable-library-js/Result.js";
+import { List_distinct } from "@fable-org/fable-library-js/Seq2.js";
+import { map as map_2, tryFind as tryFind_1 } from "@fable-org/fable-library-js/Seq.js";
+import { FSharpMap__Change, ofList, toList, FSharpMap__get_Count, FSharpMap__get_IsEmpty, FSharpMap__ContainsKey, filter as filter_1, FSharpMap__Add, FSharpMap__Remove, FSharpMap, FSharpMap__get_Item, toSeq } from "@fable-org/fable-library-js/Map.js";
+import { FSharpSet, empty as empty_1, map as map_3 } from "@fable-org/fable-library-js/Set.js";
+
+export function Converters_fieldKeyToString(key: Shared_FieldKey): string {
+    return key.fields[0];
+}
+
+export function Converters_stringToFieldKey(s: string): Shared_FieldKey {
+    return new Shared_FieldKey(parse(s));
+}
+
+/**
+ * Canonicalize a field label or key to snake_case for consistent field key generation
+ * Converts: "Patient Refused Administration of test" → "patient_refused_administration_of_test"
+ * This is the single source of truth for field name canonicalization
+ */
+export function Helpers_canonicalizeFieldKey(input: string): string {
+    if (isNullOrWhiteSpace(input)) {
+        return "field_unknown";
+    }
+    else {
+        const s_5: string = trim(replace(replace(replace(trimEnd(input.toLowerCase().trim(), ":"), "[\\s\\-]+", "_"), "[^a-z0-9_]", ""), "_+", "_"), "_");
+        if (isNullOrEmpty(s_5)) {
+            return "field_unknown";
+        }
+        else {
+            return s_5;
+        }
+    }
+}
+
+export function Helpers_generateDeterministicGuid(fieldName: string): string {
+    const hash: int32 = stringHash(Helpers_canonicalizeFieldKey(fieldName)) | 0;
+    const bytes: uint8[] = fill(new Array(16), 0, 16, 0);
+    for (let i = 0; i <= 3; i++) {
+        setItem(bytes, i, (hash >> (i * 8)) & 0xFF);
+        setItem(bytes, i + 4, ((hash >> 1) >> (i * 8)) & 0xFF);
+        setItem(bytes, i + 8, ((hash >> 2) >> (i * 8)) & 0xFF);
+        setItem(bytes, i + 12, ((hash >> 3) >> (i * 8)) & 0xFF);
+    }
+    setItem(bytes, 6, (item(6, bytes) & 15) | 64);
+    setItem(bytes, 8, (item(8, bytes) & 63) | 128);
+    return arrayToGuid(bytes);
+}
+
+/**
+ * Finds a form field by its label string in a specific step.
+ */
+export function Helpers_FieldFinders_findFormFieldInStepByLabelString<FieldType>(label: string, stepNumber: int32, formSpec: Spec_FormSpec$1<FieldType>): FSharpList<[Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>]> {
+    return defaultArg(map<Spec_FormStep$1<FieldType>, FSharpList<[Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>]>>((step_1: Spec_FormStep$1<FieldType>): FSharpList<[Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>]> => map_1<Spec_FormField$1<FieldType>, [Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>]>((field_1: Spec_FormField$1<FieldType>): [Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>] => ([step_1, field_1] as [Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>]), filter<Spec_FormField$1<FieldType>>((field: Spec_FormField$1<FieldType>): boolean => (field.Label === label), step_1.Fields)), tryFind<Spec_FormStep$1<FieldType>>((step: Spec_FormStep$1<FieldType>): boolean => (step.StepOrder === stepNumber), formSpec.Steps)), empty<[Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>]>());
+}
+
+/**
+ * Finds a form field by its label string across all steps in the form.
+ */
+export function Helpers_FieldFinders_findFormFieldInFormByLabelString<FieldType>(label: string, formSpec: Spec_FormSpec$1<FieldType>): FSharpList<[Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>]> {
+    return collect<Spec_FormStep$1<FieldType>, [Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>]>((step: Spec_FormStep$1<FieldType>): FSharpList<[Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>]> => map_1<Spec_FormField$1<FieldType>, [Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>]>((field_1: Spec_FormField$1<FieldType>): [Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>] => ([step, field_1] as [Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>]), filter<Spec_FormField$1<FieldType>>((field: Spec_FormField$1<FieldType>): boolean => (field.Label === label), step.Fields)), formSpec.Steps);
+}
+
+/**
+ * Finds a unique form field by its label string in a specific step.
+ * Returns Ok with the field if exactly one is found, Error otherwise.
+ */
+export function Helpers_FieldFinders_findUniqueFormFieldInStepByLabelString<FieldType>(label: string, stepNumber: int32, formSpec: Spec_FormSpec$1<FieldType>): FSharpResult$2_$union<[Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>], string> {
+    const fields: FSharpList<[Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>]> = Helpers_FieldFinders_findFormFieldInStepByLabelString<FieldType>(label, stepNumber, formSpec);
+    if (!isEmpty(fields)) {
+        if (isEmpty(tail(fields))) {
+            return FSharpResult$2_Ok<[Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>], string>(head(fields));
+        }
+        else {
+            return FSharpResult$2_Error<[Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>], string>(`Multiple fields found with label '${label}' in step ${stepNumber}`);
+        }
+    }
+    else {
+        return FSharpResult$2_Error<[Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>], string>(`No field found with label '${label}' in step ${stepNumber}`);
+    }
+}
+
+/**
+ * Finds a unique form field by its label string across all steps in the form.
+ * Returns Ok with the field if exactly one is found, Error otherwise.
+ */
+export function Helpers_FieldFinders_findUniqueFormFieldInFormByLabelString<FieldType>(label: string, formSpec: Spec_FormSpec$1<FieldType>): FSharpResult$2_$union<[Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>], string> {
+    const fields: FSharpList<[Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>]> = Helpers_FieldFinders_findFormFieldInFormByLabelString<FieldType>(label, formSpec);
+    if (!isEmpty(fields)) {
+        if (isEmpty(tail(fields))) {
+            return FSharpResult$2_Ok<[Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>], string>(head(fields));
+        }
+        else {
+            return FSharpResult$2_Error<[Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>], string>(`Multiple fields found with label '${label}' across all steps`);
+        }
+    }
+    else {
+        return FSharpResult$2_Error<[Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>], string>(`No field found with label '${label}' in any step`);
+    }
+}
+
+/**
+ * Finds a form field by its FieldKey across all steps in a FormSpec.
+ */
+export function Helpers_FieldFinders_tryFindFieldByKey<UserField>(fieldKey: Shared_FieldKey, formSpec: Spec_FormSpec$1<UserField>): Option<Spec_FormField$1<UserField>> {
+    return tryFind<Spec_FormField$1<UserField>>((field: Spec_FormField$1<UserField>): boolean => equals(field.FieldKey, fieldKey), collect<Spec_FormStep$1<UserField>, Spec_FormField$1<UserField>>((step: Spec_FormStep$1<UserField>): FSharpList<Spec_FormField$1<UserField>> => step.Fields, formSpec.Steps));
+}
+
+/**
+ * Finds a form step by its step number.
+ */
+export function Helpers_FieldFinders_tryFindFormStepByStepNumber<UserField>(stepNumber: int32, formSpec: Spec_FormSpec$1<UserField>): Option<Spec_FormStep$1<UserField>> {
+    return tryFind<Spec_FormStep$1<UserField>>((step: Spec_FormStep$1<UserField>): boolean => (step.StepOrder === stepNumber), formSpec.Steps);
+}
+
+/**
+ * Finds a form field by its field order number within a specific step.
+ */
+export function Helpers_FieldFinders_tryFindFieldInSpec<UserField>(fieldNumber: int32, stepNumber: int32, formSpec: Spec_FormSpec$1<UserField>): Option<Spec_FormField$1<UserField>> {
+    const stepOpt: Option<Spec_FormStep$1<UserField>> = tryFind<Spec_FormStep$1<UserField>>((step: Spec_FormStep$1<UserField>): boolean => (step.StepOrder === stepNumber), formSpec.Steps);
+    if (stepOpt != null) {
+        const fieldOpt: Option<Spec_FormField$1<UserField>> = tryFind<Spec_FormField$1<UserField>>((field: Spec_FormField$1<UserField>): boolean => (field.FieldOrder === fieldNumber), value_1(stepOpt).Fields);
+        if (fieldOpt != null) {
+            return value_1(fieldOpt);
+        }
+        else {
+            return undefined;
+        }
+    }
+    else {
+        return undefined;
+    }
+}
+
+/**
+ * Gets all unique field labels from a FormSpec.
+ */
+export function Helpers_FieldFinders_getAllFieldNames<UserField>(formSpec: Spec_FormSpec$1<UserField>): FSharpList<string> {
+    return List_distinct<string>(map_1<Spec_FormField$1<UserField>, string>((field: Spec_FormField$1<UserField>): string => field.Label, collect<Spec_FormStep$1<UserField>, Spec_FormField$1<UserField>>((step: Spec_FormStep$1<UserField>): FSharpList<Spec_FormField$1<UserField>> => step.Fields, formSpec.Steps)), {
+        Equals: (x: string, y: string): boolean => (x === y),
+        GetHashCode: stringHash,
+    });
+}
+
+/**
+ * Gets all step names/identifiers from a FormSpec.
+ */
+export function Helpers_FieldFinders_getAllStepNames<UserField>(formSpec: Spec_FormSpec$1<UserField>): FSharpList<string> {
+    return map_1<Spec_FormStep$1<UserField>, string>((step: Spec_FormStep$1<UserField>): string => (`Step ${step.StepOrder}`), formSpec.Steps);
+}
+
+/**
+ * Converts a FieldType discriminated union to its string representation.
+ */
+export function Helpers_FieldTypeUtils_getFieldTypeName(fieldType: any): string {
+    if (fieldType instanceof Spec_FieldType) {
+        const ft = fieldType as Spec_FieldType_$union;
+        switch (ft.tag) {
+            case /* TextArea */ 1:
+                return "TextArea";
+            case /* Email */ 2:
+                return "Email";
+            case /* Password */ 3:
+                return "Password";
+            case /* Search */ 4:
+                return "Search";
+            case /* Color */ 5:
+                return "Color";
+            case /* Number */ 6:
+                return "Number";
+            case /* Tel */ 7:
+                return "Tel";
+            case /* Date */ 8:
+                return "Date";
+            case /* DateTimeLocal */ 9:
+                return "DateTimeLocal";
+            case /* Time */ 10:
+                return "Time";
+            case /* Checkbox */ 11:
+                return "Checkbox";
+            case /* Radio */ 12:
+                return "Radio";
+            case /* SingleChoice */ 13:
+                return "SingleChoice";
+            case /* Dropdown */ 14:
+                return "Dropdown";
+            case /* MultiChoice */ 15:
+                return "MultiChoice";
+            case /* CheckboxList */ 16:
+                return "CheckboxList";
+            case /* TagList */ 17:
+                return "TagList";
+            case /* TextAutoComplete */ 18:
+                return "TextAutoComplete";
+            case /* Matrix */ 19:
+                return "Matrix";
+            case /* Signature */ 20:
+                return "Signature";
+            case /* Message */ 21:
+                return "Message";
+            case /* PluginField */ 22:
+                return `PluginField(${ft.fields[0].PluginId})`;
+            default:
+                return "Text";
+        }
+    }
+    else {
+        return "Unknown";
+    }
+}
+
+/**
+ * Checks if two FieldType values match by discriminated union case name.
+ * This allows matching field types with different data content (e.g., Message fields with different Heading/Message).
+ */
+export function Helpers_FieldTypeUtils_fieldTypesMatchByCaseName(fieldType1: any, fieldType2: any): boolean {
+    let matchResult: int32, ft1: Spec_FieldType_$union, ft2: Spec_FieldType_$union;
+    if (fieldType1 instanceof Spec_FieldType) {
+        if (fieldType2 instanceof Spec_FieldType) {
+            matchResult = 0;
+            ft1 = (fieldType1 as Spec_FieldType_$union);
+            ft2 = (fieldType2 as Spec_FieldType_$union);
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            let matchResult_1: int32;
+            switch (ft1!.tag) {
+                case /* Message */ 21: {
+                    if (ft2!.tag === /* Message */ 21) {
+                        matchResult_1 = 0;
+                    }
+                    else {
+                        matchResult_1 = 10;
+                    }
+                    break;
+                }
+                case /* Matrix */ 19: {
+                    if (ft2!.tag === /* Matrix */ 19) {
+                        matchResult_1 = 1;
+                    }
+                    else {
+                        matchResult_1 = 10;
+                    }
+                    break;
+                }
+                case /* SingleChoice */ 13: {
+                    if (ft2!.tag === /* SingleChoice */ 13) {
+                        matchResult_1 = 2;
+                    }
+                    else {
+                        matchResult_1 = 10;
+                    }
+                    break;
+                }
+                case /* MultiChoice */ 15: {
+                    if (ft2!.tag === /* MultiChoice */ 15) {
+                        matchResult_1 = 3;
+                    }
+                    else {
+                        matchResult_1 = 10;
+                    }
+                    break;
+                }
+                case /* Radio */ 12: {
+                    if (ft2!.tag === /* Radio */ 12) {
+                        matchResult_1 = 4;
+                    }
+                    else {
+                        matchResult_1 = 10;
+                    }
+                    break;
+                }
+                case /* Dropdown */ 14: {
+                    if (ft2!.tag === /* Dropdown */ 14) {
+                        matchResult_1 = 5;
+                    }
+                    else {
+                        matchResult_1 = 10;
+                    }
+                    break;
+                }
+                case /* Checkbox */ 11: {
+                    if (ft2!.tag === /* Checkbox */ 11) {
+                        matchResult_1 = 6;
+                    }
+                    else {
+                        matchResult_1 = 10;
+                    }
+                    break;
+                }
+                case /* CheckboxList */ 16: {
+                    if (ft2!.tag === /* CheckboxList */ 16) {
+                        matchResult_1 = 7;
+                    }
+                    else {
+                        matchResult_1 = 10;
+                    }
+                    break;
+                }
+                case /* TagList */ 17: {
+                    if (ft2!.tag === /* TagList */ 17) {
+                        matchResult_1 = 8;
+                    }
+                    else {
+                        matchResult_1 = 10;
+                    }
+                    break;
+                }
+                case /* TextAutoComplete */ 18: {
+                    if (ft2!.tag === /* TextAutoComplete */ 18) {
+                        matchResult_1 = 9;
+                    }
+                    else {
+                        matchResult_1 = 10;
+                    }
+                    break;
+                }
+                default:
+                    matchResult_1 = 10;
+            }
+            switch (matchResult_1) {
+                case 0:
+                    return true;
+                case 1:
+                    return true;
+                case 2:
+                    return true;
+                case 3:
+                    return true;
+                case 4:
+                    return true;
+                case 5:
+                    return true;
+                case 6:
+                    return true;
+                case 7:
+                    return true;
+                case 8:
+                    return true;
+                case 9:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        default:
+            return false;
+    }
+}
+
+/**
+ * Updates a form field within a specific step in a FormSpec.
+ */
+export function Helpers_FormSpecMutators_updateFormFieldInFormSpecStep<UserField>(inField: Spec_FormField$1<UserField>, formStep: Spec_FormStep$1<UserField>, formSpec: Spec_FormSpec$1<UserField>): Spec_FormSpec$1<UserField> {
+    const outStep: Spec_FormStep$1<UserField> = new Spec_FormStep$1(formStep.StepOrder, formStep.StepLabel, map_1<Spec_FormField$1<UserField>, Spec_FormField$1<UserField>>((f: Spec_FormField$1<UserField>): Spec_FormField$1<UserField> => {
+        if (equals(f.FieldKey, inField.FieldKey)) {
+            return inField;
+        }
+        else {
+            return f;
+        }
+    }, formStep.Fields));
+    return new Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, map_1<Spec_FormStep$1<UserField>, Spec_FormStep$1<UserField>>((s: Spec_FormStep$1<UserField>): Spec_FormStep$1<UserField> => {
+        if (s.StepOrder === formStep.StepOrder) {
+            return outStep;
+        }
+        else {
+            return s;
+        }
+    }, formSpec.Steps), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+
+/**
+ * Updates a form step within a FormSpec.
+ */
+export function Helpers_FormSpecMutators_updateFormStepInFormSpec<UserField>(formStep: Spec_FormStep$1<UserField>, formSpec: Spec_FormSpec$1<UserField>): Spec_FormSpec$1<UserField> {
+    return new Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, map_1<Spec_FormStep$1<UserField>, Spec_FormStep$1<UserField>>((s: Spec_FormStep$1<UserField>): Spec_FormStep$1<UserField> => {
+        if (s.StepOrder === formStep.StepOrder) {
+            return formStep;
+        }
+        else {
+            return s;
+        }
+    }, formSpec.Steps), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+
+/**
+ * Adds a form field to a specific step in a FormSpec.
+ */
+export function Helpers_FormSpecMutators_addFormFieldToStep<UserField>(formStep: Spec_FormStep$1<UserField>, formSpec: Spec_FormSpec$1<UserField>, formField: Spec_FormField$1<UserField>): Spec_FormSpec$1<UserField> {
+    const outStep: Spec_FormStep$1<UserField> = new Spec_FormStep$1(formStep.StepOrder, formStep.StepLabel, append(formStep.Fields, singleton(formField)));
+    return new Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, map_1<Spec_FormStep$1<UserField>, Spec_FormStep$1<UserField>>((s: Spec_FormStep$1<UserField>): Spec_FormStep$1<UserField> => {
+        if (s.StepOrder === formStep.StepOrder) {
+            return outStep;
+        }
+        else {
+            return s;
+        }
+    }, formSpec.Steps), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+
+/**
+ * Removes a form field from a specific step in a FormSpec.
+ */
+export function Helpers_FormSpecMutators_removeFormFieldFromFormSpec<UserField>(formStepOrder: int32, formField: Spec_FormField$1<UserField>, formSpec: Spec_FormSpec$1<UserField>): Spec_FormSpec$1<UserField> {
+    return new Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, map_1<Spec_FormStep$1<UserField>, Spec_FormStep$1<UserField>>((s: Spec_FormStep$1<UserField>): Spec_FormStep$1<UserField> => {
+        if (s.StepOrder === formStepOrder) {
+            return new Spec_FormStep$1(s.StepOrder, s.StepLabel, mapIndexed<Spec_FormField$1<UserField>, Spec_FormField$1<UserField>>((i: int32, f_1: Spec_FormField$1<UserField>): Spec_FormField$1<UserField> => (new Spec_FormField$1(i + 1, f_1.FieldKey, f_1.Label, f_1.Notes, f_1.DependsOn, f_1.IsOptional, f_1.IsDeprecated, f_1.FieldType)), filter<Spec_FormField$1<UserField>>((f: Spec_FormField$1<UserField>): boolean => (f.FieldOrder !== formField.FieldOrder), s.Fields)));
+        }
+        else {
+            return s;
+        }
+    }, formSpec.Steps), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+
+/**
+ * Inserts a form field at a specific position within a step.
+ */
+export function Helpers_FormSpecMutators_insertFormFieldToStepAt<UserField>(formStep: Spec_FormStep$1<UserField>, newPositionFieldOrder: int32, fieldKey: Shared_FieldKey): FSharpList<Spec_FormField$1<UserField>> {
+    return mapIndexed<Spec_FormField$1<UserField>, Spec_FormField$1<UserField>>((index_1: int32, f_1: Spec_FormField$1<UserField>): Spec_FormField$1<UserField> => (new Spec_FormField$1(index_1 + 1, f_1.FieldKey, f_1.Label, f_1.Notes, f_1.DependsOn, f_1.IsOptional, f_1.IsDeprecated, f_1.FieldType)), insertAt<Spec_FormField$1<UserField>>(newPositionFieldOrder - 1, find<Spec_FormField$1<UserField>>((f: Spec_FormField$1<UserField>): boolean => equals(f.FieldKey, fieldKey), formStep.Fields), formStep.Fields));
+}
+
+/**
+ * Moves a form field up in order within a step.
+ */
+export function Helpers_FormSpecMutators_moveFormFieldUpInFormSpec<UserField>(formStepOrder: int32, formField: Spec_FormField$1<UserField>, formSpec: Spec_FormSpec$1<UserField>): Spec_FormSpec$1<UserField> {
+    return new Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, map_1<Spec_FormStep$1<UserField>, Spec_FormStep$1<UserField>>((s: Spec_FormStep$1<UserField>): Spec_FormStep$1<UserField> => {
+        if (s.StepOrder === formStepOrder) {
+            return new Spec_FormStep$1(s.StepOrder, s.StepLabel, mapIndexed<Spec_FormField$1<UserField>, Spec_FormField$1<UserField>>((index: int32, f_2: Spec_FormField$1<UserField>): Spec_FormField$1<UserField> => (new Spec_FormField$1(index + 1, f_2.FieldKey, f_2.Label, f_2.Notes, f_2.DependsOn, f_2.IsOptional, f_2.IsDeprecated, f_2.FieldType)), sortBy<Spec_FormField$1<UserField>, int32>((f_1: Spec_FormField$1<UserField>): int32 => f_1.FieldOrder, map_1<Spec_FormField$1<UserField>, Spec_FormField$1<UserField>>((f: Spec_FormField$1<UserField>): Spec_FormField$1<UserField> => {
+                if (f.FieldOrder === formField.FieldOrder) {
+                    return new Spec_FormField$1(formField.FieldOrder - 1, f.FieldKey, f.Label, f.Notes, f.DependsOn, f.IsOptional, f.IsDeprecated, f.FieldType);
+                }
+                else if (f.FieldOrder === (formField.FieldOrder - 1)) {
+                    return new Spec_FormField$1(formField.FieldOrder, f.FieldKey, f.Label, f.Notes, f.DependsOn, f.IsOptional, f.IsDeprecated, f.FieldType);
+                }
+                else {
+                    return f;
+                }
+            }, s.Fields), {
+                Compare: comparePrimitives,
+            })));
+        }
+        else {
+            return s;
+        }
+    }, formSpec.Steps), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+
+/**
+ * Moves a form field down in order within a step.
+ */
+export function Helpers_FormSpecMutators_moveFormFieldDownInFormSpec<UserField>(formStepOrder: int32, formField: Spec_FormField$1<UserField>, formSpec: Spec_FormSpec$1<UserField>): Spec_FormSpec$1<UserField> {
+    return new Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, map_1<Spec_FormStep$1<UserField>, Spec_FormStep$1<UserField>>((s: Spec_FormStep$1<UserField>): Spec_FormStep$1<UserField> => {
+        if (s.StepOrder === formStepOrder) {
+            return new Spec_FormStep$1(s.StepOrder, s.StepLabel, mapIndexed<Spec_FormField$1<UserField>, Spec_FormField$1<UserField>>((index: int32, f_2: Spec_FormField$1<UserField>): Spec_FormField$1<UserField> => (new Spec_FormField$1(index + 1, f_2.FieldKey, f_2.Label, f_2.Notes, f_2.DependsOn, f_2.IsOptional, f_2.IsDeprecated, f_2.FieldType)), sortBy<Spec_FormField$1<UserField>, int32>((f_1: Spec_FormField$1<UserField>): int32 => f_1.FieldOrder, map_1<Spec_FormField$1<UserField>, Spec_FormField$1<UserField>>((f: Spec_FormField$1<UserField>): Spec_FormField$1<UserField> => {
+                if (f.FieldOrder === formField.FieldOrder) {
+                    return new Spec_FormField$1(formField.FieldOrder + 1, f.FieldKey, f.Label, f.Notes, f.DependsOn, f.IsOptional, f.IsDeprecated, f.FieldType);
+                }
+                else if (f.FieldOrder === (formField.FieldOrder + 1)) {
+                    return new Spec_FormField$1(formField.FieldOrder, f.FieldKey, f.Label, f.Notes, f.DependsOn, f.IsOptional, f.IsDeprecated, f.FieldType);
+                }
+                else {
+                    return f;
+                }
+            }, s.Fields), {
+                Compare: comparePrimitives,
+            })));
+        }
+        else {
+            return s;
+        }
+    }, formSpec.Steps), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+
+/**
+ * Moves a form field to a specific position within a step by its FieldKey.
+ */
+export function Helpers_FormSpecMutators_moveFieldByKeyToPositionInFormStepSpec<UserField>(fieldKey: Shared_FieldKey, newPositionFieldOrder: int32, formStepOrder: int32, formSpec: Spec_FormSpec$1<UserField>): Spec_FormSpec$1<UserField> {
+    const formStep: Option<Spec_FormStep$1<UserField>> = Helpers_FieldFinders_tryFindFormStepByStepNumber<UserField>(formStepOrder, formSpec);
+    if (formStep != null) {
+        const formStep_1: Spec_FormStep$1<UserField> = value_1(formStep);
+        return new Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, map_1<Spec_FormStep$1<UserField>, Spec_FormStep$1<UserField>>((s: Spec_FormStep$1<UserField>): Spec_FormStep$1<UserField> => {
+            if (s.StepOrder === formStep_1.StepOrder) {
+                return new Spec_FormStep$1(s.StepOrder, s.StepLabel, mapIndexed<Spec_FormField$1<UserField>, Spec_FormField$1<UserField>>((index_1: int32, f_1: Spec_FormField$1<UserField>): Spec_FormField$1<UserField> => (new Spec_FormField$1(index_1 + 1, f_1.FieldKey, f_1.Label, f_1.Notes, f_1.DependsOn, f_1.IsOptional, f_1.IsDeprecated, f_1.FieldType)), List_distinct<Spec_FormField$1<UserField>>(insertAt<Spec_FormField$1<UserField>>(newPositionFieldOrder - 1, find<Spec_FormField$1<UserField>>((f: Spec_FormField$1<UserField>): boolean => equals(f.FieldKey, fieldKey), s.Fields), s.Fields), {
+                    Equals: equals,
+                    GetHashCode: safeHash,
+                })));
+            }
+            else {
+                return s;
+            }
+        }, formSpec.Steps), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+    }
+    else {
+        return formSpec;
+    }
+}
+
+/**
+ * Moves a form step up in order.
+ */
+export function Helpers_FormSpecMutators_moveFormStepUpInFormSpec<UserField>(formStepOrder: int32, formSpec: Spec_FormSpec$1<UserField>): Spec_FormSpec$1<UserField> {
+    return new Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, mapIndexed<Spec_FormStep$1<UserField>, Spec_FormStep$1<UserField>>((i: int32, s_1: Spec_FormStep$1<UserField>): Spec_FormStep$1<UserField> => (new Spec_FormStep$1(i + 1, s_1.StepLabel, s_1.Fields)), sortBy<Spec_FormStep$1<UserField>, int32>((s: Spec_FormStep$1<UserField>): int32 => s.StepOrder, map_1<Spec_FormStep$1<UserField>, Spec_FormStep$1<UserField>>((innerStep: Spec_FormStep$1<UserField>): Spec_FormStep$1<UserField> => {
+        if (innerStep.StepOrder === (formStepOrder - 1)) {
+            return new Spec_FormStep$1(formStepOrder + 1, innerStep.StepLabel, innerStep.Fields);
+        }
+        else if (innerStep.StepOrder === formStepOrder) {
+            return new Spec_FormStep$1(formStepOrder - 1, innerStep.StepLabel, innerStep.Fields);
+        }
+        else {
+            return innerStep;
+        }
+    }, formSpec.Steps), {
+        Compare: comparePrimitives,
+    })), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+
+/**
+ * Moves a form step down in order.
+ */
+export function Helpers_FormSpecMutators_moveFormStepDownInFormSpec<UserField>(formStepOrder: int32, formSpec: Spec_FormSpec$1<UserField>): Spec_FormSpec$1<UserField> {
+    return new Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, mapIndexed<Spec_FormStep$1<UserField>, Spec_FormStep$1<UserField>>((i: int32, s_1: Spec_FormStep$1<UserField>): Spec_FormStep$1<UserField> => (new Spec_FormStep$1(i + 1, s_1.StepLabel, s_1.Fields)), sortBy<Spec_FormStep$1<UserField>, int32>((s: Spec_FormStep$1<UserField>): int32 => s.StepOrder, map_1<Spec_FormStep$1<UserField>, Spec_FormStep$1<UserField>>((innerStep: Spec_FormStep$1<UserField>): Spec_FormStep$1<UserField> => {
+        if (innerStep.StepOrder === (formStepOrder + 1)) {
+            return new Spec_FormStep$1(formStepOrder - 1, innerStep.StepLabel, innerStep.Fields);
+        }
+        else if (innerStep.StepOrder === formStepOrder) {
+            return new Spec_FormStep$1(formStepOrder + 1, innerStep.StepLabel, innerStep.Fields);
+        }
+        else {
+            return innerStep;
+        }
+    }, formSpec.Steps), {
+        Compare: comparePrimitives,
+    })), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+
+/**
+ * Removes a form step from a FormSpec.
+ */
+export function Helpers_FormSpecMutators_removeFormStepFromFormSpec<UserField>(formStepOrder: int32, formSpec: Spec_FormSpec$1<UserField>): Spec_FormSpec$1<UserField> {
+    return new Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, mapIndexed<Spec_FormStep$1<UserField>, Spec_FormStep$1<UserField>>((i: int32, s_1: Spec_FormStep$1<UserField>): Spec_FormStep$1<UserField> => (new Spec_FormStep$1(i + 1, s_1.StepLabel, s_1.Fields)), filter<Spec_FormStep$1<UserField>>((s: Spec_FormStep$1<UserField>): boolean => (s.StepOrder !== formStepOrder), formSpec.Steps)), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+
+/**
+ * Flattens a multi-step FormSpec into a single step with all fields.
+ * Field orders are adjusted to be unique across all steps.
+ */
+export function Helpers_FormSpecTransformers_flattenSpecSteps<UserField>(formSpec: Spec_FormSpec$1<UserField>): Spec_FormSpec$1<UserField> {
+    const flatten = (steps_mut: FSharpList<Spec_FormStep$1<UserField>>, acc_mut: FSharpList<Spec_FormField$1<UserField>>): FSharpList<Spec_FormField$1<UserField>> => {
+        flatten:
+        while (true) {
+            const steps: FSharpList<Spec_FormStep$1<UserField>> = steps_mut, acc: FSharpList<Spec_FormField$1<UserField>> = acc_mut;
+            if (!isEmpty(steps)) {
+                const step: Spec_FormStep$1<UserField> = head(steps);
+                steps_mut = tail(steps);
+                acc_mut = append(acc, map_1<Spec_FormField$1<UserField>, Spec_FormField$1<UserField>>((field: Spec_FormField$1<UserField>): Spec_FormField$1<UserField> => (new Spec_FormField$1((step.StepOrder * 1000) + field.FieldOrder, field.FieldKey, field.Label, field.Notes, field.DependsOn, field.IsOptional, field.IsDeprecated, field.FieldType)), step.Fields));
+                continue flatten;
+            }
+            else {
+                return acc;
+            }
+            break;
+        }
+    };
+    return new Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, singleton(new Spec_FormStep$1(1, "Complete Form", flatten(formSpec.Steps, empty<Spec_FormField$1<UserField>>()))), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+
+/**
+ * Validates that all steps in a FormSpec have at least one field.
+ */
+export function Helpers_FormSpecValidators_allStepsHaveFields<UserField>(formSpec: Spec_FormSpec$1<UserField>): boolean {
+    return forAll<Spec_FormStep$1<UserField>>((step: Spec_FormStep$1<UserField>): boolean => !isEmpty(step.Fields), formSpec.Steps);
+}
+
+/**
+ * Checks if a FormSpec has a ClinicalPathway configured.
+ */
+export function Helpers_FormSpecValidators_hasClinicalPathway<UserField>(formSpec: Spec_FormSpec$1<UserField>): boolean {
+    return formSpec.ClinicalPathway != null;
+}
+
+export function Helpers_specFieldOptionsToValueOptions(options: FSharpList<Shared_FieldOption>): FSharpList<Shared_FieldOption> {
+    return map_1<Shared_FieldOption, Shared_FieldOption>((o: Shared_FieldOption): Shared_FieldOption => (new Shared_FieldOption(o.Description, o.Value, o.OptionKey)), options);
+}
+
+export function Helpers_optionsFromSpecField(field: Spec_FormField$1<Spec_FieldType_$union>): FSharpList<Shared_FieldOption> {
+    const matchValue: Spec_FieldType_$union = field.FieldType;
+    switch (matchValue.tag) {
+        case /* PluginField */ 22:
+            return empty<Shared_FieldOption>();
+        case /* CheckboxList */ 16:
+            return matchValue.fields[0].Options;
+        case /* MultiChoice */ 15:
+            return matchValue.fields[0].Options;
+        case /* TagList */ 17:
+            return matchValue.fields[0].Options;
+        case /* Dropdown */ 14:
+            return matchValue.fields[0].Options;
+        case /* Radio */ 12:
+            return matchValue.fields[0].Options;
+        case /* SingleChoice */ 13:
+            return matchValue.fields[0].Options;
+        case /* TextAutoComplete */ 18:
+            return matchValue.fields[0].Options;
+        case /* Matrix */ 19:
+            return matchValue.fields[0].Options;
+        default:
+            return empty<Shared_FieldOption>();
+    }
+}
+
+export function Helpers_readValue<FieldType>(field: Spec_FormField$1<FieldType>, values: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<FieldType>>): string {
+    const matchValue: Option<Shared_FieldKey> = tryFind_1<Shared_FieldKey>((k: Shared_FieldKey): boolean => equals(k, field.FieldKey), map_2<[Shared_FieldKey, Values_FieldDetails$1<FieldType>], Shared_FieldKey>((tuple: [Shared_FieldKey, Values_FieldDetails$1<FieldType>]): Shared_FieldKey => tuple[0], toSeq<Shared_FieldKey, Values_FieldDetails$1<FieldType>>(values)));
+    if (matchValue != null) {
+        const matchValue_1: Shared_FieldValue_$union = FSharpMap__get_Item(values, value_1(matchValue)).FieldValue;
+        if (matchValue_1.tag === /* Single */ 0) {
+            return matchValue_1.fields[0].Value;
+        }
+        else {
+            return "";
+        }
+    }
+    else {
+        return "";
+    }
+}
+
+export function Helpers_readManyValue<FieldType>(fieldKey: Shared_FieldKey, values: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<FieldType>>): FSharpSet<string> {
+    const matchValue: Option<Shared_FieldKey> = tryFind_1<Shared_FieldKey>((k: Shared_FieldKey): boolean => equals(k, fieldKey), map_2<[Shared_FieldKey, Values_FieldDetails$1<FieldType>], Shared_FieldKey>((tuple: [Shared_FieldKey, Values_FieldDetails$1<FieldType>]): Shared_FieldKey => tuple[0], toSeq<Shared_FieldKey, Values_FieldDetails$1<FieldType>>(values)));
+    if (matchValue != null) {
+        const matchValue_1: Shared_FieldValue_$union = FSharpMap__get_Item(values, value_1(matchValue)).FieldValue;
+        if (matchValue_1.tag === /* Multiple */ 1) {
+            return map_3<Shared_FieldAnswer, string>((v_1: Shared_FieldAnswer): string => v_1.Value, matchValue_1.fields[0], {
+                Compare: comparePrimitives,
+            });
+        }
+        else {
+            return empty_1<string>({
+                Compare: comparePrimitives,
+            });
+        }
+    }
+    else {
+        return empty_1<string>({
+            Compare: comparePrimitives,
+        });
+    }
+}
+
+export function Helpers_updateSingleFunc(formatter: ((arg0: string) => string), specField: Spec_FormField$1<Spec_FieldType_$union>, newValue: string, values: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>): FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>> {
+    let Value: string, matchValue: Option<Shared_FieldOption>;
+    const fieldOptions: FSharpList<Shared_FieldOption> = Helpers_optionsFromSpecField(specField);
+    const newFieldDetails: Values_FieldDetails$1<Spec_FieldType_$union> = new Values_FieldDetails$1(specField.FieldOrder, specField.FieldKey, specField.Label, Shared_FieldValue_Single((Value = formatter(newValue), new Shared_FieldAnswer(specField.FieldKey, (matchValue = tryFind<Shared_FieldOption>((o: Shared_FieldOption): boolean => (o.Value === newValue), fieldOptions), (matchValue == null) ? newValue : value_1(matchValue).Description), Value))), specField.FieldType, Helpers_specFieldOptionsToValueOptions(fieldOptions));
+    const matchValue_1: Option<Shared_FieldKey> = tryFind_1<Shared_FieldKey>((k: Shared_FieldKey): boolean => equals(k, newFieldDetails.Key), map_2<[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>>(values)));
+    if (matchValue_1 != null) {
+        const key: Shared_FieldKey = value_1(matchValue_1);
+        const f: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>> = FSharpMap__Remove(values, key);
+        return FSharpMap__Add(values, key, newFieldDetails);
+    }
+    else {
+        return FSharpMap__Add(values, newFieldDetails.Key, newFieldDetails);
+    }
+}
+
+export function Helpers_updateManyFunc(formatter: ((arg0: string) => string), specField: Spec_FormField$1<Spec_FieldType_$union>, newValue: FSharpSet<string>, values: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>): FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>> {
+    const newFieldDetails: Values_FieldDetails$1<Spec_FieldType_$union> = new Values_FieldDetails$1(specField.FieldOrder, specField.FieldKey, specField.Label, Shared_FieldValue_Multiple(map_3<string, Shared_FieldAnswer>((v: string): Shared_FieldAnswer => {
+        let matchValue: Option<Shared_FieldOption>;
+        const Value: string = formatter(v);
+        return new Shared_FieldAnswer(specField.FieldKey, (matchValue = tryFind<Shared_FieldOption>((o: Shared_FieldOption): boolean => (o.Value === v), Helpers_optionsFromSpecField(specField)), (matchValue == null) ? v : value_1(matchValue).Description), Value);
+    }, newValue, {
+        Compare: compare,
+    })), specField.FieldType, Helpers_specFieldOptionsToValueOptions(Helpers_optionsFromSpecField(specField)));
+    const matchValue_1: Option<Shared_FieldKey> = tryFind_1<Shared_FieldKey>((k: Shared_FieldKey): boolean => equals(k, newFieldDetails.Key), map_2<[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>>(values)));
+    if (matchValue_1 != null) {
+        const key: Shared_FieldKey = value_1(matchValue_1);
+        return FSharpMap__Add(FSharpMap__Remove(values, newFieldDetails.Key), newFieldDetails.Key, newFieldDetails);
+    }
+    else {
+        return FSharpMap__Add(values, newFieldDetails.Key, newFieldDetails);
+    }
+}
+
+/**
+ * It adds OR updates a form field's value based on its type
+ * Returns the updated DynamicStepValues
+ */
+export function Helpers_updateFormFieldValue(field: Spec_FormField$1<Spec_FieldType_$union>, newValue: any, values: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>): FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>> {
+    const newFieldDetails: Values_FieldDetails$1<Spec_FieldType_$union> = new Values_FieldDetails$1(field.FieldOrder, field.FieldKey, field.Label, (() => {
+        throw new Error("updateFormFieldValue: Field type handling not implemented.");
+    })(), field.FieldType, Helpers_specFieldOptionsToValueOptions(Helpers_optionsFromSpecField(field)));
+    const matchValue_1: Option<Shared_FieldKey> = tryFind_1<Shared_FieldKey>((k: Shared_FieldKey): boolean => equals(k, newFieldDetails.Key), map_2<[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>>(values)));
+    if (matchValue_1 != null) {
+        const key: Shared_FieldKey = value_1(matchValue_1);
+        return FSharpMap__Add(FSharpMap__Remove(values, key), key, newFieldDetails);
+    }
+    else {
+        return FSharpMap__Add(values, newFieldDetails.Key, newFieldDetails);
+    }
+}
+
+/**
+ * Updates a form's values with a new field value
+ * Returns the updated form
+ */
+export function Helpers_updateFormValuesWithField<T>(fieldKeyAndValue_: Shared_FieldKey, fieldKeyAndValue__1: Values_FieldDetails$1<Spec_FieldType_$union>, form: T, getSteps: ((arg0: T) => FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>), setSteps: ((arg0: FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>, arg1: T) => T)): T {
+    let patternInput: [FSharpList<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>, FSharpList<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>];
+    const fieldKeyAndValue = [fieldKeyAndValue_, fieldKeyAndValue__1] as [Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>];
+    let stepOrderResult: FSharpResult$2_$union<Values_StepOrder, string>;
+    const filteredFormSteps: FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>> = filter_1<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>((_arg: Values_StepOrder, fieldValues: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>): boolean => FSharpMap__ContainsKey(fieldValues, fieldKeyAndValue[0]), getSteps(form));
+    stepOrderResult = (FSharpMap__get_IsEmpty(filteredFormSteps) ? FSharpResult$2_Error<Values_StepOrder, string>("No fields found") : ((FSharpMap__get_Count(filteredFormSteps) > 1) ? FSharpResult$2_Error<Values_StepOrder, string>("More than one field found") : FSharpResult$2_Ok<Values_StepOrder, string>(head<[Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]>(toList<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>(filteredFormSteps))[0])));
+    if (stepOrderResult.tag === /* Ok */ 0) {
+        const stepOrd: Values_StepOrder = stepOrderResult.fields[0];
+        const foundStepValues: FSharpList<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]> = toList<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>(FSharpMap__get_Item(getSteps(form), stepOrd));
+        const foundField: Option<int32> = tryFindIndex<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>((tupledArg_1: [Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]): boolean => equals(tupledArg_1[0], fieldKeyAndValue[0]), foundStepValues);
+        const dynamicStepValues: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>> = ofList<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>(append<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>(singleton(fieldKeyAndValue), (foundField == null) ? foundStepValues : ((patternInput = splitAt<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>(value_1(foundField), foundStepValues), append(patternInput[0], tail<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>(patternInput[1]))))), {
+            Compare: compare,
+        });
+        return setSteps(FSharpMap__Change(getSteps(form), stepOrd, (_arg_3: Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>): Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>> => dynamicStepValues), form);
+    }
+    else {
+        toConsole(`ERROR updating value: ${stepOrderResult.fields[0]}`);
+        return form;
+    }
+}
+
+/**
+ * Finds and updates a form field's value by its label string in a specific step
+ * Returns Ok with the updated form if successful, Error otherwise
+ */
+export function Helpers_findAndUpdateFormField<T>(label: string, stepNumber: int32, newValue: any, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>, form: T, getSteps: ((arg0: T) => FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>), setSteps: ((arg0: FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>, arg1: T) => T)): FSharpResult$2_$union<T, string> {
+    return Result_Map<[Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>], T, string>((tupledArg: [Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>]): T => {
+        const field: Spec_FormField$1<Spec_FieldType_$union> = tupledArg[1];
+        const fieldKeyAndValue = [field.FieldKey, FSharpMap__get_Item(Helpers_updateFormFieldValue(field, newValue, FSharpMap__get_Item(getSteps(form), new Values_StepOrder(tupledArg[0].StepOrder))), field.FieldKey)] as [Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>];
+        return Helpers_updateFormValuesWithField<T>(fieldKeyAndValue[0], fieldKeyAndValue[1], form, getSteps, setSteps);
+    }, Helpers_FieldFinders_findUniqueFormFieldInStepByLabelString<Spec_FieldType_$union>(label, stepNumber, formSpec));
+}
+
+/**
+ * Finds and updates a form field's value by its label string across all steps
+ * Returns Ok with the updated form if successful, Error otherwise
+ */
+export function Helpers_findAndUpdateFormFieldInAnyStep<T>(label: string, newValue: any, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>, form: T, getSteps: ((arg0: T) => FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>), setSteps: ((arg0: FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>, arg1: T) => T)): FSharpResult$2_$union<T, string> {
+    return Result_Map<[Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>], T, string>((tupledArg: [Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>]): T => {
+        const field: Spec_FormField$1<Spec_FieldType_$union> = tupledArg[1];
+        const fieldKeyAndValue = [field.FieldKey, FSharpMap__get_Item(Helpers_updateFormFieldValue(field, newValue, FSharpMap__get_Item(getSteps(form), new Values_StepOrder(tupledArg[0].StepOrder))), field.FieldKey)] as [Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>];
+        return Helpers_updateFormValuesWithField<T>(fieldKeyAndValue[0], fieldKeyAndValue[1], form, getSteps, setSteps);
+    }, Helpers_FieldFinders_findUniqueFormFieldInFormByLabelString<Spec_FieldType_$union>(label, formSpec));
+}
+
+//# sourceMappingURL=Helpers.ts.map