@f1studio/form-spec 5.0.0-alpha.101

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

@@ -0,0 +1,1618 @@
+import { FSharpRef, Record } from "@fable-org/fable-library-js/Types.js";
+import { uncurry2, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { obj_type, enum_type, int32_type, array_type, bool_type, option_type, record_type, string_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { map as map_2, value as value_2, Option } from "@fable-org/fable-library-js/Option.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { Spec_FormSpec$1_$reflection, Spec_FieldType_$reflection, Spec_FormSpec$1, ClinicalPathway_ClinicalPathwaySpec, Spec_Score, Spec_ScoreRange, Spec_ScoreColor_Danger, Spec_ScoreColor_Warning, Spec_ScoreColor_Success, Spec_ScoreColor_Info, Spec_ScoreColor_Link, Spec_ScoreColor_Primary, Spec_ScoreColor_Unspecified, Spec_ScoreColor_$union, Spec_FormStep$1, Spec_FormField$1, Spec_FieldType_PluginField, Spec_FieldType_Message, Spec_FieldType_Signature, Spec_SignatureInfo, Spec_FieldType_Matrix, Spec_FieldType_TextAutoComplete, Spec_FieldType_TagList, Spec_FieldType_CheckboxList, Spec_FieldType_MultiChoice, Spec_MultiChoiceInfo, Spec_FieldType_Dropdown, Spec_FieldType_SingleChoice, Spec_FieldType_Radio, Spec_SingleChoiceInfo, Spec_FieldType_Checkbox, Spec_FieldType_Time, Spec_FieldType_DateTimeLocal, Spec_FieldType_Date, Spec_FieldType_Tel, Spec_FieldType_Number, Spec_FieldType_Color, Spec_FieldType_Search, Spec_FieldType_Password, Spec_FieldType_Email, Spec_FieldType_TextArea, Spec_FieldType_Text, Spec_TextInfo, Spec_FieldType_$union, Spec_PluginFieldConfig, Spec_MessageInfo, Spec_MatrixInfo, Spec_BooleanInfo, Spec_MessageType_Danger, Spec_MessageType_Info, Spec_MessageType_Error, Spec_MessageType_Success, Spec_MessageType_Warning, Spec_MessageType_$union, Spec_DependsOn, Spec_Evaluator_Contains, Spec_Evaluator_IsEmpty, Spec_Evaluator_Exists, Spec_Evaluator_LessThanOrEquals, Spec_Evaluator_LessThan, Spec_Evaluator_GreaterThanOrEquals, Spec_Evaluator_GreaterThan, Spec_Evaluator_NotEquals, Spec_Evaluator_Equals, Spec_Evaluator_$union, Shared_FieldOption, Shared_FieldOptionKey, Shared_MatrixItemKey, Shared_TransitionKey, Shared_StateKey, Shared_FieldKey } from "../FormSpec.js";
+import { tryParse } from "@fable-org/fable-library-js/Guid.js";
+import { ofArray, reverse, empty, FSharpList, cons, map, toArray } from "@fable-org/fable-library-js/List.js";
+import { sumBy, tryFind, collect, map as map_1, fold } from "@fable-org/fable-library-js/Array.js";
+import { Auto_generateBoxedEncoder_437914C6, toString } from "../fable_modules/Thoth.Json.10.4.1/Encode.fs.js";
+import { FSharpResult$2_$union, Result_ToOption } from "@fable-org/fable-library-js/Result.js";
+import { Auto_generateBoxedDecoder_Z6670B51, fromString } from "../fable_modules/Thoth.Json.10.4.1/Decode.fs.js";
+import { printf, toConsole } from "@fable-org/fable-library-js/String.js";
+
+export class Types_FieldKeyTS extends Record implements IEquatable<Types_FieldKeyTS>, IComparable<Types_FieldKeyTS> {
+    readonly Value: string;
+    constructor(Value: string) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Types_FieldKeyTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.FieldKeyTS", [], Types_FieldKeyTS, () => [["Value", string_type]]);
+}
+
+export class Types_StateKeyTS extends Record implements IEquatable<Types_StateKeyTS>, IComparable<Types_StateKeyTS> {
+    readonly Value: string;
+    constructor(Value: string) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Types_StateKeyTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.StateKeyTS", [], Types_StateKeyTS, () => [["Value", string_type]]);
+}
+
+export class Types_TransitionKeyTS extends Record implements IEquatable<Types_TransitionKeyTS>, IComparable<Types_TransitionKeyTS> {
+    readonly Value: string;
+    constructor(Value: string) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Types_TransitionKeyTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.TransitionKeyTS", [], Types_TransitionKeyTS, () => [["Value", string_type]]);
+}
+
+export class Types_MatrixItemKeyTS extends Record implements IEquatable<Types_MatrixItemKeyTS>, IComparable<Types_MatrixItemKeyTS> {
+    readonly Value: string;
+    constructor(Value: string) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Types_MatrixItemKeyTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.MatrixItemKeyTS", [], Types_MatrixItemKeyTS, () => [["Value", string_type]]);
+}
+
+export class Types_FieldOptionKeyTS extends Record implements IEquatable<Types_FieldOptionKeyTS>, IComparable<Types_FieldOptionKeyTS> {
+    readonly Value: string;
+    constructor(Value: string) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Types_FieldOptionKeyTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.FieldOptionKeyTS", [], Types_FieldOptionKeyTS, () => [["Value", string_type]]);
+}
+
+export class Types_FieldOptionTS extends Record implements IEquatable<Types_FieldOptionTS>, IComparable<Types_FieldOptionTS> {
+    readonly Description: string;
+    readonly Value: string;
+    readonly OptionKey: Types_FieldOptionKeyTS;
+    constructor(Description: string, Value: string, OptionKey: Types_FieldOptionKeyTS) {
+        super();
+        this.Description = Description;
+        this.Value = Value;
+        this.OptionKey = OptionKey;
+    }
+}
+
+export function Types_FieldOptionTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.FieldOptionTS", [], Types_FieldOptionTS, () => [["Description", string_type], ["Value", string_type], ["OptionKey", Types_FieldOptionKeyTS_$reflection()]]);
+}
+
+export class Types_TextInfoTS extends Record implements IEquatable<Types_TextInfoTS>, IComparable<Types_TextInfoTS> {
+    readonly Value: Option<string>;
+    constructor(Value: Option<string>) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Types_TextInfoTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.TextInfoTS", [], Types_TextInfoTS, () => [["Value", option_type(string_type)]]);
+}
+
+export class Types_BooleanInfoTS extends Record implements IEquatable<Types_BooleanInfoTS>, IComparable<Types_BooleanInfoTS> {
+    readonly DefaultValue: Option<boolean>;
+    readonly Selection: Option<boolean>;
+    constructor(DefaultValue: Option<boolean>, Selection$: Option<boolean>) {
+        super();
+        this.DefaultValue = DefaultValue;
+        this.Selection = Selection$;
+    }
+}
+
+export function Types_BooleanInfoTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.BooleanInfoTS", [], Types_BooleanInfoTS, () => [["DefaultValue", option_type(bool_type)], ["Selection", option_type(bool_type)]]);
+}
+
+export class Types_CheckboxInfoTS extends Record implements IEquatable<Types_CheckboxInfoTS>, IComparable<Types_CheckboxInfoTS> {
+    readonly DefaultValue: Option<boolean>;
+    readonly Selection: Option<boolean>;
+    constructor(DefaultValue: Option<boolean>, Selection$: Option<boolean>) {
+        super();
+        this.DefaultValue = DefaultValue;
+        this.Selection = Selection$;
+    }
+}
+
+export function Types_CheckboxInfoTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.CheckboxInfoTS", [], Types_CheckboxInfoTS, () => [["DefaultValue", option_type(bool_type)], ["Selection", option_type(bool_type)]]);
+}
+
+export class Types_SingleChoiceInfoTS extends Record implements IEquatable<Types_SingleChoiceInfoTS>, IComparable<Types_SingleChoiceInfoTS> {
+    readonly Options: Types_FieldOptionTS[];
+    constructor(Options: Types_FieldOptionTS[]) {
+        super();
+        this.Options = Options;
+    }
+}
+
+export function Types_SingleChoiceInfoTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.SingleChoiceInfoTS", [], Types_SingleChoiceInfoTS, () => [["Options", array_type(Types_FieldOptionTS_$reflection())]]);
+}
+
+export class Types_MultiChoiceInfoTS extends Record implements IEquatable<Types_MultiChoiceInfoTS>, IComparable<Types_MultiChoiceInfoTS> {
+    readonly Options: Types_FieldOptionTS[];
+    constructor(Options: Types_FieldOptionTS[]) {
+        super();
+        this.Options = Options;
+    }
+}
+
+export function Types_MultiChoiceInfoTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.MultiChoiceInfoTS", [], Types_MultiChoiceInfoTS, () => [["Options", array_type(Types_FieldOptionTS_$reflection())]]);
+}
+
+export class Types_MessageInfoTS extends Record implements IEquatable<Types_MessageInfoTS>, IComparable<Types_MessageInfoTS> {
+    readonly Heading: string;
+    readonly MessageType: int32;
+    readonly Message: string;
+    readonly Footer: Option<string>;
+    constructor(Heading: string, MessageType: int32, Message: string, Footer: Option<string>) {
+        super();
+        this.Heading = Heading;
+        this.MessageType = (MessageType | 0);
+        this.Message = Message;
+        this.Footer = Footer;
+    }
+}
+
+export function Types_MessageInfoTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.MessageInfoTS", [], Types_MessageInfoTS, () => [["Heading", string_type], ["MessageType", enum_type("F1.Studio.FormSpec.Interop.OptionBased.Types.MessageTypeTS", int32_type, [["Warning", 0], ["Success", 1], ["Error", 2], ["Info", 3], ["Danger", 4]])], ["Message", string_type], ["Footer", option_type(string_type)]]);
+}
+
+export class Types_MatrixItemTS extends Record implements IEquatable<Types_MatrixItemTS>, IComparable<Types_MatrixItemTS> {
+    readonly ItemKey: Types_MatrixItemKeyTS;
+    readonly ItemLabel: string;
+    constructor(ItemKey: Types_MatrixItemKeyTS, ItemLabel: string) {
+        super();
+        this.ItemKey = ItemKey;
+        this.ItemLabel = ItemLabel;
+    }
+}
+
+export function Types_MatrixItemTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.MatrixItemTS", [], Types_MatrixItemTS, () => [["ItemKey", Types_MatrixItemKeyTS_$reflection()], ["ItemLabel", string_type]]);
+}
+
+export class Types_MatrixInfoTS extends Record implements IEquatable<Types_MatrixInfoTS>, IComparable<Types_MatrixInfoTS> {
+    readonly Items: Types_FieldOptionTS[];
+    readonly Options: Types_FieldOptionTS[];
+    constructor(Items: Types_FieldOptionTS[], Options: Types_FieldOptionTS[]) {
+        super();
+        this.Items = Items;
+        this.Options = Options;
+    }
+}
+
+export function Types_MatrixInfoTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.MatrixInfoTS", [], Types_MatrixInfoTS, () => [["Items", array_type(Types_FieldOptionTS_$reflection())], ["Options", array_type(Types_FieldOptionTS_$reflection())]]);
+}
+
+export class Types_SignatureInfoTS extends Record implements IEquatable<Types_SignatureInfoTS>, IComparable<Types_SignatureInfoTS> {
+    readonly Value: Option<string>;
+    constructor(Value: Option<string>) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Types_SignatureInfoTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.SignatureInfoTS", [], Types_SignatureInfoTS, () => [["Value", option_type(string_type)]]);
+}
+
+export class Types_PluginFieldConfigTS extends Record implements IEquatable<Types_PluginFieldConfigTS>, IComparable<Types_PluginFieldConfigTS> {
+    readonly PluginId: string;
+    readonly FieldName: string;
+    constructor(PluginId: string, FieldName: string) {
+        super();
+        this.PluginId = PluginId;
+        this.FieldName = FieldName;
+    }
+}
+
+export function Types_PluginFieldConfigTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.PluginFieldConfigTS", [], Types_PluginFieldConfigTS, () => [["PluginId", string_type], ["FieldName", string_type]]);
+}
+
+export class Types_FieldTypeTS extends Record implements IEquatable<Types_FieldTypeTS>, IComparable<Types_FieldTypeTS> {
+    readonly Type: string;
+    readonly TextInfo: Option<Types_TextInfoTS>;
+    readonly BooleanInfo: Option<Types_BooleanInfoTS>;
+    readonly CheckboxInfo: Option<Types_CheckboxInfoTS>;
+    readonly SingleChoiceInfo: Option<Types_SingleChoiceInfoTS>;
+    readonly MultiChoiceInfo: Option<Types_MultiChoiceInfoTS>;
+    readonly MessageInfo: Option<Types_MessageInfoTS>;
+    readonly MatrixInfo: Option<Types_MatrixInfoTS>;
+    readonly SignatureInfo: Option<Types_SignatureInfoTS>;
+    readonly PluginConfig: Option<Types_PluginFieldConfigTS>;
+    constructor(Type: string, TextInfo: Option<Types_TextInfoTS>, BooleanInfo: Option<Types_BooleanInfoTS>, CheckboxInfo: Option<Types_CheckboxInfoTS>, SingleChoiceInfo: Option<Types_SingleChoiceInfoTS>, MultiChoiceInfo: Option<Types_MultiChoiceInfoTS>, MessageInfo: Option<Types_MessageInfoTS>, MatrixInfo: Option<Types_MatrixInfoTS>, SignatureInfo: Option<Types_SignatureInfoTS>, PluginConfig: Option<Types_PluginFieldConfigTS>) {
+        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;
+    }
+}
+
+export function Types_FieldTypeTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.FieldTypeTS", [], Types_FieldTypeTS, () => [["Type", string_type], ["TextInfo", option_type(Types_TextInfoTS_$reflection())], ["BooleanInfo", option_type(Types_BooleanInfoTS_$reflection())], ["CheckboxInfo", option_type(Types_CheckboxInfoTS_$reflection())], ["SingleChoiceInfo", option_type(Types_SingleChoiceInfoTS_$reflection())], ["MultiChoiceInfo", option_type(Types_MultiChoiceInfoTS_$reflection())], ["MessageInfo", option_type(Types_MessageInfoTS_$reflection())], ["MatrixInfo", option_type(Types_MatrixInfoTS_$reflection())], ["SignatureInfo", option_type(Types_SignatureInfoTS_$reflection())], ["PluginConfig", option_type(Types_PluginFieldConfigTS_$reflection())]]);
+}
+
+export class Types_DependsOnTS extends Record implements IEquatable<Types_DependsOnTS>, IComparable<Types_DependsOnTS> {
+    readonly FieldKey: Types_FieldKeyTS;
+    readonly FieldValue: string;
+    readonly Evaluator: int32;
+    constructor(FieldKey: Types_FieldKeyTS, FieldValue: string, Evaluator: int32) {
+        super();
+        this.FieldKey = FieldKey;
+        this.FieldValue = FieldValue;
+        this.Evaluator = (Evaluator | 0);
+    }
+}
+
+export function Types_DependsOnTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.DependsOnTS", [], Types_DependsOnTS, () => [["FieldKey", Types_FieldKeyTS_$reflection()], ["FieldValue", string_type], ["Evaluator", enum_type("F1.Studio.FormSpec.Interop.OptionBased.Types.EvaluatorTS", int32_type, [["Equals", 0], ["NotEquals", 1], ["GreaterThan", 2], ["GreaterThanOrEquals", 3], ["LessThan", 4], ["LessThanOrEquals", 5], ["Exists", 6], ["IsEmpty", 7], ["Contains", 8]])]]);
+}
+
+export class Types_FormFieldTS extends Record implements IEquatable<Types_FormFieldTS>, IComparable<Types_FormFieldTS> {
+    readonly FieldOrder: int32;
+    readonly FieldKey: Types_FieldKeyTS;
+    readonly Label: string;
+    readonly Notes: Option<string>;
+    readonly DependsOn: Option<Types_DependsOnTS>;
+    readonly IsOptional: boolean;
+    readonly IsDeprecated: boolean;
+    readonly FieldType: Types_FieldTypeTS;
+    constructor(FieldOrder: int32, FieldKey: Types_FieldKeyTS, Label: string, Notes: Option<string>, DependsOn: Option<Types_DependsOnTS>, IsOptional: boolean, IsDeprecated: boolean, FieldType: Types_FieldTypeTS) {
+        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;
+    }
+}
+
+export function Types_FormFieldTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.FormFieldTS", [], Types_FormFieldTS, () => [["FieldOrder", int32_type], ["FieldKey", Types_FieldKeyTS_$reflection()], ["Label", string_type], ["Notes", option_type(string_type)], ["DependsOn", option_type(Types_DependsOnTS_$reflection())], ["IsOptional", bool_type], ["IsDeprecated", bool_type], ["FieldType", Types_FieldTypeTS_$reflection()]]);
+}
+
+export class Types_FormStepTS extends Record implements IEquatable<Types_FormStepTS>, IComparable<Types_FormStepTS> {
+    readonly StepOrder: int32;
+    readonly StepLabel: string;
+    readonly Fields: Types_FormFieldTS[];
+    constructor(StepOrder: int32, StepLabel: string, Fields: Types_FormFieldTS[]) {
+        super();
+        this.StepOrder = (StepOrder | 0);
+        this.StepLabel = StepLabel;
+        this.Fields = Fields;
+    }
+}
+
+export function Types_FormStepTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.FormStepTS", [], Types_FormStepTS, () => [["StepOrder", int32_type], ["StepLabel", string_type], ["Fields", array_type(Types_FormFieldTS_$reflection())]]);
+}
+
+export class Types_ScoreRangeTS extends Record implements IEquatable<Types_ScoreRangeTS>, IComparable<Types_ScoreRangeTS> {
+    readonly Id: string;
+    readonly Min: int32;
+    readonly Max: int32;
+    readonly Label: string;
+    readonly Tag: int32;
+    constructor(Id: string, Min: int32, Max: int32, Label: string, Tag: int32) {
+        super();
+        this.Id = Id;
+        this.Min = (Min | 0);
+        this.Max = (Max | 0);
+        this.Label = Label;
+        this.Tag = (Tag | 0);
+    }
+}
+
+export function Types_ScoreRangeTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.ScoreRangeTS", [], Types_ScoreRangeTS, () => [["Id", string_type], ["Min", int32_type], ["Max", int32_type], ["Label", string_type], ["Tag", enum_type("F1.Studio.FormSpec.Interop.OptionBased.Types.ScoreColorTS", int32_type, [["Unspecified", 0], ["Primary", 1], ["Link", 2], ["Info", 3], ["Success", 4], ["Warning", 5], ["Danger", 6]])]]);
+}
+
+export class Types_ScoreTS extends Record implements IEquatable<Types_ScoreTS>, IComparable<Types_ScoreTS> {
+    readonly MaxScore: int32;
+    readonly ScoreRanges: Types_ScoreRangeTS[];
+    constructor(MaxScore: int32, ScoreRanges: Types_ScoreRangeTS[]) {
+        super();
+        this.MaxScore = (MaxScore | 0);
+        this.ScoreRanges = ScoreRanges;
+    }
+}
+
+export function Types_ScoreTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.ScoreTS", [], Types_ScoreTS, () => [["MaxScore", int32_type], ["ScoreRanges", array_type(Types_ScoreRangeTS_$reflection())]]);
+}
+
+export class Types_ClinicalPathwaySpecTS extends Record implements IEquatable<Types_ClinicalPathwaySpecTS>, IComparable<Types_ClinicalPathwaySpecTS> {
+    readonly PathwayId: string;
+    readonly PathwayName: string;
+    readonly Version: string;
+    readonly ProtocolSource: string;
+    constructor(PathwayId: string, PathwayName: string, Version: string, ProtocolSource: string) {
+        super();
+        this.PathwayId = PathwayId;
+        this.PathwayName = PathwayName;
+        this.Version = Version;
+        this.ProtocolSource = ProtocolSource;
+    }
+}
+
+export function Types_ClinicalPathwaySpecTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.ClinicalPathwaySpecTS", [], Types_ClinicalPathwaySpecTS, () => [["PathwayId", string_type], ["PathwayName", string_type], ["Version", string_type], ["ProtocolSource", string_type]]);
+}
+
+export class Types_FormSpecTS extends Record implements IEquatable<Types_FormSpecTS>, IComparable<Types_FormSpecTS> {
+    readonly Id: string;
+    readonly Code: Option<string>;
+    readonly Title: string;
+    readonly Abstract: string;
+    readonly Version: string;
+    readonly FormSpecVersion: string;
+    readonly Steps: Types_FormStepTS[];
+    readonly CategoryTags: string[];
+    readonly Score: Option<Types_ScoreTS>;
+    readonly AssociatedCodes: string[];
+    readonly RequiresReview: boolean;
+    readonly RequiresReviewAndApproval: boolean;
+    readonly ClinicalPathway: Option<Types_ClinicalPathwaySpecTS>;
+    constructor(Id: string, Code: Option<string>, Title: string, Abstract: string, Version: string, FormSpecVersion: string, Steps: Types_FormStepTS[], CategoryTags: string[], Score: Option<Types_ScoreTS>, AssociatedCodes: string[], RequiresReview: boolean, RequiresReviewAndApproval: boolean, ClinicalPathway: Option<Types_ClinicalPathwaySpecTS>) {
+        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;
+    }
+}
+
+export function Types_FormSpecTS_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpec.Interop.OptionBased.Types.FormSpecTS", [], Types_FormSpecTS, () => [["Id", string_type], ["Code", option_type(string_type)], ["Title", string_type], ["Abstract", string_type], ["Version", string_type], ["FormSpecVersion", string_type], ["Steps", array_type(Types_FormStepTS_$reflection())], ["CategoryTags", array_type(string_type)], ["Score", option_type(Types_ScoreTS_$reflection())], ["AssociatedCodes", array_type(string_type)], ["RequiresReview", bool_type], ["RequiresReviewAndApproval", bool_type], ["ClinicalPathway", option_type(Types_ClinicalPathwaySpecTS_$reflection())]]);
+}
+
+/**
+ * Convert F# FieldKey to TypeScript representation
+ */
+export function Converters_fieldKeyToTS(_arg: Shared_FieldKey): Types_FieldKeyTS {
+    return new Types_FieldKeyTS(_arg.fields[0]);
+}
+
+/**
+ * Convert TypeScript FieldKey to F# representation
+ */
+export function Converters_fieldKeyFromTS(key: Types_FieldKeyTS): Option<Shared_FieldKey> {
+    let matchValue: [boolean, string];
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = ([tryParse(key.Value, new FSharpRef<string>((): string => outArg, (v: string): void => {
+        outArg = v;
+    })), outArg] as [boolean, string]);
+    if (matchValue[0]) {
+        return new Shared_FieldKey(matchValue[1]);
+    }
+    else {
+        return undefined;
+    }
+}
+
+/**
+ * Convert F# StateKey to TypeScript representation
+ */
+export function Converters_stateKeyToTS(_arg: Shared_StateKey): Types_StateKeyTS {
+    return new Types_StateKeyTS(_arg.fields[0]);
+}
+
+/**
+ * Convert TypeScript StateKey to F# representation
+ */
+export function Converters_stateKeyFromTS(key: Types_StateKeyTS): Option<Shared_StateKey> {
+    let matchValue: [boolean, string];
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = ([tryParse(key.Value, new FSharpRef<string>((): string => outArg, (v: string): void => {
+        outArg = v;
+    })), outArg] as [boolean, string]);
+    if (matchValue[0]) {
+        return new Shared_StateKey(matchValue[1]);
+    }
+    else {
+        return undefined;
+    }
+}
+
+/**
+ * Convert F# TransitionKey to TypeScript representation
+ */
+export function Converters_transitionKeyToTS(_arg: Shared_TransitionKey): Types_TransitionKeyTS {
+    return new Types_TransitionKeyTS(_arg.fields[0]);
+}
+
+/**
+ * Convert F# MatrixItemKey to TypeScript representation
+ */
+export function Converters_matrixItemKeyToTS(_arg: Shared_MatrixItemKey): Types_MatrixItemKeyTS {
+    return new Types_MatrixItemKeyTS(_arg.fields[0]);
+}
+
+/**
+ * Convert F# FieldOptionKey to TypeScript representation
+ */
+export function Converters_fieldOptionKeyToTS(_arg: Shared_FieldOptionKey): Types_FieldOptionKeyTS {
+    return new Types_FieldOptionKeyTS(_arg.fields[0]);
+}
+
+/**
+ * Convert TypeScript FieldOptionKey to F# representation
+ */
+export function Converters_fieldOptionKeyFromTS(key: Types_FieldOptionKeyTS): Option<Shared_FieldOptionKey> {
+    let matchValue: [boolean, string];
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = ([tryParse(key.Value, new FSharpRef<string>((): string => outArg, (v: string): void => {
+        outArg = v;
+    })), outArg] as [boolean, string]);
+    if (matchValue[0]) {
+        return new Shared_FieldOptionKey(matchValue[1]);
+    }
+    else {
+        return undefined;
+    }
+}
+
+/**
+ * Convert F# FieldOption to TypeScript representation
+ */
+export function Converters_fieldOptionToTS(option: Shared_FieldOption): Types_FieldOptionTS {
+    return new Types_FieldOptionTS(option.Description, option.Value, Converters_fieldOptionKeyToTS(option.OptionKey));
+}
+
+/**
+ * Convert TypeScript FieldOption to F# representation
+ */
+export function Converters_fieldOptionFromTS(option: Types_FieldOptionTS): Option<Shared_FieldOption> {
+    const matchValue: Option<Shared_FieldOptionKey> = Converters_fieldOptionKeyFromTS(option.OptionKey);
+    if (matchValue == null) {
+        return undefined;
+    }
+    else {
+        return new Shared_FieldOption(option.Description, option.Value, value_2(matchValue));
+    }
+}
+
+/**
+ * Convert F# Evaluator to TypeScript representation
+ */
+export function Converters_evaluatorToTS(evaluator: Spec_Evaluator_$union): int32 {
+    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;
+    }
+}
+
+/**
+ * Convert TypeScript Evaluator to F# representation
+ */
+export function Converters_evaluatorFromTS(evaluator: int32): Option<Spec_Evaluator_$union> {
+    switch (evaluator) {
+        case 0:
+            return Spec_Evaluator_Equals();
+        case 1:
+            return Spec_Evaluator_NotEquals();
+        case 2:
+            return Spec_Evaluator_GreaterThan();
+        case 3:
+            return Spec_Evaluator_GreaterThanOrEquals();
+        case 4:
+            return Spec_Evaluator_LessThan();
+        case 5:
+            return Spec_Evaluator_LessThanOrEquals();
+        case 6:
+            return Spec_Evaluator_Exists();
+        case 7:
+            return Spec_Evaluator_IsEmpty();
+        case 8:
+            return Spec_Evaluator_Contains();
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Convert F# DependsOn to TypeScript representation
+ */
+export function Converters_dependsOnToTS(deps: Spec_DependsOn): Types_DependsOnTS {
+    return new Types_DependsOnTS(Converters_fieldKeyToTS(deps.FieldKey), deps.FieldValue, Converters_evaluatorToTS(deps.Evaluator));
+}
+
+/**
+ * Convert TypeScript DependsOn to F# representation
+ */
+export function Converters_dependsOnFromTS(deps: Types_DependsOnTS): Option<Spec_DependsOn> {
+    const matchValue: Option<Shared_FieldKey> = Converters_fieldKeyFromTS(deps.FieldKey);
+    const matchValue_1: Option<Spec_Evaluator_$union> = Converters_evaluatorFromTS(deps.Evaluator);
+    let matchResult: int32, eval$: Spec_Evaluator_$union, key: Shared_FieldKey;
+    if (matchValue != null) {
+        if (matchValue_1 != null) {
+            matchResult = 0;
+            eval$ = value_2(matchValue_1);
+            key = value_2(matchValue);
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Spec_DependsOn(key!, deps.FieldValue, eval$!);
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Convert F# MessageType to TypeScript representation
+ */
+export function Converters_messageTypeToTS(msgType: Spec_MessageType_$union): int32 {
+    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;
+    }
+}
+
+/**
+ * Convert TypeScript MessageType to F# representation
+ */
+export function Converters_messageTypeFromTS(msgType: int32): Option<Spec_MessageType_$union> {
+    switch (msgType) {
+        case 0:
+            return Spec_MessageType_Warning();
+        case 1:
+            return Spec_MessageType_Success();
+        case 2:
+            return Spec_MessageType_Error();
+        case 3:
+            return Spec_MessageType_Info();
+        case 4:
+            return Spec_MessageType_Danger();
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Convert F# FieldType to TypeScript representation
+ */
+export function Converters_fieldTypeToTS(fieldType: Spec_FieldType_$union): Types_FieldTypeTS {
+    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: Spec_BooleanInfo = 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(toArray<Types_FieldOptionTS>(map<Shared_FieldOption, Types_FieldOptionTS>(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(toArray<Types_FieldOptionTS>(map<Shared_FieldOption, Types_FieldOptionTS>(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(toArray<Types_FieldOptionTS>(map<Shared_FieldOption, Types_FieldOptionTS>(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(toArray<Types_FieldOptionTS>(map<Shared_FieldOption, Types_FieldOptionTS>(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(toArray<Types_FieldOptionTS>(map<Shared_FieldOption, Types_FieldOptionTS>(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(toArray<Types_FieldOptionTS>(map<Shared_FieldOption, Types_FieldOptionTS>(Converters_fieldOptionToTS, fieldType.fields[0].Options))), undefined, undefined, undefined, undefined);
+        case /* TextAutoComplete */ 18:
+            return new Types_FieldTypeTS("TextAutoComplete", undefined, undefined, undefined, new Types_SingleChoiceInfoTS(toArray<Types_FieldOptionTS>(map<Shared_FieldOption, Types_FieldOptionTS>(Converters_fieldOptionToTS, fieldType.fields[0].Options))), undefined, undefined, undefined, undefined, undefined);
+        case /* Matrix */ 19: {
+            const info_19: Spec_MatrixInfo = fieldType.fields[0];
+            return new Types_FieldTypeTS("Matrix", undefined, undefined, undefined, undefined, undefined, undefined, new Types_MatrixInfoTS(toArray<Types_FieldOptionTS>(map<Shared_FieldOption, Types_FieldOptionTS>(Converters_fieldOptionToTS, info_19.Items)), toArray<Types_FieldOptionTS>(map<Shared_FieldOption, Types_FieldOptionTS>(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: Spec_MessageInfo = 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: Spec_PluginFieldConfig = 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);
+    }
+}
+
+/**
+ * Convert TypeScript FieldType to F# representation
+ */
+export function Converters_fieldTypeFromTS(fieldType: Types_FieldTypeTS): Option<Spec_FieldType_$union> {
+    const matchValue: string = fieldType.Type;
+    switch (matchValue) {
+        case "Text": {
+            const matchValue_1: Option<Types_TextInfoTS> = fieldType.TextInfo;
+            if (matchValue_1 == null) {
+                return undefined;
+            }
+            else {
+                return Spec_FieldType_Text(new Spec_TextInfo(value_2(matchValue_1).Value));
+            }
+        }
+        case "TextArea": {
+            const matchValue_2: Option<Types_TextInfoTS> = fieldType.TextInfo;
+            if (matchValue_2 == null) {
+                return undefined;
+            }
+            else {
+                return Spec_FieldType_TextArea(new Spec_TextInfo(value_2(matchValue_2).Value));
+            }
+        }
+        case "Email": {
+            const matchValue_3: Option<Types_TextInfoTS> = fieldType.TextInfo;
+            if (matchValue_3 == null) {
+                return undefined;
+            }
+            else {
+                return Spec_FieldType_Email(new Spec_TextInfo(value_2(matchValue_3).Value));
+            }
+        }
+        case "Password": {
+            const matchValue_4: Option<Types_TextInfoTS> = fieldType.TextInfo;
+            if (matchValue_4 == null) {
+                return undefined;
+            }
+            else {
+                return Spec_FieldType_Password(new Spec_TextInfo(value_2(matchValue_4).Value));
+            }
+        }
+        case "Search": {
+            const matchValue_5: Option<Types_TextInfoTS> = fieldType.TextInfo;
+            if (matchValue_5 == null) {
+                return undefined;
+            }
+            else {
+                return Spec_FieldType_Search(new Spec_TextInfo(value_2(matchValue_5).Value));
+            }
+        }
+        case "Color": {
+            const matchValue_6: Option<Types_TextInfoTS> = fieldType.TextInfo;
+            if (matchValue_6 == null) {
+                return undefined;
+            }
+            else {
+                return Spec_FieldType_Color(new Spec_TextInfo(value_2(matchValue_6).Value));
+            }
+        }
+        case "Number": {
+            const matchValue_7: Option<Types_TextInfoTS> = fieldType.TextInfo;
+            if (matchValue_7 == null) {
+                return undefined;
+            }
+            else {
+                return Spec_FieldType_Number(new Spec_TextInfo(value_2(matchValue_7).Value));
+            }
+        }
+        case "Tel": {
+            const matchValue_8: Option<Types_TextInfoTS> = fieldType.TextInfo;
+            if (matchValue_8 == null) {
+                return undefined;
+            }
+            else {
+                return Spec_FieldType_Tel(new Spec_TextInfo(value_2(matchValue_8).Value));
+            }
+        }
+        case "Date": {
+            const matchValue_9: Option<Types_TextInfoTS> = fieldType.TextInfo;
+            if (matchValue_9 == null) {
+                return undefined;
+            }
+            else {
+                return Spec_FieldType_Date(new Spec_TextInfo(value_2(matchValue_9).Value));
+            }
+        }
+        case "DateTimeLocal": {
+            const matchValue_10: Option<Types_TextInfoTS> = fieldType.TextInfo;
+            if (matchValue_10 == null) {
+                return undefined;
+            }
+            else {
+                return Spec_FieldType_DateTimeLocal(new Spec_TextInfo(value_2(matchValue_10).Value));
+            }
+        }
+        case "Time": {
+            const matchValue_11: Option<Types_TextInfoTS> = fieldType.TextInfo;
+            if (matchValue_11 == null) {
+                return undefined;
+            }
+            else {
+                return Spec_FieldType_Time(new Spec_TextInfo(value_2(matchValue_11).Value));
+            }
+        }
+        case "Checkbox": {
+            const matchValue_12: Option<Types_CheckboxInfoTS> = fieldType.CheckboxInfo;
+            if (matchValue_12 == null) {
+                return undefined;
+            }
+            else {
+                const info_11: Types_CheckboxInfoTS = value_2(matchValue_12);
+                return Spec_FieldType_Checkbox(new Spec_BooleanInfo(info_11.DefaultValue, info_11.Selection));
+            }
+        }
+        case "Radio": {
+            const matchValue_13: Option<Types_SingleChoiceInfoTS> = fieldType.SingleChoiceInfo;
+            if (matchValue_13 == null) {
+                return undefined;
+            }
+            else {
+                const convertedOptions: Option<FSharpList<Shared_FieldOption>> = fold<Option<Shared_FieldOption>, Option<FSharpList<Shared_FieldOption>>>((acc: Option<FSharpList<Shared_FieldOption>>, opt: Option<Shared_FieldOption>): Option<FSharpList<Shared_FieldOption>> => {
+                    let matchResult: int32, item: Shared_FieldOption, list: FSharpList<Shared_FieldOption>;
+                    if (acc != null) {
+                        if (opt != null) {
+                            matchResult = 0;
+                            item = value_2(opt);
+                            list = value_2(acc);
+                        }
+                        else {
+                            matchResult = 1;
+                        }
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                    switch (matchResult) {
+                        case 0:
+                            return cons(item!, list!);
+                        default:
+                            return undefined;
+                    }
+                }, empty<Shared_FieldOption>(), map_1<Types_FieldOptionTS, Option<Shared_FieldOption>>(Converters_fieldOptionFromTS, value_2(matchValue_13).Options));
+                if (convertedOptions == null) {
+                    return undefined;
+                }
+                else {
+                    return Spec_FieldType_Radio(new Spec_SingleChoiceInfo(reverse<Shared_FieldOption>(value_2(convertedOptions))));
+                }
+            }
+        }
+        case "SingleChoice": {
+            const matchValue_15: Option<Types_SingleChoiceInfoTS> = fieldType.SingleChoiceInfo;
+            if (matchValue_15 == null) {
+                return undefined;
+            }
+            else {
+                const convertedOptions_1: Option<FSharpList<Shared_FieldOption>> = fold<Option<Shared_FieldOption>, Option<FSharpList<Shared_FieldOption>>>((acc_1: Option<FSharpList<Shared_FieldOption>>, opt_1: Option<Shared_FieldOption>): Option<FSharpList<Shared_FieldOption>> => {
+                    let matchResult_1: int32, item_1: Shared_FieldOption, list_1: FSharpList<Shared_FieldOption>;
+                    if (acc_1 != null) {
+                        if (opt_1 != null) {
+                            matchResult_1 = 0;
+                            item_1 = value_2(opt_1);
+                            list_1 = value_2(acc_1);
+                        }
+                        else {
+                            matchResult_1 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_1 = 1;
+                    }
+                    switch (matchResult_1) {
+                        case 0:
+                            return cons(item_1!, list_1!);
+                        default:
+                            return undefined;
+                    }
+                }, empty<Shared_FieldOption>(), map_1<Types_FieldOptionTS, Option<Shared_FieldOption>>(Converters_fieldOptionFromTS, value_2(matchValue_15).Options));
+                if (convertedOptions_1 == null) {
+                    return undefined;
+                }
+                else {
+                    return Spec_FieldType_SingleChoice(new Spec_SingleChoiceInfo(reverse<Shared_FieldOption>(value_2(convertedOptions_1))));
+                }
+            }
+        }
+        case "Dropdown": {
+            const matchValue_17: Option<Types_SingleChoiceInfoTS> = fieldType.SingleChoiceInfo;
+            if (matchValue_17 == null) {
+                return undefined;
+            }
+            else {
+                const convertedOptions_2: Option<FSharpList<Shared_FieldOption>> = fold<Option<Shared_FieldOption>, Option<FSharpList<Shared_FieldOption>>>((acc_2: Option<FSharpList<Shared_FieldOption>>, opt_2: Option<Shared_FieldOption>): Option<FSharpList<Shared_FieldOption>> => {
+                    let matchResult_2: int32, item_2: Shared_FieldOption, list_2: FSharpList<Shared_FieldOption>;
+                    if (acc_2 != null) {
+                        if (opt_2 != null) {
+                            matchResult_2 = 0;
+                            item_2 = value_2(opt_2);
+                            list_2 = value_2(acc_2);
+                        }
+                        else {
+                            matchResult_2 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_2 = 1;
+                    }
+                    switch (matchResult_2) {
+                        case 0:
+                            return cons(item_2!, list_2!);
+                        default:
+                            return undefined;
+                    }
+                }, empty<Shared_FieldOption>(), map_1<Types_FieldOptionTS, Option<Shared_FieldOption>>(Converters_fieldOptionFromTS, value_2(matchValue_17).Options));
+                if (convertedOptions_2 == null) {
+                    return undefined;
+                }
+                else {
+                    return Spec_FieldType_Dropdown(new Spec_SingleChoiceInfo(reverse<Shared_FieldOption>(value_2(convertedOptions_2))));
+                }
+            }
+        }
+        case "MultiChoice": {
+            const matchValue_19: Option<Types_MultiChoiceInfoTS> = fieldType.MultiChoiceInfo;
+            if (matchValue_19 == null) {
+                return undefined;
+            }
+            else {
+                const convertedOptions_3: Option<FSharpList<Shared_FieldOption>> = fold<Option<Shared_FieldOption>, Option<FSharpList<Shared_FieldOption>>>((acc_3: Option<FSharpList<Shared_FieldOption>>, opt_3: Option<Shared_FieldOption>): Option<FSharpList<Shared_FieldOption>> => {
+                    let matchResult_3: int32, item_3: Shared_FieldOption, list_3: FSharpList<Shared_FieldOption>;
+                    if (acc_3 != null) {
+                        if (opt_3 != null) {
+                            matchResult_3 = 0;
+                            item_3 = value_2(opt_3);
+                            list_3 = value_2(acc_3);
+                        }
+                        else {
+                            matchResult_3 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_3 = 1;
+                    }
+                    switch (matchResult_3) {
+                        case 0:
+                            return cons(item_3!, list_3!);
+                        default:
+                            return undefined;
+                    }
+                }, empty<Shared_FieldOption>(), map_1<Types_FieldOptionTS, Option<Shared_FieldOption>>(Converters_fieldOptionFromTS, value_2(matchValue_19).Options));
+                if (convertedOptions_3 == null) {
+                    return undefined;
+                }
+                else {
+                    return Spec_FieldType_MultiChoice(new Spec_MultiChoiceInfo(reverse<Shared_FieldOption>(value_2(convertedOptions_3))));
+                }
+            }
+        }
+        case "CheckboxList": {
+            const matchValue_21: Option<Types_MultiChoiceInfoTS> = fieldType.MultiChoiceInfo;
+            if (matchValue_21 == null) {
+                return undefined;
+            }
+            else {
+                const convertedOptions_4: Option<FSharpList<Shared_FieldOption>> = fold<Option<Shared_FieldOption>, Option<FSharpList<Shared_FieldOption>>>((acc_4: Option<FSharpList<Shared_FieldOption>>, opt_4: Option<Shared_FieldOption>): Option<FSharpList<Shared_FieldOption>> => {
+                    let matchResult_4: int32, item_4: Shared_FieldOption, list_4: FSharpList<Shared_FieldOption>;
+                    if (acc_4 != null) {
+                        if (opt_4 != null) {
+                            matchResult_4 = 0;
+                            item_4 = value_2(opt_4);
+                            list_4 = value_2(acc_4);
+                        }
+                        else {
+                            matchResult_4 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_4 = 1;
+                    }
+                    switch (matchResult_4) {
+                        case 0:
+                            return cons(item_4!, list_4!);
+                        default:
+                            return undefined;
+                    }
+                }, empty<Shared_FieldOption>(), map_1<Types_FieldOptionTS, Option<Shared_FieldOption>>(Converters_fieldOptionFromTS, value_2(matchValue_21).Options));
+                if (convertedOptions_4 == null) {
+                    return undefined;
+                }
+                else {
+                    return Spec_FieldType_CheckboxList(new Spec_MultiChoiceInfo(reverse<Shared_FieldOption>(value_2(convertedOptions_4))));
+                }
+            }
+        }
+        case "TagList": {
+            const matchValue_23: Option<Types_MultiChoiceInfoTS> = fieldType.MultiChoiceInfo;
+            if (matchValue_23 == null) {
+                return undefined;
+            }
+            else {
+                const convertedOptions_5: Option<FSharpList<Shared_FieldOption>> = fold<Option<Shared_FieldOption>, Option<FSharpList<Shared_FieldOption>>>((acc_5: Option<FSharpList<Shared_FieldOption>>, opt_5: Option<Shared_FieldOption>): Option<FSharpList<Shared_FieldOption>> => {
+                    let matchResult_5: int32, item_5: Shared_FieldOption, list_5: FSharpList<Shared_FieldOption>;
+                    if (acc_5 != null) {
+                        if (opt_5 != null) {
+                            matchResult_5 = 0;
+                            item_5 = value_2(opt_5);
+                            list_5 = value_2(acc_5);
+                        }
+                        else {
+                            matchResult_5 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_5 = 1;
+                    }
+                    switch (matchResult_5) {
+                        case 0:
+                            return cons(item_5!, list_5!);
+                        default:
+                            return undefined;
+                    }
+                }, empty<Shared_FieldOption>(), map_1<Types_FieldOptionTS, Option<Shared_FieldOption>>(Converters_fieldOptionFromTS, value_2(matchValue_23).Options));
+                if (convertedOptions_5 == null) {
+                    return undefined;
+                }
+                else {
+                    return Spec_FieldType_TagList(new Spec_MultiChoiceInfo(reverse<Shared_FieldOption>(value_2(convertedOptions_5))));
+                }
+            }
+        }
+        case "TextAutoComplete": {
+            const matchValue_25: Option<Types_SingleChoiceInfoTS> = fieldType.SingleChoiceInfo;
+            if (matchValue_25 == null) {
+                return undefined;
+            }
+            else {
+                const convertedOptions_6: Option<FSharpList<Shared_FieldOption>> = fold<Option<Shared_FieldOption>, Option<FSharpList<Shared_FieldOption>>>((acc_6: Option<FSharpList<Shared_FieldOption>>, opt_6: Option<Shared_FieldOption>): Option<FSharpList<Shared_FieldOption>> => {
+                    let matchResult_6: int32, item_6: Shared_FieldOption, list_6: FSharpList<Shared_FieldOption>;
+                    if (acc_6 != null) {
+                        if (opt_6 != null) {
+                            matchResult_6 = 0;
+                            item_6 = value_2(opt_6);
+                            list_6 = value_2(acc_6);
+                        }
+                        else {
+                            matchResult_6 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_6 = 1;
+                    }
+                    switch (matchResult_6) {
+                        case 0:
+                            return cons(item_6!, list_6!);
+                        default:
+                            return undefined;
+                    }
+                }, empty<Shared_FieldOption>(), map_1<Types_FieldOptionTS, Option<Shared_FieldOption>>(Converters_fieldOptionFromTS, value_2(matchValue_25).Options));
+                if (convertedOptions_6 == null) {
+                    return undefined;
+                }
+                else {
+                    return Spec_FieldType_TextAutoComplete(new Spec_SingleChoiceInfo(reverse<Shared_FieldOption>(value_2(convertedOptions_6))));
+                }
+            }
+        }
+        case "Matrix": {
+            const matchValue_27: Option<Types_MatrixInfoTS> = fieldType.MatrixInfo;
+            if (matchValue_27 == null) {
+                return undefined;
+            }
+            else {
+                const info_19: Types_MatrixInfoTS = value_2(matchValue_27);
+                const convertedItems: Option<FSharpList<Shared_FieldOption>> = fold<Option<Shared_FieldOption>, Option<FSharpList<Shared_FieldOption>>>((acc_7: Option<FSharpList<Shared_FieldOption>>, opt_7: Option<Shared_FieldOption>): Option<FSharpList<Shared_FieldOption>> => {
+                    let matchResult_7: int32, item_7: Shared_FieldOption, list_7: FSharpList<Shared_FieldOption>;
+                    if (acc_7 != null) {
+                        if (opt_7 != null) {
+                            matchResult_7 = 0;
+                            item_7 = value_2(opt_7);
+                            list_7 = value_2(acc_7);
+                        }
+                        else {
+                            matchResult_7 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_7 = 1;
+                    }
+                    switch (matchResult_7) {
+                        case 0:
+                            return cons(item_7!, list_7!);
+                        default:
+                            return undefined;
+                    }
+                }, empty<Shared_FieldOption>(), map_1<Types_FieldOptionTS, Option<Shared_FieldOption>>(Converters_fieldOptionFromTS, info_19.Items));
+                const convertedOptions_7: Option<FSharpList<Shared_FieldOption>> = fold<Option<Shared_FieldOption>, Option<FSharpList<Shared_FieldOption>>>((acc_8: Option<FSharpList<Shared_FieldOption>>, opt_8: Option<Shared_FieldOption>): Option<FSharpList<Shared_FieldOption>> => {
+                    let matchResult_8: int32, item_8: Shared_FieldOption, list_8: FSharpList<Shared_FieldOption>;
+                    if (acc_8 != null) {
+                        if (opt_8 != null) {
+                            matchResult_8 = 0;
+                            item_8 = value_2(opt_8);
+                            list_8 = value_2(acc_8);
+                        }
+                        else {
+                            matchResult_8 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_8 = 1;
+                    }
+                    switch (matchResult_8) {
+                        case 0:
+                            return cons(item_8!, list_8!);
+                        default:
+                            return undefined;
+                    }
+                }, empty<Shared_FieldOption>(), map_1<Types_FieldOptionTS, Option<Shared_FieldOption>>(Converters_fieldOptionFromTS, info_19.Options));
+                let matchResult_9: int32, items: FSharpList<Shared_FieldOption>, opts_7: FSharpList<Shared_FieldOption>;
+                if (convertedItems != null) {
+                    if (convertedOptions_7 != null) {
+                        matchResult_9 = 0;
+                        items = value_2(convertedItems);
+                        opts_7 = value_2(convertedOptions_7);
+                    }
+                    else {
+                        matchResult_9 = 1;
+                    }
+                }
+                else {
+                    matchResult_9 = 1;
+                }
+                switch (matchResult_9) {
+                    case 0:
+                        return Spec_FieldType_Matrix(new Spec_MatrixInfo(reverse<Shared_FieldOption>(items!), reverse<Shared_FieldOption>(opts_7!)));
+                    default:
+                        return undefined;
+                }
+            }
+        }
+        case "Signature": {
+            const matchValue_31: Option<Types_SignatureInfoTS> = fieldType.SignatureInfo;
+            if (matchValue_31 == null) {
+                return undefined;
+            }
+            else {
+                return Spec_FieldType_Signature(new Spec_SignatureInfo(value_2(matchValue_31).Value));
+            }
+        }
+        case "Message": {
+            const matchValue_32: Option<Types_MessageInfoTS> = fieldType.MessageInfo;
+            if (matchValue_32 == null) {
+                return undefined;
+            }
+            else {
+                const info_21: Types_MessageInfoTS = value_2(matchValue_32);
+                const matchValue_33: Option<Spec_MessageType_$union> = Converters_messageTypeFromTS(info_21.MessageType);
+                if (matchValue_33 == null) {
+                    return undefined;
+                }
+                else {
+                    return Spec_FieldType_Message(new Spec_MessageInfo(info_21.Heading, value_2(matchValue_33), info_21.Message, info_21.Footer));
+                }
+            }
+        }
+        case "PluginField": {
+            const matchValue_34: Option<Types_PluginFieldConfigTS> = fieldType.PluginConfig;
+            if (matchValue_34 == null) {
+                return undefined;
+            }
+            else {
+                const config: Types_PluginFieldConfigTS = value_2(matchValue_34);
+                return Spec_FieldType_PluginField(new Spec_PluginFieldConfig(config.PluginId, config.FieldName));
+            }
+        }
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Convert F# FormField to TypeScript representation
+ */
+export function Converters_formFieldToTS(field: Spec_FormField$1<Spec_FieldType_$union>): Types_FormFieldTS {
+    return new Types_FormFieldTS(field.FieldOrder, Converters_fieldKeyToTS(field.FieldKey), field.Label, field.Notes, map_2<Spec_DependsOn, Types_DependsOnTS>(Converters_dependsOnToTS, field.DependsOn), field.IsOptional, field.IsDeprecated, Converters_fieldTypeToTS(field.FieldType));
+}
+
+/**
+ * Convert TypeScript FormField to F# representation
+ */
+export function Converters_formFieldFromTS(field: Types_FormFieldTS): Option<Spec_FormField$1<Spec_FieldType_$union>> {
+    let matchValue_3: Option<Types_DependsOnTS>;
+    const matchValue: Option<Shared_FieldKey> = Converters_fieldKeyFromTS(field.FieldKey);
+    const matchValue_1: Option<Spec_FieldType_$union> = Converters_fieldTypeFromTS(field.FieldType);
+    let matchResult: int32, fieldType: Spec_FieldType_$union, key: Shared_FieldKey;
+    if (matchValue != null) {
+        if (matchValue_1 != null) {
+            matchResult = 0;
+            fieldType = value_2(matchValue_1);
+            key = value_2(matchValue);
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Spec_FormField$1(field.FieldOrder, key!, field.Label, field.Notes, (matchValue_3 = field.DependsOn, (matchValue_3 == null) ? undefined : Converters_dependsOnFromTS(value_2(matchValue_3))), field.IsOptional, field.IsDeprecated, fieldType!);
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Convert F# FormStep to TypeScript representation
+ */
+export function Converters_formStepToTS(step: Spec_FormStep$1<Spec_FieldType_$union>): Types_FormStepTS {
+    return new Types_FormStepTS(step.StepOrder, step.StepLabel, toArray<Types_FormFieldTS>(map<Spec_FormField$1<Spec_FieldType_$union>, Types_FormFieldTS>(Converters_formFieldToTS, step.Fields)));
+}
+
+/**
+ * Convert TypeScript FormStep to F# representation
+ */
+export function Converters_formStepFromTS(step: Types_FormStepTS): Option<Spec_FormStep$1<Spec_FieldType_$union>> {
+    const convertedFields: Option<FSharpList<Spec_FormField$1<Spec_FieldType_$union>>> = fold<Option<Spec_FormField$1<Spec_FieldType_$union>>, Option<FSharpList<Spec_FormField$1<Spec_FieldType_$union>>>>((acc: Option<FSharpList<Spec_FormField$1<Spec_FieldType_$union>>>, field_1: Option<Spec_FormField$1<Spec_FieldType_$union>>): Option<FSharpList<Spec_FormField$1<Spec_FieldType_$union>>> => {
+        let matchResult: int32, item: Spec_FormField$1<Spec_FieldType_$union>, list: FSharpList<Spec_FormField$1<Spec_FieldType_$union>>;
+        if (acc != null) {
+            if (field_1 != null) {
+                matchResult = 0;
+                item = value_2(field_1);
+                list = value_2(acc);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return cons(item!, list!);
+            default:
+                return undefined;
+        }
+    }, empty<Spec_FormField$1<Spec_FieldType_$union>>(), map_1<Types_FormFieldTS, Option<Spec_FormField$1<Spec_FieldType_$union>>>(Converters_formFieldFromTS, step.Fields));
+    if (convertedFields == null) {
+        return undefined;
+    }
+    else {
+        return new Spec_FormStep$1(step.StepOrder, step.StepLabel, reverse<Spec_FormField$1<Spec_FieldType_$union>>(value_2(convertedFields)));
+    }
+}
+
+/**
+ * Convert F# ScoreColor to TypeScript representation
+ */
+export function Converters_scoreColorToTS(color: Spec_ScoreColor_$union): int32 {
+    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;
+    }
+}
+
+/**
+ * Convert TypeScript ScoreColor to F# representation
+ */
+export function Converters_scoreColorFromTS(color: int32): Option<Spec_ScoreColor_$union> {
+    switch (color) {
+        case 0:
+            return Spec_ScoreColor_Unspecified();
+        case 1:
+            return Spec_ScoreColor_Primary();
+        case 2:
+            return Spec_ScoreColor_Link();
+        case 3:
+            return Spec_ScoreColor_Info();
+        case 4:
+            return Spec_ScoreColor_Success();
+        case 5:
+            return Spec_ScoreColor_Warning();
+        case 6:
+            return Spec_ScoreColor_Danger();
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Convert F# ScoreRange to TypeScript representation
+ */
+export function Converters_scoreRangeToTS(range: Spec_ScoreRange): Types_ScoreRangeTS {
+    return new Types_ScoreRangeTS(range.Id, range.Min, range.Max, range.Label, Converters_scoreColorToTS(range.Tag));
+}
+
+/**
+ * Convert TypeScript ScoreRange to F# representation
+ */
+export function Converters_scoreRangeFromTS(range: Types_ScoreRangeTS): Option<Spec_ScoreRange> {
+    let matchValue: [boolean, string];
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = ([tryParse(range.Id, new FSharpRef<string>((): string => outArg, (v: string): void => {
+        outArg = v;
+    })), outArg] as [boolean, string]);
+    const matchValue_1: Option<Spec_ScoreColor_$union> = Converters_scoreColorFromTS(range.Tag);
+    let matchResult: int32;
+    if (matchValue[0]) {
+        if (matchValue_1 != null) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Spec_ScoreRange(matchValue[1], range.Min, range.Max, range.Label, value_2(matchValue_1));
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Convert F# Score to TypeScript representation
+ */
+export function Converters_scoreToTS(score: Spec_Score): Types_ScoreTS {
+    return new Types_ScoreTS(score.MaxScore, toArray<Types_ScoreRangeTS>(map<Spec_ScoreRange, Types_ScoreRangeTS>(Converters_scoreRangeToTS, score.ScoreRanges)));
+}
+
+/**
+ * Convert TypeScript Score to F# representation
+ */
+export function Converters_scoreFromTS(score: Types_ScoreTS): Option<Spec_Score> {
+    const convertedRanges: Option<FSharpList<Spec_ScoreRange>> = fold<Option<Spec_ScoreRange>, Option<FSharpList<Spec_ScoreRange>>>((acc: Option<FSharpList<Spec_ScoreRange>>, range_1: Option<Spec_ScoreRange>): Option<FSharpList<Spec_ScoreRange>> => {
+        let matchResult: int32, item: Spec_ScoreRange, list: FSharpList<Spec_ScoreRange>;
+        if (acc != null) {
+            if (range_1 != null) {
+                matchResult = 0;
+                item = value_2(range_1);
+                list = value_2(acc);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return cons(item!, list!);
+            default:
+                return undefined;
+        }
+    }, empty<Spec_ScoreRange>(), map_1<Types_ScoreRangeTS, Option<Spec_ScoreRange>>(Converters_scoreRangeFromTS, score.ScoreRanges));
+    if (convertedRanges == null) {
+        return undefined;
+    }
+    else {
+        return new Spec_Score(score.MaxScore, reverse<Spec_ScoreRange>(value_2(convertedRanges)));
+    }
+}
+
+/**
+ * Convert F# ClinicalPathwaySpec to TypeScript representation (simplified)
+ */
+export function Converters_clinicalPathwayToTS(pathway: ClinicalPathway_ClinicalPathwaySpec): Types_ClinicalPathwaySpecTS {
+    return new Types_ClinicalPathwaySpecTS(pathway.PathwayId, pathway.PathwayName, pathway.Version, pathway.ProtocolSource);
+}
+
+/**
+ * Convert TypeScript ClinicalPathwaySpec to F# representation (simplified)
+ * Note: This is a simplified conversion - full conversion would require more fields
+ */
+export function Converters_clinicalPathwayFromTS(pathway: Types_ClinicalPathwaySpecTS): Option<ClinicalPathway_ClinicalPathwaySpec> {
+    return undefined;
+}
+
+/**
+ * Convert F# FormSpec to TypeScript representation
+ */
+export function Converters_formSpecToTS(spec: Spec_FormSpec$1<Spec_FieldType_$union>): Types_FormSpecTS {
+    return new Types_FormSpecTS(spec.Id, spec.Code, spec.Title, spec.Abstract, spec.Version, spec.FormSpecVersion, toArray<Types_FormStepTS>(map<Spec_FormStep$1<Spec_FieldType_$union>, Types_FormStepTS>(Converters_formStepToTS, spec.Steps)), toArray<string>(spec.CategoryTags), map_2<Spec_Score, Types_ScoreTS>(Converters_scoreToTS, spec.Score), toArray<string>(spec.AssociatedCodes), spec.RequiresReview, spec.RequiresReviewAndApproval, map_2<ClinicalPathway_ClinicalPathwaySpec, Types_ClinicalPathwaySpecTS>(Converters_clinicalPathwayToTS, spec.ClinicalPathway));
+}
+
+/**
+ * Convert TypeScript FormSpec to F# representation
+ */
+export function Converters_formSpecFromTS(spec: Types_FormSpecTS): Option<Spec_FormSpec$1<Spec_FieldType_$union>> {
+    let matchValue: [boolean, string];
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = ([tryParse(spec.Id, new FSharpRef<string>((): string => outArg, (v: string): void => {
+        outArg = v;
+    })), outArg] as [boolean, string]);
+    if (matchValue[0]) {
+        const convertedSteps: Option<FSharpList<Spec_FormStep$1<Spec_FieldType_$union>>> = fold<Option<Spec_FormStep$1<Spec_FieldType_$union>>, Option<FSharpList<Spec_FormStep$1<Spec_FieldType_$union>>>>((acc: Option<FSharpList<Spec_FormStep$1<Spec_FieldType_$union>>>, step_1: Option<Spec_FormStep$1<Spec_FieldType_$union>>): Option<FSharpList<Spec_FormStep$1<Spec_FieldType_$union>>> => {
+            let matchResult: int32, item: Spec_FormStep$1<Spec_FieldType_$union>, list: FSharpList<Spec_FormStep$1<Spec_FieldType_$union>>;
+            if (acc != null) {
+                if (step_1 != null) {
+                    matchResult = 0;
+                    item = value_2(step_1);
+                    list = value_2(acc);
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0:
+                    return cons(item!, list!);
+                default:
+                    return undefined;
+            }
+        }, empty<Spec_FormStep$1<Spec_FieldType_$union>>(), map_1<Types_FormStepTS, Option<Spec_FormStep$1<Spec_FieldType_$union>>>(Converters_formStepFromTS, spec.Steps));
+        let scoreResult: Option<Spec_Score>;
+        const matchValue_2: Option<Types_ScoreTS> = spec.Score;
+        scoreResult = ((matchValue_2 == null) ? undefined : Converters_scoreFromTS(value_2(matchValue_2)));
+        if (convertedSteps == null) {
+            return undefined;
+        }
+        else {
+            return new Spec_FormSpec$1(matchValue[1], spec.Code, spec.Title, spec.Abstract, spec.Version, spec.FormSpecVersion, reverse<Spec_FormStep$1<Spec_FieldType_$union>>(value_2(convertedSteps)), ofArray<string>(spec.CategoryTags), scoreResult, ofArray<string>(spec.AssociatedCodes), spec.RequiresReview, spec.RequiresReviewAndApproval, undefined);
+        }
+    }
+    else {
+        return undefined;
+    }
+}
+
+/**
+ * Validate a TypeScript FormSpec object from JavaScript/TypeScript
+ */
+export function Validators_validateFormSpec(input: any): Option<Types_FormSpecTS> {
+    const stringified: string = toString(4, Auto_generateBoxedEncoder_437914C6(obj_type, undefined, undefined, undefined)(input));
+    return Result_ToOption<Types_FormSpecTS, string>(fromString<Types_FormSpecTS>(uncurry2(Auto_generateBoxedDecoder_Z6670B51(Types_FormSpecTS_$reflection(), undefined, undefined)), stringified));
+}
+
+/**
+ * Validate and convert a TypeScript FormSpec to F# domain type
+ */
+export function Validators_validateAndConvert(input: any): Option<Spec_FormSpec$1<Spec_FieldType_$union>> {
+    const matchValue: Option<Types_FormSpecTS> = Validators_validateFormSpec(input);
+    if (matchValue == null) {
+        return undefined;
+    }
+    else {
+        return Converters_formSpecFromTS(value_2(matchValue));
+    }
+}
+
+/**
+ * Main entry point: Validate a FormSpec from TypeScript/JavaScript
+ */
+export function Api_validateFormSpec<$a>(): ((arg0: $a) => Option<Types_FormSpecTS>) {
+    return Validators_validateFormSpec;
+}
+
+/**
+ * Validate and convert a FormSpec to F# domain type
+ */
+export function Api_validateAndConvertFormSpec<$a>(): ((arg0: $a) => Option<Spec_FormSpec$1<Spec_FieldType_$union>>) {
+    return Validators_validateAndConvert;
+}
+
+/**
+ * Convert F# FormSpec to TypeScript representation
+ */
+export function Api_formSpecToTypeScript(spec: Spec_FormSpec$1<Spec_FieldType_$union>): Types_FormSpecTS {
+    return Converters_formSpecToTS(spec);
+}
+
+/**
+ * Convert TypeScript FormSpec to F# representation
+ */
+export function Api_formSpecFromTypeScript(spec: Types_FormSpecTS): Option<Spec_FormSpec$1<Spec_FieldType_$union>> {
+    return Converters_formSpecFromTS(spec);
+}
+
+/**
+ * Convert F# FormSpec JSON string (with union arrays) to FormSpecTS
+ * TypeScript: (json: string) => Option<FormSpecTS>
+ * Usage: Api.getFormSpecTSfromFormSpecFSjsonString(fsJsonString)
+ * 
+ * This function handles JSON from APIs that send F# serialized FormSpec format:
+ * - FieldKey: ["FieldKey", "guid"] → { Value: "guid" }
+ * - FieldType: ["Text", {}] → { Type: "Text", TextInfo: {...}, ... }
+ */
+export function Api_getFormSpecTSfromFormSpecFSjsonString(formSpecFSstring: string): Option<Types_FormSpecTS> {
+    const matchValue: FSharpResult$2_$union<Spec_FormSpec$1<Spec_FieldType_$union>, string> = fromString<Spec_FormSpec$1<Spec_FieldType_$union>>(uncurry2(Auto_generateBoxedDecoder_Z6670B51(Spec_FormSpec$1_$reflection(Spec_FieldType_$reflection()), undefined, undefined)), formSpecFSstring);
+    if (matchValue.tag === /* Error */ 1) {
+        return undefined;
+    }
+    else {
+        return Api_formSpecToTypeScript(matchValue.fields[0]);
+    }
+}
+
+/**
+ * Convert FormSpecTS JSON string to F# FormSpec
+ * TypeScript: (json: string) => Option<FormSpec>
+ * Usage: Api.getFormSpecFSfromFormSpecTSjsonString(tsJsonString)
+ * 
+ * This function converts FormSpecTS JSON (flat structure) back to F# FormSpec format:
+ * - { Value: "guid" } → FieldKey: ["FieldKey", "guid"]
+ * - { Type: "Text", ... } → FieldType: ["Text", {...}]
+ */
+export function Api_getFormSpecFSfromFormSpecTSjsonString(formSpecTSstring: string): Option<Spec_FormSpec$1<Spec_FieldType_$union>> {
+    const matchValue: FSharpResult$2_$union<Types_FormSpecTS, string> = fromString<Types_FormSpecTS>(uncurry2(Auto_generateBoxedDecoder_Z6670B51(Types_FormSpecTS_$reflection(), undefined, undefined)), formSpecTSstring);
+    if (matchValue.tag === /* Error */ 1) {
+        return undefined;
+    }
+    else {
+        return Api_formSpecFromTypeScript(matchValue.fields[0]);
+    }
+}
+
+/**
+ * Serialize a FormSpec to JSON string
+ */
+export function Api_serializeFormSpec(spec: Types_FormSpecTS): string {
+    return toString(2, Auto_generateBoxedEncoder_437914C6(Types_FormSpecTS_$reflection(), undefined, undefined, undefined)(spec));
+}
+
+/**
+ * Deserialize a FormSpec from JSON string
+ */
+export function Api_deserializeFormSpecTS(jsonTS: string): Option<Types_FormSpecTS> {
+    toConsole(printf("API.Option: Deserializing FormSpecTS!"));
+    const matchValue: FSharpResult$2_$union<Types_FormSpecTS, string> = fromString<Types_FormSpecTS>(uncurry2(Auto_generateBoxedDecoder_Z6670B51(Types_FormSpecTS_$reflection(), undefined, undefined)), jsonTS);
+    if (matchValue.tag === /* Error */ 1) {
+        return undefined;
+    }
+    else {
+        return matchValue.fields[0];
+    }
+}
+
+/**
+ * Convert F# FieldKey (discriminated union) to TypeScript FieldKeyTS
+ * TypeScript: (fieldKey: { tag: number, fields: string[] }) => FieldKeyTS
+ * Usage: Api.fieldKeyToTypeScript(fsharpFieldKey)
+ */
+export function Api_fieldKeyToTypeScript(fieldKey: Shared_FieldKey): Types_FieldKeyTS {
+    return Converters_fieldKeyToTS(fieldKey);
+}
+
+/**
+ * Get all field keys from a FormSpec
+ */
+export function Api_getFieldKeys(spec: Types_FormSpecTS): Types_FieldKeyTS[] {
+    return map_1<Types_FormFieldTS, Types_FieldKeyTS>((field: Types_FormFieldTS): Types_FieldKeyTS => field.FieldKey, collect<Types_FormStepTS, Types_FormFieldTS>((step: Types_FormStepTS): Types_FormFieldTS[] => step.Fields, spec.Steps));
+}
+
+/**
+ * Find a field by its key
+ */
+export function Api_findFieldByKey(spec: Types_FormSpecTS, key: Types_FieldKeyTS): Option<Types_FormFieldTS> {
+    return tryFind<Types_FormFieldTS>((field: Types_FormFieldTS): boolean => (field.FieldKey.Value === key.Value), collect<Types_FormStepTS, Types_FormFieldTS>((step: Types_FormStepTS): Types_FormFieldTS[] => step.Fields, spec.Steps));
+}
+
+/**
+ * Get all fields of a specific type
+ */
+export function Api_getFieldsByType(spec: Types_FormSpecTS, fieldType: string): Types_FormFieldTS[] {
+    const array_1: Types_FormFieldTS[] = collect<Types_FormStepTS, Types_FormFieldTS>((step: Types_FormStepTS): Types_FormFieldTS[] => step.Fields, spec.Steps);
+    return array_1.filter((field: Types_FormFieldTS): boolean => (field.FieldType.Type === fieldType));
+}
+
+/**
+ * Check if a FormSpec is valid (basic validation)
+ */
+export function Api_isValidFormSpec(spec: Types_FormSpecTS): boolean {
+    if ((spec.Steps.length > 0) && (spec.Title.length > 0)) {
+        return spec.Version.length > 0;
+    }
+    else {
+        return false;
+    }
+}
+
+/**
+ * Get a summary of the FormSpec
+ */
+export function Api_getFormSpecSummary(spec: Types_FormSpecTS): any {
+    let StepCount: int32;
+    return (StepCount = (spec.Steps.length | 0), {
+        FieldCount: sumBy<Types_FormStepTS, int32>((s: Types_FormStepTS): int32 => s.Fields.length, spec.Steps, {
+            GetZero: (): int32 => 0,
+            Add: (x: int32, y: int32): int32 => (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