@f1studio/form-spec 5.0.0-alpha.101

package/FormSpec.TS/Interop/FormSpec.Values.Api.Option.js

@@ -0,0 +1,1367 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get ValuesApi_createCompleteStatus () {
+        return ValuesApi_createCompleteStatus;
+    },
+    get ValuesApi_createDraftStatus () {
+        return ValuesApi_createDraftStatus;
+    },
+    get ValuesApi_createFieldAnswer () {
+        return ValuesApi_createFieldAnswer;
+    },
+    get ValuesApi_createMatrixFieldValue () {
+        return ValuesApi_createMatrixFieldValue;
+    },
+    get ValuesApi_createMultipleFieldValue () {
+        return ValuesApi_createMultipleFieldValue;
+    },
+    get ValuesApi_createPendingStatus () {
+        return ValuesApi_createPendingStatus;
+    },
+    get ValuesApi_createSingleFieldValue () {
+        return ValuesApi_createSingleFieldValue;
+    },
+    get ValuesApi_deserializeDynamicFormResultData () {
+        return ValuesApi_deserializeDynamicFormResultData;
+    },
+    get ValuesApi_dynamicFormFromTypeScript () {
+        return ValuesApi_dynamicFormFromTypeScript;
+    },
+    get ValuesApi_dynamicFormResultDataFromTypeScript () {
+        return ValuesApi_dynamicFormResultDataFromTypeScript;
+    },
+    get ValuesApi_dynamicFormResultDataToTypeScript () {
+        return ValuesApi_dynamicFormResultDataToTypeScript;
+    },
+    get ValuesApi_dynamicFormToTypeScript () {
+        return ValuesApi_dynamicFormToTypeScript;
+    },
+    get ValuesApi_serializeDynamicFormResultData () {
+        return ValuesApi_serializeDynamicFormResultData;
+    },
+    get ValuesApi_validateAndConvertDynamicFormResultData () {
+        return ValuesApi_validateAndConvertDynamicFormResultData;
+    },
+    get ValuesApi_validateDynamicForm () {
+        return ValuesApi_validateDynamicForm;
+    },
+    get ValuesApi_validateDynamicFormResultData () {
+        return ValuesApi_validateDynamicFormResultData;
+    },
+    get ValuesApi_validateFieldAnswer () {
+        return ValuesApi_validateFieldAnswer;
+    },
+    get ValuesApi_validateFieldValue () {
+        return ValuesApi_validateFieldValue;
+    },
+    get ValuesBuilders_createCompleteStatus () {
+        return ValuesBuilders_createCompleteStatus;
+    },
+    get ValuesBuilders_createDraftStatus () {
+        return ValuesBuilders_createDraftStatus;
+    },
+    get ValuesBuilders_createFieldAnswer () {
+        return ValuesBuilders_createFieldAnswer;
+    },
+    get ValuesBuilders_createMatrixFieldValue () {
+        return ValuesBuilders_createMatrixFieldValue;
+    },
+    get ValuesBuilders_createMultipleFieldValue () {
+        return ValuesBuilders_createMultipleFieldValue;
+    },
+    get ValuesBuilders_createPendingStatus () {
+        return ValuesBuilders_createPendingStatus;
+    },
+    get ValuesBuilders_createSingleFieldValue () {
+        return ValuesBuilders_createSingleFieldValue;
+    },
+    get ValuesConverters_dynamicFormFromTS () {
+        return ValuesConverters_dynamicFormFromTS;
+    },
+    get ValuesConverters_dynamicFormResultDataFromTS () {
+        return ValuesConverters_dynamicFormResultDataFromTS;
+    },
+    get ValuesConverters_dynamicFormResultDataToTS () {
+        return ValuesConverters_dynamicFormResultDataToTS;
+    },
+    get ValuesConverters_dynamicFormSpecDetailsFromTS () {
+        return ValuesConverters_dynamicFormSpecDetailsFromTS;
+    },
+    get ValuesConverters_dynamicFormSpecDetailsToTS () {
+        return ValuesConverters_dynamicFormSpecDetailsToTS;
+    },
+    get ValuesConverters_dynamicFormToTS () {
+        return ValuesConverters_dynamicFormToTS;
+    },
+    get ValuesConverters_dynamicStepValuesFromTS () {
+        return ValuesConverters_dynamicStepValuesFromTS;
+    },
+    get ValuesConverters_dynamicStepValuesToTS () {
+        return ValuesConverters_dynamicStepValuesToTS;
+    },
+    get ValuesConverters_errorTrackingFromTS () {
+        return ValuesConverters_errorTrackingFromTS;
+    },
+    get ValuesConverters_errorTrackingToTS () {
+        return ValuesConverters_errorTrackingToTS;
+    },
+    get ValuesConverters_fableFormModelFromTS () {
+        return ValuesConverters_fableFormModelFromTS;
+    },
+    get ValuesConverters_fableFormModelToTS () {
+        return ValuesConverters_fableFormModelToTS;
+    },
+    get ValuesConverters_fableFormStateFromTS () {
+        return ValuesConverters_fableFormStateFromTS;
+    },
+    get ValuesConverters_fableFormStateToTS () {
+        return ValuesConverters_fableFormStateToTS;
+    },
+    get ValuesConverters_fieldAnswerFromTS () {
+        return ValuesConverters_fieldAnswerFromTS;
+    },
+    get ValuesConverters_fieldAnswerToTS () {
+        return ValuesConverters_fieldAnswerToTS;
+    },
+    get ValuesConverters_fieldDetailsFromTS () {
+        return ValuesConverters_fieldDetailsFromTS;
+    },
+    get ValuesConverters_fieldDetailsToTS () {
+        return ValuesConverters_fieldDetailsToTS;
+    },
+    get ValuesConverters_fieldValueFromTS () {
+        return ValuesConverters_fieldValueFromTS;
+    },
+    get ValuesConverters_fieldValueToTS () {
+        return ValuesConverters_fieldValueToTS;
+    },
+    get ValuesConverters_formStatusFromTS () {
+        return ValuesConverters_formStatusFromTS;
+    },
+    get ValuesConverters_formStatusToTS () {
+        return ValuesConverters_formStatusToTS;
+    },
+    get ValuesConverters_matrixAnswerFromTS () {
+        return ValuesConverters_matrixAnswerFromTS;
+    },
+    get ValuesConverters_matrixAnswerToTS () {
+        return ValuesConverters_matrixAnswerToTS;
+    },
+    get ValuesConverters_signatureFromTS () {
+        return ValuesConverters_signatureFromTS;
+    },
+    get ValuesConverters_signatureToTS () {
+        return ValuesConverters_signatureToTS;
+    },
+    get ValuesConverters_signatureTypeFromTS () {
+        return ValuesConverters_signatureTypeFromTS;
+    },
+    get ValuesConverters_signatureTypeToTS () {
+        return ValuesConverters_signatureTypeToTS;
+    },
+    get ValuesTypes_DynamicFormResultDataTS () {
+        return ValuesTypes_DynamicFormResultDataTS;
+    },
+    get ValuesTypes_DynamicFormResultDataTS_$reflection () {
+        return ValuesTypes_DynamicFormResultDataTS_$reflection;
+    },
+    get ValuesTypes_DynamicFormSpecDetailsTS () {
+        return ValuesTypes_DynamicFormSpecDetailsTS;
+    },
+    get ValuesTypes_DynamicFormSpecDetailsTS_$reflection () {
+        return ValuesTypes_DynamicFormSpecDetailsTS_$reflection;
+    },
+    get ValuesTypes_DynamicFormTS () {
+        return ValuesTypes_DynamicFormTS;
+    },
+    get ValuesTypes_DynamicFormTS_$reflection () {
+        return ValuesTypes_DynamicFormTS_$reflection;
+    },
+    get ValuesTypes_ErrorTrackingTS () {
+        return ValuesTypes_ErrorTrackingTS;
+    },
+    get ValuesTypes_ErrorTrackingTS_$reflection () {
+        return ValuesTypes_ErrorTrackingTS_$reflection;
+    },
+    get ValuesTypes_FableFormModelTS () {
+        return ValuesTypes_FableFormModelTS;
+    },
+    get ValuesTypes_FableFormModelTS_$reflection () {
+        return ValuesTypes_FableFormModelTS_$reflection;
+    },
+    get ValuesTypes_FableFormStateTS () {
+        return ValuesTypes_FableFormStateTS;
+    },
+    get ValuesTypes_FableFormStateTS_$reflection () {
+        return ValuesTypes_FableFormStateTS_$reflection;
+    },
+    get ValuesTypes_FieldAnswerTS () {
+        return ValuesTypes_FieldAnswerTS;
+    },
+    get ValuesTypes_FieldAnswerTS_$reflection () {
+        return ValuesTypes_FieldAnswerTS_$reflection;
+    },
+    get ValuesTypes_FieldDetailsTS () {
+        return ValuesTypes_FieldDetailsTS;
+    },
+    get ValuesTypes_FieldDetailsTS_$reflection () {
+        return ValuesTypes_FieldDetailsTS_$reflection;
+    },
+    get ValuesTypes_FieldValueTS () {
+        return ValuesTypes_FieldValueTS;
+    },
+    get ValuesTypes_FieldValueTS_$reflection () {
+        return ValuesTypes_FieldValueTS_$reflection;
+    },
+    get ValuesTypes_FormStatusTS () {
+        return ValuesTypes_FormStatusTS;
+    },
+    get ValuesTypes_FormStatusTS_$reflection () {
+        return ValuesTypes_FormStatusTS_$reflection;
+    },
+    get ValuesTypes_MatrixAnswerTS () {
+        return ValuesTypes_MatrixAnswerTS;
+    },
+    get ValuesTypes_MatrixAnswerTS_$reflection () {
+        return ValuesTypes_MatrixAnswerTS_$reflection;
+    },
+    get ValuesTypes_SignatureTS () {
+        return ValuesTypes_SignatureTS;
+    },
+    get ValuesTypes_SignatureTS_$reflection () {
+        return ValuesTypes_SignatureTS_$reflection;
+    },
+    get ValuesValidators_validateAndConvertDynamicFormResultData () {
+        return ValuesValidators_validateAndConvertDynamicFormResultData;
+    },
+    get ValuesValidators_validateDynamicForm () {
+        return ValuesValidators_validateDynamicForm;
+    },
+    get ValuesValidators_validateDynamicFormResultData () {
+        return ValuesValidators_validateDynamicFormResultData;
+    },
+    get ValuesValidators_validateFieldAnswer () {
+        return ValuesValidators_validateFieldAnswer;
+    },
+    get ValuesValidators_validateFieldValue () {
+        return ValuesValidators_validateFieldValue;
+    }
+});
+const _Types = require("@fable-org/fable-library-js/Types.js");
+const _FormSpecApiOption = require("./FormSpec.Api.Option.js");
+const _Util = require("@fable-org/fable-library-js/Util.js");
+const _Reflection = require("@fable-org/fable-library-js/Reflection.js");
+const _Option = require("@fable-org/fable-library-js/Option.js");
+const _FormSpec = require("../FormSpec.js");
+const _List = require("@fable-org/fable-library-js/List.js");
+const _Map = require("@fable-org/fable-library-js/Map.js");
+const _Array = require("@fable-org/fable-library-js/Array.js");
+const _Guid = require("@fable-org/fable-library-js/Guid.js");
+const _Set = require("@fable-org/fable-library-js/Set.js");
+const _Date = require("@fable-org/fable-library-js/Date.js");
+const _Encodefs = require("../fable_modules/Thoth.Json.10.4.1/Encode.fs.js");
+const _Result = require("@fable-org/fable-library-js/Result.js");
+const _Decodefs = require("../fable_modules/Thoth.Json.10.4.1/Decode.fs.js");
+class ValuesTypes_FieldAnswerTS extends _Types.Record {
+    constructor(FieldKey, Description, Value){
+        super();
+        this.FieldKey = FieldKey;
+        this.Description = Description;
+        this.Value = Value;
+    }
+}
+function ValuesTypes_FieldAnswerTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.FieldAnswerTS", [], ValuesTypes_FieldAnswerTS, ()=>[
+            [
+                "FieldKey",
+                (0, _FormSpecApiOption.Types_FieldKeyTS_$reflection)()
+            ],
+            [
+                "Description",
+                _Reflection.string_type
+            ],
+            [
+                "Value",
+                _Reflection.string_type
+            ]
+        ]);
+}
+class ValuesTypes_MatrixAnswerTS extends _Types.Record {
+    constructor(FieldKey, Description, Values){
+        super();
+        this.FieldKey = FieldKey;
+        this.Description = Description;
+        this.Values = Values;
+    }
+}
+function ValuesTypes_MatrixAnswerTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.MatrixAnswerTS", [], ValuesTypes_MatrixAnswerTS, ()=>[
+            [
+                "FieldKey",
+                (0, _FormSpecApiOption.Types_FieldKeyTS_$reflection)()
+            ],
+            [
+                "Description",
+                _Reflection.string_type
+            ],
+            [
+                "Values",
+                (0, _Reflection.array_type)((0, _Reflection.tuple_type)((0, _FormSpecApiOption.Types_MatrixItemKeyTS_$reflection)(), _Reflection.string_type))
+            ]
+        ]);
+}
+class ValuesTypes_FieldValueTS extends _Types.Record {
+    constructor(Type, FieldAnswer, FieldAnswers, MatrixAnswer){
+        super();
+        this.Type = Type;
+        this.FieldAnswer = FieldAnswer;
+        this.FieldAnswers = FieldAnswers;
+        this.MatrixAnswer = MatrixAnswer;
+    }
+}
+function ValuesTypes_FieldValueTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.FieldValueTS", [], ValuesTypes_FieldValueTS, ()=>[
+            [
+                "Type",
+                _Reflection.string_type
+            ],
+            [
+                "FieldAnswer",
+                (0, _Reflection.option_type)(ValuesTypes_FieldAnswerTS_$reflection())
+            ],
+            [
+                "FieldAnswers",
+                (0, _Reflection.option_type)((0, _Reflection.array_type)(ValuesTypes_FieldAnswerTS_$reflection()))
+            ],
+            [
+                "MatrixAnswer",
+                (0, _Reflection.option_type)(ValuesTypes_MatrixAnswerTS_$reflection())
+            ]
+        ]);
+}
+class ValuesTypes_FieldDetailsTS extends _Types.Record {
+    constructor(FieldOrder, Key, Label, FieldValue, FieldType, Options){
+        super();
+        this.FieldOrder = FieldOrder | 0;
+        this.Key = Key;
+        this.Label = Label;
+        this.FieldValue = FieldValue;
+        this.FieldType = FieldType;
+        this.Options = Options;
+    }
+}
+function ValuesTypes_FieldDetailsTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.FieldDetailsTS", [], ValuesTypes_FieldDetailsTS, ()=>[
+            [
+                "FieldOrder",
+                _Reflection.int32_type
+            ],
+            [
+                "Key",
+                (0, _FormSpecApiOption.Types_FieldKeyTS_$reflection)()
+            ],
+            [
+                "Label",
+                _Reflection.string_type
+            ],
+            [
+                "FieldValue",
+                ValuesTypes_FieldValueTS_$reflection()
+            ],
+            [
+                "FieldType",
+                (0, _FormSpecApiOption.Types_FieldTypeTS_$reflection)()
+            ],
+            [
+                "Options",
+                (0, _Reflection.array_type)((0, _FormSpecApiOption.Types_FieldOptionTS_$reflection)())
+            ]
+        ]);
+}
+class ValuesTypes_FormStatusTS extends _Types.Record {
+    constructor(Type, DraftId){
+        super();
+        this.Type = Type;
+        this.DraftId = DraftId;
+    }
+}
+function ValuesTypes_FormStatusTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.FormStatusTS", [], ValuesTypes_FormStatusTS, ()=>[
+            [
+                "Type",
+                _Reflection.string_type
+            ],
+            [
+                "DraftId",
+                (0, _Reflection.option_type)(_Reflection.string_type)
+            ]
+        ]);
+}
+class ValuesTypes_SignatureTS extends _Types.Record {
+    constructor(ApprovedById, ApprovedByFullName, ApprovedByDate, ApprovalSignature, SignatureType){
+        super();
+        this.ApprovedById = ApprovedById;
+        this.ApprovedByFullName = ApprovedByFullName;
+        this.ApprovedByDate = ApprovedByDate;
+        this.ApprovalSignature = ApprovalSignature;
+        this.SignatureType = SignatureType | 0;
+    }
+}
+function ValuesTypes_SignatureTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.SignatureTS", [], ValuesTypes_SignatureTS, ()=>[
+            [
+                "ApprovedById",
+                _Reflection.string_type
+            ],
+            [
+                "ApprovedByFullName",
+                _Reflection.string_type
+            ],
+            [
+                "ApprovedByDate",
+                _Reflection.string_type
+            ],
+            [
+                "ApprovalSignature",
+                _Reflection.string_type
+            ],
+            [
+                "SignatureType",
+                (0, _Reflection.enum_type)("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.SignatureTypeTS", _Reflection.int32_type, [
+                    [
+                        "Review",
+                        0
+                    ],
+                    [
+                        "Approval",
+                        1
+                    ]
+                ])
+            ]
+        ]);
+}
+class ValuesTypes_DynamicFormSpecDetailsTS extends _Types.Record {
+    constructor(FormSpecId, FormSpecCode, FormSpecVersion, DynamicVersion, MaxScore, Status, Signatures){
+        super();
+        this.FormSpecId = FormSpecId;
+        this.FormSpecCode = FormSpecCode;
+        this.FormSpecVersion = FormSpecVersion;
+        this.DynamicVersion = DynamicVersion;
+        this.MaxScore = MaxScore;
+        this.Status = Status;
+        this.Signatures = Signatures;
+    }
+}
+function ValuesTypes_DynamicFormSpecDetailsTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.DynamicFormSpecDetailsTS", [], ValuesTypes_DynamicFormSpecDetailsTS, ()=>[
+            [
+                "FormSpecId",
+                _Reflection.string_type
+            ],
+            [
+                "FormSpecCode",
+                (0, _Reflection.option_type)(_Reflection.string_type)
+            ],
+            [
+                "FormSpecVersion",
+                _Reflection.string_type
+            ],
+            [
+                "DynamicVersion",
+                _Reflection.string_type
+            ],
+            [
+                "MaxScore",
+                (0, _Reflection.option_type)((0, _FormSpecApiOption.Types_ScoreTS_$reflection)())
+            ],
+            [
+                "Status",
+                ValuesTypes_FormStatusTS_$reflection()
+            ],
+            [
+                "Signatures",
+                (0, _Reflection.array_type)(ValuesTypes_SignatureTS_$reflection())
+            ]
+        ]);
+}
+class ValuesTypes_FableFormStateTS extends _Types.Record {
+    constructor(Type, Error$, Success){
+        super();
+        this.Type = Type;
+        this.Error = Error$;
+        this.Success = Success;
+    }
+}
+function ValuesTypes_FableFormStateTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.FableFormStateTS", [], ValuesTypes_FableFormStateTS, ()=>[
+            [
+                "Type",
+                _Reflection.string_type
+            ],
+            [
+                "Error",
+                (0, _Reflection.option_type)(_Reflection.string_type)
+            ],
+            [
+                "Success",
+                (0, _Reflection.option_type)(_Reflection.string_type)
+            ]
+        ]);
+}
+class ValuesTypes_ErrorTrackingTS extends _Types.Record {
+    constructor(Type, ShowAllErrors, ShowFieldError){
+        super();
+        this.Type = Type;
+        this.ShowAllErrors = ShowAllErrors;
+        this.ShowFieldError = ShowFieldError;
+    }
+}
+function ValuesTypes_ErrorTrackingTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.ErrorTrackingTS", [], ValuesTypes_ErrorTrackingTS, ()=>[
+            [
+                "Type",
+                _Reflection.string_type
+            ],
+            [
+                "ShowAllErrors",
+                _Reflection.bool_type
+            ],
+            [
+                "ShowFieldError",
+                (0, _Reflection.array_type)(_Reflection.string_type)
+            ]
+        ]);
+}
+class ValuesTypes_FableFormModelTS extends _Types.Record {
+    constructor(Values, State, ErrorTracking){
+        super();
+        this.Values = Values;
+        this.State = State;
+        this.ErrorTracking = ErrorTracking;
+    }
+}
+function ValuesTypes_FableFormModelTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.FableFormModelTS", [], ValuesTypes_FableFormModelTS, ()=>[
+            [
+                "Values",
+                (0, _Reflection.array_type)((0, _Reflection.tuple_type)((0, _FormSpecApiOption.Types_FieldKeyTS_$reflection)(), ValuesTypes_FieldDetailsTS_$reflection()))
+            ],
+            [
+                "State",
+                ValuesTypes_FableFormStateTS_$reflection()
+            ],
+            [
+                "ErrorTracking",
+                ValuesTypes_ErrorTrackingTS_$reflection()
+            ]
+        ]);
+}
+class ValuesTypes_DynamicFormTS extends _Types.Record {
+    constructor(DynamicFormSpecDetails, Steps){
+        super();
+        this.DynamicFormSpecDetails = DynamicFormSpecDetails;
+        this.Steps = Steps;
+    }
+}
+function ValuesTypes_DynamicFormTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.DynamicFormTS", [], ValuesTypes_DynamicFormTS, ()=>[
+            [
+                "DynamicFormSpecDetails",
+                ValuesTypes_DynamicFormSpecDetailsTS_$reflection()
+            ],
+            [
+                "Steps",
+                (0, _Reflection.array_type)((0, _Reflection.tuple_type)(_Reflection.int32_type, ValuesTypes_FableFormModelTS_$reflection()))
+            ]
+        ]);
+}
+class ValuesTypes_DynamicFormResultDataTS extends _Types.Record {
+    constructor(ResultFormSpecDetails, ResultSteps){
+        super();
+        this.ResultFormSpecDetails = ResultFormSpecDetails;
+        this.ResultSteps = ResultSteps;
+    }
+}
+function ValuesTypes_DynamicFormResultDataTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.ValuesTypes.DynamicFormResultDataTS", [], ValuesTypes_DynamicFormResultDataTS, ()=>[
+            [
+                "ResultFormSpecDetails",
+                ValuesTypes_DynamicFormSpecDetailsTS_$reflection()
+            ],
+            [
+                "ResultSteps",
+                (0, _Reflection.array_type)((0, _Reflection.tuple_type)(_Reflection.int32_type, (0, _Reflection.array_type)((0, _Reflection.tuple_type)((0, _FormSpecApiOption.Types_FieldKeyTS_$reflection)(), ValuesTypes_FieldDetailsTS_$reflection()))))
+            ]
+        ]);
+}
+function ValuesConverters_fieldAnswerToTS(answer) {
+    return new ValuesTypes_FieldAnswerTS((0, _FormSpecApiOption.Converters_fieldKeyToTS)(answer.FieldKey), answer.Description, answer.Value);
+}
+function ValuesConverters_fieldAnswerFromTS(answer) {
+    const matchValue = (0, _FormSpecApiOption.Converters_fieldKeyFromTS)(answer.FieldKey);
+    if (matchValue == null) {
+        return undefined;
+    } else {
+        return new _FormSpec.Shared_FieldAnswer((0, _Option.value)(matchValue), answer.Description, answer.Value);
+    }
+}
+function ValuesConverters_matrixAnswerToTS(answer) {
+    return new ValuesTypes_MatrixAnswerTS((0, _FormSpecApiOption.Converters_fieldKeyToTS)(answer.FieldKey), answer.Description, (0, _List.toArray)((0, _List.map)((tupledArg)=>[
+            new _FormSpecApiOption.Types_MatrixItemKeyTS(tupledArg[0].fields[0]),
+            tupledArg[1]
+        ], (0, _Map.toList)(answer.Values))));
+}
+function ValuesConverters_matrixAnswerFromTS(answer) {
+    const matchValue = (0, _FormSpecApiOption.Converters_fieldKeyFromTS)(answer.FieldKey);
+    if (matchValue == null) {
+        return undefined;
+    } else {
+        const fieldKey = (0, _Option.value)(matchValue);
+        let valuesMap;
+        const array_1 = (0, _Array.map)((tupledArg)=>{
+            let matchValue_1;
+            let outArg = "00000000-0000-0000-0000-000000000000";
+            matchValue_1 = [
+                (0, _Guid.tryParse)(tupledArg[0].Value, new _Types.FSharpRef(()=>outArg, (v)=>{
+                    outArg = v;
+                })),
+                outArg
+            ];
+            if (matchValue_1[0]) {
+                return [
+                    new _FormSpec.Shared_MatrixItemKey(matchValue_1[1]),
+                    tupledArg[1]
+                ];
+            } else {
+                return undefined;
+            }
+        }, answer.Values);
+        valuesMap = (0, _Array.fold)((acc, item)=>{
+            let matchResult, key, map, value_1;
+            if (acc != null) {
+                if (item != null) {
+                    matchResult = 0;
+                    key = (0, _Option.value)(item)[0];
+                    map = (0, _Option.value)(acc);
+                    value_1 = (0, _Option.value)(item)[1];
+                } else {
+                    matchResult = 1;
+                }
+            } else {
+                matchResult = 1;
+            }
+            switch(matchResult){
+                case 0:
+                    return (0, _Map.add)(key, value_1, map);
+                default:
+                    return undefined;
+            }
+        }, (0, _Map.empty)({
+            Compare: _Util.compare
+        }), array_1);
+        if (valuesMap == null) {
+            return undefined;
+        } else {
+            return new _FormSpec.Shared_MatrixAnswer(fieldKey, answer.Description, (0, _Option.value)(valuesMap));
+        }
+    }
+}
+function ValuesConverters_fieldValueToTS(value) {
+    switch(value.tag){
+        case /* Multiple */ 1:
+            return new ValuesTypes_FieldValueTS("Multiple", undefined, (0, _List.toArray)((0, _List.map)(ValuesConverters_fieldAnswerToTS, (0, _Set.toList)(value.fields[0]))), undefined);
+        case /* Matrix */ 2:
+            return new ValuesTypes_FieldValueTS("Matrix", undefined, undefined, ValuesConverters_matrixAnswerToTS(value.fields[0]));
+        case /* PluginData */ 3:
+            {
+                const pluginData = value.fields[0];
+                return new ValuesTypes_FieldValueTS("PluginData", undefined, undefined, undefined);
+            }
+        default:
+            return new ValuesTypes_FieldValueTS("Single", ValuesConverters_fieldAnswerToTS(value.fields[0]), undefined, undefined);
+    }
+}
+function ValuesConverters_fieldValueFromTS(value) {
+    const matchValue = value.Type;
+    switch(matchValue){
+        case "Single":
+            {
+                const matchValue_1 = value.FieldAnswer;
+                if (matchValue_1 == null) {
+                    return undefined;
+                } else {
+                    const matchValue_2 = ValuesConverters_fieldAnswerFromTS((0, _Option.value)(matchValue_1));
+                    if (matchValue_2 == null) {
+                        return undefined;
+                    } else {
+                        return (0, _FormSpec.Shared_FieldValue_Single)((0, _Option.value)(matchValue_2));
+                    }
+                }
+            }
+        case "Multiple":
+            {
+                const matchValue_3 = value.FieldAnswers;
+                if (matchValue_3 == null) {
+                    return undefined;
+                } else {
+                    let convertedAnswers;
+                    const array_1 = (0, _Array.map)(ValuesConverters_fieldAnswerFromTS, (0, _Option.value)(matchValue_3));
+                    convertedAnswers = (0, _Array.fold)((acc, answer_2)=>{
+                        let matchResult, item, set$;
+                        if (acc != null) {
+                            if (answer_2 != null) {
+                                matchResult = 0;
+                                item = (0, _Option.value)(answer_2);
+                                set$ = (0, _Option.value)(acc);
+                            } else {
+                                matchResult = 1;
+                            }
+                        } else {
+                            matchResult = 1;
+                        }
+                        switch(matchResult){
+                            case 0:
+                                return (0, _Set.add)(item, set$);
+                            default:
+                                return undefined;
+                        }
+                    }, (0, _Set.empty)({
+                        Compare: _Util.compare
+                    }), array_1);
+                    if (convertedAnswers == null) {
+                        return undefined;
+                    } else {
+                        return (0, _FormSpec.Shared_FieldValue_Multiple)((0, _Option.value)(convertedAnswers));
+                    }
+                }
+            }
+        case "Matrix":
+            {
+                const matchValue_5 = value.MatrixAnswer;
+                if (matchValue_5 == null) {
+                    return undefined;
+                } else {
+                    const matchValue_6 = ValuesConverters_matrixAnswerFromTS((0, _Option.value)(matchValue_5));
+                    if (matchValue_6 == null) {
+                        return undefined;
+                    } else {
+                        return (0, _FormSpec.Shared_FieldValue_Matrix)((0, _Option.value)(matchValue_6));
+                    }
+                }
+            }
+        default:
+            return undefined;
+    }
+}
+function ValuesConverters_fieldDetailsToTS(details) {
+    return new ValuesTypes_FieldDetailsTS(details.FieldOrder, (0, _FormSpecApiOption.Converters_fieldKeyToTS)(details.Key), details.Label, ValuesConverters_fieldValueToTS(details.FieldValue), (0, _FormSpecApiOption.Converters_fieldTypeToTS)(details.FieldType), (0, _List.toArray)((0, _List.map)(_FormSpecApiOption.Converters_fieldOptionToTS, details.Options)));
+}
+function ValuesConverters_fieldDetailsFromTS(details) {
+    const matchValue = (0, _FormSpecApiOption.Converters_fieldKeyFromTS)(details.Key);
+    const matchValue_1 = ValuesConverters_fieldValueFromTS(details.FieldValue);
+    const matchValue_2 = (0, _FormSpecApiOption.Converters_fieldTypeFromTS)(details.FieldType);
+    let matchResult, fieldType, fieldValue, key;
+    if (matchValue != null) {
+        if (matchValue_1 != null) {
+            if (matchValue_2 != null) {
+                matchResult = 0;
+                fieldType = (0, _Option.value)(matchValue_2);
+                fieldValue = (0, _Option.value)(matchValue_1);
+                key = (0, _Option.value)(matchValue);
+            } else {
+                matchResult = 1;
+            }
+        } else {
+            matchResult = 1;
+        }
+    } else {
+        matchResult = 1;
+    }
+    switch(matchResult){
+        case 0:
+            {
+                const options = (0, _Array.fold)((acc, opt)=>{
+                    let matchResult_1, item, list;
+                    if (acc != null) {
+                        if (opt != null) {
+                            matchResult_1 = 0;
+                            item = (0, _Option.value)(opt);
+                            list = (0, _Option.value)(acc);
+                        } else {
+                            matchResult_1 = 1;
+                        }
+                    } else {
+                        matchResult_1 = 1;
+                    }
+                    switch(matchResult_1){
+                        case 0:
+                            return (0, _List.cons)(item, list);
+                        default:
+                            return undefined;
+                    }
+                }, (0, _List.empty)(), (0, _Array.map)(_FormSpecApiOption.Converters_fieldOptionFromTS, details.Options));
+                if (options == null) {
+                    return undefined;
+                } else {
+                    return new _FormSpec.Values_FieldDetails$1(details.FieldOrder, key, details.Label, fieldValue, fieldType, (0, _List.reverse)((0, _Option.value)(options)));
+                }
+            }
+        default:
+            return undefined;
+    }
+}
+function ValuesConverters_formStatusToTS(status) {
+    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);
+    }
+}
+function ValuesConverters_formStatusFromTS(status) {
+    const matchValue = status.Type;
+    switch(matchValue){
+        case "Pending":
+            return (0, _FormSpec.Values_FormStatus_Pending)();
+        case "Draft":
+            {
+                const matchValue_1 = status.DraftId;
+                if (matchValue_1 == null) {
+                    return undefined;
+                } else {
+                    let matchValue_2;
+                    let outArg = "00000000-0000-0000-0000-000000000000";
+                    matchValue_2 = [
+                        (0, _Guid.tryParse)((0, _Option.value)(matchValue_1), new _Types.FSharpRef(()=>outArg, (v)=>{
+                            outArg = v;
+                        })),
+                        outArg
+                    ];
+                    if (matchValue_2[0]) {
+                        return (0, _FormSpec.Values_FormStatus_Draft)(matchValue_2[1]);
+                    } else {
+                        return undefined;
+                    }
+                }
+            }
+        case "WaitingForReview":
+            return (0, _FormSpec.Values_FormStatus_WaitingForReview)();
+        case "WaitingForApproval":
+            return (0, _FormSpec.Values_FormStatus_WaitingForApproval)();
+        case "Complete":
+            return (0, _FormSpec.Values_FormStatus_Complete)();
+        default:
+            return undefined;
+    }
+}
+function ValuesConverters_signatureTypeToTS(sigType) {
+    if (sigType.tag === /* Approval */ 1) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+function ValuesConverters_signatureTypeFromTS(sigType) {
+    switch(sigType){
+        case 0:
+            return (0, _FormSpec.Values_SignatureType_Review)();
+        case 1:
+            return (0, _FormSpec.Values_SignatureType_Approval)();
+        default:
+            return undefined;
+    }
+}
+function ValuesConverters_signatureToTS(signature) {
+    return new ValuesTypes_SignatureTS(signature.ApprovedById, signature.ApprovedByFullName, (0, _Date.toString)(signature.ApprovedByDate, "O"), signature.ApprovalSignature, ValuesConverters_signatureTypeToTS(signature.SignatureType));
+}
+function ValuesConverters_signatureFromTS(signature) {
+    let matchValue;
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = [
+        (0, _Guid.tryParse)(signature.ApprovedById, new _Types.FSharpRef(()=>outArg, (v)=>{
+            outArg = v;
+        })),
+        outArg
+    ];
+    let matchValue_1;
+    let outArg_1 = (0, _Date.minValue)();
+    matchValue_1 = [
+        (0, _Date.tryParse)(signature.ApprovedByDate, new _Types.FSharpRef(()=>outArg_1, (v_1)=>{
+            outArg_1 = v_1;
+        })),
+        outArg_1
+    ];
+    const matchValue_2 = ValuesConverters_signatureTypeFromTS(signature.SignatureType);
+    let matchResult;
+    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 _FormSpec.Values_Signature(matchValue[1], signature.ApprovedByFullName, matchValue_1[1], signature.ApprovalSignature, (0, _Option.value)(matchValue_2));
+        default:
+            return undefined;
+    }
+}
+function ValuesConverters_dynamicStepValuesToTS(stepValues) {
+    return (0, _List.toArray)((0, _List.map)((tupledArg)=>[
+            (0, _FormSpecApiOption.Converters_fieldKeyToTS)(tupledArg[0]),
+            ValuesConverters_fieldDetailsToTS(tupledArg[1])
+        ], (0, _Map.toList)(stepValues)));
+}
+function ValuesConverters_dynamicStepValuesFromTS(stepValues) {
+    const array_1 = (0, _Array.map)((tupledArg)=>{
+        const matchValue = (0, _FormSpecApiOption.Converters_fieldKeyFromTS)(tupledArg[0]);
+        const matchValue_1 = ValuesConverters_fieldDetailsFromTS(tupledArg[1]);
+        let matchResult, details, key;
+        if (matchValue != null) {
+            if (matchValue_1 != null) {
+                matchResult = 0;
+                details = (0, _Option.value)(matchValue_1);
+                key = (0, _Option.value)(matchValue);
+            } else {
+                matchResult = 1;
+            }
+        } else {
+            matchResult = 1;
+        }
+        switch(matchResult){
+            case 0:
+                return [
+                    key,
+                    details
+                ];
+            default:
+                return undefined;
+        }
+    }, stepValues);
+    return (0, _Array.fold)((acc, item)=>{
+        let matchResult_1, details_1, key_1, map;
+        if (acc != null) {
+            if (item != null) {
+                matchResult_1 = 0;
+                details_1 = (0, _Option.value)(item)[1];
+                key_1 = (0, _Option.value)(item)[0];
+                map = (0, _Option.value)(acc);
+            } else {
+                matchResult_1 = 1;
+            }
+        } else {
+            matchResult_1 = 1;
+        }
+        switch(matchResult_1){
+            case 0:
+                return (0, _Map.add)(key_1, details_1, map);
+            default:
+                return undefined;
+        }
+    }, (0, _Map.empty)({
+        Compare: _Util.compare
+    }), array_1);
+}
+function ValuesConverters_dynamicFormSpecDetailsToTS(details) {
+    return new ValuesTypes_DynamicFormSpecDetailsTS(details.FormSpecId, details.FormSpecCode, details.FormSpecVersion, details.DynamicVersion, (0, _Option.map)(_FormSpecApiOption.Converters_scoreToTS, details.MaxScore), ValuesConverters_formStatusToTS(details.Status), (0, _List.toArray)((0, _List.map)(ValuesConverters_signatureToTS, details.Signatures)));
+}
+function ValuesConverters_dynamicFormSpecDetailsFromTS(details) {
+    let matchValue;
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = [
+        (0, _Guid.tryParse)(details.FormSpecId, new _Types.FSharpRef(()=>outArg, (v)=>{
+            outArg = v;
+        })),
+        outArg
+    ];
+    if (matchValue[0]) {
+        const statusResult = ValuesConverters_formStatusFromTS(details.Status);
+        const signaturesResult = (0, _Array.fold)((acc, sigOpt)=>{
+            let matchResult, item, list;
+            if (acc != null) {
+                if (sigOpt != null) {
+                    matchResult = 0;
+                    item = (0, _Option.value)(sigOpt);
+                    list = (0, _Option.value)(acc);
+                } else {
+                    matchResult = 1;
+                }
+            } else {
+                matchResult = 1;
+            }
+            switch(matchResult){
+                case 0:
+                    return (0, _List.cons)(item, list);
+                default:
+                    return undefined;
+            }
+        }, (0, _List.empty)(), (0, _Array.map)(ValuesConverters_signatureFromTS, details.Signatures));
+        let maxScoreResult;
+        const matchValue_2 = details.MaxScore;
+        maxScoreResult = matchValue_2 == null ? undefined : (0, _FormSpecApiOption.Converters_scoreFromTS)((0, _Option.value)(matchValue_2));
+        let matchResult_1, signatures, status;
+        if (statusResult != null) {
+            if (signaturesResult != null) {
+                matchResult_1 = 0;
+                signatures = (0, _Option.value)(signaturesResult);
+                status = (0, _Option.value)(statusResult);
+            } else {
+                matchResult_1 = 1;
+            }
+        } else {
+            matchResult_1 = 1;
+        }
+        switch(matchResult_1){
+            case 0:
+                return new _FormSpec.Values_DynamicFormSpecDetails(matchValue[1], details.FormSpecCode, details.FormSpecVersion, details.DynamicVersion, maxScoreResult, status, (0, _List.reverse)(signatures));
+            default:
+                return undefined;
+        }
+    } else {
+        return undefined;
+    }
+}
+function ValuesConverters_fableFormStateToTS(state) {
+    return undefined;
+}
+function ValuesConverters_fableFormStateFromTS(state) {
+    const matchValue = state.Type;
+    switch(matchValue){
+        case "Idle":
+            return (0, _Option.some)("Idle");
+        case "Loading":
+            return (0, _Option.some)("Loading");
+        case "Error":
+            {
+                const matchValue_1 = state.Error;
+                if (matchValue_1 == null) {
+                    return undefined;
+                } else {
+                    return (0, _Option.some)({
+                        Error: (0, _Option.value)(matchValue_1)
+                    });
+                }
+            }
+        case "Success":
+            {
+                const matchValue_2 = state.Success;
+                if (matchValue_2 == null) {
+                    return undefined;
+                } else {
+                    return (0, _Option.some)({
+                        Success: (0, _Option.value)(matchValue_2)
+                    });
+                }
+            }
+        default:
+            return undefined;
+    }
+}
+function ValuesConverters_errorTrackingToTS(tracking) {
+    return undefined;
+}
+function ValuesConverters_errorTrackingFromTS(tracking) {
+    return (0, _Option.some)({
+        ShowAllErrors: tracking.ShowAllErrors,
+        ShowFieldError: (0, _Set.ofArray)(tracking.ShowFieldError, {
+            Compare: _Util.comparePrimitives
+        })
+    });
+}
+function ValuesConverters_fableFormModelToTS(model) {
+    return undefined;
+}
+function ValuesConverters_fableFormModelFromTS(model) {
+    const matchValue = ValuesConverters_dynamicStepValuesFromTS(model.Values);
+    const matchValue_1 = ValuesConverters_fableFormStateFromTS(model.State);
+    const matchValue_2 = ValuesConverters_errorTrackingFromTS(model.ErrorTracking);
+    let matchResult, errorTracking, state, values;
+    if (matchValue != null) {
+        if (matchValue_1 != null) {
+            if (matchValue_2 != null) {
+                matchResult = 0;
+                errorTracking = (0, _Option.value)(matchValue_2);
+                state = (0, _Option.value)(matchValue_1);
+                values = (0, _Option.value)(matchValue);
+            } else {
+                matchResult = 1;
+            }
+        } else {
+            matchResult = 1;
+        }
+    } else {
+        matchResult = 1;
+    }
+    switch(matchResult){
+        case 0:
+            return (0, _Option.some)({
+                ErrorTracking: errorTracking,
+                State: state,
+                Values: values
+            });
+        default:
+            return undefined;
+    }
+}
+function ValuesConverters_dynamicFormToTS(form) {
+    try {
+        const detailsTS = ValuesConverters_dynamicFormSpecDetailsToTS(form.DynamicFormSpecDetails);
+        const stepsTS = (0, _List.fold)((acc, item)=>{
+            let matchResult, list_1, model_1, order;
+            if (acc != null) {
+                if (item != null) {
+                    matchResult = 0;
+                    list_1 = (0, _Option.value)(acc);
+                    model_1 = (0, _Option.value)(item)[1];
+                    order = (0, _Option.value)(item)[0];
+                } else {
+                    matchResult = 1;
+                }
+            } else {
+                matchResult = 1;
+            }
+            switch(matchResult){
+                case 0:
+                    return (0, _List.cons)([
+                        order,
+                        model_1
+                    ], list_1);
+                default:
+                    return undefined;
+            }
+        }, (0, _List.empty)(), (0, _List.map)((tupledArg)=>{
+            const stepOrder = tupledArg[0].fields[0] | 0;
+            const matchValue = ValuesConverters_fableFormModelToTS(tupledArg[1]);
+            if (matchValue == null) {
+                return undefined;
+            } else {
+                return [
+                    stepOrder,
+                    (0, _Option.value)(matchValue)
+                ];
+            }
+        }, (0, _Map.toList)(form.Steps)));
+        return stepsTS == null ? undefined : new ValuesTypes_DynamicFormTS(detailsTS, (0, _List.toArray)((0, _List.reverse)((0, _Option.value)(stepsTS))));
+    } catch (matchValue_2) {
+        return undefined;
+    }
+}
+function ValuesConverters_dynamicFormFromTS(form) {
+    const matchValue = ValuesConverters_dynamicFormSpecDetailsFromTS(form.DynamicFormSpecDetails);
+    if (matchValue == null) {
+        return undefined;
+    } else {
+        const details = (0, _Option.value)(matchValue);
+        let steps;
+        const array_1 = (0, _Array.map)((tupledArg)=>{
+            const matchValue_1 = ValuesConverters_fableFormModelFromTS(tupledArg[1]);
+            if (matchValue_1 == null) {
+                return undefined;
+            } else {
+                return [
+                    new _FormSpec.Values_StepOrder(tupledArg[0]),
+                    (0, _Option.value)(matchValue_1)
+                ];
+            }
+        }, form.Steps);
+        steps = (0, _Array.fold)((acc, item)=>{
+            let matchResult, map, model_1, order;
+            if (acc != null) {
+                if (item != null) {
+                    matchResult = 0;
+                    map = (0, _Option.value)(acc);
+                    model_1 = (0, _Option.value)(item)[1];
+                    order = (0, _Option.value)(item)[0];
+                } else {
+                    matchResult = 1;
+                }
+            } else {
+                matchResult = 1;
+            }
+            switch(matchResult){
+                case 0:
+                    return (0, _Map.add)(order, model_1, map);
+                default:
+                    return undefined;
+            }
+        }, (0, _Map.empty)({
+            Compare: _Util.compare
+        }), array_1);
+        if (steps == null) {
+            return undefined;
+        } else {
+            return (0, _Option.some)({
+                DynamicFormSpecDetails: details,
+                Steps: (0, _Option.value)(steps)
+            });
+        }
+    }
+}
+function ValuesConverters_dynamicFormResultDataToTS(data) {
+    return new ValuesTypes_DynamicFormResultDataTS(ValuesConverters_dynamicFormSpecDetailsToTS(data.ResultFormSpecDetails), (0, _List.toArray)((0, _List.map)((tupledArg)=>[
+            tupledArg[0].fields[0],
+            ValuesConverters_dynamicStepValuesToTS(tupledArg[1])
+        ], (0, _Map.toList)(data.ResultSteps))));
+}
+function ValuesConverters_dynamicFormResultDataFromTS(data) {
+    const matchValue = ValuesConverters_dynamicFormSpecDetailsFromTS(data.ResultFormSpecDetails);
+    if (matchValue == null) {
+        return undefined;
+    } else {
+        const details = (0, _Option.value)(matchValue);
+        let resultSteps;
+        const array_1 = (0, _Array.map)((tupledArg)=>{
+            const matchValue_1 = ValuesConverters_dynamicStepValuesFromTS(tupledArg[1]);
+            if (matchValue_1 == null) {
+                return undefined;
+            } else {
+                return [
+                    new _FormSpec.Values_StepOrder(tupledArg[0]),
+                    (0, _Option.value)(matchValue_1)
+                ];
+            }
+        }, data.ResultSteps);
+        resultSteps = (0, _Array.fold)((acc, item)=>{
+            let matchResult, map, order, values;
+            if (acc != null) {
+                if (item != null) {
+                    matchResult = 0;
+                    map = (0, _Option.value)(acc);
+                    order = (0, _Option.value)(item)[0];
+                    values = (0, _Option.value)(item)[1];
+                } else {
+                    matchResult = 1;
+                }
+            } else {
+                matchResult = 1;
+            }
+            switch(matchResult){
+                case 0:
+                    return (0, _Map.add)(order, values, map);
+                default:
+                    return undefined;
+            }
+        }, (0, _Map.empty)({
+            Compare: _Util.compare
+        }), array_1);
+        if (resultSteps == null) {
+            return undefined;
+        } else {
+            return new _FormSpec.Values_DynamicFormResultData$1(details, (0, _Option.value)(resultSteps));
+        }
+    }
+}
+function ValuesValidators_validateDynamicFormResultData(input) {
+    const stringified = (0, _Encodefs.toString)(4, (0, _Encodefs.Auto_generateBoxedEncoder_437914C6)(_Reflection.obj_type, undefined, undefined, undefined)(input));
+    return (0, _Result.Result_ToOption)((0, _Decodefs.fromString)((0, _Util.uncurry2)((0, _Decodefs.Auto_generateBoxedDecoder_Z6670B51)(ValuesTypes_DynamicFormResultDataTS_$reflection(), undefined, undefined)), stringified));
+}
+function ValuesValidators_validateAndConvertDynamicFormResultData(input) {
+    const matchValue = ValuesValidators_validateDynamicFormResultData(input);
+    if (matchValue == null) {
+        return undefined;
+    } else {
+        return ValuesConverters_dynamicFormResultDataFromTS((0, _Option.value)(matchValue));
+    }
+}
+function ValuesValidators_validateDynamicForm(input) {
+    const stringified = (0, _Encodefs.toString)(4, (0, _Encodefs.Auto_generateBoxedEncoder_437914C6)(_Reflection.obj_type, undefined, undefined, undefined)(input));
+    return (0, _Result.Result_ToOption)((0, _Decodefs.fromString)((0, _Util.uncurry2)((0, _Decodefs.Auto_generateBoxedDecoder_Z6670B51)(ValuesTypes_DynamicFormTS_$reflection(), undefined, undefined)), stringified));
+}
+function ValuesValidators_validateFieldAnswer(input) {
+    const stringified = (0, _Encodefs.toString)(4, (0, _Encodefs.Auto_generateBoxedEncoder_437914C6)(_Reflection.obj_type, undefined, undefined, undefined)(input));
+    return (0, _Result.Result_ToOption)((0, _Decodefs.fromString)((0, _Util.uncurry2)((0, _Decodefs.Auto_generateBoxedDecoder_Z6670B51)(ValuesTypes_FieldAnswerTS_$reflection(), undefined, undefined)), stringified));
+}
+function ValuesValidators_validateFieldValue(input) {
+    const stringified = (0, _Encodefs.toString)(4, (0, _Encodefs.Auto_generateBoxedEncoder_437914C6)(_Reflection.obj_type, undefined, undefined, undefined)(input));
+    return (0, _Result.Result_ToOption)((0, _Decodefs.fromString)((0, _Util.uncurry2)((0, _Decodefs.Auto_generateBoxedDecoder_Z6670B51)(ValuesTypes_FieldValueTS_$reflection(), undefined, undefined)), stringified));
+}
+function ValuesBuilders_createFieldAnswer(fieldKey, description, value) {
+    return new ValuesTypes_FieldAnswerTS(fieldKey, description, value);
+}
+function ValuesBuilders_createSingleFieldValue(answer) {
+    return new ValuesTypes_FieldValueTS("Single", answer, undefined, undefined);
+}
+function ValuesBuilders_createMultipleFieldValue(answers) {
+    return new ValuesTypes_FieldValueTS("Multiple", undefined, answers, undefined);
+}
+function ValuesBuilders_createMatrixFieldValue(answer) {
+    return new ValuesTypes_FieldValueTS("Matrix", undefined, undefined, answer);
+}
+function ValuesBuilders_createPendingStatus() {
+    return new ValuesTypes_FormStatusTS("Pending", undefined);
+}
+function ValuesBuilders_createDraftStatus(draftId) {
+    return new ValuesTypes_FormStatusTS("Draft", draftId);
+}
+function ValuesBuilders_createCompleteStatus() {
+    return new ValuesTypes_FormStatusTS("Complete", undefined);
+}
+function ValuesApi_validateDynamicFormResultData() {
+    return ValuesValidators_validateDynamicFormResultData;
+}
+function ValuesApi_validateAndConvertDynamicFormResultData() {
+    return ValuesValidators_validateAndConvertDynamicFormResultData;
+}
+function ValuesApi_validateDynamicForm() {
+    return ValuesValidators_validateDynamicForm;
+}
+function ValuesApi_validateFieldAnswer() {
+    return ValuesValidators_validateFieldAnswer;
+}
+function ValuesApi_validateFieldValue() {
+    return ValuesValidators_validateFieldValue;
+}
+function ValuesApi_dynamicFormResultDataToTypeScript(data) {
+    return ValuesConverters_dynamicFormResultDataToTS(data);
+}
+function ValuesApi_dynamicFormResultDataFromTypeScript(data) {
+    return ValuesConverters_dynamicFormResultDataFromTS(data);
+}
+function ValuesApi_dynamicFormToTypeScript(form) {
+    return ValuesConverters_dynamicFormToTS(form);
+}
+function ValuesApi_dynamicFormFromTypeScript(form) {
+    return ValuesConverters_dynamicFormFromTS(form);
+}
+const ValuesApi_createFieldAnswer = (fieldKey)=>(description)=>(value)=>ValuesBuilders_createFieldAnswer(fieldKey, description, value);
+const ValuesApi_createSingleFieldValue = ValuesBuilders_createSingleFieldValue;
+const ValuesApi_createMultipleFieldValue = ValuesBuilders_createMultipleFieldValue;
+const ValuesApi_createMatrixFieldValue = ValuesBuilders_createMatrixFieldValue;
+const ValuesApi_createPendingStatus = ValuesBuilders_createPendingStatus;
+const ValuesApi_createDraftStatus = ValuesBuilders_createDraftStatus;
+const ValuesApi_createCompleteStatus = ValuesBuilders_createCompleteStatus;
+function ValuesApi_serializeDynamicFormResultData(data) {
+    return (0, _Encodefs.toString)(2, (0, _Encodefs.Auto_generateBoxedEncoder_437914C6)(ValuesTypes_DynamicFormResultDataTS_$reflection(), undefined, undefined, undefined)(data));
+}
+function ValuesApi_deserializeDynamicFormResultData(json) {
+    const matchValue = (0, _Decodefs.fromString)((0, _Util.uncurry2)((0, _Decodefs.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
+
+//# sourceMappingURL=FormSpec.Values.Api.Option.js.map