@f1studio/form-spec 5.0.0-alpha.101

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

@@ -0,0 +1,1961 @@
+"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 Api_deserializeFormSpecTS () {
+        return Api_deserializeFormSpecTS;
+    },
+    get Api_fieldKeyToTypeScript () {
+        return Api_fieldKeyToTypeScript;
+    },
+    get Api_findFieldByKey () {
+        return Api_findFieldByKey;
+    },
+    get Api_formSpecFromTypeScript () {
+        return Api_formSpecFromTypeScript;
+    },
+    get Api_formSpecToTypeScript () {
+        return Api_formSpecToTypeScript;
+    },
+    get Api_getFieldKeys () {
+        return Api_getFieldKeys;
+    },
+    get Api_getFieldsByType () {
+        return Api_getFieldsByType;
+    },
+    get Api_getFormSpecFSfromFormSpecTSjsonString () {
+        return Api_getFormSpecFSfromFormSpecTSjsonString;
+    },
+    get Api_getFormSpecSummary () {
+        return Api_getFormSpecSummary;
+    },
+    get Api_getFormSpecTSfromFormSpecFSjsonString () {
+        return Api_getFormSpecTSfromFormSpecFSjsonString;
+    },
+    get Api_isValidFormSpec () {
+        return Api_isValidFormSpec;
+    },
+    get Api_serializeFormSpec () {
+        return Api_serializeFormSpec;
+    },
+    get Api_validateAndConvertFormSpec () {
+        return Api_validateAndConvertFormSpec;
+    },
+    get Api_validateFormSpec () {
+        return Api_validateFormSpec;
+    },
+    get Converters_clinicalPathwayFromTS () {
+        return Converters_clinicalPathwayFromTS;
+    },
+    get Converters_clinicalPathwayToTS () {
+        return Converters_clinicalPathwayToTS;
+    },
+    get Converters_dependsOnFromTS () {
+        return Converters_dependsOnFromTS;
+    },
+    get Converters_dependsOnToTS () {
+        return Converters_dependsOnToTS;
+    },
+    get Converters_evaluatorFromTS () {
+        return Converters_evaluatorFromTS;
+    },
+    get Converters_evaluatorToTS () {
+        return Converters_evaluatorToTS;
+    },
+    get Converters_fieldKeyFromTS () {
+        return Converters_fieldKeyFromTS;
+    },
+    get Converters_fieldKeyToTS () {
+        return Converters_fieldKeyToTS;
+    },
+    get Converters_fieldOptionFromTS () {
+        return Converters_fieldOptionFromTS;
+    },
+    get Converters_fieldOptionKeyFromTS () {
+        return Converters_fieldOptionKeyFromTS;
+    },
+    get Converters_fieldOptionKeyToTS () {
+        return Converters_fieldOptionKeyToTS;
+    },
+    get Converters_fieldOptionToTS () {
+        return Converters_fieldOptionToTS;
+    },
+    get Converters_fieldTypeFromTS () {
+        return Converters_fieldTypeFromTS;
+    },
+    get Converters_fieldTypeToTS () {
+        return Converters_fieldTypeToTS;
+    },
+    get Converters_formFieldFromTS () {
+        return Converters_formFieldFromTS;
+    },
+    get Converters_formFieldToTS () {
+        return Converters_formFieldToTS;
+    },
+    get Converters_formSpecFromTS () {
+        return Converters_formSpecFromTS;
+    },
+    get Converters_formSpecToTS () {
+        return Converters_formSpecToTS;
+    },
+    get Converters_formStepFromTS () {
+        return Converters_formStepFromTS;
+    },
+    get Converters_formStepToTS () {
+        return Converters_formStepToTS;
+    },
+    get Converters_matrixItemKeyToTS () {
+        return Converters_matrixItemKeyToTS;
+    },
+    get Converters_messageTypeFromTS () {
+        return Converters_messageTypeFromTS;
+    },
+    get Converters_messageTypeToTS () {
+        return Converters_messageTypeToTS;
+    },
+    get Converters_scoreColorFromTS () {
+        return Converters_scoreColorFromTS;
+    },
+    get Converters_scoreColorToTS () {
+        return Converters_scoreColorToTS;
+    },
+    get Converters_scoreFromTS () {
+        return Converters_scoreFromTS;
+    },
+    get Converters_scoreRangeFromTS () {
+        return Converters_scoreRangeFromTS;
+    },
+    get Converters_scoreRangeToTS () {
+        return Converters_scoreRangeToTS;
+    },
+    get Converters_scoreToTS () {
+        return Converters_scoreToTS;
+    },
+    get Converters_stateKeyFromTS () {
+        return Converters_stateKeyFromTS;
+    },
+    get Converters_stateKeyToTS () {
+        return Converters_stateKeyToTS;
+    },
+    get Converters_transitionKeyToTS () {
+        return Converters_transitionKeyToTS;
+    },
+    get Types_BooleanInfoTS () {
+        return Types_BooleanInfoTS;
+    },
+    get Types_BooleanInfoTS_$reflection () {
+        return Types_BooleanInfoTS_$reflection;
+    },
+    get Types_CheckboxInfoTS () {
+        return Types_CheckboxInfoTS;
+    },
+    get Types_CheckboxInfoTS_$reflection () {
+        return Types_CheckboxInfoTS_$reflection;
+    },
+    get Types_ClinicalPathwaySpecTS () {
+        return Types_ClinicalPathwaySpecTS;
+    },
+    get Types_ClinicalPathwaySpecTS_$reflection () {
+        return Types_ClinicalPathwaySpecTS_$reflection;
+    },
+    get Types_DependsOnTS () {
+        return Types_DependsOnTS;
+    },
+    get Types_DependsOnTS_$reflection () {
+        return Types_DependsOnTS_$reflection;
+    },
+    get Types_FieldKeyTS () {
+        return Types_FieldKeyTS;
+    },
+    get Types_FieldKeyTS_$reflection () {
+        return Types_FieldKeyTS_$reflection;
+    },
+    get Types_FieldOptionKeyTS () {
+        return Types_FieldOptionKeyTS;
+    },
+    get Types_FieldOptionKeyTS_$reflection () {
+        return Types_FieldOptionKeyTS_$reflection;
+    },
+    get Types_FieldOptionTS () {
+        return Types_FieldOptionTS;
+    },
+    get Types_FieldOptionTS_$reflection () {
+        return Types_FieldOptionTS_$reflection;
+    },
+    get Types_FieldTypeTS () {
+        return Types_FieldTypeTS;
+    },
+    get Types_FieldTypeTS_$reflection () {
+        return Types_FieldTypeTS_$reflection;
+    },
+    get Types_FormFieldTS () {
+        return Types_FormFieldTS;
+    },
+    get Types_FormFieldTS_$reflection () {
+        return Types_FormFieldTS_$reflection;
+    },
+    get Types_FormSpecTS () {
+        return Types_FormSpecTS;
+    },
+    get Types_FormSpecTS_$reflection () {
+        return Types_FormSpecTS_$reflection;
+    },
+    get Types_FormStepTS () {
+        return Types_FormStepTS;
+    },
+    get Types_FormStepTS_$reflection () {
+        return Types_FormStepTS_$reflection;
+    },
+    get Types_MatrixInfoTS () {
+        return Types_MatrixInfoTS;
+    },
+    get Types_MatrixInfoTS_$reflection () {
+        return Types_MatrixInfoTS_$reflection;
+    },
+    get Types_MatrixItemKeyTS () {
+        return Types_MatrixItemKeyTS;
+    },
+    get Types_MatrixItemKeyTS_$reflection () {
+        return Types_MatrixItemKeyTS_$reflection;
+    },
+    get Types_MatrixItemTS () {
+        return Types_MatrixItemTS;
+    },
+    get Types_MatrixItemTS_$reflection () {
+        return Types_MatrixItemTS_$reflection;
+    },
+    get Types_MessageInfoTS () {
+        return Types_MessageInfoTS;
+    },
+    get Types_MessageInfoTS_$reflection () {
+        return Types_MessageInfoTS_$reflection;
+    },
+    get Types_MultiChoiceInfoTS () {
+        return Types_MultiChoiceInfoTS;
+    },
+    get Types_MultiChoiceInfoTS_$reflection () {
+        return Types_MultiChoiceInfoTS_$reflection;
+    },
+    get Types_PluginFieldConfigTS () {
+        return Types_PluginFieldConfigTS;
+    },
+    get Types_PluginFieldConfigTS_$reflection () {
+        return Types_PluginFieldConfigTS_$reflection;
+    },
+    get Types_ScoreRangeTS () {
+        return Types_ScoreRangeTS;
+    },
+    get Types_ScoreRangeTS_$reflection () {
+        return Types_ScoreRangeTS_$reflection;
+    },
+    get Types_ScoreTS () {
+        return Types_ScoreTS;
+    },
+    get Types_ScoreTS_$reflection () {
+        return Types_ScoreTS_$reflection;
+    },
+    get Types_SignatureInfoTS () {
+        return Types_SignatureInfoTS;
+    },
+    get Types_SignatureInfoTS_$reflection () {
+        return Types_SignatureInfoTS_$reflection;
+    },
+    get Types_SingleChoiceInfoTS () {
+        return Types_SingleChoiceInfoTS;
+    },
+    get Types_SingleChoiceInfoTS_$reflection () {
+        return Types_SingleChoiceInfoTS_$reflection;
+    },
+    get Types_StateKeyTS () {
+        return Types_StateKeyTS;
+    },
+    get Types_StateKeyTS_$reflection () {
+        return Types_StateKeyTS_$reflection;
+    },
+    get Types_TextInfoTS () {
+        return Types_TextInfoTS;
+    },
+    get Types_TextInfoTS_$reflection () {
+        return Types_TextInfoTS_$reflection;
+    },
+    get Types_TransitionKeyTS () {
+        return Types_TransitionKeyTS;
+    },
+    get Types_TransitionKeyTS_$reflection () {
+        return Types_TransitionKeyTS_$reflection;
+    },
+    get Validators_validateAndConvert () {
+        return Validators_validateAndConvert;
+    },
+    get Validators_validateFormSpec () {
+        return Validators_validateFormSpec;
+    }
+});
+const _Types = require("@fable-org/fable-library-js/Types.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 _Guid = require("@fable-org/fable-library-js/Guid.js");
+const _List = require("@fable-org/fable-library-js/List.js");
+const _Array = require("@fable-org/fable-library-js/Array.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");
+const _String = require("@fable-org/fable-library-js/String.js");
+class Types_FieldKeyTS extends _Types.Record {
+    constructor(Value){
+        super();
+        this.Value = Value;
+    }
+}
+function Types_FieldKeyTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.FieldKeyTS", [], Types_FieldKeyTS, ()=>[
+            [
+                "Value",
+                _Reflection.string_type
+            ]
+        ]);
+}
+class Types_StateKeyTS extends _Types.Record {
+    constructor(Value){
+        super();
+        this.Value = Value;
+    }
+}
+function Types_StateKeyTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.StateKeyTS", [], Types_StateKeyTS, ()=>[
+            [
+                "Value",
+                _Reflection.string_type
+            ]
+        ]);
+}
+class Types_TransitionKeyTS extends _Types.Record {
+    constructor(Value){
+        super();
+        this.Value = Value;
+    }
+}
+function Types_TransitionKeyTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.TransitionKeyTS", [], Types_TransitionKeyTS, ()=>[
+            [
+                "Value",
+                _Reflection.string_type
+            ]
+        ]);
+}
+class Types_MatrixItemKeyTS extends _Types.Record {
+    constructor(Value){
+        super();
+        this.Value = Value;
+    }
+}
+function Types_MatrixItemKeyTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.MatrixItemKeyTS", [], Types_MatrixItemKeyTS, ()=>[
+            [
+                "Value",
+                _Reflection.string_type
+            ]
+        ]);
+}
+class Types_FieldOptionKeyTS extends _Types.Record {
+    constructor(Value){
+        super();
+        this.Value = Value;
+    }
+}
+function Types_FieldOptionKeyTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.FieldOptionKeyTS", [], Types_FieldOptionKeyTS, ()=>[
+            [
+                "Value",
+                _Reflection.string_type
+            ]
+        ]);
+}
+class Types_FieldOptionTS extends _Types.Record {
+    constructor(Description, Value, OptionKey){
+        super();
+        this.Description = Description;
+        this.Value = Value;
+        this.OptionKey = OptionKey;
+    }
+}
+function Types_FieldOptionTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.FieldOptionTS", [], Types_FieldOptionTS, ()=>[
+            [
+                "Description",
+                _Reflection.string_type
+            ],
+            [
+                "Value",
+                _Reflection.string_type
+            ],
+            [
+                "OptionKey",
+                Types_FieldOptionKeyTS_$reflection()
+            ]
+        ]);
+}
+class Types_TextInfoTS extends _Types.Record {
+    constructor(Value){
+        super();
+        this.Value = Value;
+    }
+}
+function Types_TextInfoTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.TextInfoTS", [], Types_TextInfoTS, ()=>[
+            [
+                "Value",
+                (0, _Reflection.option_type)(_Reflection.string_type)
+            ]
+        ]);
+}
+class Types_BooleanInfoTS extends _Types.Record {
+    constructor(DefaultValue, Selection$){
+        super();
+        this.DefaultValue = DefaultValue;
+        this.Selection = Selection$;
+    }
+}
+function Types_BooleanInfoTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.BooleanInfoTS", [], Types_BooleanInfoTS, ()=>[
+            [
+                "DefaultValue",
+                (0, _Reflection.option_type)(_Reflection.bool_type)
+            ],
+            [
+                "Selection",
+                (0, _Reflection.option_type)(_Reflection.bool_type)
+            ]
+        ]);
+}
+class Types_CheckboxInfoTS extends _Types.Record {
+    constructor(DefaultValue, Selection$){
+        super();
+        this.DefaultValue = DefaultValue;
+        this.Selection = Selection$;
+    }
+}
+function Types_CheckboxInfoTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.CheckboxInfoTS", [], Types_CheckboxInfoTS, ()=>[
+            [
+                "DefaultValue",
+                (0, _Reflection.option_type)(_Reflection.bool_type)
+            ],
+            [
+                "Selection",
+                (0, _Reflection.option_type)(_Reflection.bool_type)
+            ]
+        ]);
+}
+class Types_SingleChoiceInfoTS extends _Types.Record {
+    constructor(Options){
+        super();
+        this.Options = Options;
+    }
+}
+function Types_SingleChoiceInfoTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.SingleChoiceInfoTS", [], Types_SingleChoiceInfoTS, ()=>[
+            [
+                "Options",
+                (0, _Reflection.array_type)(Types_FieldOptionTS_$reflection())
+            ]
+        ]);
+}
+class Types_MultiChoiceInfoTS extends _Types.Record {
+    constructor(Options){
+        super();
+        this.Options = Options;
+    }
+}
+function Types_MultiChoiceInfoTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.MultiChoiceInfoTS", [], Types_MultiChoiceInfoTS, ()=>[
+            [
+                "Options",
+                (0, _Reflection.array_type)(Types_FieldOptionTS_$reflection())
+            ]
+        ]);
+}
+class Types_MessageInfoTS extends _Types.Record {
+    constructor(Heading, MessageType, Message, Footer){
+        super();
+        this.Heading = Heading;
+        this.MessageType = MessageType | 0;
+        this.Message = Message;
+        this.Footer = Footer;
+    }
+}
+function Types_MessageInfoTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.MessageInfoTS", [], Types_MessageInfoTS, ()=>[
+            [
+                "Heading",
+                _Reflection.string_type
+            ],
+            [
+                "MessageType",
+                (0, _Reflection.enum_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.MessageTypeTS", _Reflection.int32_type, [
+                    [
+                        "Warning",
+                        0
+                    ],
+                    [
+                        "Success",
+                        1
+                    ],
+                    [
+                        "Error",
+                        2
+                    ],
+                    [
+                        "Info",
+                        3
+                    ],
+                    [
+                        "Danger",
+                        4
+                    ]
+                ])
+            ],
+            [
+                "Message",
+                _Reflection.string_type
+            ],
+            [
+                "Footer",
+                (0, _Reflection.option_type)(_Reflection.string_type)
+            ]
+        ]);
+}
+class Types_MatrixItemTS extends _Types.Record {
+    constructor(ItemKey, ItemLabel){
+        super();
+        this.ItemKey = ItemKey;
+        this.ItemLabel = ItemLabel;
+    }
+}
+function Types_MatrixItemTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.MatrixItemTS", [], Types_MatrixItemTS, ()=>[
+            [
+                "ItemKey",
+                Types_MatrixItemKeyTS_$reflection()
+            ],
+            [
+                "ItemLabel",
+                _Reflection.string_type
+            ]
+        ]);
+}
+class Types_MatrixInfoTS extends _Types.Record {
+    constructor(Items, Options){
+        super();
+        this.Items = Items;
+        this.Options = Options;
+    }
+}
+function Types_MatrixInfoTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.MatrixInfoTS", [], Types_MatrixInfoTS, ()=>[
+            [
+                "Items",
+                (0, _Reflection.array_type)(Types_FieldOptionTS_$reflection())
+            ],
+            [
+                "Options",
+                (0, _Reflection.array_type)(Types_FieldOptionTS_$reflection())
+            ]
+        ]);
+}
+class Types_SignatureInfoTS extends _Types.Record {
+    constructor(Value){
+        super();
+        this.Value = Value;
+    }
+}
+function Types_SignatureInfoTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.SignatureInfoTS", [], Types_SignatureInfoTS, ()=>[
+            [
+                "Value",
+                (0, _Reflection.option_type)(_Reflection.string_type)
+            ]
+        ]);
+}
+class Types_PluginFieldConfigTS extends _Types.Record {
+    constructor(PluginId, FieldName){
+        super();
+        this.PluginId = PluginId;
+        this.FieldName = FieldName;
+    }
+}
+function Types_PluginFieldConfigTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.PluginFieldConfigTS", [], Types_PluginFieldConfigTS, ()=>[
+            [
+                "PluginId",
+                _Reflection.string_type
+            ],
+            [
+                "FieldName",
+                _Reflection.string_type
+            ]
+        ]);
+}
+class Types_FieldTypeTS extends _Types.Record {
+    constructor(Type, TextInfo, BooleanInfo, CheckboxInfo, SingleChoiceInfo, MultiChoiceInfo, MessageInfo, MatrixInfo, SignatureInfo, PluginConfig){
+        super();
+        this.Type = Type;
+        this.TextInfo = TextInfo;
+        this.BooleanInfo = BooleanInfo;
+        this.CheckboxInfo = CheckboxInfo;
+        this.SingleChoiceInfo = SingleChoiceInfo;
+        this.MultiChoiceInfo = MultiChoiceInfo;
+        this.MessageInfo = MessageInfo;
+        this.MatrixInfo = MatrixInfo;
+        this.SignatureInfo = SignatureInfo;
+        this.PluginConfig = PluginConfig;
+    }
+}
+function Types_FieldTypeTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.FieldTypeTS", [], Types_FieldTypeTS, ()=>[
+            [
+                "Type",
+                _Reflection.string_type
+            ],
+            [
+                "TextInfo",
+                (0, _Reflection.option_type)(Types_TextInfoTS_$reflection())
+            ],
+            [
+                "BooleanInfo",
+                (0, _Reflection.option_type)(Types_BooleanInfoTS_$reflection())
+            ],
+            [
+                "CheckboxInfo",
+                (0, _Reflection.option_type)(Types_CheckboxInfoTS_$reflection())
+            ],
+            [
+                "SingleChoiceInfo",
+                (0, _Reflection.option_type)(Types_SingleChoiceInfoTS_$reflection())
+            ],
+            [
+                "MultiChoiceInfo",
+                (0, _Reflection.option_type)(Types_MultiChoiceInfoTS_$reflection())
+            ],
+            [
+                "MessageInfo",
+                (0, _Reflection.option_type)(Types_MessageInfoTS_$reflection())
+            ],
+            [
+                "MatrixInfo",
+                (0, _Reflection.option_type)(Types_MatrixInfoTS_$reflection())
+            ],
+            [
+                "SignatureInfo",
+                (0, _Reflection.option_type)(Types_SignatureInfoTS_$reflection())
+            ],
+            [
+                "PluginConfig",
+                (0, _Reflection.option_type)(Types_PluginFieldConfigTS_$reflection())
+            ]
+        ]);
+}
+class Types_DependsOnTS extends _Types.Record {
+    constructor(FieldKey, FieldValue, Evaluator){
+        super();
+        this.FieldKey = FieldKey;
+        this.FieldValue = FieldValue;
+        this.Evaluator = Evaluator | 0;
+    }
+}
+function Types_DependsOnTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.DependsOnTS", [], Types_DependsOnTS, ()=>[
+            [
+                "FieldKey",
+                Types_FieldKeyTS_$reflection()
+            ],
+            [
+                "FieldValue",
+                _Reflection.string_type
+            ],
+            [
+                "Evaluator",
+                (0, _Reflection.enum_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.EvaluatorTS", _Reflection.int32_type, [
+                    [
+                        "Equals",
+                        0
+                    ],
+                    [
+                        "NotEquals",
+                        1
+                    ],
+                    [
+                        "GreaterThan",
+                        2
+                    ],
+                    [
+                        "GreaterThanOrEquals",
+                        3
+                    ],
+                    [
+                        "LessThan",
+                        4
+                    ],
+                    [
+                        "LessThanOrEquals",
+                        5
+                    ],
+                    [
+                        "Exists",
+                        6
+                    ],
+                    [
+                        "IsEmpty",
+                        7
+                    ],
+                    [
+                        "Contains",
+                        8
+                    ]
+                ])
+            ]
+        ]);
+}
+class Types_FormFieldTS extends _Types.Record {
+    constructor(FieldOrder, FieldKey, Label, Notes, DependsOn, IsOptional, IsDeprecated, FieldType){
+        super();
+        this.FieldOrder = FieldOrder | 0;
+        this.FieldKey = FieldKey;
+        this.Label = Label;
+        this.Notes = Notes;
+        this.DependsOn = DependsOn;
+        this.IsOptional = IsOptional;
+        this.IsDeprecated = IsDeprecated;
+        this.FieldType = FieldType;
+    }
+}
+function Types_FormFieldTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.FormFieldTS", [], Types_FormFieldTS, ()=>[
+            [
+                "FieldOrder",
+                _Reflection.int32_type
+            ],
+            [
+                "FieldKey",
+                Types_FieldKeyTS_$reflection()
+            ],
+            [
+                "Label",
+                _Reflection.string_type
+            ],
+            [
+                "Notes",
+                (0, _Reflection.option_type)(_Reflection.string_type)
+            ],
+            [
+                "DependsOn",
+                (0, _Reflection.option_type)(Types_DependsOnTS_$reflection())
+            ],
+            [
+                "IsOptional",
+                _Reflection.bool_type
+            ],
+            [
+                "IsDeprecated",
+                _Reflection.bool_type
+            ],
+            [
+                "FieldType",
+                Types_FieldTypeTS_$reflection()
+            ]
+        ]);
+}
+class Types_FormStepTS extends _Types.Record {
+    constructor(StepOrder, StepLabel, Fields){
+        super();
+        this.StepOrder = StepOrder | 0;
+        this.StepLabel = StepLabel;
+        this.Fields = Fields;
+    }
+}
+function Types_FormStepTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.FormStepTS", [], Types_FormStepTS, ()=>[
+            [
+                "StepOrder",
+                _Reflection.int32_type
+            ],
+            [
+                "StepLabel",
+                _Reflection.string_type
+            ],
+            [
+                "Fields",
+                (0, _Reflection.array_type)(Types_FormFieldTS_$reflection())
+            ]
+        ]);
+}
+class Types_ScoreRangeTS extends _Types.Record {
+    constructor(Id, Min, Max, Label, Tag){
+        super();
+        this.Id = Id;
+        this.Min = Min | 0;
+        this.Max = Max | 0;
+        this.Label = Label;
+        this.Tag = Tag | 0;
+    }
+}
+function Types_ScoreRangeTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.ScoreRangeTS", [], Types_ScoreRangeTS, ()=>[
+            [
+                "Id",
+                _Reflection.string_type
+            ],
+            [
+                "Min",
+                _Reflection.int32_type
+            ],
+            [
+                "Max",
+                _Reflection.int32_type
+            ],
+            [
+                "Label",
+                _Reflection.string_type
+            ],
+            [
+                "Tag",
+                (0, _Reflection.enum_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.ScoreColorTS", _Reflection.int32_type, [
+                    [
+                        "Unspecified",
+                        0
+                    ],
+                    [
+                        "Primary",
+                        1
+                    ],
+                    [
+                        "Link",
+                        2
+                    ],
+                    [
+                        "Info",
+                        3
+                    ],
+                    [
+                        "Success",
+                        4
+                    ],
+                    [
+                        "Warning",
+                        5
+                    ],
+                    [
+                        "Danger",
+                        6
+                    ]
+                ])
+            ]
+        ]);
+}
+class Types_ScoreTS extends _Types.Record {
+    constructor(MaxScore, ScoreRanges){
+        super();
+        this.MaxScore = MaxScore | 0;
+        this.ScoreRanges = ScoreRanges;
+    }
+}
+function Types_ScoreTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.ScoreTS", [], Types_ScoreTS, ()=>[
+            [
+                "MaxScore",
+                _Reflection.int32_type
+            ],
+            [
+                "ScoreRanges",
+                (0, _Reflection.array_type)(Types_ScoreRangeTS_$reflection())
+            ]
+        ]);
+}
+class Types_ClinicalPathwaySpecTS extends _Types.Record {
+    constructor(PathwayId, PathwayName, Version, ProtocolSource){
+        super();
+        this.PathwayId = PathwayId;
+        this.PathwayName = PathwayName;
+        this.Version = Version;
+        this.ProtocolSource = ProtocolSource;
+    }
+}
+function Types_ClinicalPathwaySpecTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.ClinicalPathwaySpecTS", [], Types_ClinicalPathwaySpecTS, ()=>[
+            [
+                "PathwayId",
+                _Reflection.string_type
+            ],
+            [
+                "PathwayName",
+                _Reflection.string_type
+            ],
+            [
+                "Version",
+                _Reflection.string_type
+            ],
+            [
+                "ProtocolSource",
+                _Reflection.string_type
+            ]
+        ]);
+}
+class Types_FormSpecTS extends _Types.Record {
+    constructor(Id, Code, Title, Abstract, Version, FormSpecVersion, Steps, CategoryTags, Score, AssociatedCodes, RequiresReview, RequiresReviewAndApproval, ClinicalPathway){
+        super();
+        this.Id = Id;
+        this.Code = Code;
+        this.Title = Title;
+        this.Abstract = Abstract;
+        this.Version = Version;
+        this.FormSpecVersion = FormSpecVersion;
+        this.Steps = Steps;
+        this.CategoryTags = CategoryTags;
+        this.Score = Score;
+        this.AssociatedCodes = AssociatedCodes;
+        this.RequiresReview = RequiresReview;
+        this.RequiresReviewAndApproval = RequiresReviewAndApproval;
+        this.ClinicalPathway = ClinicalPathway;
+    }
+}
+function Types_FormSpecTS_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.FormSpec.Interop.OptionBased.Types.FormSpecTS", [], Types_FormSpecTS, ()=>[
+            [
+                "Id",
+                _Reflection.string_type
+            ],
+            [
+                "Code",
+                (0, _Reflection.option_type)(_Reflection.string_type)
+            ],
+            [
+                "Title",
+                _Reflection.string_type
+            ],
+            [
+                "Abstract",
+                _Reflection.string_type
+            ],
+            [
+                "Version",
+                _Reflection.string_type
+            ],
+            [
+                "FormSpecVersion",
+                _Reflection.string_type
+            ],
+            [
+                "Steps",
+                (0, _Reflection.array_type)(Types_FormStepTS_$reflection())
+            ],
+            [
+                "CategoryTags",
+                (0, _Reflection.array_type)(_Reflection.string_type)
+            ],
+            [
+                "Score",
+                (0, _Reflection.option_type)(Types_ScoreTS_$reflection())
+            ],
+            [
+                "AssociatedCodes",
+                (0, _Reflection.array_type)(_Reflection.string_type)
+            ],
+            [
+                "RequiresReview",
+                _Reflection.bool_type
+            ],
+            [
+                "RequiresReviewAndApproval",
+                _Reflection.bool_type
+            ],
+            [
+                "ClinicalPathway",
+                (0, _Reflection.option_type)(Types_ClinicalPathwaySpecTS_$reflection())
+            ]
+        ]);
+}
+function Converters_fieldKeyToTS(_arg) {
+    return new Types_FieldKeyTS(_arg.fields[0]);
+}
+function Converters_fieldKeyFromTS(key) {
+    let matchValue;
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = [
+        (0, _Guid.tryParse)(key.Value, new _Types.FSharpRef(()=>outArg, (v)=>{
+            outArg = v;
+        })),
+        outArg
+    ];
+    if (matchValue[0]) {
+        return new _FormSpec.Shared_FieldKey(matchValue[1]);
+    } else {
+        return undefined;
+    }
+}
+function Converters_stateKeyToTS(_arg) {
+    return new Types_StateKeyTS(_arg.fields[0]);
+}
+function Converters_stateKeyFromTS(key) {
+    let matchValue;
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = [
+        (0, _Guid.tryParse)(key.Value, new _Types.FSharpRef(()=>outArg, (v)=>{
+            outArg = v;
+        })),
+        outArg
+    ];
+    if (matchValue[0]) {
+        return new _FormSpec.Shared_StateKey(matchValue[1]);
+    } else {
+        return undefined;
+    }
+}
+function Converters_transitionKeyToTS(_arg) {
+    return new Types_TransitionKeyTS(_arg.fields[0]);
+}
+function Converters_matrixItemKeyToTS(_arg) {
+    return new Types_MatrixItemKeyTS(_arg.fields[0]);
+}
+function Converters_fieldOptionKeyToTS(_arg) {
+    return new Types_FieldOptionKeyTS(_arg.fields[0]);
+}
+function Converters_fieldOptionKeyFromTS(key) {
+    let matchValue;
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = [
+        (0, _Guid.tryParse)(key.Value, new _Types.FSharpRef(()=>outArg, (v)=>{
+            outArg = v;
+        })),
+        outArg
+    ];
+    if (matchValue[0]) {
+        return new _FormSpec.Shared_FieldOptionKey(matchValue[1]);
+    } else {
+        return undefined;
+    }
+}
+function Converters_fieldOptionToTS(option) {
+    return new Types_FieldOptionTS(option.Description, option.Value, Converters_fieldOptionKeyToTS(option.OptionKey));
+}
+function Converters_fieldOptionFromTS(option) {
+    const matchValue = Converters_fieldOptionKeyFromTS(option.OptionKey);
+    if (matchValue == null) {
+        return undefined;
+    } else {
+        return new _FormSpec.Shared_FieldOption(option.Description, option.Value, (0, _Option.value)(matchValue));
+    }
+}
+function Converters_evaluatorToTS(evaluator) {
+    switch(evaluator.tag){
+        case /* NotEquals */ 1:
+            return 1;
+        case /* GreaterThan */ 2:
+            return 2;
+        case /* GreaterThanOrEquals */ 3:
+            return 3;
+        case /* LessThan */ 4:
+            return 4;
+        case /* LessThanOrEquals */ 5:
+            return 5;
+        case /* Exists */ 6:
+            return 6;
+        case /* IsEmpty */ 7:
+            return 7;
+        case /* Contains */ 8:
+            return 8;
+        default:
+            return 0;
+    }
+}
+function Converters_evaluatorFromTS(evaluator) {
+    switch(evaluator){
+        case 0:
+            return (0, _FormSpec.Spec_Evaluator_Equals)();
+        case 1:
+            return (0, _FormSpec.Spec_Evaluator_NotEquals)();
+        case 2:
+            return (0, _FormSpec.Spec_Evaluator_GreaterThan)();
+        case 3:
+            return (0, _FormSpec.Spec_Evaluator_GreaterThanOrEquals)();
+        case 4:
+            return (0, _FormSpec.Spec_Evaluator_LessThan)();
+        case 5:
+            return (0, _FormSpec.Spec_Evaluator_LessThanOrEquals)();
+        case 6:
+            return (0, _FormSpec.Spec_Evaluator_Exists)();
+        case 7:
+            return (0, _FormSpec.Spec_Evaluator_IsEmpty)();
+        case 8:
+            return (0, _FormSpec.Spec_Evaluator_Contains)();
+        default:
+            return undefined;
+    }
+}
+function Converters_dependsOnToTS(deps) {
+    return new Types_DependsOnTS(Converters_fieldKeyToTS(deps.FieldKey), deps.FieldValue, Converters_evaluatorToTS(deps.Evaluator));
+}
+function Converters_dependsOnFromTS(deps) {
+    const matchValue = Converters_fieldKeyFromTS(deps.FieldKey);
+    const matchValue_1 = Converters_evaluatorFromTS(deps.Evaluator);
+    let matchResult, eval$, key;
+    if (matchValue != null) {
+        if (matchValue_1 != null) {
+            matchResult = 0;
+            eval$ = (0, _Option.value)(matchValue_1);
+            key = (0, _Option.value)(matchValue);
+        } else {
+            matchResult = 1;
+        }
+    } else {
+        matchResult = 1;
+    }
+    switch(matchResult){
+        case 0:
+            return new _FormSpec.Spec_DependsOn(key, deps.FieldValue, eval$);
+        default:
+            return undefined;
+    }
+}
+function Converters_messageTypeToTS(msgType) {
+    switch(msgType.tag){
+        case /* Success */ 1:
+            return 1;
+        case /* Error */ 2:
+            return 2;
+        case /* Info */ 3:
+            return 3;
+        case /* Danger */ 4:
+            return 4;
+        default:
+            return 0;
+    }
+}
+function Converters_messageTypeFromTS(msgType) {
+    switch(msgType){
+        case 0:
+            return (0, _FormSpec.Spec_MessageType_Warning)();
+        case 1:
+            return (0, _FormSpec.Spec_MessageType_Success)();
+        case 2:
+            return (0, _FormSpec.Spec_MessageType_Error)();
+        case 3:
+            return (0, _FormSpec.Spec_MessageType_Info)();
+        case 4:
+            return (0, _FormSpec.Spec_MessageType_Danger)();
+        default:
+            return undefined;
+    }
+}
+function Converters_fieldTypeToTS(fieldType) {
+    switch(fieldType.tag){
+        case /* TextArea */ 1:
+            return new Types_FieldTypeTS("TextArea", new Types_TextInfoTS(fieldType.fields[0].Value), undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+        case /* Email */ 2:
+            return new Types_FieldTypeTS("Email", new Types_TextInfoTS(fieldType.fields[0].Value), undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+        case /* Password */ 3:
+            return new Types_FieldTypeTS("Password", new Types_TextInfoTS(fieldType.fields[0].Value), undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+        case /* Search */ 4:
+            return new Types_FieldTypeTS("Search", new Types_TextInfoTS(fieldType.fields[0].Value), undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+        case /* Color */ 5:
+            return new Types_FieldTypeTS("Color", new Types_TextInfoTS(fieldType.fields[0].Value), undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+        case /* Number */ 6:
+            return new Types_FieldTypeTS("Number", new Types_TextInfoTS(fieldType.fields[0].Value), undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+        case /* Tel */ 7:
+            return new Types_FieldTypeTS("Tel", new Types_TextInfoTS(fieldType.fields[0].Value), undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+        case /* Date */ 8:
+            return new Types_FieldTypeTS("Date", new Types_TextInfoTS(fieldType.fields[0].Value), undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+        case /* DateTimeLocal */ 9:
+            return new Types_FieldTypeTS("DateTimeLocal", new Types_TextInfoTS(fieldType.fields[0].Value), undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+        case /* Time */ 10:
+            return new Types_FieldTypeTS("Time", new Types_TextInfoTS(fieldType.fields[0].Value), undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+        case /* Checkbox */ 11:
+            {
+                const info_11 = fieldType.fields[0];
+                return new Types_FieldTypeTS("Checkbox", undefined, undefined, new Types_CheckboxInfoTS(info_11.DefaultValue, info_11.Selection), undefined, undefined, undefined, undefined, undefined, undefined);
+            }
+        case /* Radio */ 12:
+            return new Types_FieldTypeTS("Radio", undefined, undefined, undefined, new Types_SingleChoiceInfoTS((0, _List.toArray)((0, _List.map)(Converters_fieldOptionToTS, fieldType.fields[0].Options))), undefined, undefined, undefined, undefined, undefined);
+        case /* SingleChoice */ 13:
+            return new Types_FieldTypeTS("SingleChoice", undefined, undefined, undefined, new Types_SingleChoiceInfoTS((0, _List.toArray)((0, _List.map)(Converters_fieldOptionToTS, fieldType.fields[0].Options))), undefined, undefined, undefined, undefined, undefined);
+        case /* Dropdown */ 14:
+            return new Types_FieldTypeTS("Dropdown", undefined, undefined, undefined, new Types_SingleChoiceInfoTS((0, _List.toArray)((0, _List.map)(Converters_fieldOptionToTS, fieldType.fields[0].Options))), undefined, undefined, undefined, undefined, undefined);
+        case /* MultiChoice */ 15:
+            return new Types_FieldTypeTS("MultiChoice", undefined, undefined, undefined, undefined, new Types_MultiChoiceInfoTS((0, _List.toArray)((0, _List.map)(Converters_fieldOptionToTS, fieldType.fields[0].Options))), undefined, undefined, undefined, undefined);
+        case /* CheckboxList */ 16:
+            return new Types_FieldTypeTS("CheckboxList", undefined, undefined, undefined, undefined, new Types_MultiChoiceInfoTS((0, _List.toArray)((0, _List.map)(Converters_fieldOptionToTS, fieldType.fields[0].Options))), undefined, undefined, undefined, undefined);
+        case /* TagList */ 17:
+            return new Types_FieldTypeTS("TagList", undefined, undefined, undefined, undefined, new Types_MultiChoiceInfoTS((0, _List.toArray)((0, _List.map)(Converters_fieldOptionToTS, fieldType.fields[0].Options))), undefined, undefined, undefined, undefined);
+        case /* TextAutoComplete */ 18:
+            return new Types_FieldTypeTS("TextAutoComplete", undefined, undefined, undefined, new Types_SingleChoiceInfoTS((0, _List.toArray)((0, _List.map)(Converters_fieldOptionToTS, fieldType.fields[0].Options))), undefined, undefined, undefined, undefined, undefined);
+        case /* Matrix */ 19:
+            {
+                const info_19 = fieldType.fields[0];
+                return new Types_FieldTypeTS("Matrix", undefined, undefined, undefined, undefined, undefined, undefined, new Types_MatrixInfoTS((0, _List.toArray)((0, _List.map)(Converters_fieldOptionToTS, info_19.Items)), (0, _List.toArray)((0, _List.map)(Converters_fieldOptionToTS, info_19.Options))), undefined, undefined);
+            }
+        case /* Signature */ 20:
+            return new Types_FieldTypeTS("Signature", undefined, undefined, undefined, undefined, undefined, undefined, undefined, new Types_SignatureInfoTS(fieldType.fields[0].Value), undefined);
+        case /* Message */ 21:
+            {
+                const info_21 = fieldType.fields[0];
+                return new Types_FieldTypeTS("Message", undefined, undefined, undefined, undefined, undefined, new Types_MessageInfoTS(info_21.Heading, Converters_messageTypeToTS(info_21.MessageType), info_21.Message, info_21.Footer), undefined, undefined, undefined);
+            }
+        case /* PluginField */ 22:
+            {
+                const config = fieldType.fields[0];
+                return new Types_FieldTypeTS("PluginField", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, new Types_PluginFieldConfigTS(config.PluginId, config.FieldName));
+            }
+        default:
+            return new Types_FieldTypeTS("Text", new Types_TextInfoTS(fieldType.fields[0].Value), undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    }
+}
+function Converters_fieldTypeFromTS(fieldType) {
+    const matchValue = fieldType.Type;
+    switch(matchValue){
+        case "Text":
+            {
+                const matchValue_1 = fieldType.TextInfo;
+                if (matchValue_1 == null) {
+                    return undefined;
+                } else {
+                    return (0, _FormSpec.Spec_FieldType_Text)(new _FormSpec.Spec_TextInfo((0, _Option.value)(matchValue_1).Value));
+                }
+            }
+        case "TextArea":
+            {
+                const matchValue_2 = fieldType.TextInfo;
+                if (matchValue_2 == null) {
+                    return undefined;
+                } else {
+                    return (0, _FormSpec.Spec_FieldType_TextArea)(new _FormSpec.Spec_TextInfo((0, _Option.value)(matchValue_2).Value));
+                }
+            }
+        case "Email":
+            {
+                const matchValue_3 = fieldType.TextInfo;
+                if (matchValue_3 == null) {
+                    return undefined;
+                } else {
+                    return (0, _FormSpec.Spec_FieldType_Email)(new _FormSpec.Spec_TextInfo((0, _Option.value)(matchValue_3).Value));
+                }
+            }
+        case "Password":
+            {
+                const matchValue_4 = fieldType.TextInfo;
+                if (matchValue_4 == null) {
+                    return undefined;
+                } else {
+                    return (0, _FormSpec.Spec_FieldType_Password)(new _FormSpec.Spec_TextInfo((0, _Option.value)(matchValue_4).Value));
+                }
+            }
+        case "Search":
+            {
+                const matchValue_5 = fieldType.TextInfo;
+                if (matchValue_5 == null) {
+                    return undefined;
+                } else {
+                    return (0, _FormSpec.Spec_FieldType_Search)(new _FormSpec.Spec_TextInfo((0, _Option.value)(matchValue_5).Value));
+                }
+            }
+        case "Color":
+            {
+                const matchValue_6 = fieldType.TextInfo;
+                if (matchValue_6 == null) {
+                    return undefined;
+                } else {
+                    return (0, _FormSpec.Spec_FieldType_Color)(new _FormSpec.Spec_TextInfo((0, _Option.value)(matchValue_6).Value));
+                }
+            }
+        case "Number":
+            {
+                const matchValue_7 = fieldType.TextInfo;
+                if (matchValue_7 == null) {
+                    return undefined;
+                } else {
+                    return (0, _FormSpec.Spec_FieldType_Number)(new _FormSpec.Spec_TextInfo((0, _Option.value)(matchValue_7).Value));
+                }
+            }
+        case "Tel":
+            {
+                const matchValue_8 = fieldType.TextInfo;
+                if (matchValue_8 == null) {
+                    return undefined;
+                } else {
+                    return (0, _FormSpec.Spec_FieldType_Tel)(new _FormSpec.Spec_TextInfo((0, _Option.value)(matchValue_8).Value));
+                }
+            }
+        case "Date":
+            {
+                const matchValue_9 = fieldType.TextInfo;
+                if (matchValue_9 == null) {
+                    return undefined;
+                } else {
+                    return (0, _FormSpec.Spec_FieldType_Date)(new _FormSpec.Spec_TextInfo((0, _Option.value)(matchValue_9).Value));
+                }
+            }
+        case "DateTimeLocal":
+            {
+                const matchValue_10 = fieldType.TextInfo;
+                if (matchValue_10 == null) {
+                    return undefined;
+                } else {
+                    return (0, _FormSpec.Spec_FieldType_DateTimeLocal)(new _FormSpec.Spec_TextInfo((0, _Option.value)(matchValue_10).Value));
+                }
+            }
+        case "Time":
+            {
+                const matchValue_11 = fieldType.TextInfo;
+                if (matchValue_11 == null) {
+                    return undefined;
+                } else {
+                    return (0, _FormSpec.Spec_FieldType_Time)(new _FormSpec.Spec_TextInfo((0, _Option.value)(matchValue_11).Value));
+                }
+            }
+        case "Checkbox":
+            {
+                const matchValue_12 = fieldType.CheckboxInfo;
+                if (matchValue_12 == null) {
+                    return undefined;
+                } else {
+                    const info_11 = (0, _Option.value)(matchValue_12);
+                    return (0, _FormSpec.Spec_FieldType_Checkbox)(new _FormSpec.Spec_BooleanInfo(info_11.DefaultValue, info_11.Selection));
+                }
+            }
+        case "Radio":
+            {
+                const matchValue_13 = fieldType.SingleChoiceInfo;
+                if (matchValue_13 == null) {
+                    return undefined;
+                } else {
+                    const convertedOptions = (0, _Array.fold)((acc, opt)=>{
+                        let matchResult, item, list;
+                        if (acc != null) {
+                            if (opt != null) {
+                                matchResult = 0;
+                                item = (0, _Option.value)(opt);
+                                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)(Converters_fieldOptionFromTS, (0, _Option.value)(matchValue_13).Options));
+                    if (convertedOptions == null) {
+                        return undefined;
+                    } else {
+                        return (0, _FormSpec.Spec_FieldType_Radio)(new _FormSpec.Spec_SingleChoiceInfo((0, _List.reverse)((0, _Option.value)(convertedOptions))));
+                    }
+                }
+            }
+        case "SingleChoice":
+            {
+                const matchValue_15 = fieldType.SingleChoiceInfo;
+                if (matchValue_15 == null) {
+                    return undefined;
+                } else {
+                    const convertedOptions_1 = (0, _Array.fold)((acc_1, opt_1)=>{
+                        let matchResult_1, item_1, list_1;
+                        if (acc_1 != null) {
+                            if (opt_1 != null) {
+                                matchResult_1 = 0;
+                                item_1 = (0, _Option.value)(opt_1);
+                                list_1 = (0, _Option.value)(acc_1);
+                            } else {
+                                matchResult_1 = 1;
+                            }
+                        } else {
+                            matchResult_1 = 1;
+                        }
+                        switch(matchResult_1){
+                            case 0:
+                                return (0, _List.cons)(item_1, list_1);
+                            default:
+                                return undefined;
+                        }
+                    }, (0, _List.empty)(), (0, _Array.map)(Converters_fieldOptionFromTS, (0, _Option.value)(matchValue_15).Options));
+                    if (convertedOptions_1 == null) {
+                        return undefined;
+                    } else {
+                        return (0, _FormSpec.Spec_FieldType_SingleChoice)(new _FormSpec.Spec_SingleChoiceInfo((0, _List.reverse)((0, _Option.value)(convertedOptions_1))));
+                    }
+                }
+            }
+        case "Dropdown":
+            {
+                const matchValue_17 = fieldType.SingleChoiceInfo;
+                if (matchValue_17 == null) {
+                    return undefined;
+                } else {
+                    const convertedOptions_2 = (0, _Array.fold)((acc_2, opt_2)=>{
+                        let matchResult_2, item_2, list_2;
+                        if (acc_2 != null) {
+                            if (opt_2 != null) {
+                                matchResult_2 = 0;
+                                item_2 = (0, _Option.value)(opt_2);
+                                list_2 = (0, _Option.value)(acc_2);
+                            } else {
+                                matchResult_2 = 1;
+                            }
+                        } else {
+                            matchResult_2 = 1;
+                        }
+                        switch(matchResult_2){
+                            case 0:
+                                return (0, _List.cons)(item_2, list_2);
+                            default:
+                                return undefined;
+                        }
+                    }, (0, _List.empty)(), (0, _Array.map)(Converters_fieldOptionFromTS, (0, _Option.value)(matchValue_17).Options));
+                    if (convertedOptions_2 == null) {
+                        return undefined;
+                    } else {
+                        return (0, _FormSpec.Spec_FieldType_Dropdown)(new _FormSpec.Spec_SingleChoiceInfo((0, _List.reverse)((0, _Option.value)(convertedOptions_2))));
+                    }
+                }
+            }
+        case "MultiChoice":
+            {
+                const matchValue_19 = fieldType.MultiChoiceInfo;
+                if (matchValue_19 == null) {
+                    return undefined;
+                } else {
+                    const convertedOptions_3 = (0, _Array.fold)((acc_3, opt_3)=>{
+                        let matchResult_3, item_3, list_3;
+                        if (acc_3 != null) {
+                            if (opt_3 != null) {
+                                matchResult_3 = 0;
+                                item_3 = (0, _Option.value)(opt_3);
+                                list_3 = (0, _Option.value)(acc_3);
+                            } else {
+                                matchResult_3 = 1;
+                            }
+                        } else {
+                            matchResult_3 = 1;
+                        }
+                        switch(matchResult_3){
+                            case 0:
+                                return (0, _List.cons)(item_3, list_3);
+                            default:
+                                return undefined;
+                        }
+                    }, (0, _List.empty)(), (0, _Array.map)(Converters_fieldOptionFromTS, (0, _Option.value)(matchValue_19).Options));
+                    if (convertedOptions_3 == null) {
+                        return undefined;
+                    } else {
+                        return (0, _FormSpec.Spec_FieldType_MultiChoice)(new _FormSpec.Spec_MultiChoiceInfo((0, _List.reverse)((0, _Option.value)(convertedOptions_3))));
+                    }
+                }
+            }
+        case "CheckboxList":
+            {
+                const matchValue_21 = fieldType.MultiChoiceInfo;
+                if (matchValue_21 == null) {
+                    return undefined;
+                } else {
+                    const convertedOptions_4 = (0, _Array.fold)((acc_4, opt_4)=>{
+                        let matchResult_4, item_4, list_4;
+                        if (acc_4 != null) {
+                            if (opt_4 != null) {
+                                matchResult_4 = 0;
+                                item_4 = (0, _Option.value)(opt_4);
+                                list_4 = (0, _Option.value)(acc_4);
+                            } else {
+                                matchResult_4 = 1;
+                            }
+                        } else {
+                            matchResult_4 = 1;
+                        }
+                        switch(matchResult_4){
+                            case 0:
+                                return (0, _List.cons)(item_4, list_4);
+                            default:
+                                return undefined;
+                        }
+                    }, (0, _List.empty)(), (0, _Array.map)(Converters_fieldOptionFromTS, (0, _Option.value)(matchValue_21).Options));
+                    if (convertedOptions_4 == null) {
+                        return undefined;
+                    } else {
+                        return (0, _FormSpec.Spec_FieldType_CheckboxList)(new _FormSpec.Spec_MultiChoiceInfo((0, _List.reverse)((0, _Option.value)(convertedOptions_4))));
+                    }
+                }
+            }
+        case "TagList":
+            {
+                const matchValue_23 = fieldType.MultiChoiceInfo;
+                if (matchValue_23 == null) {
+                    return undefined;
+                } else {
+                    const convertedOptions_5 = (0, _Array.fold)((acc_5, opt_5)=>{
+                        let matchResult_5, item_5, list_5;
+                        if (acc_5 != null) {
+                            if (opt_5 != null) {
+                                matchResult_5 = 0;
+                                item_5 = (0, _Option.value)(opt_5);
+                                list_5 = (0, _Option.value)(acc_5);
+                            } else {
+                                matchResult_5 = 1;
+                            }
+                        } else {
+                            matchResult_5 = 1;
+                        }
+                        switch(matchResult_5){
+                            case 0:
+                                return (0, _List.cons)(item_5, list_5);
+                            default:
+                                return undefined;
+                        }
+                    }, (0, _List.empty)(), (0, _Array.map)(Converters_fieldOptionFromTS, (0, _Option.value)(matchValue_23).Options));
+                    if (convertedOptions_5 == null) {
+                        return undefined;
+                    } else {
+                        return (0, _FormSpec.Spec_FieldType_TagList)(new _FormSpec.Spec_MultiChoiceInfo((0, _List.reverse)((0, _Option.value)(convertedOptions_5))));
+                    }
+                }
+            }
+        case "TextAutoComplete":
+            {
+                const matchValue_25 = fieldType.SingleChoiceInfo;
+                if (matchValue_25 == null) {
+                    return undefined;
+                } else {
+                    const convertedOptions_6 = (0, _Array.fold)((acc_6, opt_6)=>{
+                        let matchResult_6, item_6, list_6;
+                        if (acc_6 != null) {
+                            if (opt_6 != null) {
+                                matchResult_6 = 0;
+                                item_6 = (0, _Option.value)(opt_6);
+                                list_6 = (0, _Option.value)(acc_6);
+                            } else {
+                                matchResult_6 = 1;
+                            }
+                        } else {
+                            matchResult_6 = 1;
+                        }
+                        switch(matchResult_6){
+                            case 0:
+                                return (0, _List.cons)(item_6, list_6);
+                            default:
+                                return undefined;
+                        }
+                    }, (0, _List.empty)(), (0, _Array.map)(Converters_fieldOptionFromTS, (0, _Option.value)(matchValue_25).Options));
+                    if (convertedOptions_6 == null) {
+                        return undefined;
+                    } else {
+                        return (0, _FormSpec.Spec_FieldType_TextAutoComplete)(new _FormSpec.Spec_SingleChoiceInfo((0, _List.reverse)((0, _Option.value)(convertedOptions_6))));
+                    }
+                }
+            }
+        case "Matrix":
+            {
+                const matchValue_27 = fieldType.MatrixInfo;
+                if (matchValue_27 == null) {
+                    return undefined;
+                } else {
+                    const info_19 = (0, _Option.value)(matchValue_27);
+                    const convertedItems = (0, _Array.fold)((acc_7, opt_7)=>{
+                        let matchResult_7, item_7, list_7;
+                        if (acc_7 != null) {
+                            if (opt_7 != null) {
+                                matchResult_7 = 0;
+                                item_7 = (0, _Option.value)(opt_7);
+                                list_7 = (0, _Option.value)(acc_7);
+                            } else {
+                                matchResult_7 = 1;
+                            }
+                        } else {
+                            matchResult_7 = 1;
+                        }
+                        switch(matchResult_7){
+                            case 0:
+                                return (0, _List.cons)(item_7, list_7);
+                            default:
+                                return undefined;
+                        }
+                    }, (0, _List.empty)(), (0, _Array.map)(Converters_fieldOptionFromTS, info_19.Items));
+                    const convertedOptions_7 = (0, _Array.fold)((acc_8, opt_8)=>{
+                        let matchResult_8, item_8, list_8;
+                        if (acc_8 != null) {
+                            if (opt_8 != null) {
+                                matchResult_8 = 0;
+                                item_8 = (0, _Option.value)(opt_8);
+                                list_8 = (0, _Option.value)(acc_8);
+                            } else {
+                                matchResult_8 = 1;
+                            }
+                        } else {
+                            matchResult_8 = 1;
+                        }
+                        switch(matchResult_8){
+                            case 0:
+                                return (0, _List.cons)(item_8, list_8);
+                            default:
+                                return undefined;
+                        }
+                    }, (0, _List.empty)(), (0, _Array.map)(Converters_fieldOptionFromTS, info_19.Options));
+                    let matchResult_9, items, opts_7;
+                    if (convertedItems != null) {
+                        if (convertedOptions_7 != null) {
+                            matchResult_9 = 0;
+                            items = (0, _Option.value)(convertedItems);
+                            opts_7 = (0, _Option.value)(convertedOptions_7);
+                        } else {
+                            matchResult_9 = 1;
+                        }
+                    } else {
+                        matchResult_9 = 1;
+                    }
+                    switch(matchResult_9){
+                        case 0:
+                            return (0, _FormSpec.Spec_FieldType_Matrix)(new _FormSpec.Spec_MatrixInfo((0, _List.reverse)(items), (0, _List.reverse)(opts_7)));
+                        default:
+                            return undefined;
+                    }
+                }
+            }
+        case "Signature":
+            {
+                const matchValue_31 = fieldType.SignatureInfo;
+                if (matchValue_31 == null) {
+                    return undefined;
+                } else {
+                    return (0, _FormSpec.Spec_FieldType_Signature)(new _FormSpec.Spec_SignatureInfo((0, _Option.value)(matchValue_31).Value));
+                }
+            }
+        case "Message":
+            {
+                const matchValue_32 = fieldType.MessageInfo;
+                if (matchValue_32 == null) {
+                    return undefined;
+                } else {
+                    const info_21 = (0, _Option.value)(matchValue_32);
+                    const matchValue_33 = Converters_messageTypeFromTS(info_21.MessageType);
+                    if (matchValue_33 == null) {
+                        return undefined;
+                    } else {
+                        return (0, _FormSpec.Spec_FieldType_Message)(new _FormSpec.Spec_MessageInfo(info_21.Heading, (0, _Option.value)(matchValue_33), info_21.Message, info_21.Footer));
+                    }
+                }
+            }
+        case "PluginField":
+            {
+                const matchValue_34 = fieldType.PluginConfig;
+                if (matchValue_34 == null) {
+                    return undefined;
+                } else {
+                    const config = (0, _Option.value)(matchValue_34);
+                    return (0, _FormSpec.Spec_FieldType_PluginField)(new _FormSpec.Spec_PluginFieldConfig(config.PluginId, config.FieldName));
+                }
+            }
+        default:
+            return undefined;
+    }
+}
+function Converters_formFieldToTS(field) {
+    return new Types_FormFieldTS(field.FieldOrder, Converters_fieldKeyToTS(field.FieldKey), field.Label, field.Notes, (0, _Option.map)(Converters_dependsOnToTS, field.DependsOn), field.IsOptional, field.IsDeprecated, Converters_fieldTypeToTS(field.FieldType));
+}
+function Converters_formFieldFromTS(field) {
+    let matchValue_3;
+    const matchValue = Converters_fieldKeyFromTS(field.FieldKey);
+    const matchValue_1 = Converters_fieldTypeFromTS(field.FieldType);
+    let matchResult, fieldType, key;
+    if (matchValue != null) {
+        if (matchValue_1 != null) {
+            matchResult = 0;
+            fieldType = (0, _Option.value)(matchValue_1);
+            key = (0, _Option.value)(matchValue);
+        } else {
+            matchResult = 1;
+        }
+    } else {
+        matchResult = 1;
+    }
+    switch(matchResult){
+        case 0:
+            return new _FormSpec.Spec_FormField$1(field.FieldOrder, key, field.Label, field.Notes, (matchValue_3 = field.DependsOn, matchValue_3 == null ? undefined : Converters_dependsOnFromTS((0, _Option.value)(matchValue_3))), field.IsOptional, field.IsDeprecated, fieldType);
+        default:
+            return undefined;
+    }
+}
+function Converters_formStepToTS(step) {
+    return new Types_FormStepTS(step.StepOrder, step.StepLabel, (0, _List.toArray)((0, _List.map)(Converters_formFieldToTS, step.Fields)));
+}
+function Converters_formStepFromTS(step) {
+    const convertedFields = (0, _Array.fold)((acc, field_1)=>{
+        let matchResult, item, list;
+        if (acc != null) {
+            if (field_1 != null) {
+                matchResult = 0;
+                item = (0, _Option.value)(field_1);
+                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)(Converters_formFieldFromTS, step.Fields));
+    if (convertedFields == null) {
+        return undefined;
+    } else {
+        return new _FormSpec.Spec_FormStep$1(step.StepOrder, step.StepLabel, (0, _List.reverse)((0, _Option.value)(convertedFields)));
+    }
+}
+function Converters_scoreColorToTS(color) {
+    switch(color.tag){
+        case /* Primary */ 1:
+            return 1;
+        case /* Link */ 2:
+            return 2;
+        case /* Info */ 3:
+            return 3;
+        case /* Success */ 4:
+            return 4;
+        case /* Warning */ 5:
+            return 5;
+        case /* Danger */ 6:
+            return 6;
+        default:
+            return 0;
+    }
+}
+function Converters_scoreColorFromTS(color) {
+    switch(color){
+        case 0:
+            return (0, _FormSpec.Spec_ScoreColor_Unspecified)();
+        case 1:
+            return (0, _FormSpec.Spec_ScoreColor_Primary)();
+        case 2:
+            return (0, _FormSpec.Spec_ScoreColor_Link)();
+        case 3:
+            return (0, _FormSpec.Spec_ScoreColor_Info)();
+        case 4:
+            return (0, _FormSpec.Spec_ScoreColor_Success)();
+        case 5:
+            return (0, _FormSpec.Spec_ScoreColor_Warning)();
+        case 6:
+            return (0, _FormSpec.Spec_ScoreColor_Danger)();
+        default:
+            return undefined;
+    }
+}
+function Converters_scoreRangeToTS(range) {
+    return new Types_ScoreRangeTS(range.Id, range.Min, range.Max, range.Label, Converters_scoreColorToTS(range.Tag));
+}
+function Converters_scoreRangeFromTS(range) {
+    let matchValue;
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = [
+        (0, _Guid.tryParse)(range.Id, new _Types.FSharpRef(()=>outArg, (v)=>{
+            outArg = v;
+        })),
+        outArg
+    ];
+    const matchValue_1 = Converters_scoreColorFromTS(range.Tag);
+    let matchResult;
+    if (matchValue[0]) {
+        if (matchValue_1 != null) {
+            matchResult = 0;
+        } else {
+            matchResult = 1;
+        }
+    } else {
+        matchResult = 1;
+    }
+    switch(matchResult){
+        case 0:
+            return new _FormSpec.Spec_ScoreRange(matchValue[1], range.Min, range.Max, range.Label, (0, _Option.value)(matchValue_1));
+        default:
+            return undefined;
+    }
+}
+function Converters_scoreToTS(score) {
+    return new Types_ScoreTS(score.MaxScore, (0, _List.toArray)((0, _List.map)(Converters_scoreRangeToTS, score.ScoreRanges)));
+}
+function Converters_scoreFromTS(score) {
+    const convertedRanges = (0, _Array.fold)((acc, range_1)=>{
+        let matchResult, item, list;
+        if (acc != null) {
+            if (range_1 != null) {
+                matchResult = 0;
+                item = (0, _Option.value)(range_1);
+                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)(Converters_scoreRangeFromTS, score.ScoreRanges));
+    if (convertedRanges == null) {
+        return undefined;
+    } else {
+        return new _FormSpec.Spec_Score(score.MaxScore, (0, _List.reverse)((0, _Option.value)(convertedRanges)));
+    }
+}
+function Converters_clinicalPathwayToTS(pathway) {
+    return new Types_ClinicalPathwaySpecTS(pathway.PathwayId, pathway.PathwayName, pathway.Version, pathway.ProtocolSource);
+}
+function Converters_clinicalPathwayFromTS(pathway) {
+    return undefined;
+}
+function Converters_formSpecToTS(spec) {
+    return new Types_FormSpecTS(spec.Id, spec.Code, spec.Title, spec.Abstract, spec.Version, spec.FormSpecVersion, (0, _List.toArray)((0, _List.map)(Converters_formStepToTS, spec.Steps)), (0, _List.toArray)(spec.CategoryTags), (0, _Option.map)(Converters_scoreToTS, spec.Score), (0, _List.toArray)(spec.AssociatedCodes), spec.RequiresReview, spec.RequiresReviewAndApproval, (0, _Option.map)(Converters_clinicalPathwayToTS, spec.ClinicalPathway));
+}
+function Converters_formSpecFromTS(spec) {
+    let matchValue;
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = [
+        (0, _Guid.tryParse)(spec.Id, new _Types.FSharpRef(()=>outArg, (v)=>{
+            outArg = v;
+        })),
+        outArg
+    ];
+    if (matchValue[0]) {
+        const convertedSteps = (0, _Array.fold)((acc, step_1)=>{
+            let matchResult, item, list;
+            if (acc != null) {
+                if (step_1 != null) {
+                    matchResult = 0;
+                    item = (0, _Option.value)(step_1);
+                    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)(Converters_formStepFromTS, spec.Steps));
+        let scoreResult;
+        const matchValue_2 = spec.Score;
+        scoreResult = matchValue_2 == null ? undefined : Converters_scoreFromTS((0, _Option.value)(matchValue_2));
+        if (convertedSteps == null) {
+            return undefined;
+        } else {
+            return new _FormSpec.Spec_FormSpec$1(matchValue[1], spec.Code, spec.Title, spec.Abstract, spec.Version, spec.FormSpecVersion, (0, _List.reverse)((0, _Option.value)(convertedSteps)), (0, _List.ofArray)(spec.CategoryTags), scoreResult, (0, _List.ofArray)(spec.AssociatedCodes), spec.RequiresReview, spec.RequiresReviewAndApproval, undefined);
+        }
+    } else {
+        return undefined;
+    }
+}
+function Validators_validateFormSpec(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)(Types_FormSpecTS_$reflection(), undefined, undefined)), stringified));
+}
+function Validators_validateAndConvert(input) {
+    const matchValue = Validators_validateFormSpec(input);
+    if (matchValue == null) {
+        return undefined;
+    } else {
+        return Converters_formSpecFromTS((0, _Option.value)(matchValue));
+    }
+}
+function Api_validateFormSpec() {
+    return Validators_validateFormSpec;
+}
+function Api_validateAndConvertFormSpec() {
+    return Validators_validateAndConvert;
+}
+function Api_formSpecToTypeScript(spec) {
+    return Converters_formSpecToTS(spec);
+}
+function Api_formSpecFromTypeScript(spec) {
+    return Converters_formSpecFromTS(spec);
+}
+function Api_getFormSpecTSfromFormSpecFSjsonString(formSpecFSstring) {
+    const matchValue = (0, _Decodefs.fromString)((0, _Util.uncurry2)((0, _Decodefs.Auto_generateBoxedDecoder_Z6670B51)((0, _FormSpec.Spec_FormSpec$1_$reflection)((0, _FormSpec.Spec_FieldType_$reflection)()), undefined, undefined)), formSpecFSstring);
+    if (matchValue.tag === /* Error */ 1) {
+        return undefined;
+    } else {
+        return Api_formSpecToTypeScript(matchValue.fields[0]);
+    }
+}
+function Api_getFormSpecFSfromFormSpecTSjsonString(formSpecTSstring) {
+    const matchValue = (0, _Decodefs.fromString)((0, _Util.uncurry2)((0, _Decodefs.Auto_generateBoxedDecoder_Z6670B51)(Types_FormSpecTS_$reflection(), undefined, undefined)), formSpecTSstring);
+    if (matchValue.tag === /* Error */ 1) {
+        return undefined;
+    } else {
+        return Api_formSpecFromTypeScript(matchValue.fields[0]);
+    }
+}
+function Api_serializeFormSpec(spec) {
+    return (0, _Encodefs.toString)(2, (0, _Encodefs.Auto_generateBoxedEncoder_437914C6)(Types_FormSpecTS_$reflection(), undefined, undefined, undefined)(spec));
+}
+function Api_deserializeFormSpecTS(jsonTS) {
+    (0, _String.toConsole)((0, _String.printf)("API.Option: Deserializing FormSpecTS!"));
+    const matchValue = (0, _Decodefs.fromString)((0, _Util.uncurry2)((0, _Decodefs.Auto_generateBoxedDecoder_Z6670B51)(Types_FormSpecTS_$reflection(), undefined, undefined)), jsonTS);
+    if (matchValue.tag === /* Error */ 1) {
+        return undefined;
+    } else {
+        return matchValue.fields[0];
+    }
+}
+function Api_fieldKeyToTypeScript(fieldKey) {
+    return Converters_fieldKeyToTS(fieldKey);
+}
+function Api_getFieldKeys(spec) {
+    return (0, _Array.map)((field)=>field.FieldKey, (0, _Array.collect)((step)=>step.Fields, spec.Steps));
+}
+function Api_findFieldByKey(spec, key) {
+    return (0, _Array.tryFind)((field)=>field.FieldKey.Value === key.Value, (0, _Array.collect)((step)=>step.Fields, spec.Steps));
+}
+function Api_getFieldsByType(spec, fieldType) {
+    const array_1 = (0, _Array.collect)((step)=>step.Fields, spec.Steps);
+    return array_1.filter((field)=>field.FieldType.Type === fieldType);
+}
+function Api_isValidFormSpec(spec) {
+    if (spec.Steps.length > 0 && spec.Title.length > 0) {
+        return spec.Version.length > 0;
+    } else {
+        return false;
+    }
+}
+function Api_getFormSpecSummary(spec) {
+    let StepCount;
+    return StepCount = spec.Steps.length | 0, {
+        FieldCount: (0, _Array.sumBy)((s)=>s.Fields.length, spec.Steps, {
+            GetZero: ()=>0,
+            Add: (x, y)=>x + y
+        }),
+        Id: spec.Id,
+        RequiresApproval: spec.RequiresReviewAndApproval,
+        RequiresReview: spec.RequiresReview,
+        StepCount: StepCount,
+        Title: spec.Title,
+        Version: spec.Version
+    };
+} //# sourceMappingURL=FormSpec.Api.Option.ts.map
+
+//# sourceMappingURL=FormSpec.Api.Option.js.map