@f1studio/form-spec 5.0.0-alpha.101

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

@@ -0,0 +1,1214 @@
+import { FSharpRef, Record } from "@fable-org/fable-library-js/Types.js";
+import { Converters_scoreFromTS, Converters_scoreToTS, Converters_fieldOptionFromTS, Converters_fieldTypeFromTS, Converters_fieldOptionToTS, Converters_fieldTypeToTS, Converters_fieldKeyFromTS, Converters_fieldKeyToTS, Types_ScoreTS_$reflection, Types_ScoreTS, Types_FieldOptionTS_$reflection, Types_FieldTypeTS_$reflection, Types_FieldOptionTS, Types_FieldTypeTS, Types_MatrixItemKeyTS_$reflection, Types_MatrixItemKeyTS, Types_FieldKeyTS_$reflection, Types_FieldKeyTS } from "./FormSpec.Api.Option.js";
+import { uncurry2, comparePrimitives, compare, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { obj_type, bool_type, enum_type, int32_type, option_type, array_type, tuple_type, record_type, string_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { some, map as map_3, value as value_2, Option } from "@fable-org/fable-library-js/Option.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { Values_DynamicFormResultData$1, Values_DynamicForm$1, Values_StepOrder, Values_DynamicFormSpecDetails, Spec_Score, Values_Signature, Values_SignatureType_Approval, Values_SignatureType_Review, Values_SignatureType_$union, Values_FormStatus_Complete, Values_FormStatus_WaitingForApproval, Values_FormStatus_WaitingForReview, Values_FormStatus_Draft, Values_FormStatus_Pending, Values_FormStatus_$union, Spec_FieldType_$union, Values_FieldDetails$1, Shared_FieldOption, Shared_FieldValue_Matrix, Shared_FieldValue_Multiple, Shared_FieldValue_Single, Shared_FieldValue_$union, Shared_PluginDataProperty, Shared_MatrixAnswer, Shared_MatrixItemKey, Shared_FieldKey, Shared_FieldAnswer } from "../FormSpec.js";
+import { fold as fold_1, reverse, empty as empty_2, cons, FSharpList, map as map_1, toArray } from "@fable-org/fable-library-js/List.js";
+import { empty, add, FSharpMap, toList } from "@fable-org/fable-library-js/Map.js";
+import { fold, map as map_2 } from "@fable-org/fable-library-js/Array.js";
+import { tryParse } from "@fable-org/fable-library-js/Guid.js";
+import { ofArray, empty as empty_1, add as add_1, FSharpSet, toList as toList_1 } from "@fable-org/fable-library-js/Set.js";
+import { tryParse as tryParse_1, minValue, toString } from "@fable-org/fable-library-js/Date.js";
+import { Auto_generateBoxedEncoder_437914C6, toString as toString_1 } from "../fable_modules/Thoth.Json.10.4.1/Encode.fs.js";
+import { FSharpResult$2_$union, Result_ToOption } from "@fable-org/fable-library-js/Result.js";
+import { Auto_generateBoxedDecoder_Z6670B51, fromString } from "../fable_modules/Thoth.Json.10.4.1/Decode.fs.js";
+
+export class ValuesTypes_FieldAnswerTS extends Record implements IEquatable<ValuesTypes_FieldAnswerTS>, IComparable<ValuesTypes_FieldAnswerTS> {
+    readonly FieldKey: Types_FieldKeyTS;
+    readonly Description: string;
+    readonly Value: string;
+    constructor(FieldKey: Types_FieldKeyTS, Description: string, Value: string) {
+        super();
+        this.FieldKey = FieldKey;
+        this.Description = Description;
+        this.Value = Value;
+    }
+}
+
+export function ValuesTypes_FieldAnswerTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.FieldAnswerTS", [], ValuesTypes_FieldAnswerTS, () => [["FieldKey", Types_FieldKeyTS_$reflection()], ["Description", string_type], ["Value", string_type]]);
+}
+
+export class ValuesTypes_MatrixAnswerTS extends Record implements IEquatable<ValuesTypes_MatrixAnswerTS>, IComparable<ValuesTypes_MatrixAnswerTS> {
+    readonly FieldKey: Types_FieldKeyTS;
+    readonly Description: string;
+    readonly Values: [Types_MatrixItemKeyTS, string][];
+    constructor(FieldKey: Types_FieldKeyTS, Description: string, Values: [Types_MatrixItemKeyTS, string][]) {
+        super();
+        this.FieldKey = FieldKey;
+        this.Description = Description;
+        this.Values = Values;
+    }
+}
+
+export function ValuesTypes_MatrixAnswerTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.MatrixAnswerTS", [], ValuesTypes_MatrixAnswerTS, () => [["FieldKey", Types_FieldKeyTS_$reflection()], ["Description", string_type], ["Values", array_type(tuple_type(Types_MatrixItemKeyTS_$reflection(), string_type))]]);
+}
+
+export class ValuesTypes_FieldValueTS extends Record implements IEquatable<ValuesTypes_FieldValueTS>, IComparable<ValuesTypes_FieldValueTS> {
+    readonly Type: string;
+    readonly FieldAnswer: Option<ValuesTypes_FieldAnswerTS>;
+    readonly FieldAnswers: Option<ValuesTypes_FieldAnswerTS[]>;
+    readonly MatrixAnswer: Option<ValuesTypes_MatrixAnswerTS>;
+    constructor(Type: string, FieldAnswer: Option<ValuesTypes_FieldAnswerTS>, FieldAnswers: Option<ValuesTypes_FieldAnswerTS[]>, MatrixAnswer: Option<ValuesTypes_MatrixAnswerTS>) {
+        super();
+        this.Type = Type;
+        this.FieldAnswer = FieldAnswer;
+        this.FieldAnswers = FieldAnswers;
+        this.MatrixAnswer = MatrixAnswer;
+    }
+}
+
+export function ValuesTypes_FieldValueTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.FieldValueTS", [], ValuesTypes_FieldValueTS, () => [["Type", string_type], ["FieldAnswer", option_type(ValuesTypes_FieldAnswerTS_$reflection())], ["FieldAnswers", option_type(array_type(ValuesTypes_FieldAnswerTS_$reflection()))], ["MatrixAnswer", option_type(ValuesTypes_MatrixAnswerTS_$reflection())]]);
+}
+
+export class ValuesTypes_FieldDetailsTS extends Record implements IEquatable<ValuesTypes_FieldDetailsTS>, IComparable<ValuesTypes_FieldDetailsTS> {
+    readonly FieldOrder: int32;
+    readonly Key: Types_FieldKeyTS;
+    readonly Label: string;
+    readonly FieldValue: ValuesTypes_FieldValueTS;
+    readonly FieldType: Types_FieldTypeTS;
+    readonly Options: Types_FieldOptionTS[];
+    constructor(FieldOrder: int32, Key: Types_FieldKeyTS, Label: string, FieldValue: ValuesTypes_FieldValueTS, FieldType: Types_FieldTypeTS, Options: Types_FieldOptionTS[]) {
+        super();
+        this.FieldOrder = (FieldOrder | 0);
+        this.Key = Key;
+        this.Label = Label;
+        this.FieldValue = FieldValue;
+        this.FieldType = FieldType;
+        this.Options = Options;
+    }
+}
+
+export function ValuesTypes_FieldDetailsTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.FieldDetailsTS", [], ValuesTypes_FieldDetailsTS, () => [["FieldOrder", int32_type], ["Key", Types_FieldKeyTS_$reflection()], ["Label", string_type], ["FieldValue", ValuesTypes_FieldValueTS_$reflection()], ["FieldType", Types_FieldTypeTS_$reflection()], ["Options", array_type(Types_FieldOptionTS_$reflection())]]);
+}
+
+export class ValuesTypes_FormStatusTS extends Record implements IEquatable<ValuesTypes_FormStatusTS>, IComparable<ValuesTypes_FormStatusTS> {
+    readonly Type: string;
+    readonly DraftId: Option<string>;
+    constructor(Type: string, DraftId: Option<string>) {
+        super();
+        this.Type = Type;
+        this.DraftId = DraftId;
+    }
+}
+
+export function ValuesTypes_FormStatusTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.FormStatusTS", [], ValuesTypes_FormStatusTS, () => [["Type", string_type], ["DraftId", option_type(string_type)]]);
+}
+
+export class ValuesTypes_SignatureTS extends Record implements IEquatable<ValuesTypes_SignatureTS>, IComparable<ValuesTypes_SignatureTS> {
+    readonly ApprovedById: string;
+    readonly ApprovedByFullName: string;
+    readonly ApprovedByDate: string;
+    readonly ApprovalSignature: string;
+    readonly SignatureType: int32;
+    constructor(ApprovedById: string, ApprovedByFullName: string, ApprovedByDate: string, ApprovalSignature: string, SignatureType: int32) {
+        super();
+        this.ApprovedById = ApprovedById;
+        this.ApprovedByFullName = ApprovedByFullName;
+        this.ApprovedByDate = ApprovedByDate;
+        this.ApprovalSignature = ApprovalSignature;
+        this.SignatureType = (SignatureType | 0);
+    }
+}
+
+export function ValuesTypes_SignatureTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.SignatureTS", [], ValuesTypes_SignatureTS, () => [["ApprovedById", string_type], ["ApprovedByFullName", string_type], ["ApprovedByDate", string_type], ["ApprovalSignature", string_type], ["SignatureType", enum_type("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.SignatureTypeTS", int32_type, [["Review", 0], ["Approval", 1]])]]);
+}
+
+export class ValuesTypes_DynamicFormSpecDetailsTS extends Record implements IEquatable<ValuesTypes_DynamicFormSpecDetailsTS>, IComparable<ValuesTypes_DynamicFormSpecDetailsTS> {
+    readonly FormSpecId: string;
+    readonly FormSpecCode: Option<string>;
+    readonly FormSpecVersion: string;
+    readonly DynamicVersion: string;
+    readonly MaxScore: Option<Types_ScoreTS>;
+    readonly Status: ValuesTypes_FormStatusTS;
+    readonly Signatures: ValuesTypes_SignatureTS[];
+    constructor(FormSpecId: string, FormSpecCode: Option<string>, FormSpecVersion: string, DynamicVersion: string, MaxScore: Option<Types_ScoreTS>, Status: ValuesTypes_FormStatusTS, Signatures: ValuesTypes_SignatureTS[]) {
+        super();
+        this.FormSpecId = FormSpecId;
+        this.FormSpecCode = FormSpecCode;
+        this.FormSpecVersion = FormSpecVersion;
+        this.DynamicVersion = DynamicVersion;
+        this.MaxScore = MaxScore;
+        this.Status = Status;
+        this.Signatures = Signatures;
+    }
+}
+
+export function ValuesTypes_DynamicFormSpecDetailsTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.DynamicFormSpecDetailsTS", [], ValuesTypes_DynamicFormSpecDetailsTS, () => [["FormSpecId", string_type], ["FormSpecCode", option_type(string_type)], ["FormSpecVersion", string_type], ["DynamicVersion", string_type], ["MaxScore", option_type(Types_ScoreTS_$reflection())], ["Status", ValuesTypes_FormStatusTS_$reflection()], ["Signatures", array_type(ValuesTypes_SignatureTS_$reflection())]]);
+}
+
+export class ValuesTypes_FableFormStateTS extends Record implements IEquatable<ValuesTypes_FableFormStateTS>, IComparable<ValuesTypes_FableFormStateTS> {
+    readonly Type: string;
+    readonly Error: Option<string>;
+    readonly Success: Option<string>;
+    constructor(Type: string, Error$: Option<string>, Success: Option<string>) {
+        super();
+        this.Type = Type;
+        this.Error = Error$;
+        this.Success = Success;
+    }
+}
+
+export function ValuesTypes_FableFormStateTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.FableFormStateTS", [], ValuesTypes_FableFormStateTS, () => [["Type", string_type], ["Error", option_type(string_type)], ["Success", option_type(string_type)]]);
+}
+
+export class ValuesTypes_ErrorTrackingTS extends Record implements IEquatable<ValuesTypes_ErrorTrackingTS>, IComparable<ValuesTypes_ErrorTrackingTS> {
+    readonly Type: string;
+    readonly ShowAllErrors: boolean;
+    readonly ShowFieldError: string[];
+    constructor(Type: string, ShowAllErrors: boolean, ShowFieldError: string[]) {
+        super();
+        this.Type = Type;
+        this.ShowAllErrors = ShowAllErrors;
+        this.ShowFieldError = ShowFieldError;
+    }
+}
+
+export function ValuesTypes_ErrorTrackingTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.ErrorTrackingTS", [], ValuesTypes_ErrorTrackingTS, () => [["Type", string_type], ["ShowAllErrors", bool_type], ["ShowFieldError", array_type(string_type)]]);
+}
+
+export class ValuesTypes_FableFormModelTS extends Record implements IEquatable<ValuesTypes_FableFormModelTS>, IComparable<ValuesTypes_FableFormModelTS> {
+    readonly Values: [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][];
+    readonly State: ValuesTypes_FableFormStateTS;
+    readonly ErrorTracking: ValuesTypes_ErrorTrackingTS;
+    constructor(Values: [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][], State: ValuesTypes_FableFormStateTS, ErrorTracking: ValuesTypes_ErrorTrackingTS) {
+        super();
+        this.Values = Values;
+        this.State = State;
+        this.ErrorTracking = ErrorTracking;
+    }
+}
+
+export function ValuesTypes_FableFormModelTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.FableFormModelTS", [], ValuesTypes_FableFormModelTS, () => [["Values", array_type(tuple_type(Types_FieldKeyTS_$reflection(), ValuesTypes_FieldDetailsTS_$reflection()))], ["State", ValuesTypes_FableFormStateTS_$reflection()], ["ErrorTracking", ValuesTypes_ErrorTrackingTS_$reflection()]]);
+}
+
+export class ValuesTypes_DynamicFormTS extends Record implements IEquatable<ValuesTypes_DynamicFormTS>, IComparable<ValuesTypes_DynamicFormTS> {
+    readonly DynamicFormSpecDetails: ValuesTypes_DynamicFormSpecDetailsTS;
+    readonly Steps: [int32, ValuesTypes_FableFormModelTS][];
+    constructor(DynamicFormSpecDetails: ValuesTypes_DynamicFormSpecDetailsTS, Steps: [int32, ValuesTypes_FableFormModelTS][]) {
+        super();
+        this.DynamicFormSpecDetails = DynamicFormSpecDetails;
+        this.Steps = Steps;
+    }
+}
+
+export function ValuesTypes_DynamicFormTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.DynamicFormTS", [], ValuesTypes_DynamicFormTS, () => [["DynamicFormSpecDetails", ValuesTypes_DynamicFormSpecDetailsTS_$reflection()], ["Steps", array_type(tuple_type(int32_type, ValuesTypes_FableFormModelTS_$reflection()))]]);
+}
+
+export class ValuesTypes_DynamicFormResultDataTS extends Record implements IEquatable<ValuesTypes_DynamicFormResultDataTS>, IComparable<ValuesTypes_DynamicFormResultDataTS> {
+    readonly ResultFormSpecDetails: ValuesTypes_DynamicFormSpecDetailsTS;
+    readonly ResultSteps: [int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]][];
+    constructor(ResultFormSpecDetails: ValuesTypes_DynamicFormSpecDetailsTS, ResultSteps: [int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]][]) {
+        super();
+        this.ResultFormSpecDetails = ResultFormSpecDetails;
+        this.ResultSteps = ResultSteps;
+    }
+}
+
+export function ValuesTypes_DynamicFormResultDataTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.DynamicFormResultDataTS", [], ValuesTypes_DynamicFormResultDataTS, () => [["ResultFormSpecDetails", ValuesTypes_DynamicFormSpecDetailsTS_$reflection()], ["ResultSteps", array_type(tuple_type(int32_type, array_type(tuple_type(Types_FieldKeyTS_$reflection(), ValuesTypes_FieldDetailsTS_$reflection()))))]]);
+}
+
+/**
+ * Convert F# FieldAnswer to TypeScript representation
+ */
+export function ValuesConverters_fieldAnswerToTS(answer: Shared_FieldAnswer): ValuesTypes_FieldAnswerTS {
+    return new ValuesTypes_FieldAnswerTS(Converters_fieldKeyToTS(answer.FieldKey), answer.Description, answer.Value);
+}
+
+/**
+ * Convert TypeScript FieldAnswer to F# representation
+ */
+export function ValuesConverters_fieldAnswerFromTS(answer: ValuesTypes_FieldAnswerTS): Option<Shared_FieldAnswer> {
+    const matchValue: Option<Shared_FieldKey> = Converters_fieldKeyFromTS(answer.FieldKey);
+    if (matchValue == null) {
+        return undefined;
+    }
+    else {
+        return new Shared_FieldAnswer(value_2(matchValue), answer.Description, answer.Value);
+    }
+}
+
+/**
+ * Convert F# MatrixAnswer to TypeScript representation
+ */
+export function ValuesConverters_matrixAnswerToTS(answer: Shared_MatrixAnswer): ValuesTypes_MatrixAnswerTS {
+    return new ValuesTypes_MatrixAnswerTS(Converters_fieldKeyToTS(answer.FieldKey), answer.Description, toArray<[Types_MatrixItemKeyTS, string]>(map_1<[Shared_MatrixItemKey, string], [Types_MatrixItemKeyTS, string]>((tupledArg: [Shared_MatrixItemKey, string]): [Types_MatrixItemKeyTS, string] => ([new Types_MatrixItemKeyTS(tupledArg[0].fields[0]), tupledArg[1]] as [Types_MatrixItemKeyTS, string]), toList<Shared_MatrixItemKey, string>(answer.Values))));
+}
+
+/**
+ * Convert TypeScript MatrixAnswer to F# representation
+ */
+export function ValuesConverters_matrixAnswerFromTS(answer: ValuesTypes_MatrixAnswerTS): Option<Shared_MatrixAnswer> {
+    const matchValue: Option<Shared_FieldKey> = Converters_fieldKeyFromTS(answer.FieldKey);
+    if (matchValue == null) {
+        return undefined;
+    }
+    else {
+        const fieldKey: Shared_FieldKey = value_2(matchValue);
+        let valuesMap: Option<FSharpMap<Shared_MatrixItemKey, string>>;
+        const array_1: Option<[Shared_MatrixItemKey, string]>[] = map_2<[Types_MatrixItemKeyTS, string], Option<[Shared_MatrixItemKey, string]>>((tupledArg: [Types_MatrixItemKeyTS, string]): Option<[Shared_MatrixItemKey, string]> => {
+            let matchValue_1: [boolean, string];
+            let outArg = "00000000-0000-0000-0000-000000000000";
+            matchValue_1 = ([tryParse(tupledArg[0].Value, new FSharpRef<string>((): string => outArg, (v: string): void => {
+                outArg = v;
+            })), outArg] as [boolean, string]);
+            if (matchValue_1[0]) {
+                return [new Shared_MatrixItemKey(matchValue_1[1]), tupledArg[1]] as [Shared_MatrixItemKey, string];
+            }
+            else {
+                return undefined;
+            }
+        }, answer.Values);
+        valuesMap = fold<Option<[Shared_MatrixItemKey, string]>, Option<FSharpMap<Shared_MatrixItemKey, string>>>((acc: Option<FSharpMap<Shared_MatrixItemKey, string>>, item: Option<[Shared_MatrixItemKey, string]>): Option<FSharpMap<Shared_MatrixItemKey, string>> => {
+            let matchResult: int32, key: Shared_MatrixItemKey, map: FSharpMap<Shared_MatrixItemKey, string>, value_1: string;
+            if (acc != null) {
+                if (item != null) {
+                    matchResult = 0;
+                    key = value_2(item)[0];
+                    map = value_2(acc);
+                    value_1 = value_2(item)[1];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0:
+                    return add<Shared_MatrixItemKey, string>(key!, value_1!, map!);
+                default:
+                    return undefined;
+            }
+        }, empty<Shared_MatrixItemKey, string>({
+            Compare: compare,
+        }), array_1);
+        if (valuesMap == null) {
+            return undefined;
+        }
+        else {
+            return new Shared_MatrixAnswer(fieldKey, answer.Description, value_2(valuesMap));
+        }
+    }
+}
+
+/**
+ * Convert F# FieldValue to TypeScript representation
+ */
+export function ValuesConverters_fieldValueToTS(value: Shared_FieldValue_$union): ValuesTypes_FieldValueTS {
+    switch (value.tag) {
+        case /* Multiple */ 1:
+            return new ValuesTypes_FieldValueTS("Multiple", undefined, toArray<ValuesTypes_FieldAnswerTS>(map_1<Shared_FieldAnswer, ValuesTypes_FieldAnswerTS>(ValuesConverters_fieldAnswerToTS, toList_1<Shared_FieldAnswer>(value.fields[0]))), undefined);
+        case /* Matrix */ 2:
+            return new ValuesTypes_FieldValueTS("Matrix", undefined, undefined, ValuesConverters_matrixAnswerToTS(value.fields[0]));
+        case /* PluginData */ 3: {
+            const pluginData: FSharpList<Shared_PluginDataProperty> = value.fields[0];
+            return new ValuesTypes_FieldValueTS("PluginData", undefined, undefined, undefined);
+        }
+        default:
+            return new ValuesTypes_FieldValueTS("Single", ValuesConverters_fieldAnswerToTS(value.fields[0]), undefined, undefined);
+    }
+}
+
+/**
+ * Convert TypeScript FieldValue to F# representation
+ */
+export function ValuesConverters_fieldValueFromTS(value: ValuesTypes_FieldValueTS): Option<Shared_FieldValue_$union> {
+    const matchValue: string = value.Type;
+    switch (matchValue) {
+        case "Single": {
+            const matchValue_1: Option<ValuesTypes_FieldAnswerTS> = value.FieldAnswer;
+            if (matchValue_1 == null) {
+                return undefined;
+            }
+            else {
+                const matchValue_2: Option<Shared_FieldAnswer> = ValuesConverters_fieldAnswerFromTS(value_2(matchValue_1));
+                if (matchValue_2 == null) {
+                    return undefined;
+                }
+                else {
+                    return Shared_FieldValue_Single(value_2(matchValue_2));
+                }
+            }
+        }
+        case "Multiple": {
+            const matchValue_3: Option<ValuesTypes_FieldAnswerTS[]> = value.FieldAnswers;
+            if (matchValue_3 == null) {
+                return undefined;
+            }
+            else {
+                let convertedAnswers: Option<FSharpSet<Shared_FieldAnswer>>;
+                const array_1: Option<Shared_FieldAnswer>[] = map_2<ValuesTypes_FieldAnswerTS, Option<Shared_FieldAnswer>>(ValuesConverters_fieldAnswerFromTS, value_2(matchValue_3));
+                convertedAnswers = fold<Option<Shared_FieldAnswer>, Option<FSharpSet<Shared_FieldAnswer>>>((acc: Option<FSharpSet<Shared_FieldAnswer>>, answer_2: Option<Shared_FieldAnswer>): Option<FSharpSet<Shared_FieldAnswer>> => {
+                    let matchResult: int32, item: Shared_FieldAnswer, set$: FSharpSet<Shared_FieldAnswer>;
+                    if (acc != null) {
+                        if (answer_2 != null) {
+                            matchResult = 0;
+                            item = value_2(answer_2);
+                            set$ = value_2(acc);
+                        }
+                        else {
+                            matchResult = 1;
+                        }
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                    switch (matchResult) {
+                        case 0:
+                            return add_1<Shared_FieldAnswer>(item!, set$!);
+                        default:
+                            return undefined;
+                    }
+                }, empty_1<Shared_FieldAnswer>({
+                    Compare: compare,
+                }), array_1);
+                if (convertedAnswers == null) {
+                    return undefined;
+                }
+                else {
+                    return Shared_FieldValue_Multiple(value_2(convertedAnswers));
+                }
+            }
+        }
+        case "Matrix": {
+            const matchValue_5: Option<ValuesTypes_MatrixAnswerTS> = value.MatrixAnswer;
+            if (matchValue_5 == null) {
+                return undefined;
+            }
+            else {
+                const matchValue_6: Option<Shared_MatrixAnswer> = ValuesConverters_matrixAnswerFromTS(value_2(matchValue_5));
+                if (matchValue_6 == null) {
+                    return undefined;
+                }
+                else {
+                    return Shared_FieldValue_Matrix(value_2(matchValue_6));
+                }
+            }
+        }
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Convert F# FieldDetails to TypeScript representation
+ */
+export function ValuesConverters_fieldDetailsToTS(details: Values_FieldDetails$1<Spec_FieldType_$union>): ValuesTypes_FieldDetailsTS {
+    return new ValuesTypes_FieldDetailsTS(details.FieldOrder, Converters_fieldKeyToTS(details.Key), details.Label, ValuesConverters_fieldValueToTS(details.FieldValue), Converters_fieldTypeToTS(details.FieldType), toArray<Types_FieldOptionTS>(map_1<Shared_FieldOption, Types_FieldOptionTS>(Converters_fieldOptionToTS, details.Options)));
+}
+
+/**
+ * Convert TypeScript FieldDetails to F# representation
+ */
+export function ValuesConverters_fieldDetailsFromTS(details: ValuesTypes_FieldDetailsTS): Option<Values_FieldDetails$1<Spec_FieldType_$union>> {
+    const matchValue: Option<Shared_FieldKey> = Converters_fieldKeyFromTS(details.Key);
+    const matchValue_1: Option<Shared_FieldValue_$union> = ValuesConverters_fieldValueFromTS(details.FieldValue);
+    const matchValue_2: Option<Spec_FieldType_$union> = Converters_fieldTypeFromTS(details.FieldType);
+    let matchResult: int32, fieldType: Spec_FieldType_$union, fieldValue: Shared_FieldValue_$union, key: Shared_FieldKey;
+    if (matchValue != null) {
+        if (matchValue_1 != null) {
+            if (matchValue_2 != null) {
+                matchResult = 0;
+                fieldType = value_2(matchValue_2);
+                fieldValue = value_2(matchValue_1);
+                key = value_2(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            const options: Option<FSharpList<Shared_FieldOption>> = fold<Option<Shared_FieldOption>, Option<FSharpList<Shared_FieldOption>>>((acc: Option<FSharpList<Shared_FieldOption>>, opt: Option<Shared_FieldOption>): Option<FSharpList<Shared_FieldOption>> => {
+                let matchResult_1: int32, item: Shared_FieldOption, list: FSharpList<Shared_FieldOption>;
+                if (acc != null) {
+                    if (opt != null) {
+                        matchResult_1 = 0;
+                        item = value_2(opt);
+                        list = value_2(acc);
+                    }
+                    else {
+                        matchResult_1 = 1;
+                    }
+                }
+                else {
+                    matchResult_1 = 1;
+                }
+                switch (matchResult_1) {
+                    case 0:
+                        return cons(item!, list!);
+                    default:
+                        return undefined;
+                }
+            }, empty_2<Shared_FieldOption>(), map_2<Types_FieldOptionTS, Option<Shared_FieldOption>>(Converters_fieldOptionFromTS, details.Options));
+            if (options == null) {
+                return undefined;
+            }
+            else {
+                return new Values_FieldDetails$1(details.FieldOrder, key!, details.Label, fieldValue!, fieldType!, reverse<Shared_FieldOption>(value_2(options)));
+            }
+        }
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Convert F# FormStatus to TypeScript representation
+ */
+export function ValuesConverters_formStatusToTS(status: Values_FormStatus_$union): ValuesTypes_FormStatusTS {
+    switch (status.tag) {
+        case /* Draft */ 1:
+            return new ValuesTypes_FormStatusTS("Draft", status.fields[0]);
+        case /* WaitingForReview */ 2:
+            return new ValuesTypes_FormStatusTS("WaitingForReview", undefined);
+        case /* WaitingForApproval */ 3:
+            return new ValuesTypes_FormStatusTS("WaitingForApproval", undefined);
+        case /* Complete */ 4:
+            return new ValuesTypes_FormStatusTS("Complete", undefined);
+        default:
+            return new ValuesTypes_FormStatusTS("Pending", undefined);
+    }
+}
+
+/**
+ * Convert TypeScript FormStatus to F# representation
+ */
+export function ValuesConverters_formStatusFromTS(status: ValuesTypes_FormStatusTS): Option<Values_FormStatus_$union> {
+    const matchValue: string = status.Type;
+    switch (matchValue) {
+        case "Pending":
+            return Values_FormStatus_Pending();
+        case "Draft": {
+            const matchValue_1: Option<string> = status.DraftId;
+            if (matchValue_1 == null) {
+                return undefined;
+            }
+            else {
+                let matchValue_2: [boolean, string];
+                let outArg = "00000000-0000-0000-0000-000000000000";
+                matchValue_2 = ([tryParse(value_2(matchValue_1), new FSharpRef<string>((): string => outArg, (v: string): void => {
+                    outArg = v;
+                })), outArg] as [boolean, string]);
+                if (matchValue_2[0]) {
+                    return Values_FormStatus_Draft(matchValue_2[1]);
+                }
+                else {
+                    return undefined;
+                }
+            }
+        }
+        case "WaitingForReview":
+            return Values_FormStatus_WaitingForReview();
+        case "WaitingForApproval":
+            return Values_FormStatus_WaitingForApproval();
+        case "Complete":
+            return Values_FormStatus_Complete();
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Convert F# SignatureType to TypeScript representation
+ */
+export function ValuesConverters_signatureTypeToTS(sigType: Values_SignatureType_$union): int32 {
+    if (sigType.tag === /* Approval */ 1) {
+        return 1;
+    }
+    else {
+        return 0;
+    }
+}
+
+/**
+ * Convert TypeScript SignatureType to F# representation
+ */
+export function ValuesConverters_signatureTypeFromTS(sigType: int32): Option<Values_SignatureType_$union> {
+    switch (sigType) {
+        case 0:
+            return Values_SignatureType_Review();
+        case 1:
+            return Values_SignatureType_Approval();
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Convert F# Signature to TypeScript representation
+ */
+export function ValuesConverters_signatureToTS(signature: Values_Signature): ValuesTypes_SignatureTS {
+    return new ValuesTypes_SignatureTS(signature.ApprovedById, signature.ApprovedByFullName, toString(signature.ApprovedByDate, "O"), signature.ApprovalSignature, ValuesConverters_signatureTypeToTS(signature.SignatureType));
+}
+
+/**
+ * Convert TypeScript Signature to F# representation
+ */
+export function ValuesConverters_signatureFromTS(signature: ValuesTypes_SignatureTS): Option<Values_Signature> {
+    let matchValue: [boolean, string];
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = ([tryParse(signature.ApprovedById, new FSharpRef<string>((): string => outArg, (v: string): void => {
+        outArg = v;
+    })), outArg] as [boolean, string]);
+    let matchValue_1: [boolean, Date];
+    let outArg_1: Date = minValue();
+    matchValue_1 = ([tryParse_1(signature.ApprovedByDate, new FSharpRef<Date>((): Date => outArg_1, (v_1: Date): void => {
+        outArg_1 = v_1;
+    })), outArg_1] as [boolean, Date]);
+    const matchValue_2: Option<Values_SignatureType_$union> = ValuesConverters_signatureTypeFromTS(signature.SignatureType);
+    let matchResult: int32;
+    if (matchValue[0]) {
+        if (matchValue_1[0]) {
+            if (matchValue_2 != null) {
+                matchResult = 0;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Values_Signature(matchValue[1], signature.ApprovedByFullName, matchValue_1[1], signature.ApprovalSignature, value_2(matchValue_2));
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Convert F# DynamicStepValues to TypeScript representation
+ */
+export function ValuesConverters_dynamicStepValuesToTS(stepValues: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>): [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][] {
+    return toArray<[Types_FieldKeyTS, ValuesTypes_FieldDetailsTS]>(map_1<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>], [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS]>((tupledArg: [Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]): [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS] => ([Converters_fieldKeyToTS(tupledArg[0]), ValuesConverters_fieldDetailsToTS(tupledArg[1])] as [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS]), toList<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>(stepValues)));
+}
+
+/**
+ * Convert TypeScript DynamicStepValues to F# representation
+ */
+export function ValuesConverters_dynamicStepValuesFromTS(stepValues: [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]): Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>> {
+    const array_1: Option<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>[] = map_2<[Types_FieldKeyTS, ValuesTypes_FieldDetailsTS], Option<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>>((tupledArg: [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS]): Option<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]> => {
+        const matchValue: Option<Shared_FieldKey> = Converters_fieldKeyFromTS(tupledArg[0]);
+        const matchValue_1: Option<Values_FieldDetails$1<Spec_FieldType_$union>> = ValuesConverters_fieldDetailsFromTS(tupledArg[1]);
+        let matchResult: int32, details: Values_FieldDetails$1<Spec_FieldType_$union>, key: Shared_FieldKey;
+        if (matchValue != null) {
+            if (matchValue_1 != null) {
+                matchResult = 0;
+                details = value_2(matchValue_1);
+                key = value_2(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return [key!, details!] as [Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>];
+            default:
+                return undefined;
+        }
+    }, stepValues);
+    return fold<Option<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>, Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>>((acc: Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>, item: Option<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>): Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>> => {
+        let matchResult_1: int32, details_1: Values_FieldDetails$1<Spec_FieldType_$union>, key_1: Shared_FieldKey, map: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>;
+        if (acc != null) {
+            if (item != null) {
+                matchResult_1 = 0;
+                details_1 = value_2(item)[1];
+                key_1 = value_2(item)[0];
+                map = value_2(acc);
+            }
+            else {
+                matchResult_1 = 1;
+            }
+        }
+        else {
+            matchResult_1 = 1;
+        }
+        switch (matchResult_1) {
+            case 0:
+                return add<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>(key_1!, details_1!, map!);
+            default:
+                return undefined;
+        }
+    }, empty<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>({
+        Compare: compare,
+    }), array_1);
+}
+
+/**
+ * Convert F# DynamicFormSpecDetails to TypeScript representation
+ */
+export function ValuesConverters_dynamicFormSpecDetailsToTS(details: Values_DynamicFormSpecDetails): ValuesTypes_DynamicFormSpecDetailsTS {
+    return new ValuesTypes_DynamicFormSpecDetailsTS(details.FormSpecId, details.FormSpecCode, details.FormSpecVersion, details.DynamicVersion, map_3<Spec_Score, Types_ScoreTS>(Converters_scoreToTS, details.MaxScore), ValuesConverters_formStatusToTS(details.Status), toArray<ValuesTypes_SignatureTS>(map_1<Values_Signature, ValuesTypes_SignatureTS>(ValuesConverters_signatureToTS, details.Signatures)));
+}
+
+/**
+ * Convert TypeScript DynamicFormSpecDetails to F# representation
+ */
+export function ValuesConverters_dynamicFormSpecDetailsFromTS(details: ValuesTypes_DynamicFormSpecDetailsTS): Option<Values_DynamicFormSpecDetails> {
+    let matchValue: [boolean, string];
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = ([tryParse(details.FormSpecId, new FSharpRef<string>((): string => outArg, (v: string): void => {
+        outArg = v;
+    })), outArg] as [boolean, string]);
+    if (matchValue[0]) {
+        const statusResult: Option<Values_FormStatus_$union> = ValuesConverters_formStatusFromTS(details.Status);
+        const signaturesResult: Option<FSharpList<Values_Signature>> = fold<Option<Values_Signature>, Option<FSharpList<Values_Signature>>>((acc: Option<FSharpList<Values_Signature>>, sigOpt: Option<Values_Signature>): Option<FSharpList<Values_Signature>> => {
+            let matchResult: int32, item: Values_Signature, list: FSharpList<Values_Signature>;
+            if (acc != null) {
+                if (sigOpt != null) {
+                    matchResult = 0;
+                    item = value_2(sigOpt);
+                    list = value_2(acc);
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0:
+                    return cons(item!, list!);
+                default:
+                    return undefined;
+            }
+        }, empty_2<Values_Signature>(), map_2<ValuesTypes_SignatureTS, Option<Values_Signature>>(ValuesConverters_signatureFromTS, details.Signatures));
+        let maxScoreResult: Option<Spec_Score>;
+        const matchValue_2: Option<Types_ScoreTS> = details.MaxScore;
+        maxScoreResult = ((matchValue_2 == null) ? undefined : Converters_scoreFromTS(value_2(matchValue_2)));
+        let matchResult_1: int32, signatures: FSharpList<Values_Signature>, status: Values_FormStatus_$union;
+        if (statusResult != null) {
+            if (signaturesResult != null) {
+                matchResult_1 = 0;
+                signatures = value_2(signaturesResult);
+                status = value_2(statusResult);
+            }
+            else {
+                matchResult_1 = 1;
+            }
+        }
+        else {
+            matchResult_1 = 1;
+        }
+        switch (matchResult_1) {
+            case 0:
+                return new Values_DynamicFormSpecDetails(matchValue[1], details.FormSpecCode, details.FormSpecVersion, details.DynamicVersion, maxScoreResult, status!, reverse<Values_Signature>(signatures!));
+            default:
+                return undefined;
+        }
+    }
+    else {
+        return undefined;
+    }
+}
+
+/**
+ * Convert F# FableFormState to TypeScript representation
+ * Note: This is a simplified representation - actual Fable.Form.View.State may differ
+ * Fable doesn't support reflection, so this is a placeholder that returns None
+ * In practice, you would need to pattern match on the concrete State type
+ */
+export function ValuesConverters_fableFormStateToTS(state: any): Option<ValuesTypes_FableFormStateTS> {
+    return undefined;
+}
+
+/**
+ * Convert TypeScript FableFormState to F# representation
+ * Note: This returns obj as we can't directly construct Fable.Form types
+ */
+export function ValuesConverters_fableFormStateFromTS(state: ValuesTypes_FableFormStateTS): Option<any> {
+    const matchValue: string = state.Type;
+    switch (matchValue) {
+        case "Idle":
+            return some("Idle");
+        case "Loading":
+            return some("Loading");
+        case "Error": {
+            const matchValue_1: Option<string> = state.Error;
+            if (matchValue_1 == null) {
+                return undefined;
+            }
+            else {
+                return some({
+                    Error: value_2(matchValue_1),
+                });
+            }
+        }
+        case "Success": {
+            const matchValue_2: Option<string> = state.Success;
+            if (matchValue_2 == null) {
+                return undefined;
+            }
+            else {
+                return some({
+                    Success: value_2(matchValue_2),
+                });
+            }
+        }
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Convert F# ErrorTracking to TypeScript representation
+ * Note: Fable doesn't support reflection, so this is a placeholder
+ * In practice, you would need to pattern match on the concrete ErrorTracking type
+ */
+export function ValuesConverters_errorTrackingToTS(tracking: any): Option<ValuesTypes_ErrorTrackingTS> {
+    return undefined;
+}
+
+/**
+ * Convert TypeScript ErrorTracking to F# representation
+ * Note: This returns obj as we can't directly construct Fable.Form types
+ */
+export function ValuesConverters_errorTrackingFromTS(tracking: ValuesTypes_ErrorTrackingTS): Option<any> {
+    return some({
+        ShowAllErrors: tracking.ShowAllErrors,
+        ShowFieldError: ofArray<string>(tracking.ShowFieldError, {
+            Compare: comparePrimitives,
+        }),
+    });
+}
+
+/**
+ * Convert F# FableFormModel to TypeScript representation
+ * Note: This handles Form.View.Model<DynamicStepValues>
+ * This is a simplified version - in practice, you may need to handle this differently
+ */
+export function ValuesConverters_fableFormModelToTS(model: any): Option<ValuesTypes_FableFormModelTS> {
+    return undefined;
+}
+
+/**
+ * Convert TypeScript FableFormModel to F# representation
+ * Note: This returns obj as we can't directly construct Fable.Form types
+ */
+export function ValuesConverters_fableFormModelFromTS(model: ValuesTypes_FableFormModelTS): Option<any> {
+    const matchValue: Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>> = ValuesConverters_dynamicStepValuesFromTS(model.Values);
+    const matchValue_1: Option<any> = ValuesConverters_fableFormStateFromTS(model.State);
+    const matchValue_2: Option<any> = ValuesConverters_errorTrackingFromTS(model.ErrorTracking);
+    let matchResult: int32, errorTracking: any, state: any, values: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>;
+    if (matchValue != null) {
+        if (matchValue_1 != null) {
+            if (matchValue_2 != null) {
+                matchResult = 0;
+                errorTracking = value_2(matchValue_2);
+                state = value_2(matchValue_1);
+                values = value_2(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return some({
+                ErrorTracking: errorTracking!,
+                State: state!,
+                Values: values!,
+            });
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Convert F# DynamicForm to TypeScript representation
+ */
+export function ValuesConverters_dynamicFormToTS<FableFormModel>(form: Values_DynamicForm$1<FableFormModel>): Option<ValuesTypes_DynamicFormTS> {
+    try {
+        const detailsTS: ValuesTypes_DynamicFormSpecDetailsTS = ValuesConverters_dynamicFormSpecDetailsToTS(form.DynamicFormSpecDetails);
+        const stepsTS: Option<FSharpList<[int32, ValuesTypes_FableFormModelTS]>> = fold_1<Option<[int32, ValuesTypes_FableFormModelTS]>, Option<FSharpList<[int32, ValuesTypes_FableFormModelTS]>>>((acc: Option<FSharpList<[int32, ValuesTypes_FableFormModelTS]>>, item: Option<[int32, ValuesTypes_FableFormModelTS]>): Option<FSharpList<[int32, ValuesTypes_FableFormModelTS]>> => {
+            let matchResult: int32, list_1: FSharpList<[int32, ValuesTypes_FableFormModelTS]>, model_1: ValuesTypes_FableFormModelTS, order: int32;
+            if (acc != null) {
+                if (item != null) {
+                    matchResult = 0;
+                    list_1 = value_2(acc);
+                    model_1 = value_2(item)[1];
+                    order = value_2(item)[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0:
+                    return cons([order!, model_1!] as [int32, ValuesTypes_FableFormModelTS], list_1!);
+                default:
+                    return undefined;
+            }
+        }, empty_2<[int32, ValuesTypes_FableFormModelTS]>(), map_1<[Values_StepOrder, FableFormModel], Option<[int32, ValuesTypes_FableFormModelTS]>>((tupledArg: [Values_StepOrder, FableFormModel]): Option<[int32, ValuesTypes_FableFormModelTS]> => {
+            const stepOrder: int32 = tupledArg[0].fields[0] | 0;
+            const matchValue: Option<ValuesTypes_FableFormModelTS> = ValuesConverters_fableFormModelToTS(tupledArg[1]);
+            if (matchValue == null) {
+                return undefined;
+            }
+            else {
+                return [stepOrder, value_2(matchValue)] as [int32, ValuesTypes_FableFormModelTS];
+            }
+        }, toList<Values_StepOrder, FableFormModel>(form.Steps)));
+        return (stepsTS == null) ? undefined : (new ValuesTypes_DynamicFormTS(detailsTS, toArray<[int32, ValuesTypes_FableFormModelTS]>(reverse<[int32, ValuesTypes_FableFormModelTS]>(value_2(stepsTS)))));
+    }
+    catch (matchValue_2: any) {
+        return undefined;
+    }
+}
+
+/**
+ * Convert TypeScript DynamicForm to F# representation
+ * Note: Returns obj as we can't directly construct generic DynamicForm
+ */
+export function ValuesConverters_dynamicFormFromTS(form: ValuesTypes_DynamicFormTS): Option<any> {
+    const matchValue: Option<Values_DynamicFormSpecDetails> = ValuesConverters_dynamicFormSpecDetailsFromTS(form.DynamicFormSpecDetails);
+    if (matchValue == null) {
+        return undefined;
+    }
+    else {
+        const details: Values_DynamicFormSpecDetails = value_2(matchValue);
+        let steps: Option<FSharpMap<Values_StepOrder, any>>;
+        const array_1: Option<[Values_StepOrder, any]>[] = map_2<[int32, ValuesTypes_FableFormModelTS], Option<[Values_StepOrder, any]>>((tupledArg: [int32, ValuesTypes_FableFormModelTS]): Option<[Values_StepOrder, any]> => {
+            const matchValue_1: Option<any> = ValuesConverters_fableFormModelFromTS(tupledArg[1]);
+            if (matchValue_1 == null) {
+                return undefined;
+            }
+            else {
+                return [new Values_StepOrder(tupledArg[0]), value_2(matchValue_1)] as [Values_StepOrder, any];
+            }
+        }, form.Steps);
+        steps = fold<Option<[Values_StepOrder, any]>, Option<FSharpMap<Values_StepOrder, any>>>((acc: Option<FSharpMap<Values_StepOrder, any>>, item: Option<[Values_StepOrder, any]>): Option<FSharpMap<Values_StepOrder, any>> => {
+            let matchResult: int32, map: FSharpMap<Values_StepOrder, any>, model_1: any, order: Values_StepOrder;
+            if (acc != null) {
+                if (item != null) {
+                    matchResult = 0;
+                    map = value_2(acc);
+                    model_1 = value_2(item)[1];
+                    order = value_2(item)[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0:
+                    return add<Values_StepOrder, any>(order!, model_1!, map!);
+                default:
+                    return undefined;
+            }
+        }, empty<Values_StepOrder, any>({
+            Compare: compare,
+        }), array_1);
+        if (steps == null) {
+            return undefined;
+        }
+        else {
+            return some({
+                DynamicFormSpecDetails: details,
+                Steps: value_2(steps),
+            });
+        }
+    }
+}
+
+/**
+ * Convert F# DynamicFormResultData to TypeScript representation
+ */
+export function ValuesConverters_dynamicFormResultDataToTS(data: Values_DynamicFormResultData$1<Spec_FieldType_$union>): ValuesTypes_DynamicFormResultDataTS {
+    return new ValuesTypes_DynamicFormResultDataTS(ValuesConverters_dynamicFormSpecDetailsToTS(data.ResultFormSpecDetails), toArray<[int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]]>(map_1<[Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>], [int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]]>((tupledArg: [Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]): [int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]] => ([tupledArg[0].fields[0], ValuesConverters_dynamicStepValuesToTS(tupledArg[1])] as [int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]]), toList<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>(data.ResultSteps))));
+}
+
+/**
+ * Convert TypeScript DynamicFormResultData to F# representation
+ */
+export function ValuesConverters_dynamicFormResultDataFromTS(data: ValuesTypes_DynamicFormResultDataTS): Option<Values_DynamicFormResultData$1<Spec_FieldType_$union>> {
+    const matchValue: Option<Values_DynamicFormSpecDetails> = ValuesConverters_dynamicFormSpecDetailsFromTS(data.ResultFormSpecDetails);
+    if (matchValue == null) {
+        return undefined;
+    }
+    else {
+        const details: Values_DynamicFormSpecDetails = value_2(matchValue);
+        let resultSteps: Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>>;
+        const array_1: Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]>[] = map_2<[int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]], Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]>>((tupledArg: [int32, [Types_FieldKeyTS, ValuesTypes_FieldDetailsTS][]]): Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]> => {
+            const matchValue_1: Option<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>> = ValuesConverters_dynamicStepValuesFromTS(tupledArg[1]);
+            if (matchValue_1 == null) {
+                return undefined;
+            }
+            else {
+                return [new Values_StepOrder(tupledArg[0]), value_2(matchValue_1)] as [Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>];
+            }
+        }, data.ResultSteps);
+        resultSteps = fold<Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]>, Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>>>((acc: Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>>, item: Option<[Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]>): Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>> => {
+            let matchResult: int32, map: FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>, order: Values_StepOrder, values: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>;
+            if (acc != null) {
+                if (item != null) {
+                    matchResult = 0;
+                    map = value_2(acc);
+                    order = value_2(item)[0];
+                    values = value_2(item)[1];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0:
+                    return add<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>(order!, values!, map!);
+                default:
+                    return undefined;
+            }
+        }, empty<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>({
+            Compare: compare,
+        }), array_1);
+        if (resultSteps == null) {
+            return undefined;
+        }
+        else {
+            return new Values_DynamicFormResultData$1(details, value_2(resultSteps));
+        }
+    }
+}
+
+/**
+ * Validate a TypeScript DynamicFormResultData object from JavaScript/TypeScript
+ */
+export function ValuesValidators_validateDynamicFormResultData(input: any): Option<ValuesTypes_DynamicFormResultDataTS> {
+    const stringified: string = toString_1(4, Auto_generateBoxedEncoder_437914C6(obj_type, undefined, undefined, undefined)(input));
+    return Result_ToOption<ValuesTypes_DynamicFormResultDataTS, string>(fromString<ValuesTypes_DynamicFormResultDataTS>(uncurry2(Auto_generateBoxedDecoder_Z6670B51(ValuesTypes_DynamicFormResultDataTS_$reflection(), undefined, undefined)), stringified));
+}
+
+/**
+ * Validate and convert a TypeScript DynamicFormResultData to F# domain type
+ */
+export function ValuesValidators_validateAndConvertDynamicFormResultData(input: any): Option<Values_DynamicFormResultData$1<Spec_FieldType_$union>> {
+    const matchValue: Option<ValuesTypes_DynamicFormResultDataTS> = ValuesValidators_validateDynamicFormResultData(input);
+    if (matchValue == null) {
+        return undefined;
+    }
+    else {
+        return ValuesConverters_dynamicFormResultDataFromTS(value_2(matchValue));
+    }
+}
+
+/**
+ * Validate a TypeScript DynamicForm object
+ */
+export function ValuesValidators_validateDynamicForm(input: any): Option<ValuesTypes_DynamicFormTS> {
+    const stringified: string = toString_1(4, Auto_generateBoxedEncoder_437914C6(obj_type, undefined, undefined, undefined)(input));
+    return Result_ToOption<ValuesTypes_DynamicFormTS, string>(fromString<ValuesTypes_DynamicFormTS>(uncurry2(Auto_generateBoxedDecoder_Z6670B51(ValuesTypes_DynamicFormTS_$reflection(), undefined, undefined)), stringified));
+}
+
+/**
+ * Validate a TypeScript FieldAnswer object
+ */
+export function ValuesValidators_validateFieldAnswer(input: any): Option<ValuesTypes_FieldAnswerTS> {
+    const stringified: string = toString_1(4, Auto_generateBoxedEncoder_437914C6(obj_type, undefined, undefined, undefined)(input));
+    return Result_ToOption<ValuesTypes_FieldAnswerTS, string>(fromString<ValuesTypes_FieldAnswerTS>(uncurry2(Auto_generateBoxedDecoder_Z6670B51(ValuesTypes_FieldAnswerTS_$reflection(), undefined, undefined)), stringified));
+}
+
+/**
+ * Validate a TypeScript FieldValue object
+ */
+export function ValuesValidators_validateFieldValue(input: any): Option<ValuesTypes_FieldValueTS> {
+    const stringified: string = toString_1(4, Auto_generateBoxedEncoder_437914C6(obj_type, undefined, undefined, undefined)(input));
+    return Result_ToOption<ValuesTypes_FieldValueTS, string>(fromString<ValuesTypes_FieldValueTS>(uncurry2(Auto_generateBoxedDecoder_Z6670B51(ValuesTypes_FieldValueTS_$reflection(), undefined, undefined)), stringified));
+}
+
+/**
+ * Create a new FieldAnswer
+ */
+export function ValuesBuilders_createFieldAnswer(fieldKey: Types_FieldKeyTS, description: string, value: string): ValuesTypes_FieldAnswerTS {
+    return new ValuesTypes_FieldAnswerTS(fieldKey, description, value);
+}
+
+/**
+ * Create a new FieldValue with Single case
+ */
+export function ValuesBuilders_createSingleFieldValue(answer: ValuesTypes_FieldAnswerTS): ValuesTypes_FieldValueTS {
+    return new ValuesTypes_FieldValueTS("Single", answer, undefined, undefined);
+}
+
+/**
+ * Create a new FieldValue with Multiple case
+ */
+export function ValuesBuilders_createMultipleFieldValue(answers: ValuesTypes_FieldAnswerTS[]): ValuesTypes_FieldValueTS {
+    return new ValuesTypes_FieldValueTS("Multiple", undefined, answers, undefined);
+}
+
+/**
+ * Create a new FieldValue with Matrix case
+ */
+export function ValuesBuilders_createMatrixFieldValue(answer: ValuesTypes_MatrixAnswerTS): ValuesTypes_FieldValueTS {
+    return new ValuesTypes_FieldValueTS("Matrix", undefined, undefined, answer);
+}
+
+/**
+ * Create a new FormStatus with Pending case
+ */
+export function ValuesBuilders_createPendingStatus(): ValuesTypes_FormStatusTS {
+    return new ValuesTypes_FormStatusTS("Pending", undefined);
+}
+
+/**
+ * Create a new FormStatus with Draft case
+ */
+export function ValuesBuilders_createDraftStatus(draftId: string): ValuesTypes_FormStatusTS {
+    return new ValuesTypes_FormStatusTS("Draft", draftId);
+}
+
+/**
+ * Create a new FormStatus with Complete case
+ */
+export function ValuesBuilders_createCompleteStatus(): ValuesTypes_FormStatusTS {
+    return new ValuesTypes_FormStatusTS("Complete", undefined);
+}
+
+/**
+ * Main entry point: Validate a DynamicFormResultData from TypeScript/JavaScript
+ */
+export function ValuesApi_validateDynamicFormResultData<$a>(): ((arg0: $a) => Option<ValuesTypes_DynamicFormResultDataTS>) {
+    return ValuesValidators_validateDynamicFormResultData;
+}
+
+/**
+ * Validate and convert a DynamicFormResultData to F# domain type
+ */
+export function ValuesApi_validateAndConvertDynamicFormResultData<$a>(): ((arg0: $a) => Option<Values_DynamicFormResultData$1<Spec_FieldType_$union>>) {
+    return ValuesValidators_validateAndConvertDynamicFormResultData;
+}
+
+/**
+ * Validate a DynamicForm from TypeScript
+ */
+export function ValuesApi_validateDynamicForm<$a>(): ((arg0: $a) => Option<ValuesTypes_DynamicFormTS>) {
+    return ValuesValidators_validateDynamicForm;
+}
+
+/**
+ * Validate a FieldAnswer from TypeScript
+ */
+export function ValuesApi_validateFieldAnswer<$a>(): ((arg0: $a) => Option<ValuesTypes_FieldAnswerTS>) {
+    return ValuesValidators_validateFieldAnswer;
+}
+
+/**
+ * Validate a FieldValue from TypeScript
+ */
+export function ValuesApi_validateFieldValue<$a>(): ((arg0: $a) => Option<ValuesTypes_FieldValueTS>) {
+    return ValuesValidators_validateFieldValue;
+}
+
+/**
+ * Convert F# DynamicFormResultData to TypeScript representation
+ */
+export function ValuesApi_dynamicFormResultDataToTypeScript(data: Values_DynamicFormResultData$1<Spec_FieldType_$union>): ValuesTypes_DynamicFormResultDataTS {
+    return ValuesConverters_dynamicFormResultDataToTS(data);
+}
+
+/**
+ * Convert TypeScript DynamicFormResultData to F# representation
+ */
+export function ValuesApi_dynamicFormResultDataFromTypeScript(data: ValuesTypes_DynamicFormResultDataTS): Option<Values_DynamicFormResultData$1<Spec_FieldType_$union>> {
+    return ValuesConverters_dynamicFormResultDataFromTS(data);
+}
+
+/**
+ * Convert F# DynamicForm to TypeScript representation
+ * Note: This requires the form to be cast to the concrete type
+ * DynamicForm<Form.View.Model<DynamicStepValues>>
+ */
+export function ValuesApi_dynamicFormToTypeScript(form: any): Option<ValuesTypes_DynamicFormTS> {
+    return ValuesConverters_dynamicFormToTS<any>(form);
+}
+
+/**
+ * Convert TypeScript DynamicForm to F# representation
+ */
+export function ValuesApi_dynamicFormFromTypeScript(form: ValuesTypes_DynamicFormTS): Option<any> {
+    return ValuesConverters_dynamicFormFromTS(form);
+}
+
+export const ValuesApi_createFieldAnswer = (fieldKey: Types_FieldKeyTS): ((arg0: string) => ((arg0: string) => ValuesTypes_FieldAnswerTS)) => ((description: string): ((arg0: string) => ValuesTypes_FieldAnswerTS) => ((value: string): ValuesTypes_FieldAnswerTS => ValuesBuilders_createFieldAnswer(fieldKey, description, value)));
+
+export const ValuesApi_createSingleFieldValue = ValuesBuilders_createSingleFieldValue;
+
+export const ValuesApi_createMultipleFieldValue = ValuesBuilders_createMultipleFieldValue;
+
+export const ValuesApi_createMatrixFieldValue = ValuesBuilders_createMatrixFieldValue;
+
+export const ValuesApi_createPendingStatus = ValuesBuilders_createPendingStatus;
+
+export const ValuesApi_createDraftStatus = ValuesBuilders_createDraftStatus;
+
+export const ValuesApi_createCompleteStatus = ValuesBuilders_createCompleteStatus;
+
+/**
+ * Serialize a DynamicFormResultData to JSON string
+ */
+export function ValuesApi_serializeDynamicFormResultData(data: ValuesTypes_DynamicFormResultDataTS): string {
+    return toString_1(2, Auto_generateBoxedEncoder_437914C6(ValuesTypes_DynamicFormResultDataTS_$reflection(), undefined, undefined, undefined)(data));
+}
+
+/**
+ * Deserialize a DynamicFormResultData from JSON string
+ */
+export function ValuesApi_deserializeDynamicFormResultData(json: string): Option<ValuesTypes_DynamicFormResultDataTS> {
+    const matchValue: FSharpResult$2_$union<ValuesTypes_DynamicFormResultDataTS, string> = fromString<ValuesTypes_DynamicFormResultDataTS>(uncurry2(Auto_generateBoxedDecoder_Z6670B51(ValuesTypes_DynamicFormResultDataTS_$reflection(), undefined, undefined)), json);
+    if (matchValue.tag === /* Error */ 1) {
+        return undefined;
+    }
+    else {
+        return matchValue.fields[0];
+    }
+}
+
+//# sourceMappingURL=FormSpec.Values.Api.Option.ts.map