@f1studio/form-spec 5.0.0-alpha.101

package/src/FormSpec.ts

@@ -0,0 +1,3114 @@
+import { FSharpRef, Record, Union } from "@fable-org/fable-library-js/Types.js";
+import { obj_type, float64_type, tuple_type, bool_type, int32_type, list_type, option_type, record_type, string_type, union_type, class_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { FSharpMap } from "@fable-org/fable-library-js/Map.js";
+import { Option } from "@fable-org/fable-library-js/Option.js";
+import { FSharpSet } from "@fable-org/fable-library-js/Set.js";
+import { ofArray, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { float64, int32 } from "@fable-org/fable-library-js/Int32.js";
+import { newGuid, tryParse } from "@fable-org/fable-library-js/Guid.js";
+import { item } from "@fable-org/fable-library-js/Array.js";
+import { split } from "@fable-org/fable-library-js/String.js";
+
+export class Shared_FieldKey extends Union<0, "FieldKey"> {
+    constructor(Item: string) {
+        super();
+        this.tag = 0;
+        this.fields = [Item];
+    }
+    readonly tag: 0;
+    readonly fields: [string];
+    cases() {
+        return ["FieldKey"];
+    }
+}
+
+export function Shared_FieldKey_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Shared.FieldKey", [], Shared_FieldKey, () => [[["Item", class_type("System.Guid")]]]);
+}
+
+export class Shared_StateKey extends Union<0, "StateKey"> {
+    constructor(Item: string) {
+        super();
+        this.tag = 0;
+        this.fields = [Item];
+    }
+    readonly tag: 0;
+    readonly fields: [string];
+    cases() {
+        return ["StateKey"];
+    }
+}
+
+export function Shared_StateKey_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Shared.StateKey", [], Shared_StateKey, () => [[["Item", class_type("System.Guid")]]]);
+}
+
+export class Shared_TransitionKey extends Union<0, "TransitionKey"> {
+    constructor(Item: string) {
+        super();
+        this.tag = 0;
+        this.fields = [Item];
+    }
+    readonly tag: 0;
+    readonly fields: [string];
+    cases() {
+        return ["TransitionKey"];
+    }
+}
+
+export function Shared_TransitionKey_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Shared.TransitionKey", [], Shared_TransitionKey, () => [[["Item", class_type("System.Guid")]]]);
+}
+
+export class Shared_MatrixItemKey extends Union<0, "MatrixItemKey"> {
+    constructor(Item: string) {
+        super();
+        this.tag = 0;
+        this.fields = [Item];
+    }
+    readonly tag: 0;
+    readonly fields: [string];
+    cases() {
+        return ["MatrixItemKey"];
+    }
+}
+
+export function Shared_MatrixItemKey_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Shared.MatrixItemKey", [], Shared_MatrixItemKey, () => [[["Item", class_type("System.Guid")]]]);
+}
+
+export class Shared_FieldOptionKey extends Union<0, "FieldOptionKey"> {
+    constructor(Item: string) {
+        super();
+        this.tag = 0;
+        this.fields = [Item];
+    }
+    readonly tag: 0;
+    readonly fields: [string];
+    cases() {
+        return ["FieldOptionKey"];
+    }
+}
+
+export function Shared_FieldOptionKey_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Shared.FieldOptionKey", [], Shared_FieldOptionKey, () => [[["Item", class_type("System.Guid")]]]);
+}
+
+export class Shared_PluginPropertyKey extends Union<0, "PluginPropertyKey"> {
+    constructor(Item: string) {
+        super();
+        this.tag = 0;
+        this.fields = [Item];
+    }
+    readonly tag: 0;
+    readonly fields: [string];
+    cases() {
+        return ["PluginPropertyKey"];
+    }
+}
+
+export function Shared_PluginPropertyKey_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Shared.PluginPropertyKey", [], Shared_PluginPropertyKey, () => [[["Item", class_type("System.Guid")]]]);
+}
+
+export class Shared_FieldOption extends Record implements IEquatable<Shared_FieldOption>, IComparable<Shared_FieldOption> {
+    readonly Description: string;
+    readonly Value: string;
+    readonly OptionKey: Shared_FieldOptionKey;
+    constructor(Description: string, Value: string, OptionKey: Shared_FieldOptionKey) {
+        super();
+        this.Description = Description;
+        this.Value = Value;
+        this.OptionKey = OptionKey;
+    }
+}
+
+export function Shared_FieldOption_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Shared.FieldOption", [], Shared_FieldOption, () => [["Description", string_type], ["Value", string_type], ["OptionKey", Shared_FieldOptionKey_$reflection()]]);
+}
+
+export class Shared_FieldAnswer extends Record implements IEquatable<Shared_FieldAnswer>, IComparable<Shared_FieldAnswer> {
+    readonly FieldKey: Shared_FieldKey;
+    readonly Description: string;
+    readonly Value: string;
+    constructor(FieldKey: Shared_FieldKey, Description: string, Value: string) {
+        super();
+        this.FieldKey = FieldKey;
+        this.Description = Description;
+        this.Value = Value;
+    }
+}
+
+export function Shared_FieldAnswer_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Shared.FieldAnswer", [], Shared_FieldAnswer, () => [["FieldKey", Shared_FieldKey_$reflection()], ["Description", string_type], ["Value", string_type]]);
+}
+
+export class Shared_MatrixAnswer extends Record implements IEquatable<Shared_MatrixAnswer>, IComparable<Shared_MatrixAnswer> {
+    readonly FieldKey: Shared_FieldKey;
+    readonly Description: string;
+    readonly Values: FSharpMap<Shared_MatrixItemKey, string>;
+    constructor(FieldKey: Shared_FieldKey, Description: string, Values: FSharpMap<Shared_MatrixItemKey, string>) {
+        super();
+        this.FieldKey = FieldKey;
+        this.Description = Description;
+        this.Values = Values;
+    }
+}
+
+export function Shared_MatrixAnswer_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Shared.MatrixAnswer", [], Shared_MatrixAnswer, () => [["FieldKey", Shared_FieldKey_$reflection()], ["Description", string_type], ["Values", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [Shared_MatrixItemKey_$reflection(), string_type])]]);
+}
+
+export class Shared_PluginDataProperty extends Record implements IEquatable<Shared_PluginDataProperty>, IComparable<Shared_PluginDataProperty> {
+    readonly PropertyKey: Shared_PluginPropertyKey;
+    readonly Name: string;
+    readonly DataType: string;
+    readonly Value: string;
+    readonly DisplayName: Option<string>;
+    readonly Unit: Option<string>;
+    readonly Description: Option<string>;
+    constructor(PropertyKey: Shared_PluginPropertyKey, Name: string, DataType: string, Value: string, DisplayName: Option<string>, Unit: Option<string>, Description: Option<string>) {
+        super();
+        this.PropertyKey = PropertyKey;
+        this.Name = Name;
+        this.DataType = DataType;
+        this.Value = Value;
+        this.DisplayName = DisplayName;
+        this.Unit = Unit;
+        this.Description = Description;
+    }
+}
+
+export function Shared_PluginDataProperty_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Shared.PluginDataProperty", [], Shared_PluginDataProperty, () => [["PropertyKey", Shared_PluginPropertyKey_$reflection()], ["Name", string_type], ["DataType", string_type], ["Value", string_type], ["DisplayName", option_type(string_type)], ["Unit", option_type(string_type)], ["Description", option_type(string_type)]]);
+}
+
+export type Shared_FieldValue_$union = 
+    | Shared_FieldValue<0>
+    | Shared_FieldValue<1>
+    | Shared_FieldValue<2>
+    | Shared_FieldValue<3>
+
+export type Shared_FieldValue_$cases = {
+    0: ["Single", [Shared_FieldAnswer]],
+    1: ["Multiple", [FSharpSet<Shared_FieldAnswer>]],
+    2: ["Matrix", [Shared_MatrixAnswer]],
+    3: ["PluginData", [FSharpList<Shared_PluginDataProperty>]]
+}
+
+export function Shared_FieldValue_Single(Item: Shared_FieldAnswer) {
+    return new Shared_FieldValue<0>(0, [Item]);
+}
+
+export function Shared_FieldValue_Multiple(Item: FSharpSet<Shared_FieldAnswer>) {
+    return new Shared_FieldValue<1>(1, [Item]);
+}
+
+export function Shared_FieldValue_Matrix(Item: Shared_MatrixAnswer) {
+    return new Shared_FieldValue<2>(2, [Item]);
+}
+
+export function Shared_FieldValue_PluginData(Item: FSharpList<Shared_PluginDataProperty>) {
+    return new Shared_FieldValue<3>(3, [Item]);
+}
+
+export class Shared_FieldValue<Tag extends keyof Shared_FieldValue_$cases> extends Union<Tag, Shared_FieldValue_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: Shared_FieldValue_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Single", "Multiple", "Matrix", "PluginData"];
+    }
+}
+
+export function Shared_FieldValue_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Shared.FieldValue", [], Shared_FieldValue, () => [[["Item", Shared_FieldAnswer_$reflection()]], [["Item", class_type("Microsoft.FSharp.Collections.FSharpSet`1", [Shared_FieldAnswer_$reflection()])]], [["Item", Shared_MatrixAnswer_$reflection()]], [["Item", list_type(Shared_PluginDataProperty_$reflection())]]]);
+}
+
+export type Shared_ConditionValue_$union = 
+    | Shared_ConditionValue<0>
+    | Shared_ConditionValue<1>
+    | Shared_ConditionValue<2>
+    | Shared_ConditionValue<3>
+
+export type Shared_ConditionValue_$cases = {
+    0: ["Single", [string]],
+    1: ["Multiple", [FSharpSet<string>]],
+    2: ["Matrix", [FSharpMap<Shared_MatrixItemKey, string>]],
+    3: ["PluginData", [Shared_PluginDataProperty]]
+}
+
+export function Shared_ConditionValue_Single(Item: string) {
+    return new Shared_ConditionValue<0>(0, [Item]);
+}
+
+export function Shared_ConditionValue_Multiple(Item: FSharpSet<string>) {
+    return new Shared_ConditionValue<1>(1, [Item]);
+}
+
+export function Shared_ConditionValue_Matrix(Item: FSharpMap<Shared_MatrixItemKey, string>) {
+    return new Shared_ConditionValue<2>(2, [Item]);
+}
+
+export function Shared_ConditionValue_PluginData(Item: Shared_PluginDataProperty) {
+    return new Shared_ConditionValue<3>(3, [Item]);
+}
+
+export class Shared_ConditionValue<Tag extends keyof Shared_ConditionValue_$cases> extends Union<Tag, Shared_ConditionValue_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: Shared_ConditionValue_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Single", "Multiple", "Matrix", "PluginData"];
+    }
+}
+
+export function Shared_ConditionValue_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Shared.ConditionValue", [], Shared_ConditionValue, () => [[["Item", string_type]], [["Item", class_type("Microsoft.FSharp.Collections.FSharpSet`1", [string_type])]], [["Item", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [Shared_MatrixItemKey_$reflection(), string_type])]], [["Item", Shared_PluginDataProperty_$reflection()]]]);
+}
+
+export class Spec_FieldResult extends Record implements IEquatable<Spec_FieldResult>, IComparable<Spec_FieldResult> {
+    readonly Patient: string;
+    readonly Order: int32;
+    readonly Question: string;
+    readonly Answer: string;
+    readonly Value: string;
+    constructor(Patient: string, Order: int32, Question: string, Answer: string, Value: string) {
+        super();
+        this.Patient = Patient;
+        this.Order = (Order | 0);
+        this.Question = Question;
+        this.Answer = Answer;
+        this.Value = Value;
+    }
+}
+
+export function Spec_FieldResult_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.FieldResult", [], Spec_FieldResult, () => [["Patient", string_type], ["Order", int32_type], ["Question", string_type], ["Answer", string_type], ["Value", string_type]]);
+}
+
+export class Spec_MinimalField extends Record implements IEquatable<Spec_MinimalField>, IComparable<Spec_MinimalField> {
+    readonly FieldOrder: int32;
+    readonly Options: FSharpList<Shared_FieldOption>;
+    constructor(FieldOrder: int32, Options: FSharpList<Shared_FieldOption>) {
+        super();
+        this.FieldOrder = (FieldOrder | 0);
+        this.Options = Options;
+    }
+}
+
+export function Spec_MinimalField_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.MinimalField", [], Spec_MinimalField, () => [["FieldOrder", int32_type], ["Options", list_type(Shared_FieldOption_$reflection())]]);
+}
+
+export type Spec_Evaluator_$union = 
+    | Spec_Evaluator<0>
+    | Spec_Evaluator<1>
+    | Spec_Evaluator<2>
+    | Spec_Evaluator<3>
+    | Spec_Evaluator<4>
+    | Spec_Evaluator<5>
+    | Spec_Evaluator<6>
+    | Spec_Evaluator<7>
+    | Spec_Evaluator<8>
+
+export type Spec_Evaluator_$cases = {
+    0: ["Equals", []],
+    1: ["NotEquals", []],
+    2: ["GreaterThan", []],
+    3: ["GreaterThanOrEquals", []],
+    4: ["LessThan", []],
+    5: ["LessThanOrEquals", []],
+    6: ["Exists", []],
+    7: ["IsEmpty", []],
+    8: ["Contains", []]
+}
+
+export function Spec_Evaluator_Equals() {
+    return new Spec_Evaluator<0>(0, []);
+}
+
+export function Spec_Evaluator_NotEquals() {
+    return new Spec_Evaluator<1>(1, []);
+}
+
+export function Spec_Evaluator_GreaterThan() {
+    return new Spec_Evaluator<2>(2, []);
+}
+
+export function Spec_Evaluator_GreaterThanOrEquals() {
+    return new Spec_Evaluator<3>(3, []);
+}
+
+export function Spec_Evaluator_LessThan() {
+    return new Spec_Evaluator<4>(4, []);
+}
+
+export function Spec_Evaluator_LessThanOrEquals() {
+    return new Spec_Evaluator<5>(5, []);
+}
+
+export function Spec_Evaluator_Exists() {
+    return new Spec_Evaluator<6>(6, []);
+}
+
+export function Spec_Evaluator_IsEmpty() {
+    return new Spec_Evaluator<7>(7, []);
+}
+
+export function Spec_Evaluator_Contains() {
+    return new Spec_Evaluator<8>(8, []);
+}
+
+export class Spec_Evaluator<Tag extends keyof Spec_Evaluator_$cases> extends Union<Tag, Spec_Evaluator_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: Spec_Evaluator_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Equals", "NotEquals", "GreaterThan", "GreaterThanOrEquals", "LessThan", "LessThanOrEquals", "Exists", "IsEmpty", "Contains"];
+    }
+}
+
+export function Spec_Evaluator_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Spec.Evaluator", [], Spec_Evaluator, () => [[], [], [], [], [], [], [], [], []]);
+}
+
+export type Spec_SpecialTextType_$union = 
+    | Spec_SpecialTextType<0>
+    | Spec_SpecialTextType<1>
+    | Spec_SpecialTextType<2>
+    | Spec_SpecialTextType<3>
+    | Spec_SpecialTextType<4>
+    | Spec_SpecialTextType<5>
+    | Spec_SpecialTextType<6>
+    | Spec_SpecialTextType<7>
+    | Spec_SpecialTextType<8>
+    | Spec_SpecialTextType<9>
+
+export type Spec_SpecialTextType_$cases = {
+    0: ["BodyTemperatureType", []],
+    1: ["BloodPressureType", []],
+    2: ["DiastolicBloodPressureType", []],
+    3: ["SystolicBloodPressureType", []],
+    4: ["HeightType", []],
+    5: ["WeightType", []],
+    6: ["PulseRateType", []],
+    7: ["HeartRateType", []],
+    8: ["RespirationRateType", []],
+    9: ["OxygenSaturationType", []]
+}
+
+export function Spec_SpecialTextType_BodyTemperatureType() {
+    return new Spec_SpecialTextType<0>(0, []);
+}
+
+export function Spec_SpecialTextType_BloodPressureType() {
+    return new Spec_SpecialTextType<1>(1, []);
+}
+
+export function Spec_SpecialTextType_DiastolicBloodPressureType() {
+    return new Spec_SpecialTextType<2>(2, []);
+}
+
+export function Spec_SpecialTextType_SystolicBloodPressureType() {
+    return new Spec_SpecialTextType<3>(3, []);
+}
+
+export function Spec_SpecialTextType_HeightType() {
+    return new Spec_SpecialTextType<4>(4, []);
+}
+
+export function Spec_SpecialTextType_WeightType() {
+    return new Spec_SpecialTextType<5>(5, []);
+}
+
+export function Spec_SpecialTextType_PulseRateType() {
+    return new Spec_SpecialTextType<6>(6, []);
+}
+
+export function Spec_SpecialTextType_HeartRateType() {
+    return new Spec_SpecialTextType<7>(7, []);
+}
+
+export function Spec_SpecialTextType_RespirationRateType() {
+    return new Spec_SpecialTextType<8>(8, []);
+}
+
+export function Spec_SpecialTextType_OxygenSaturationType() {
+    return new Spec_SpecialTextType<9>(9, []);
+}
+
+export class Spec_SpecialTextType<Tag extends keyof Spec_SpecialTextType_$cases> extends Union<Tag, Spec_SpecialTextType_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: Spec_SpecialTextType_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["BodyTemperatureType", "BloodPressureType", "DiastolicBloodPressureType", "SystolicBloodPressureType", "HeightType", "WeightType", "PulseRateType", "HeartRateType", "RespirationRateType", "OxygenSaturationType"];
+    }
+}
+
+export function Spec_SpecialTextType_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Spec.SpecialTextType", [], Spec_SpecialTextType, () => [[], [], [], [], [], [], [], [], [], []]);
+}
+
+export class Spec_DependsOn extends Record implements IEquatable<Spec_DependsOn>, IComparable<Spec_DependsOn> {
+    readonly FieldKey: Shared_FieldKey;
+    readonly FieldValue: string;
+    readonly Evaluator: Spec_Evaluator_$union;
+    constructor(FieldKey: Shared_FieldKey, FieldValue: string, Evaluator: Spec_Evaluator_$union) {
+        super();
+        this.FieldKey = FieldKey;
+        this.FieldValue = FieldValue;
+        this.Evaluator = Evaluator;
+    }
+}
+
+export function Spec_DependsOn_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.DependsOn", [], Spec_DependsOn, () => [["FieldKey", Shared_FieldKey_$reflection()], ["FieldValue", string_type], ["Evaluator", Spec_Evaluator_$reflection()]]);
+}
+
+export class Spec_SpecialTextInfo extends Record implements IEquatable<Spec_SpecialTextInfo>, IComparable<Spec_SpecialTextInfo> {
+    readonly SpecialTextType: Spec_SpecialTextType_$union;
+    readonly Value: Option<string>;
+    constructor(SpecialTextType: Spec_SpecialTextType_$union, Value: Option<string>) {
+        super();
+        this.SpecialTextType = SpecialTextType;
+        this.Value = Value;
+    }
+}
+
+export function Spec_SpecialTextInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.SpecialTextInfo", [], Spec_SpecialTextInfo, () => [["SpecialTextType", Spec_SpecialTextType_$reflection()], ["Value", option_type(string_type)]]);
+}
+
+export class Spec_TextInfo extends Record implements IEquatable<Spec_TextInfo>, IComparable<Spec_TextInfo> {
+    readonly Value: Option<string>;
+    constructor(Value: Option<string>) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Spec_TextInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.TextInfo", [], Spec_TextInfo, () => [["Value", option_type(string_type)]]);
+}
+
+export class Spec_SingleChoiceInfo extends Record implements IEquatable<Spec_SingleChoiceInfo>, IComparable<Spec_SingleChoiceInfo> {
+    readonly Options: FSharpList<Shared_FieldOption>;
+    constructor(Options: FSharpList<Shared_FieldOption>) {
+        super();
+        this.Options = Options;
+    }
+}
+
+export function Spec_SingleChoiceInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.SingleChoiceInfo", [], Spec_SingleChoiceInfo, () => [["Options", list_type(Shared_FieldOption_$reflection())]]);
+}
+
+export class Spec_MultiChoiceInfo extends Record implements IEquatable<Spec_MultiChoiceInfo>, IComparable<Spec_MultiChoiceInfo> {
+    readonly Options: FSharpList<Shared_FieldOption>;
+    constructor(Options: FSharpList<Shared_FieldOption>) {
+        super();
+        this.Options = Options;
+    }
+}
+
+export function Spec_MultiChoiceInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.MultiChoiceInfo", [], Spec_MultiChoiceInfo, () => [["Options", list_type(Shared_FieldOption_$reflection())]]);
+}
+
+export class Spec_TextToSpeechInfo extends Record implements IEquatable<Spec_TextToSpeechInfo>, IComparable<Spec_TextToSpeechInfo> {
+    readonly Value: Option<string>;
+    constructor(Value: Option<string>) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Spec_TextToSpeechInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.TextToSpeechInfo", [], Spec_TextToSpeechInfo, () => [["Value", option_type(string_type)]]);
+}
+
+export class Spec_DrugFinderInfo extends Record implements IEquatable<Spec_DrugFinderInfo>, IComparable<Spec_DrugFinderInfo> {
+    readonly Value: Option<string>;
+    constructor(Value: Option<string>) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Spec_DrugFinderInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.DrugFinderInfo", [], Spec_DrugFinderInfo, () => [["Value", option_type(string_type)]]);
+}
+
+export class Spec_DrugFinderWithFrequencyInfo extends Record implements IEquatable<Spec_DrugFinderWithFrequencyInfo>, IComparable<Spec_DrugFinderWithFrequencyInfo> {
+    readonly Value: Option<string>;
+    constructor(Value: Option<string>) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Spec_DrugFinderWithFrequencyInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.DrugFinderWithFrequencyInfo", [], Spec_DrugFinderWithFrequencyInfo, () => [["Value", option_type(string_type)]]);
+}
+
+export class Spec_AllergyFinderInfo extends Record implements IEquatable<Spec_AllergyFinderInfo>, IComparable<Spec_AllergyFinderInfo> {
+    readonly Value: Option<string>;
+    constructor(Value: Option<string>) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Spec_AllergyFinderInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.AllergyFinderInfo", [], Spec_AllergyFinderInfo, () => [["Value", option_type(string_type)]]);
+}
+
+export class Spec_ICD10FinderInfo extends Record implements IEquatable<Spec_ICD10FinderInfo>, IComparable<Spec_ICD10FinderInfo> {
+    readonly Value: Option<string>;
+    constructor(Value: Option<string>) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Spec_ICD10FinderInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.ICD10FinderInfo", [], Spec_ICD10FinderInfo, () => [["Value", option_type(string_type)]]);
+}
+
+export class Spec_CPTFinderInfo extends Record implements IEquatable<Spec_CPTFinderInfo>, IComparable<Spec_CPTFinderInfo> {
+    readonly Value: Option<string>;
+    constructor(Value: Option<string>) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Spec_CPTFinderInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.CPTFinderInfo", [], Spec_CPTFinderInfo, () => [["Value", option_type(string_type)]]);
+}
+
+export class Spec_VaccineFinderInfo extends Record implements IEquatable<Spec_VaccineFinderInfo>, IComparable<Spec_VaccineFinderInfo> {
+    readonly Value: Option<string>;
+    constructor(Value: Option<string>) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Spec_VaccineFinderInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.VaccineFinderInfo", [], Spec_VaccineFinderInfo, () => [["Value", option_type(string_type)]]);
+}
+
+export class Spec_ProviderSelectorInfo extends Record implements IEquatable<Spec_ProviderSelectorInfo>, IComparable<Spec_ProviderSelectorInfo> {
+    readonly Value: Option<string>;
+    constructor(Value: Option<string>) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Spec_ProviderSelectorInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.ProviderSelectorInfo", [], Spec_ProviderSelectorInfo, () => [["Value", option_type(string_type)]]);
+}
+
+export class Spec_BooleanInfo extends Record implements IEquatable<Spec_BooleanInfo>, IComparable<Spec_BooleanInfo> {
+    readonly DefaultValue: Option<boolean>;
+    readonly Selection: Option<boolean>;
+    constructor(DefaultValue: Option<boolean>, Selection$: Option<boolean>) {
+        super();
+        this.DefaultValue = DefaultValue;
+        this.Selection = Selection$;
+    }
+}
+
+export function Spec_BooleanInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.BooleanInfo", [], Spec_BooleanInfo, () => [["DefaultValue", option_type(bool_type)], ["Selection", option_type(bool_type)]]);
+}
+
+export type Spec_MessageType_$union = 
+    | Spec_MessageType<0>
+    | Spec_MessageType<1>
+    | Spec_MessageType<2>
+    | Spec_MessageType<3>
+    | Spec_MessageType<4>
+
+export type Spec_MessageType_$cases = {
+    0: ["Warning", []],
+    1: ["Success", []],
+    2: ["Error", []],
+    3: ["Info", []],
+    4: ["Danger", []]
+}
+
+export function Spec_MessageType_Warning() {
+    return new Spec_MessageType<0>(0, []);
+}
+
+export function Spec_MessageType_Success() {
+    return new Spec_MessageType<1>(1, []);
+}
+
+export function Spec_MessageType_Error() {
+    return new Spec_MessageType<2>(2, []);
+}
+
+export function Spec_MessageType_Info() {
+    return new Spec_MessageType<3>(3, []);
+}
+
+export function Spec_MessageType_Danger() {
+    return new Spec_MessageType<4>(4, []);
+}
+
+export class Spec_MessageType<Tag extends keyof Spec_MessageType_$cases> extends Union<Tag, Spec_MessageType_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: Spec_MessageType_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Warning", "Success", "Error", "Info", "Danger"];
+    }
+}
+
+export function Spec_MessageType_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Spec.MessageType", [], Spec_MessageType, () => [[], [], [], [], []]);
+}
+
+export class Spec_MessageInfo extends Record implements IEquatable<Spec_MessageInfo>, IComparable<Spec_MessageInfo> {
+    readonly Heading: string;
+    readonly MessageType: Spec_MessageType_$union;
+    readonly Message: string;
+    readonly Footer: Option<string>;
+    constructor(Heading: string, MessageType: Spec_MessageType_$union, Message: string, Footer: Option<string>) {
+        super();
+        this.Heading = Heading;
+        this.MessageType = MessageType;
+        this.Message = Message;
+        this.Footer = Footer;
+    }
+}
+
+export function Spec_MessageInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.MessageInfo", [], Spec_MessageInfo, () => [["Heading", string_type], ["MessageType", Spec_MessageType_$reflection()], ["Message", string_type], ["Footer", option_type(string_type)]]);
+}
+
+export class Spec_ReadOnlyInfo extends Record implements IEquatable<Spec_ReadOnlyInfo>, IComparable<Spec_ReadOnlyInfo> {
+    readonly Heading: string;
+    readonly Content: string;
+    readonly Collapsible: Option<boolean>;
+    readonly InitiallyExpanded: Option<boolean>;
+    readonly Formatting: Option<string>;
+    constructor(Heading: string, Content: string, Collapsible: Option<boolean>, InitiallyExpanded: Option<boolean>, Formatting: Option<string>) {
+        super();
+        this.Heading = Heading;
+        this.Content = Content;
+        this.Collapsible = Collapsible;
+        this.InitiallyExpanded = InitiallyExpanded;
+        this.Formatting = Formatting;
+    }
+}
+
+export function Spec_ReadOnlyInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.ReadOnlyInfo", [], Spec_ReadOnlyInfo, () => [["Heading", string_type], ["Content", string_type], ["Collapsible", option_type(bool_type)], ["InitiallyExpanded", option_type(bool_type)], ["Formatting", option_type(string_type)]]);
+}
+
+export type Spec_DemographicFields_$union = 
+    | Spec_DemographicFields<0>
+    | Spec_DemographicFields<1>
+    | Spec_DemographicFields<2>
+    | Spec_DemographicFields<3>
+    | Spec_DemographicFields<4>
+    | Spec_DemographicFields<5>
+    | Spec_DemographicFields<6>
+    | Spec_DemographicFields<7>
+    | Spec_DemographicFields<8>
+    | Spec_DemographicFields<9>
+    | Spec_DemographicFields<10>
+    | Spec_DemographicFields<11>
+
+export type Spec_DemographicFields_$cases = {
+    0: ["FirstName", []],
+    1: ["LastName", []],
+    2: ["DateOfBirth", []],
+    3: ["Gender", []],
+    4: ["MRN", []],
+    5: ["Address", []],
+    6: ["Phone", []],
+    7: ["Email", []],
+    8: ["EmergencyContact", []],
+    9: ["Insurance", []],
+    10: ["PreferredLanguage", []],
+    11: ["All", []]
+}
+
+export function Spec_DemographicFields_FirstName() {
+    return new Spec_DemographicFields<0>(0, []);
+}
+
+export function Spec_DemographicFields_LastName() {
+    return new Spec_DemographicFields<1>(1, []);
+}
+
+export function Spec_DemographicFields_DateOfBirth() {
+    return new Spec_DemographicFields<2>(2, []);
+}
+
+export function Spec_DemographicFields_Gender() {
+    return new Spec_DemographicFields<3>(3, []);
+}
+
+export function Spec_DemographicFields_MRN() {
+    return new Spec_DemographicFields<4>(4, []);
+}
+
+export function Spec_DemographicFields_Address() {
+    return new Spec_DemographicFields<5>(5, []);
+}
+
+export function Spec_DemographicFields_Phone() {
+    return new Spec_DemographicFields<6>(6, []);
+}
+
+export function Spec_DemographicFields_Email() {
+    return new Spec_DemographicFields<7>(7, []);
+}
+
+export function Spec_DemographicFields_EmergencyContact() {
+    return new Spec_DemographicFields<8>(8, []);
+}
+
+export function Spec_DemographicFields_Insurance() {
+    return new Spec_DemographicFields<9>(9, []);
+}
+
+export function Spec_DemographicFields_PreferredLanguage() {
+    return new Spec_DemographicFields<10>(10, []);
+}
+
+export function Spec_DemographicFields_All() {
+    return new Spec_DemographicFields<11>(11, []);
+}
+
+export class Spec_DemographicFields<Tag extends keyof Spec_DemographicFields_$cases> extends Union<Tag, Spec_DemographicFields_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: Spec_DemographicFields_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["FirstName", "LastName", "DateOfBirth", "Gender", "MRN", "Address", "Phone", "Email", "EmergencyContact", "Insurance", "PreferredLanguage", "All"];
+    }
+}
+
+export function Spec_DemographicFields_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Spec.DemographicFields", [], Spec_DemographicFields, () => [[], [], [], [], [], [], [], [], [], [], [], []]);
+}
+
+export class Spec_PatientDemographicsInfo extends Record implements IEquatable<Spec_PatientDemographicsInfo>, IComparable<Spec_PatientDemographicsInfo> {
+    readonly Fields: FSharpList<Spec_DemographicFields_$union>;
+    readonly RequiredFields: Option<FSharpList<Spec_DemographicFields_$union>>;
+    readonly IncludePhoto: Option<boolean>;
+    readonly AutoPopulate: Option<boolean>;
+    constructor(Fields: FSharpList<Spec_DemographicFields_$union>, RequiredFields: Option<FSharpList<Spec_DemographicFields_$union>>, IncludePhoto: Option<boolean>, AutoPopulate: Option<boolean>) {
+        super();
+        this.Fields = Fields;
+        this.RequiredFields = RequiredFields;
+        this.IncludePhoto = IncludePhoto;
+        this.AutoPopulate = AutoPopulate;
+    }
+}
+
+export function Spec_PatientDemographicsInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.PatientDemographicsInfo", [], Spec_PatientDemographicsInfo, () => [["Fields", list_type(Spec_DemographicFields_$reflection())], ["RequiredFields", option_type(list_type(Spec_DemographicFields_$reflection()))], ["IncludePhoto", option_type(bool_type)], ["AutoPopulate", option_type(bool_type)]]);
+}
+
+export type Spec_StaffRole_$union = 
+    | Spec_StaffRole<0>
+    | Spec_StaffRole<1>
+    | Spec_StaffRole<2>
+    | Spec_StaffRole<3>
+    | Spec_StaffRole<4>
+    | Spec_StaffRole<5>
+    | Spec_StaffRole<6>
+    | Spec_StaffRole<7>
+
+export type Spec_StaffRole_$cases = {
+    0: ["Physician", []],
+    1: ["Nurse", []],
+    2: ["NursePractitioner", []],
+    3: ["PhysicianAssistant", []],
+    4: ["Therapist", []],
+    5: ["Technician", []],
+    6: ["MedicalAssistant", []],
+    7: ["Other", [string]]
+}
+
+export function Spec_StaffRole_Physician() {
+    return new Spec_StaffRole<0>(0, []);
+}
+
+export function Spec_StaffRole_Nurse() {
+    return new Spec_StaffRole<1>(1, []);
+}
+
+export function Spec_StaffRole_NursePractitioner() {
+    return new Spec_StaffRole<2>(2, []);
+}
+
+export function Spec_StaffRole_PhysicianAssistant() {
+    return new Spec_StaffRole<3>(3, []);
+}
+
+export function Spec_StaffRole_Therapist() {
+    return new Spec_StaffRole<4>(4, []);
+}
+
+export function Spec_StaffRole_Technician() {
+    return new Spec_StaffRole<5>(5, []);
+}
+
+export function Spec_StaffRole_MedicalAssistant() {
+    return new Spec_StaffRole<6>(6, []);
+}
+
+export function Spec_StaffRole_Other(Item: string) {
+    return new Spec_StaffRole<7>(7, [Item]);
+}
+
+export class Spec_StaffRole<Tag extends keyof Spec_StaffRole_$cases> extends Union<Tag, Spec_StaffRole_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: Spec_StaffRole_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Physician", "Nurse", "NursePractitioner", "PhysicianAssistant", "Therapist", "Technician", "MedicalAssistant", "Other"];
+    }
+}
+
+export function Spec_StaffRole_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Spec.StaffRole", [], Spec_StaffRole, () => [[], [], [], [], [], [], [], [["Item", string_type]]]);
+}
+
+export class Spec_ClinicalStaffInfo extends Record implements IEquatable<Spec_ClinicalStaffInfo>, IComparable<Spec_ClinicalStaffInfo> {
+    readonly Role: Option<Spec_StaffRole_$union>;
+    readonly IncludeName: boolean;
+    readonly IncludeCredentials: boolean;
+    readonly IncludeLicense: boolean;
+    readonly IncludeNPI: boolean;
+    readonly IncludeSignature: boolean;
+    readonly RequireAuthentication: Option<boolean>;
+    readonly TimeStamp: Option<boolean>;
+    constructor(Role: Option<Spec_StaffRole_$union>, IncludeName: boolean, IncludeCredentials: boolean, IncludeLicense: boolean, IncludeNPI: boolean, IncludeSignature: boolean, RequireAuthentication: Option<boolean>, TimeStamp: Option<boolean>) {
+        super();
+        this.Role = Role;
+        this.IncludeName = IncludeName;
+        this.IncludeCredentials = IncludeCredentials;
+        this.IncludeLicense = IncludeLicense;
+        this.IncludeNPI = IncludeNPI;
+        this.IncludeSignature = IncludeSignature;
+        this.RequireAuthentication = RequireAuthentication;
+        this.TimeStamp = TimeStamp;
+    }
+}
+
+export function Spec_ClinicalStaffInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.ClinicalStaffInfo", [], Spec_ClinicalStaffInfo, () => [["Role", option_type(Spec_StaffRole_$reflection())], ["IncludeName", bool_type], ["IncludeCredentials", bool_type], ["IncludeLicense", bool_type], ["IncludeNPI", bool_type], ["IncludeSignature", bool_type], ["RequireAuthentication", option_type(bool_type)], ["TimeStamp", option_type(bool_type)]]);
+}
+
+export class Spec_MatrixItem extends Record implements IEquatable<Spec_MatrixItem>, IComparable<Spec_MatrixItem> {
+    readonly ItemKey: Shared_MatrixItemKey;
+    readonly ItemLabel: string;
+    constructor(ItemKey: Shared_MatrixItemKey, ItemLabel: string) {
+        super();
+        this.ItemKey = ItemKey;
+        this.ItemLabel = ItemLabel;
+    }
+}
+
+export function Spec_MatrixItem_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.MatrixItem", [], Spec_MatrixItem, () => [["ItemKey", Shared_MatrixItemKey_$reflection()], ["ItemLabel", string_type]]);
+}
+
+export class Spec_MatrixInfo extends Record implements IEquatable<Spec_MatrixInfo>, IComparable<Spec_MatrixInfo> {
+    readonly Items: FSharpList<Shared_FieldOption>;
+    readonly Options: FSharpList<Shared_FieldOption>;
+    constructor(Items: FSharpList<Shared_FieldOption>, Options: FSharpList<Shared_FieldOption>) {
+        super();
+        this.Items = Items;
+        this.Options = Options;
+    }
+}
+
+export function Spec_MatrixInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.MatrixInfo", [], Spec_MatrixInfo, () => [["Items", list_type(Shared_FieldOption_$reflection())], ["Options", list_type(Shared_FieldOption_$reflection())]]);
+}
+
+export class Spec_SignatureInfo extends Record implements IEquatable<Spec_SignatureInfo>, IComparable<Spec_SignatureInfo> {
+    readonly Value: Option<string>;
+    constructor(Value: Option<string>) {
+        super();
+        this.Value = Value;
+    }
+}
+
+export function Spec_SignatureInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.SignatureInfo", [], Spec_SignatureInfo, () => [["Value", option_type(string_type)]]);
+}
+
+export class Spec_PluginFieldConfig extends Record implements IEquatable<Spec_PluginFieldConfig>, IComparable<Spec_PluginFieldConfig> {
+    readonly PluginId: string;
+    readonly FieldName: string;
+    constructor(PluginId: string, FieldName: string) {
+        super();
+        this.PluginId = PluginId;
+        this.FieldName = FieldName;
+    }
+}
+
+export function Spec_PluginFieldConfig_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.PluginFieldConfig", [], Spec_PluginFieldConfig, () => [["PluginId", string_type], ["FieldName", string_type]]);
+}
+
+export type Spec_FieldType_$union = 
+    | Spec_FieldType<0>
+    | Spec_FieldType<1>
+    | Spec_FieldType<2>
+    | Spec_FieldType<3>
+    | Spec_FieldType<4>
+    | Spec_FieldType<5>
+    | Spec_FieldType<6>
+    | Spec_FieldType<7>
+    | Spec_FieldType<8>
+    | Spec_FieldType<9>
+    | Spec_FieldType<10>
+    | Spec_FieldType<11>
+    | Spec_FieldType<12>
+    | Spec_FieldType<13>
+    | Spec_FieldType<14>
+    | Spec_FieldType<15>
+    | Spec_FieldType<16>
+    | Spec_FieldType<17>
+    | Spec_FieldType<18>
+    | Spec_FieldType<19>
+    | Spec_FieldType<20>
+    | Spec_FieldType<21>
+    | Spec_FieldType<22>
+
+export type Spec_FieldType_$cases = {
+    0: ["Text", [Spec_TextInfo]],
+    1: ["TextArea", [Spec_TextInfo]],
+    2: ["Email", [Spec_TextInfo]],
+    3: ["Password", [Spec_TextInfo]],
+    4: ["Search", [Spec_TextInfo]],
+    5: ["Color", [Spec_TextInfo]],
+    6: ["Number", [Spec_TextInfo]],
+    7: ["Tel", [Spec_TextInfo]],
+    8: ["Date", [Spec_TextInfo]],
+    9: ["DateTimeLocal", [Spec_TextInfo]],
+    10: ["Time", [Spec_TextInfo]],
+    11: ["Checkbox", [Spec_BooleanInfo]],
+    12: ["Radio", [Spec_SingleChoiceInfo]],
+    13: ["SingleChoice", [Spec_SingleChoiceInfo]],
+    14: ["Dropdown", [Spec_SingleChoiceInfo]],
+    15: ["MultiChoice", [Spec_MultiChoiceInfo]],
+    16: ["CheckboxList", [Spec_MultiChoiceInfo]],
+    17: ["TagList", [Spec_MultiChoiceInfo]],
+    18: ["TextAutoComplete", [Spec_SingleChoiceInfo]],
+    19: ["Matrix", [Spec_MatrixInfo]],
+    20: ["Signature", [Spec_SignatureInfo]],
+    21: ["Message", [Spec_MessageInfo]],
+    22: ["PluginField", [Spec_PluginFieldConfig]]
+}
+
+export function Spec_FieldType_Text(Item: Spec_TextInfo) {
+    return new Spec_FieldType<0>(0, [Item]);
+}
+
+export function Spec_FieldType_TextArea(Item: Spec_TextInfo) {
+    return new Spec_FieldType<1>(1, [Item]);
+}
+
+export function Spec_FieldType_Email(Item: Spec_TextInfo) {
+    return new Spec_FieldType<2>(2, [Item]);
+}
+
+export function Spec_FieldType_Password(Item: Spec_TextInfo) {
+    return new Spec_FieldType<3>(3, [Item]);
+}
+
+export function Spec_FieldType_Search(Item: Spec_TextInfo) {
+    return new Spec_FieldType<4>(4, [Item]);
+}
+
+export function Spec_FieldType_Color(Item: Spec_TextInfo) {
+    return new Spec_FieldType<5>(5, [Item]);
+}
+
+export function Spec_FieldType_Number(Item: Spec_TextInfo) {
+    return new Spec_FieldType<6>(6, [Item]);
+}
+
+export function Spec_FieldType_Tel(Item: Spec_TextInfo) {
+    return new Spec_FieldType<7>(7, [Item]);
+}
+
+export function Spec_FieldType_Date(Item: Spec_TextInfo) {
+    return new Spec_FieldType<8>(8, [Item]);
+}
+
+export function Spec_FieldType_DateTimeLocal(Item: Spec_TextInfo) {
+    return new Spec_FieldType<9>(9, [Item]);
+}
+
+export function Spec_FieldType_Time(Item: Spec_TextInfo) {
+    return new Spec_FieldType<10>(10, [Item]);
+}
+
+export function Spec_FieldType_Checkbox(Item: Spec_BooleanInfo) {
+    return new Spec_FieldType<11>(11, [Item]);
+}
+
+export function Spec_FieldType_Radio(Item: Spec_SingleChoiceInfo) {
+    return new Spec_FieldType<12>(12, [Item]);
+}
+
+export function Spec_FieldType_SingleChoice(Item: Spec_SingleChoiceInfo) {
+    return new Spec_FieldType<13>(13, [Item]);
+}
+
+export function Spec_FieldType_Dropdown(Item: Spec_SingleChoiceInfo) {
+    return new Spec_FieldType<14>(14, [Item]);
+}
+
+export function Spec_FieldType_MultiChoice(Item: Spec_MultiChoiceInfo) {
+    return new Spec_FieldType<15>(15, [Item]);
+}
+
+export function Spec_FieldType_CheckboxList(Item: Spec_MultiChoiceInfo) {
+    return new Spec_FieldType<16>(16, [Item]);
+}
+
+export function Spec_FieldType_TagList(Item: Spec_MultiChoiceInfo) {
+    return new Spec_FieldType<17>(17, [Item]);
+}
+
+export function Spec_FieldType_TextAutoComplete(Item: Spec_SingleChoiceInfo) {
+    return new Spec_FieldType<18>(18, [Item]);
+}
+
+export function Spec_FieldType_Matrix(Item: Spec_MatrixInfo) {
+    return new Spec_FieldType<19>(19, [Item]);
+}
+
+export function Spec_FieldType_Signature(Item: Spec_SignatureInfo) {
+    return new Spec_FieldType<20>(20, [Item]);
+}
+
+export function Spec_FieldType_Message(Item: Spec_MessageInfo) {
+    return new Spec_FieldType<21>(21, [Item]);
+}
+
+export function Spec_FieldType_PluginField(Item: Spec_PluginFieldConfig) {
+    return new Spec_FieldType<22>(22, [Item]);
+}
+
+export class Spec_FieldType<Tag extends keyof Spec_FieldType_$cases> extends Union<Tag, Spec_FieldType_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: Spec_FieldType_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Text", "TextArea", "Email", "Password", "Search", "Color", "Number", "Tel", "Date", "DateTimeLocal", "Time", "Checkbox", "Radio", "SingleChoice", "Dropdown", "MultiChoice", "CheckboxList", "TagList", "TextAutoComplete", "Matrix", "Signature", "Message", "PluginField"];
+    }
+}
+
+export function Spec_FieldType_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Spec.FieldType", [], Spec_FieldType, () => [[["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_BooleanInfo_$reflection()]], [["Item", Spec_SingleChoiceInfo_$reflection()]], [["Item", Spec_SingleChoiceInfo_$reflection()]], [["Item", Spec_SingleChoiceInfo_$reflection()]], [["Item", Spec_MultiChoiceInfo_$reflection()]], [["Item", Spec_MultiChoiceInfo_$reflection()]], [["Item", Spec_MultiChoiceInfo_$reflection()]], [["Item", Spec_SingleChoiceInfo_$reflection()]], [["Item", Spec_MatrixInfo_$reflection()]], [["Item", Spec_SignatureInfo_$reflection()]], [["Item", Spec_MessageInfo_$reflection()]], [["Item", Spec_PluginFieldConfig_$reflection()]]]);
+}
+
+export class Spec_FieldAnswerFlag extends Record implements IEquatable<Spec_FieldAnswerFlag>, IComparable<Spec_FieldAnswerFlag> {
+    readonly OptionKey: string;
+    readonly Label: string;
+    constructor(OptionKey: string, Label: string) {
+        super();
+        this.OptionKey = OptionKey;
+        this.Label = Label;
+    }
+}
+
+export function Spec_FieldAnswerFlag_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.FieldAnswerFlag", [], Spec_FieldAnswerFlag, () => [["OptionKey", string_type], ["Label", string_type]]);
+}
+
+export class Spec_FormField$1<FieldType> extends Record implements IEquatable<Spec_FormField$1<FieldType>>, IComparable<Spec_FormField$1<FieldType>> {
+    readonly FieldOrder: int32;
+    readonly FieldKey: Shared_FieldKey;
+    readonly Label: string;
+    readonly Notes: Option<string>;
+    readonly DependsOn: Option<Spec_DependsOn>;
+    readonly IsOptional: boolean;
+    readonly IsDeprecated: boolean;
+    readonly FieldType: FieldType;
+    constructor(FieldOrder: int32, FieldKey: Shared_FieldKey, Label: string, Notes: Option<string>, DependsOn: Option<Spec_DependsOn>, IsOptional: boolean, IsDeprecated: boolean, FieldType: 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;
+    }
+}
+
+export function Spec_FormField$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return record_type("F1.Studio.Spec.FormField`1", [gen0], Spec_FormField$1, () => [["FieldOrder", int32_type], ["FieldKey", Shared_FieldKey_$reflection()], ["Label", string_type], ["Notes", option_type(string_type)], ["DependsOn", option_type(Spec_DependsOn_$reflection())], ["IsOptional", bool_type], ["IsDeprecated", bool_type], ["FieldType", gen0]]);
+}
+
+export class Spec_FormStep$1<FieldType> extends Record implements IEquatable<Spec_FormStep$1<FieldType>>, IComparable<Spec_FormStep$1<FieldType>> {
+    readonly StepOrder: int32;
+    readonly StepLabel: string;
+    readonly Fields: FSharpList<Spec_FormField$1<FieldType>>;
+    constructor(StepOrder: int32, StepLabel: string, Fields: FSharpList<Spec_FormField$1<FieldType>>) {
+        super();
+        this.StepOrder = (StepOrder | 0);
+        this.StepLabel = StepLabel;
+        this.Fields = Fields;
+    }
+}
+
+export function Spec_FormStep$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return record_type("F1.Studio.Spec.FormStep`1", [gen0], Spec_FormStep$1, () => [["StepOrder", int32_type], ["StepLabel", string_type], ["Fields", list_type(Spec_FormField$1_$reflection(gen0))]]);
+}
+
+export type Spec_ScoreColor_$union = 
+    | Spec_ScoreColor<0>
+    | Spec_ScoreColor<1>
+    | Spec_ScoreColor<2>
+    | Spec_ScoreColor<3>
+    | Spec_ScoreColor<4>
+    | Spec_ScoreColor<5>
+    | Spec_ScoreColor<6>
+
+export type Spec_ScoreColor_$cases = {
+    0: ["Unspecified", []],
+    1: ["Primary", []],
+    2: ["Link", []],
+    3: ["Info", []],
+    4: ["Success", []],
+    5: ["Warning", []],
+    6: ["Danger", []]
+}
+
+export function Spec_ScoreColor_Unspecified() {
+    return new Spec_ScoreColor<0>(0, []);
+}
+
+export function Spec_ScoreColor_Primary() {
+    return new Spec_ScoreColor<1>(1, []);
+}
+
+export function Spec_ScoreColor_Link() {
+    return new Spec_ScoreColor<2>(2, []);
+}
+
+export function Spec_ScoreColor_Info() {
+    return new Spec_ScoreColor<3>(3, []);
+}
+
+export function Spec_ScoreColor_Success() {
+    return new Spec_ScoreColor<4>(4, []);
+}
+
+export function Spec_ScoreColor_Warning() {
+    return new Spec_ScoreColor<5>(5, []);
+}
+
+export function Spec_ScoreColor_Danger() {
+    return new Spec_ScoreColor<6>(6, []);
+}
+
+export class Spec_ScoreColor<Tag extends keyof Spec_ScoreColor_$cases> extends Union<Tag, Spec_ScoreColor_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: Spec_ScoreColor_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Unspecified", "Primary", "Link", "Info", "Success", "Warning", "Danger"];
+    }
+}
+
+export function Spec_ScoreColor_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Spec.ScoreColor", [], Spec_ScoreColor, () => [[], [], [], [], [], [], []]);
+}
+
+export class Spec_ScoreRange extends Record implements IEquatable<Spec_ScoreRange>, IComparable<Spec_ScoreRange> {
+    readonly Id: string;
+    readonly Min: int32;
+    readonly Max: int32;
+    readonly Label: string;
+    readonly Tag: Spec_ScoreColor_$union;
+    constructor(Id: string, Min: int32, Max: int32, Label: string, Tag: Spec_ScoreColor_$union) {
+        super();
+        this.Id = Id;
+        this.Min = (Min | 0);
+        this.Max = (Max | 0);
+        this.Label = Label;
+        this.Tag = Tag;
+    }
+}
+
+export function Spec_ScoreRange_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.ScoreRange", [], Spec_ScoreRange, () => [["Id", class_type("System.Guid")], ["Min", int32_type], ["Max", int32_type], ["Label", string_type], ["Tag", Spec_ScoreColor_$reflection()]]);
+}
+
+export class Spec_Score extends Record implements IEquatable<Spec_Score>, IComparable<Spec_Score> {
+    readonly MaxScore: int32;
+    readonly ScoreRanges: FSharpList<Spec_ScoreRange>;
+    constructor(MaxScore: int32, ScoreRanges: FSharpList<Spec_ScoreRange>) {
+        super();
+        this.MaxScore = (MaxScore | 0);
+        this.ScoreRanges = ScoreRanges;
+    }
+}
+
+export function Spec_Score_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.Score", [], Spec_Score, () => [["MaxScore", int32_type], ["ScoreRanges", list_type(Spec_ScoreRange_$reflection())]]);
+}
+
+export class Spec_FormSpec$1<FieldType> extends Record implements IEquatable<Spec_FormSpec$1<FieldType>>, IComparable<Spec_FormSpec$1<FieldType>> {
+    readonly Id: string;
+    readonly Code: Option<string>;
+    readonly Title: string;
+    readonly Abstract: string;
+    readonly Version: string;
+    readonly FormSpecVersion: string;
+    readonly Steps: FSharpList<Spec_FormStep$1<FieldType>>;
+    readonly CategoryTags: FSharpList<string>;
+    readonly Score: Option<Spec_Score>;
+    readonly AssociatedCodes: FSharpList<string>;
+    readonly RequiresReview: boolean;
+    readonly RequiresReviewAndApproval: boolean;
+    readonly ClinicalPathway: Option<ClinicalPathway_ClinicalPathwaySpec>;
+    constructor(Id: string, Code: Option<string>, Title: string, Abstract: string, Version: string, FormSpecVersion: string, Steps: FSharpList<Spec_FormStep$1<FieldType>>, CategoryTags: FSharpList<string>, Score: Option<Spec_Score>, AssociatedCodes: FSharpList<string>, RequiresReview: boolean, RequiresReviewAndApproval: boolean, ClinicalPathway: Option<ClinicalPathway_ClinicalPathwaySpec>) {
+        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 Spec_FormSpec$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return record_type("F1.Studio.Spec.FormSpec`1", [gen0], Spec_FormSpec$1, () => [["Id", class_type("System.Guid")], ["Code", option_type(string_type)], ["Title", string_type], ["Abstract", string_type], ["Version", string_type], ["FormSpecVersion", string_type], ["Steps", list_type(Spec_FormStep$1_$reflection(gen0))], ["CategoryTags", list_type(string_type)], ["Score", option_type(Spec_Score_$reflection())], ["AssociatedCodes", list_type(string_type)], ["RequiresReview", bool_type], ["RequiresReviewAndApproval", bool_type], ["ClinicalPathway", option_type(ClinicalPathway_ClinicalPathwaySpec_$reflection())]]);
+}
+
+export function Spec_Evaluator__get_Key(x: Spec_Evaluator_$union): string {
+    switch (x.tag) {
+        case /* NotEquals */ 1:
+            return "Not Equals";
+        case /* GreaterThan */ 2:
+            return "Greater Than";
+        case /* GreaterThanOrEquals */ 3:
+            return "Greater Than Or Equals";
+        case /* LessThan */ 4:
+            return "Less Than";
+        case /* LessThanOrEquals */ 5:
+            return "Less Than Or Equals";
+        case /* Exists */ 6:
+            return "Exists";
+        case /* IsEmpty */ 7:
+            return "Is Empty";
+        case /* Contains */ 8:
+            return "Contains";
+        default:
+            return "Equals";
+    }
+}
+
+export function Spec_tryEvaluationKeyToEvaluation(str: string): Option<Spec_Evaluator_$union> {
+    switch (str) {
+        case "Equals":
+            return Spec_Evaluator_Equals();
+        case "Not Equals":
+            return Spec_Evaluator_NotEquals();
+        case "Greater Than":
+            return Spec_Evaluator_GreaterThan();
+        case "Greater Than Or Equals":
+            return Spec_Evaluator_GreaterThanOrEquals();
+        case "Less Than":
+            return Spec_Evaluator_LessThan();
+        case "Less Than Or Equals":
+            return Spec_Evaluator_LessThanOrEquals();
+        case "Exists":
+            return Spec_Evaluator_Exists();
+        case "Is Empty":
+            return Spec_Evaluator_IsEmpty();
+        case "Contains":
+            return Spec_Evaluator_Contains();
+        default:
+            return undefined;
+    }
+}
+
+export const Spec_evaluators: FSharpList<Spec_Evaluator_$union> = ofArray([Spec_Evaluator_Equals(), Spec_Evaluator_NotEquals(), Spec_Evaluator_GreaterThan(), Spec_Evaluator_GreaterThanOrEquals(), Spec_Evaluator_LessThan(), Spec_Evaluator_LessThanOrEquals(), Spec_Evaluator_Exists(), Spec_Evaluator_IsEmpty(), Spec_Evaluator_Contains()]);
+
+export function Spec_SpecialTextType__get_Label(x: Spec_SpecialTextType_$union): string {
+    switch (x.tag) {
+        case /* BloodPressureType */ 1:
+            return "Blood Pressure";
+        case /* DiastolicBloodPressureType */ 2:
+            return "Diastolic Blood Pressure";
+        case /* SystolicBloodPressureType */ 3:
+            return "Systolic Blood Pressure";
+        case /* HeightType */ 4:
+            return "Height";
+        case /* WeightType */ 5:
+            return "Weight";
+        case /* PulseRateType */ 6:
+            return "Pulse Rate";
+        case /* HeartRateType */ 7:
+            return "Heart Rate";
+        case /* RespirationRateType */ 8:
+            return "Respiration Rate";
+        case /* OxygenSaturationType */ 9:
+            return "Oxygen Saturation";
+        default:
+            return "Body Temperature";
+    }
+}
+
+export const Spec_availableSpecialTextType: FSharpList<Spec_SpecialTextType_$union> = ofArray([Spec_SpecialTextType_BodyTemperatureType(), Spec_SpecialTextType_BloodPressureType(), Spec_SpecialTextType_DiastolicBloodPressureType(), Spec_SpecialTextType_SystolicBloodPressureType(), Spec_SpecialTextType_HeightType(), Spec_SpecialTextType_WeightType(), Spec_SpecialTextType_PulseRateType(), Spec_SpecialTextType_HeartRateType(), Spec_SpecialTextType_RespirationRateType(), Spec_SpecialTextType_OxygenSaturationType()]);
+
+export function Spec_ScoreColor__get_Value(x: Spec_ScoreColor_$union): int32 {
+    switch (x.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;
+    }
+}
+
+export function Spec_scoreColorFromIndex(index: int32): Spec_ScoreColor_$union {
+    switch (index) {
+        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:
+            throw new Error(`Invalid score color index ${index}`);
+    }
+}
+
+export class ClinicalPathway_MedicationAction extends Record implements IEquatable<ClinicalPathway_MedicationAction>, IComparable<ClinicalPathway_MedicationAction> {
+    readonly Name: string;
+    readonly Dose: string;
+    readonly Route: string;
+    readonly Frequency: string;
+    readonly Duration: string;
+    readonly AsNeeded: boolean;
+    constructor(Name: string, Dose: string, Route: string, Frequency: string, Duration: string, AsNeeded: boolean) {
+        super();
+        this.Name = Name;
+        this.Dose = Dose;
+        this.Route = Route;
+        this.Frequency = Frequency;
+        this.Duration = Duration;
+        this.AsNeeded = AsNeeded;
+    }
+}
+
+export function ClinicalPathway_MedicationAction_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.MedicationAction", [], ClinicalPathway_MedicationAction, () => [["Name", string_type], ["Dose", string_type], ["Route", string_type], ["Frequency", string_type], ["Duration", string_type], ["AsNeeded", bool_type]]);
+}
+
+export class ClinicalPathway_TestAction extends Record implements IEquatable<ClinicalPathway_TestAction>, IComparable<ClinicalPathway_TestAction> {
+    readonly TestName: string;
+    readonly TestType: string;
+    readonly RequiresResult: boolean;
+    readonly CriticalValues: Option<FSharpList<[string, string]>>;
+    constructor(TestName: string, TestType: string, RequiresResult: boolean, CriticalValues: Option<FSharpList<[string, string]>>) {
+        super();
+        this.TestName = TestName;
+        this.TestType = TestType;
+        this.RequiresResult = RequiresResult;
+        this.CriticalValues = CriticalValues;
+    }
+}
+
+export function ClinicalPathway_TestAction_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.TestAction", [], ClinicalPathway_TestAction, () => [["TestName", string_type], ["TestType", string_type], ["RequiresResult", bool_type], ["CriticalValues", option_type(list_type(tuple_type(string_type, string_type)))]]);
+}
+
+export type ClinicalPathway_ReferralUrgency_$union = 
+    | ClinicalPathway_ReferralUrgency<0>
+    | ClinicalPathway_ReferralUrgency<1>
+    | ClinicalPathway_ReferralUrgency<2>
+
+export type ClinicalPathway_ReferralUrgency_$cases = {
+    0: ["Immediate", []],
+    1: ["Routine", [int32]],
+    2: ["AsNeeded", []]
+}
+
+export function ClinicalPathway_ReferralUrgency_Immediate() {
+    return new ClinicalPathway_ReferralUrgency<0>(0, []);
+}
+
+export function ClinicalPathway_ReferralUrgency_Routine(days: int32) {
+    return new ClinicalPathway_ReferralUrgency<1>(1, [days]);
+}
+
+export function ClinicalPathway_ReferralUrgency_AsNeeded() {
+    return new ClinicalPathway_ReferralUrgency<2>(2, []);
+}
+
+export class ClinicalPathway_ReferralUrgency<Tag extends keyof ClinicalPathway_ReferralUrgency_$cases> extends Union<Tag, ClinicalPathway_ReferralUrgency_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_ReferralUrgency_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Immediate", "Routine", "AsNeeded"];
+    }
+}
+
+export function ClinicalPathway_ReferralUrgency_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.ReferralUrgency", [], ClinicalPathway_ReferralUrgency, () => [[], [["days", int32_type]], []]);
+}
+
+export class ClinicalPathway_ReferralAction extends Record implements IEquatable<ClinicalPathway_ReferralAction>, IComparable<ClinicalPathway_ReferralAction> {
+    readonly Target: string;
+    readonly Urgency: ClinicalPathway_ReferralUrgency_$union;
+    readonly Reason: string;
+    constructor(Target: string, Urgency: ClinicalPathway_ReferralUrgency_$union, Reason: string) {
+        super();
+        this.Target = Target;
+        this.Urgency = Urgency;
+        this.Reason = Reason;
+    }
+}
+
+export function ClinicalPathway_ReferralAction_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.ReferralAction", [], ClinicalPathway_ReferralAction, () => [["Target", string_type], ["Urgency", ClinicalPathway_ReferralUrgency_$reflection()], ["Reason", string_type]]);
+}
+
+export class ClinicalPathway_EducationAction extends Record implements IEquatable<ClinicalPathway_EducationAction>, IComparable<ClinicalPathway_EducationAction> {
+    readonly Topics: FSharpList<string>;
+    readonly Materials: Option<FSharpList<string>>;
+    constructor(Topics: FSharpList<string>, Materials: Option<FSharpList<string>>) {
+        super();
+        this.Topics = Topics;
+        this.Materials = Materials;
+    }
+}
+
+export function ClinicalPathway_EducationAction_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.EducationAction", [], ClinicalPathway_EducationAction, () => [["Topics", list_type(string_type)], ["Materials", option_type(list_type(string_type))]]);
+}
+
+export class ClinicalPathway_ProcedureAction extends Record implements IEquatable<ClinicalPathway_ProcedureAction>, IComparable<ClinicalPathway_ProcedureAction> {
+    readonly Name: string;
+    readonly Description: string;
+    readonly Duration: Option<string>;
+    constructor(Name: string, Description: string, Duration: Option<string>) {
+        super();
+        this.Name = Name;
+        this.Description = Description;
+        this.Duration = Duration;
+    }
+}
+
+export function ClinicalPathway_ProcedureAction_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.ProcedureAction", [], ClinicalPathway_ProcedureAction, () => [["Name", string_type], ["Description", string_type], ["Duration", option_type(string_type)]]);
+}
+
+export class ClinicalPathway_DocumentationAction extends Record implements IEquatable<ClinicalPathway_DocumentationAction>, IComparable<ClinicalPathway_DocumentationAction> {
+    readonly FormName: string;
+    readonly Purpose: string;
+    readonly Required: boolean;
+    constructor(FormName: string, Purpose: string, Required: boolean) {
+        super();
+        this.FormName = FormName;
+        this.Purpose = Purpose;
+        this.Required = Required;
+    }
+}
+
+export function ClinicalPathway_DocumentationAction_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.DocumentationAction", [], ClinicalPathway_DocumentationAction, () => [["FormName", string_type], ["Purpose", string_type], ["Required", bool_type]]);
+}
+
+export type ClinicalPathway_TaskPriority_$union = 
+    | ClinicalPathway_TaskPriority<0>
+    | ClinicalPathway_TaskPriority<1>
+    | ClinicalPathway_TaskPriority<2>
+
+export type ClinicalPathway_TaskPriority_$cases = {
+    0: ["High", []],
+    1: ["Medium", []],
+    2: ["Low", []]
+}
+
+export function ClinicalPathway_TaskPriority_High() {
+    return new ClinicalPathway_TaskPriority<0>(0, []);
+}
+
+export function ClinicalPathway_TaskPriority_Medium() {
+    return new ClinicalPathway_TaskPriority<1>(1, []);
+}
+
+export function ClinicalPathway_TaskPriority_Low() {
+    return new ClinicalPathway_TaskPriority<2>(2, []);
+}
+
+export class ClinicalPathway_TaskPriority<Tag extends keyof ClinicalPathway_TaskPriority_$cases> extends Union<Tag, ClinicalPathway_TaskPriority_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_TaskPriority_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["High", "Medium", "Low"];
+    }
+}
+
+export function ClinicalPathway_TaskPriority_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.TaskPriority", [], ClinicalPathway_TaskPriority, () => [[], [], []]);
+}
+
+export type ClinicalPathway_DueDate_$union = 
+    | ClinicalPathway_DueDate<0>
+    | ClinicalPathway_DueDate<1>
+    | ClinicalPathway_DueDate<2>
+    | ClinicalPathway_DueDate<3>
+
+export type ClinicalPathway_DueDate_$cases = {
+    0: ["Today", []],
+    1: ["Tomorrow", []],
+    2: ["DaysFromNow", [int32]],
+    3: ["SpecificDate", [Date]]
+}
+
+export function ClinicalPathway_DueDate_Today() {
+    return new ClinicalPathway_DueDate<0>(0, []);
+}
+
+export function ClinicalPathway_DueDate_Tomorrow() {
+    return new ClinicalPathway_DueDate<1>(1, []);
+}
+
+export function ClinicalPathway_DueDate_DaysFromNow(Item: int32) {
+    return new ClinicalPathway_DueDate<2>(2, [Item]);
+}
+
+export function ClinicalPathway_DueDate_SpecificDate(Item: Date) {
+    return new ClinicalPathway_DueDate<3>(3, [Item]);
+}
+
+export class ClinicalPathway_DueDate<Tag extends keyof ClinicalPathway_DueDate_$cases> extends Union<Tag, ClinicalPathway_DueDate_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_DueDate_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Today", "Tomorrow", "DaysFromNow", "SpecificDate"];
+    }
+}
+
+export function ClinicalPathway_DueDate_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.DueDate", [], ClinicalPathway_DueDate, () => [[], [], [["Item", int32_type]], [["Item", class_type("System.DateTimeOffset")]]]);
+}
+
+export type ClinicalPathway_RecurrenceEnd_$union = 
+    | ClinicalPathway_RecurrenceEnd<0>
+    | ClinicalPathway_RecurrenceEnd<1>
+    | ClinicalPathway_RecurrenceEnd<2>
+
+export type ClinicalPathway_RecurrenceEnd_$cases = {
+    0: ["OnDate", [Date]],
+    1: ["AfterOccurrences", [int32]],
+    2: ["Never", []]
+}
+
+export function ClinicalPathway_RecurrenceEnd_OnDate(Item: Date) {
+    return new ClinicalPathway_RecurrenceEnd<0>(0, [Item]);
+}
+
+export function ClinicalPathway_RecurrenceEnd_AfterOccurrences(Item: int32) {
+    return new ClinicalPathway_RecurrenceEnd<1>(1, [Item]);
+}
+
+export function ClinicalPathway_RecurrenceEnd_Never() {
+    return new ClinicalPathway_RecurrenceEnd<2>(2, []);
+}
+
+export class ClinicalPathway_RecurrenceEnd<Tag extends keyof ClinicalPathway_RecurrenceEnd_$cases> extends Union<Tag, ClinicalPathway_RecurrenceEnd_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_RecurrenceEnd_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["OnDate", "AfterOccurrences", "Never"];
+    }
+}
+
+export function ClinicalPathway_RecurrenceEnd_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.RecurrenceEnd", [], ClinicalPathway_RecurrenceEnd, () => [[["Item", class_type("System.DateTimeOffset")]], [["Item", int32_type]], []]);
+}
+
+export class ClinicalPathway_RecurrencePattern extends Record implements IEquatable<ClinicalPathway_RecurrencePattern>, IComparable<ClinicalPathway_RecurrencePattern> {
+    readonly Interval: number;
+    readonly Until: ClinicalPathway_RecurrenceEnd_$union;
+    constructor(Interval: number, Until: ClinicalPathway_RecurrenceEnd_$union) {
+        super();
+        this.Interval = Interval;
+        this.Until = Until;
+    }
+}
+
+export function ClinicalPathway_RecurrencePattern_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.RecurrencePattern", [], ClinicalPathway_RecurrencePattern, () => [["Interval", class_type("System.TimeSpan")], ["Until", ClinicalPathway_RecurrenceEnd_$reflection()]]);
+}
+
+export class ClinicalPathway_TaskAction extends Record implements IEquatable<ClinicalPathway_TaskAction>, IComparable<ClinicalPathway_TaskAction> {
+    readonly Category: string;
+    readonly Description: string;
+    readonly Priority: ClinicalPathway_TaskPriority_$union;
+    readonly DueDate: ClinicalPathway_DueDate_$union;
+    readonly Assignee: string;
+    readonly Recurrence: Option<ClinicalPathway_RecurrencePattern>;
+    constructor(Category: string, Description: string, Priority: ClinicalPathway_TaskPriority_$union, DueDate: ClinicalPathway_DueDate_$union, Assignee: string, Recurrence: Option<ClinicalPathway_RecurrencePattern>) {
+        super();
+        this.Category = Category;
+        this.Description = Description;
+        this.Priority = Priority;
+        this.DueDate = DueDate;
+        this.Assignee = Assignee;
+        this.Recurrence = Recurrence;
+    }
+}
+
+export function ClinicalPathway_TaskAction_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.TaskAction", [], ClinicalPathway_TaskAction, () => [["Category", string_type], ["Description", string_type], ["Priority", ClinicalPathway_TaskPriority_$reflection()], ["DueDate", ClinicalPathway_DueDate_$reflection()], ["Assignee", string_type], ["Recurrence", option_type(ClinicalPathway_RecurrencePattern_$reflection())]]);
+}
+
+export type ClinicalPathway_AlertSeverity_$union = 
+    | ClinicalPathway_AlertSeverity<0>
+    | ClinicalPathway_AlertSeverity<1>
+    | ClinicalPathway_AlertSeverity<2>
+    | ClinicalPathway_AlertSeverity<3>
+
+export type ClinicalPathway_AlertSeverity_$cases = {
+    0: ["Low", []],
+    1: ["Medium", []],
+    2: ["High", []],
+    3: ["Critical", []]
+}
+
+export function ClinicalPathway_AlertSeverity_Low() {
+    return new ClinicalPathway_AlertSeverity<0>(0, []);
+}
+
+export function ClinicalPathway_AlertSeverity_Medium() {
+    return new ClinicalPathway_AlertSeverity<1>(1, []);
+}
+
+export function ClinicalPathway_AlertSeverity_High() {
+    return new ClinicalPathway_AlertSeverity<2>(2, []);
+}
+
+export function ClinicalPathway_AlertSeverity_Critical() {
+    return new ClinicalPathway_AlertSeverity<3>(3, []);
+}
+
+export class ClinicalPathway_AlertSeverity<Tag extends keyof ClinicalPathway_AlertSeverity_$cases> extends Union<Tag, ClinicalPathway_AlertSeverity_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_AlertSeverity_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Low", "Medium", "High", "Critical"];
+    }
+}
+
+export function ClinicalPathway_AlertSeverity_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.AlertSeverity", [], ClinicalPathway_AlertSeverity, () => [[], [], [], []]);
+}
+
+export class ClinicalPathway_AlertAction extends Record implements IEquatable<ClinicalPathway_AlertAction>, IComparable<ClinicalPathway_AlertAction> {
+    readonly Category: string;
+    readonly Message: string;
+    readonly Severity: ClinicalPathway_AlertSeverity_$union;
+    readonly ExpiresAfter: Option<number>;
+    constructor(Category: string, Message: string, Severity: ClinicalPathway_AlertSeverity_$union, ExpiresAfter: Option<number>) {
+        super();
+        this.Category = Category;
+        this.Message = Message;
+        this.Severity = Severity;
+        this.ExpiresAfter = ExpiresAfter;
+    }
+}
+
+export function ClinicalPathway_AlertAction_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.AlertAction", [], ClinicalPathway_AlertAction, () => [["Category", string_type], ["Message", string_type], ["Severity", ClinicalPathway_AlertSeverity_$reflection()], ["ExpiresAfter", option_type(class_type("System.TimeSpan"))]]);
+}
+
+export type ClinicalPathway_ProblemStatus_$union = 
+    | ClinicalPathway_ProblemStatus<0>
+    | ClinicalPathway_ProblemStatus<1>
+    | ClinicalPathway_ProblemStatus<2>
+    | ClinicalPathway_ProblemStatus<3>
+
+export type ClinicalPathway_ProblemStatus_$cases = {
+    0: ["Active", []],
+    1: ["Resolved", []],
+    2: ["Chronic", []],
+    3: ["Inactive", []]
+}
+
+export function ClinicalPathway_ProblemStatus_Active() {
+    return new ClinicalPathway_ProblemStatus<0>(0, []);
+}
+
+export function ClinicalPathway_ProblemStatus_Resolved() {
+    return new ClinicalPathway_ProblemStatus<1>(1, []);
+}
+
+export function ClinicalPathway_ProblemStatus_Chronic() {
+    return new ClinicalPathway_ProblemStatus<2>(2, []);
+}
+
+export function ClinicalPathway_ProblemStatus_Inactive() {
+    return new ClinicalPathway_ProblemStatus<3>(3, []);
+}
+
+export class ClinicalPathway_ProblemStatus<Tag extends keyof ClinicalPathway_ProblemStatus_$cases> extends Union<Tag, ClinicalPathway_ProblemStatus_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_ProblemStatus_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Active", "Resolved", "Chronic", "Inactive"];
+    }
+}
+
+export function ClinicalPathway_ProblemStatus_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.ProblemStatus", [], ClinicalPathway_ProblemStatus, () => [[], [], [], []]);
+}
+
+export class ClinicalPathway_ProblemAction extends Record implements IEquatable<ClinicalPathway_ProblemAction>, IComparable<ClinicalPathway_ProblemAction> {
+    readonly ProblemName: string;
+    readonly IcdCode: Option<string>;
+    readonly Onset: Option<Date>;
+    readonly Status: ClinicalPathway_ProblemStatus_$union;
+    readonly Notes: Option<string>;
+    constructor(ProblemName: string, IcdCode: Option<string>, Onset: Option<Date>, Status: ClinicalPathway_ProblemStatus_$union, Notes: Option<string>) {
+        super();
+        this.ProblemName = ProblemName;
+        this.IcdCode = IcdCode;
+        this.Onset = Onset;
+        this.Status = Status;
+        this.Notes = Notes;
+    }
+}
+
+export function ClinicalPathway_ProblemAction_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.ProblemAction", [], ClinicalPathway_ProblemAction, () => [["ProblemName", string_type], ["IcdCode", option_type(string_type)], ["Onset", option_type(class_type("System.DateTimeOffset"))], ["Status", ClinicalPathway_ProblemStatus_$reflection()], ["Notes", option_type(string_type)]]);
+}
+
+export class ClinicalPathway_PrescriptionAction extends Record implements IEquatable<ClinicalPathway_PrescriptionAction>, IComparable<ClinicalPathway_PrescriptionAction> {
+    readonly Medication: string;
+    readonly Dose: string;
+    readonly Route: string;
+    readonly Frequency: string;
+    readonly Duration: string;
+    readonly Quantity: int32;
+    readonly Refills: int32;
+    readonly Substitution: boolean;
+    readonly Instructions: Option<string>;
+    constructor(Medication: string, Dose: string, Route: string, Frequency: string, Duration: string, Quantity: int32, Refills: int32, Substitution: boolean, Instructions: Option<string>) {
+        super();
+        this.Medication = Medication;
+        this.Dose = Dose;
+        this.Route = Route;
+        this.Frequency = Frequency;
+        this.Duration = Duration;
+        this.Quantity = (Quantity | 0);
+        this.Refills = (Refills | 0);
+        this.Substitution = Substitution;
+        this.Instructions = Instructions;
+    }
+}
+
+export function ClinicalPathway_PrescriptionAction_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.PrescriptionAction", [], ClinicalPathway_PrescriptionAction, () => [["Medication", string_type], ["Dose", string_type], ["Route", string_type], ["Frequency", string_type], ["Duration", string_type], ["Quantity", int32_type], ["Refills", int32_type], ["Substitution", bool_type], ["Instructions", option_type(string_type)]]);
+}
+
+export type ClinicalPathway_FieldValueSource_$union = 
+    | ClinicalPathway_FieldValueSource<0>
+    | ClinicalPathway_FieldValueSource<1>
+    | ClinicalPathway_FieldValueSource<2>
+
+export type ClinicalPathway_FieldValueSource_$cases = {
+    0: ["LiteralValue", [string]],
+    1: ["FieldReference", [Shared_FieldKey]],
+    2: ["OptionKey", [Shared_FieldOptionKey]]
+}
+
+export function ClinicalPathway_FieldValueSource_LiteralValue(Item: string) {
+    return new ClinicalPathway_FieldValueSource<0>(0, [Item]);
+}
+
+export function ClinicalPathway_FieldValueSource_FieldReference(Item: Shared_FieldKey) {
+    return new ClinicalPathway_FieldValueSource<1>(1, [Item]);
+}
+
+export function ClinicalPathway_FieldValueSource_OptionKey(Item: Shared_FieldOptionKey) {
+    return new ClinicalPathway_FieldValueSource<2>(2, [Item]);
+}
+
+export class ClinicalPathway_FieldValueSource<Tag extends keyof ClinicalPathway_FieldValueSource_$cases> extends Union<Tag, ClinicalPathway_FieldValueSource_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_FieldValueSource_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["LiteralValue", "FieldReference", "OptionKey"];
+    }
+}
+
+export function ClinicalPathway_FieldValueSource_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.FieldValueSource", [], ClinicalPathway_FieldValueSource, () => [[["Item", string_type]], [["Item", Shared_FieldKey_$reflection()]], [["Item", Shared_FieldOptionKey_$reflection()]]]);
+}
+
+export class ClinicalPathway_SetFieldValueAction extends Record implements IEquatable<ClinicalPathway_SetFieldValueAction>, IComparable<ClinicalPathway_SetFieldValueAction> {
+    readonly TargetField: Shared_FieldKey;
+    readonly Value: ClinicalPathway_FieldValueSource_$union;
+    readonly Condition: Option<ClinicalPathway_TransitionCondition_$union>;
+    constructor(TargetField: Shared_FieldKey, Value: ClinicalPathway_FieldValueSource_$union, Condition: Option<ClinicalPathway_TransitionCondition_$union>) {
+        super();
+        this.TargetField = TargetField;
+        this.Value = Value;
+        this.Condition = Condition;
+    }
+}
+
+export function ClinicalPathway_SetFieldValueAction_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.SetFieldValueAction", [], ClinicalPathway_SetFieldValueAction, () => [["TargetField", Shared_FieldKey_$reflection()], ["Value", ClinicalPathway_FieldValueSource_$reflection()], ["Condition", option_type(ClinicalPathway_TransitionCondition_$reflection())]]);
+}
+
+export type ClinicalPathway_NavigationType_$union = 
+    | ClinicalPathway_NavigationType<0>
+    | ClinicalPathway_NavigationType<1>
+    | ClinicalPathway_NavigationType<2>
+    | ClinicalPathway_NavigationType<3>
+
+export type ClinicalPathway_NavigationType_$cases = {
+    0: ["OpenInNewTab", []],
+    1: ["ReplaceCurrentForm", []],
+    2: ["OpenAsModal", []],
+    3: ["QueueForLater", []]
+}
+
+export function ClinicalPathway_NavigationType_OpenInNewTab() {
+    return new ClinicalPathway_NavigationType<0>(0, []);
+}
+
+export function ClinicalPathway_NavigationType_ReplaceCurrentForm() {
+    return new ClinicalPathway_NavigationType<1>(1, []);
+}
+
+export function ClinicalPathway_NavigationType_OpenAsModal() {
+    return new ClinicalPathway_NavigationType<2>(2, []);
+}
+
+export function ClinicalPathway_NavigationType_QueueForLater() {
+    return new ClinicalPathway_NavigationType<3>(3, []);
+}
+
+export class ClinicalPathway_NavigationType<Tag extends keyof ClinicalPathway_NavigationType_$cases> extends Union<Tag, ClinicalPathway_NavigationType_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_NavigationType_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["OpenInNewTab", "ReplaceCurrentForm", "OpenAsModal", "QueueForLater"];
+    }
+}
+
+export function ClinicalPathway_NavigationType_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.NavigationType", [], ClinicalPathway_NavigationType, () => [[], [], [], []]);
+}
+
+export class ClinicalPathway_NavigateToFormAction extends Record implements IEquatable<ClinicalPathway_NavigateToFormAction>, IComparable<ClinicalPathway_NavigateToFormAction> {
+    readonly FormId: string;
+    readonly FormCode: Option<string>;
+    readonly NavigationType: ClinicalPathway_NavigationType_$union;
+    readonly PreFillMappings: Option<FSharpMap<Shared_FieldKey, Shared_FieldKey>>;
+    readonly ReturnOnComplete: boolean;
+    readonly Condition: Option<ClinicalPathway_TransitionCondition_$union>;
+    constructor(FormId: string, FormCode: Option<string>, NavigationType: ClinicalPathway_NavigationType_$union, PreFillMappings: Option<FSharpMap<Shared_FieldKey, Shared_FieldKey>>, ReturnOnComplete: boolean, Condition: Option<ClinicalPathway_TransitionCondition_$union>) {
+        super();
+        this.FormId = FormId;
+        this.FormCode = FormCode;
+        this.NavigationType = NavigationType;
+        this.PreFillMappings = PreFillMappings;
+        this.ReturnOnComplete = ReturnOnComplete;
+        this.Condition = Condition;
+    }
+}
+
+export function ClinicalPathway_NavigateToFormAction_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.NavigateToFormAction", [], ClinicalPathway_NavigateToFormAction, () => [["FormId", string_type], ["FormCode", option_type(string_type)], ["NavigationType", ClinicalPathway_NavigationType_$reflection()], ["PreFillMappings", option_type(class_type("Microsoft.FSharp.Collections.FSharpMap`2", [Shared_FieldKey_$reflection(), Shared_FieldKey_$reflection()]))], ["ReturnOnComplete", bool_type], ["Condition", option_type(ClinicalPathway_TransitionCondition_$reflection())]]);
+}
+
+export type ClinicalPathway_ActionInfo_$union = 
+    | ClinicalPathway_ActionInfo<0>
+    | ClinicalPathway_ActionInfo<1>
+    | ClinicalPathway_ActionInfo<2>
+    | ClinicalPathway_ActionInfo<3>
+    | ClinicalPathway_ActionInfo<4>
+    | ClinicalPathway_ActionInfo<5>
+    | ClinicalPathway_ActionInfo<6>
+    | ClinicalPathway_ActionInfo<7>
+    | ClinicalPathway_ActionInfo<8>
+    | ClinicalPathway_ActionInfo<9>
+    | ClinicalPathway_ActionInfo<10>
+    | ClinicalPathway_ActionInfo<11>
+
+export type ClinicalPathway_ActionInfo_$cases = {
+    0: ["Medication", [ClinicalPathway_MedicationAction]],
+    1: ["Test", [ClinicalPathway_TestAction]],
+    2: ["Referral", [ClinicalPathway_ReferralAction]],
+    3: ["Education", [ClinicalPathway_EducationAction]],
+    4: ["Procedure", [ClinicalPathway_ProcedureAction]],
+    5: ["Documentation", [ClinicalPathway_DocumentationAction]],
+    6: ["Task", [ClinicalPathway_TaskAction]],
+    7: ["Alert", [ClinicalPathway_AlertAction]],
+    8: ["Problem", [ClinicalPathway_ProblemAction]],
+    9: ["Prescription", [ClinicalPathway_PrescriptionAction]],
+    10: ["SetFieldValue", [ClinicalPathway_SetFieldValueAction]],
+    11: ["NavigateToForm", [ClinicalPathway_NavigateToFormAction]]
+}
+
+export function ClinicalPathway_ActionInfo_Medication(Item: ClinicalPathway_MedicationAction) {
+    return new ClinicalPathway_ActionInfo<0>(0, [Item]);
+}
+
+export function ClinicalPathway_ActionInfo_Test(Item: ClinicalPathway_TestAction) {
+    return new ClinicalPathway_ActionInfo<1>(1, [Item]);
+}
+
+export function ClinicalPathway_ActionInfo_Referral(Item: ClinicalPathway_ReferralAction) {
+    return new ClinicalPathway_ActionInfo<2>(2, [Item]);
+}
+
+export function ClinicalPathway_ActionInfo_Education(Item: ClinicalPathway_EducationAction) {
+    return new ClinicalPathway_ActionInfo<3>(3, [Item]);
+}
+
+export function ClinicalPathway_ActionInfo_Procedure(Item: ClinicalPathway_ProcedureAction) {
+    return new ClinicalPathway_ActionInfo<4>(4, [Item]);
+}
+
+export function ClinicalPathway_ActionInfo_Documentation(Item: ClinicalPathway_DocumentationAction) {
+    return new ClinicalPathway_ActionInfo<5>(5, [Item]);
+}
+
+export function ClinicalPathway_ActionInfo_Task(Item: ClinicalPathway_TaskAction) {
+    return new ClinicalPathway_ActionInfo<6>(6, [Item]);
+}
+
+export function ClinicalPathway_ActionInfo_Alert(Item: ClinicalPathway_AlertAction) {
+    return new ClinicalPathway_ActionInfo<7>(7, [Item]);
+}
+
+export function ClinicalPathway_ActionInfo_Problem(Item: ClinicalPathway_ProblemAction) {
+    return new ClinicalPathway_ActionInfo<8>(8, [Item]);
+}
+
+export function ClinicalPathway_ActionInfo_Prescription(Item: ClinicalPathway_PrescriptionAction) {
+    return new ClinicalPathway_ActionInfo<9>(9, [Item]);
+}
+
+export function ClinicalPathway_ActionInfo_SetFieldValue(Item: ClinicalPathway_SetFieldValueAction) {
+    return new ClinicalPathway_ActionInfo<10>(10, [Item]);
+}
+
+export function ClinicalPathway_ActionInfo_NavigateToForm(Item: ClinicalPathway_NavigateToFormAction) {
+    return new ClinicalPathway_ActionInfo<11>(11, [Item]);
+}
+
+export class ClinicalPathway_ActionInfo<Tag extends keyof ClinicalPathway_ActionInfo_$cases> extends Union<Tag, ClinicalPathway_ActionInfo_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_ActionInfo_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Medication", "Test", "Referral", "Education", "Procedure", "Documentation", "Task", "Alert", "Problem", "Prescription", "SetFieldValue", "NavigateToForm"];
+    }
+}
+
+export function ClinicalPathway_ActionInfo_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.ActionInfo", [], ClinicalPathway_ActionInfo, () => [[["Item", ClinicalPathway_MedicationAction_$reflection()]], [["Item", ClinicalPathway_TestAction_$reflection()]], [["Item", ClinicalPathway_ReferralAction_$reflection()]], [["Item", ClinicalPathway_EducationAction_$reflection()]], [["Item", ClinicalPathway_ProcedureAction_$reflection()]], [["Item", ClinicalPathway_DocumentationAction_$reflection()]], [["Item", ClinicalPathway_TaskAction_$reflection()]], [["Item", ClinicalPathway_AlertAction_$reflection()]], [["Item", ClinicalPathway_ProblemAction_$reflection()]], [["Item", ClinicalPathway_PrescriptionAction_$reflection()]], [["Item", ClinicalPathway_SetFieldValueAction_$reflection()]], [["Item", ClinicalPathway_NavigateToFormAction_$reflection()]]]);
+}
+
+export class ClinicalPathway_EvaluationInfo extends Record implements IEquatable<ClinicalPathway_EvaluationInfo>, IComparable<ClinicalPathway_EvaluationInfo> {
+    readonly EvaluationName: string;
+    readonly Parameters: FSharpList<[Shared_FieldKey, string, string]>;
+    readonly CriticalFindings: Option<FSharpList<string>>;
+    constructor(EvaluationName: string, Parameters: FSharpList<[Shared_FieldKey, string, string]>, CriticalFindings: Option<FSharpList<string>>) {
+        super();
+        this.EvaluationName = EvaluationName;
+        this.Parameters = Parameters;
+        this.CriticalFindings = CriticalFindings;
+    }
+}
+
+export function ClinicalPathway_EvaluationInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.EvaluationInfo", [], ClinicalPathway_EvaluationInfo, () => [["EvaluationName", string_type], ["Parameters", list_type(tuple_type(Shared_FieldKey_$reflection(), string_type, string_type))], ["CriticalFindings", option_type(list_type(string_type))]]);
+}
+
+export class ClinicalPathway_DecisionInfo extends Record implements IEquatable<ClinicalPathway_DecisionInfo>, IComparable<ClinicalPathway_DecisionInfo> {
+    readonly DecisionKey: string;
+    readonly Question: string;
+    readonly Options: FSharpList<string>;
+    constructor(DecisionKey: string, Question: string, Options: FSharpList<string>) {
+        super();
+        this.DecisionKey = DecisionKey;
+        this.Question = Question;
+        this.Options = Options;
+    }
+}
+
+export function ClinicalPathway_DecisionInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.DecisionInfo", [], ClinicalPathway_DecisionInfo, () => [["DecisionKey", string_type], ["Question", string_type], ["Options", list_type(string_type)]]);
+}
+
+export class ClinicalPathway_TerminalInfo extends Record implements IEquatable<ClinicalPathway_TerminalInfo>, IComparable<ClinicalPathway_TerminalInfo> {
+    readonly TerminalType: string;
+    readonly Outcome: string;
+    readonly Documentation: Option<string>;
+    constructor(TerminalType: string, Outcome: string, Documentation: Option<string>) {
+        super();
+        this.TerminalType = TerminalType;
+        this.Outcome = Outcome;
+        this.Documentation = Documentation;
+    }
+}
+
+export function ClinicalPathway_TerminalInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.TerminalInfo", [], ClinicalPathway_TerminalInfo, () => [["TerminalType", string_type], ["Outcome", string_type], ["Documentation", option_type(string_type)]]);
+}
+
+export type ClinicalPathway_StateType_$union = 
+    | ClinicalPathway_StateType<0>
+    | ClinicalPathway_StateType<1>
+    | ClinicalPathway_StateType<2>
+    | ClinicalPathway_StateType<3>
+    | ClinicalPathway_StateType<4>
+    | ClinicalPathway_StateType<5>
+
+export type ClinicalPathway_StateType_$cases = {
+    0: ["Evaluation", [ClinicalPathway_EvaluationInfo]],
+    1: ["Decision", [ClinicalPathway_DecisionInfo]],
+    2: ["Action", [ClinicalPathway_ActionInfo_$union]],
+    3: ["CompoundAction", [FSharpList<ClinicalPathway_ActionInfo_$union>]],
+    4: ["ConditionalAction", [ClinicalPathway_TransitionCondition_$union, ClinicalPathway_ActionInfo_$union, Option<ClinicalPathway_ActionInfo_$union>]],
+    5: ["Terminal", [ClinicalPathway_TerminalInfo]]
+}
+
+export function ClinicalPathway_StateType_Evaluation(Item: ClinicalPathway_EvaluationInfo) {
+    return new ClinicalPathway_StateType<0>(0, [Item]);
+}
+
+export function ClinicalPathway_StateType_Decision(Item: ClinicalPathway_DecisionInfo) {
+    return new ClinicalPathway_StateType<1>(1, [Item]);
+}
+
+export function ClinicalPathway_StateType_Action(Item: ClinicalPathway_ActionInfo_$union) {
+    return new ClinicalPathway_StateType<2>(2, [Item]);
+}
+
+export function ClinicalPathway_StateType_CompoundAction(Item: FSharpList<ClinicalPathway_ActionInfo_$union>) {
+    return new ClinicalPathway_StateType<3>(3, [Item]);
+}
+
+export function ClinicalPathway_StateType_ConditionalAction(condition: ClinicalPathway_TransitionCondition_$union, thenAction: ClinicalPathway_ActionInfo_$union, elseAction: Option<ClinicalPathway_ActionInfo_$union>) {
+    return new ClinicalPathway_StateType<4>(4, [condition, thenAction, elseAction]);
+}
+
+export function ClinicalPathway_StateType_Terminal(Item: ClinicalPathway_TerminalInfo) {
+    return new ClinicalPathway_StateType<5>(5, [Item]);
+}
+
+export class ClinicalPathway_StateType<Tag extends keyof ClinicalPathway_StateType_$cases> extends Union<Tag, ClinicalPathway_StateType_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_StateType_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Evaluation", "Decision", "Action", "CompoundAction", "ConditionalAction", "Terminal"];
+    }
+}
+
+export function ClinicalPathway_StateType_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.StateType", [], ClinicalPathway_StateType, () => [[["Item", ClinicalPathway_EvaluationInfo_$reflection()]], [["Item", ClinicalPathway_DecisionInfo_$reflection()]], [["Item", ClinicalPathway_ActionInfo_$reflection()]], [["Item", list_type(ClinicalPathway_ActionInfo_$reflection())]], [["condition", ClinicalPathway_TransitionCondition_$reflection()], ["thenAction", ClinicalPathway_ActionInfo_$reflection()], ["elseAction", option_type(ClinicalPathway_ActionInfo_$reflection())]], [["Item", ClinicalPathway_TerminalInfo_$reflection()]]]);
+}
+
+export class ClinicalPathway_StateDefinition extends Record implements IEquatable<ClinicalPathway_StateDefinition>, IComparable<ClinicalPathway_StateDefinition> {
+    readonly StateKey: Shared_StateKey;
+    readonly StateLabel: string;
+    readonly StateOrder: int32;
+    readonly StateType: ClinicalPathway_StateType_$union;
+    readonly DependsOn: Option<ClinicalPathway_StateDependency>;
+    constructor(StateKey: Shared_StateKey, StateLabel: string, StateOrder: int32, StateType: ClinicalPathway_StateType_$union, DependsOn: Option<ClinicalPathway_StateDependency>) {
+        super();
+        this.StateKey = StateKey;
+        this.StateLabel = StateLabel;
+        this.StateOrder = (StateOrder | 0);
+        this.StateType = StateType;
+        this.DependsOn = DependsOn;
+    }
+}
+
+export function ClinicalPathway_StateDefinition_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.StateDefinition", [], ClinicalPathway_StateDefinition, () => [["StateKey", Shared_StateKey_$reflection()], ["StateLabel", string_type], ["StateOrder", int32_type], ["StateType", ClinicalPathway_StateType_$reflection()], ["DependsOn", option_type(ClinicalPathway_StateDependency_$reflection())]]);
+}
+
+export class ClinicalPathway_StateDependency extends Record implements IEquatable<ClinicalPathway_StateDependency>, IComparable<ClinicalPathway_StateDependency> {
+    readonly StateKey: Shared_StateKey;
+    readonly DependencyType: string;
+    constructor(StateKey: Shared_StateKey, DependencyType: string) {
+        super();
+        this.StateKey = StateKey;
+        this.DependencyType = DependencyType;
+    }
+}
+
+export function ClinicalPathway_StateDependency_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.StateDependency", [], ClinicalPathway_StateDependency, () => [["StateKey", Shared_StateKey_$reflection()], ["DependencyType", string_type]]);
+}
+
+export type ClinicalPathway_TransitionCondition_$union = 
+    | ClinicalPathway_TransitionCondition<0>
+    | ClinicalPathway_TransitionCondition<1>
+    | ClinicalPathway_TransitionCondition<2>
+    | ClinicalPathway_TransitionCondition<3>
+    | ClinicalPathway_TransitionCondition<4>
+    | ClinicalPathway_TransitionCondition<5>
+    | ClinicalPathway_TransitionCondition<6>
+
+export type ClinicalPathway_TransitionCondition_$cases = {
+    0: ["FieldCondition", [Shared_FieldKey, ClinicalPathway_FieldEvaluator_$union, Shared_ConditionValue_$union]],
+    1: ["FieldOptionCondition", [Shared_FieldKey, Option<Shared_MatrixItemKey>, Shared_FieldOptionKey, ClinicalPathway_FieldEvaluator_$union, Shared_ConditionValue_$union]],
+    2: ["PluginPropertyCondition", [Shared_FieldKey, Shared_PluginPropertyKey, ClinicalPathway_FieldEvaluator_$union, Shared_ConditionValue_$union]],
+    3: ["StateCondition", [Shared_StateKey, ClinicalPathway_StateEvaluator_$union]],
+    4: ["CompositeCondition", [ClinicalPathway_LogicalOp_$union, FSharpList<ClinicalPathway_TransitionCondition_$union>]],
+    5: ["TestResultCondition", [string, string]],
+    6: ["Always", []]
+}
+
+export function ClinicalPathway_TransitionCondition_FieldCondition(fieldKey: Shared_FieldKey, evaluator: ClinicalPathway_FieldEvaluator_$union, value: Shared_ConditionValue_$union) {
+    return new ClinicalPathway_TransitionCondition<0>(0, [fieldKey, evaluator, value]);
+}
+
+export function ClinicalPathway_TransitionCondition_FieldOptionCondition(fieldKey: Shared_FieldKey, fieldItemKey: Option<Shared_MatrixItemKey>, optionKey: Shared_FieldOptionKey, evaluator: ClinicalPathway_FieldEvaluator_$union, value: Shared_ConditionValue_$union) {
+    return new ClinicalPathway_TransitionCondition<1>(1, [fieldKey, fieldItemKey, optionKey, evaluator, value]);
+}
+
+export function ClinicalPathway_TransitionCondition_PluginPropertyCondition(fieldKey: Shared_FieldKey, propertyKey: Shared_PluginPropertyKey, evaluator: ClinicalPathway_FieldEvaluator_$union, value: Shared_ConditionValue_$union) {
+    return new ClinicalPathway_TransitionCondition<2>(2, [fieldKey, propertyKey, evaluator, value]);
+}
+
+export function ClinicalPathway_TransitionCondition_StateCondition(stateKey: Shared_StateKey, stateEvaluator: ClinicalPathway_StateEvaluator_$union) {
+    return new ClinicalPathway_TransitionCondition<3>(3, [stateKey, stateEvaluator]);
+}
+
+export function ClinicalPathway_TransitionCondition_CompositeCondition(logicalOp: ClinicalPathway_LogicalOp_$union, conditions: FSharpList<ClinicalPathway_TransitionCondition_$union>) {
+    return new ClinicalPathway_TransitionCondition<4>(4, [logicalOp, conditions]);
+}
+
+export function ClinicalPathway_TransitionCondition_TestResultCondition(testName: string, result: string) {
+    return new ClinicalPathway_TransitionCondition<5>(5, [testName, result]);
+}
+
+export function ClinicalPathway_TransitionCondition_Always() {
+    return new ClinicalPathway_TransitionCondition<6>(6, []);
+}
+
+export class ClinicalPathway_TransitionCondition<Tag extends keyof ClinicalPathway_TransitionCondition_$cases> extends Union<Tag, ClinicalPathway_TransitionCondition_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_TransitionCondition_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["FieldCondition", "FieldOptionCondition", "PluginPropertyCondition", "StateCondition", "CompositeCondition", "TestResultCondition", "Always"];
+    }
+}
+
+export function ClinicalPathway_TransitionCondition_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.TransitionCondition", [], ClinicalPathway_TransitionCondition, () => [[["fieldKey", Shared_FieldKey_$reflection()], ["evaluator", ClinicalPathway_FieldEvaluator_$reflection()], ["value", Shared_ConditionValue_$reflection()]], [["fieldKey", Shared_FieldKey_$reflection()], ["fieldItemKey", option_type(Shared_MatrixItemKey_$reflection())], ["optionKey", Shared_FieldOptionKey_$reflection()], ["evaluator", ClinicalPathway_FieldEvaluator_$reflection()], ["value", Shared_ConditionValue_$reflection()]], [["fieldKey", Shared_FieldKey_$reflection()], ["propertyKey", Shared_PluginPropertyKey_$reflection()], ["evaluator", ClinicalPathway_FieldEvaluator_$reflection()], ["value", Shared_ConditionValue_$reflection()]], [["stateKey", Shared_StateKey_$reflection()], ["stateEvaluator", ClinicalPathway_StateEvaluator_$reflection()]], [["logicalOp", ClinicalPathway_LogicalOp_$reflection()], ["conditions", list_type(ClinicalPathway_TransitionCondition_$reflection())]], [["testName", string_type], ["result", string_type]], []]);
+}
+
+export type ClinicalPathway_FieldEvaluator_$union = 
+    | ClinicalPathway_FieldEvaluator<0>
+    | ClinicalPathway_FieldEvaluator<1>
+    | ClinicalPathway_FieldEvaluator<2>
+    | ClinicalPathway_FieldEvaluator<3>
+    | ClinicalPathway_FieldEvaluator<4>
+    | ClinicalPathway_FieldEvaluator<5>
+    | ClinicalPathway_FieldEvaluator<6>
+    | ClinicalPathway_FieldEvaluator<7>
+    | ClinicalPathway_FieldEvaluator<8>
+    | ClinicalPathway_FieldEvaluator<9>
+    | ClinicalPathway_FieldEvaluator<10>
+    | ClinicalPathway_FieldEvaluator<11>
+    | ClinicalPathway_FieldEvaluator<12>
+    | ClinicalPathway_FieldEvaluator<13>
+
+export type ClinicalPathway_FieldEvaluator_$cases = {
+    0: ["Equals", []],
+    1: ["NotEquals", []],
+    2: ["InSet", [FSharpList<string>]],
+    3: ["NotInSet", [FSharpList<string>]],
+    4: ["ContainsAll", [FSharpList<string>]],
+    5: ["GreaterThan", []],
+    6: ["GreaterOrEqual", []],
+    7: ["LessThan", []],
+    8: ["LessOrEqual", []],
+    9: ["Contains", []],
+    10: ["IsPresent", []],
+    11: ["IsAbsent", []],
+    12: ["MatchesPattern", [string]],
+    13: ["InRange", [int32, int32]]
+}
+
+export function ClinicalPathway_FieldEvaluator_Equals() {
+    return new ClinicalPathway_FieldEvaluator<0>(0, []);
+}
+
+export function ClinicalPathway_FieldEvaluator_NotEquals() {
+    return new ClinicalPathway_FieldEvaluator<1>(1, []);
+}
+
+export function ClinicalPathway_FieldEvaluator_InSet(values: FSharpList<string>) {
+    return new ClinicalPathway_FieldEvaluator<2>(2, [values]);
+}
+
+export function ClinicalPathway_FieldEvaluator_NotInSet(values: FSharpList<string>) {
+    return new ClinicalPathway_FieldEvaluator<3>(3, [values]);
+}
+
+export function ClinicalPathway_FieldEvaluator_ContainsAll(values: FSharpList<string>) {
+    return new ClinicalPathway_FieldEvaluator<4>(4, [values]);
+}
+
+export function ClinicalPathway_FieldEvaluator_GreaterThan() {
+    return new ClinicalPathway_FieldEvaluator<5>(5, []);
+}
+
+export function ClinicalPathway_FieldEvaluator_GreaterOrEqual() {
+    return new ClinicalPathway_FieldEvaluator<6>(6, []);
+}
+
+export function ClinicalPathway_FieldEvaluator_LessThan() {
+    return new ClinicalPathway_FieldEvaluator<7>(7, []);
+}
+
+export function ClinicalPathway_FieldEvaluator_LessOrEqual() {
+    return new ClinicalPathway_FieldEvaluator<8>(8, []);
+}
+
+export function ClinicalPathway_FieldEvaluator_Contains() {
+    return new ClinicalPathway_FieldEvaluator<9>(9, []);
+}
+
+export function ClinicalPathway_FieldEvaluator_IsPresent() {
+    return new ClinicalPathway_FieldEvaluator<10>(10, []);
+}
+
+export function ClinicalPathway_FieldEvaluator_IsAbsent() {
+    return new ClinicalPathway_FieldEvaluator<11>(11, []);
+}
+
+export function ClinicalPathway_FieldEvaluator_MatchesPattern(pattern: string) {
+    return new ClinicalPathway_FieldEvaluator<12>(12, [pattern]);
+}
+
+export function ClinicalPathway_FieldEvaluator_InRange(min: int32, max: int32) {
+    return new ClinicalPathway_FieldEvaluator<13>(13, [min, max]);
+}
+
+export class ClinicalPathway_FieldEvaluator<Tag extends keyof ClinicalPathway_FieldEvaluator_$cases> extends Union<Tag, ClinicalPathway_FieldEvaluator_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_FieldEvaluator_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Equals", "NotEquals", "InSet", "NotInSet", "ContainsAll", "GreaterThan", "GreaterOrEqual", "LessThan", "LessOrEqual", "Contains", "IsPresent", "IsAbsent", "MatchesPattern", "InRange"];
+    }
+}
+
+export function ClinicalPathway_FieldEvaluator_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.FieldEvaluator", [], ClinicalPathway_FieldEvaluator, () => [[], [], [["values", list_type(string_type)]], [["values", list_type(string_type)]], [["values", list_type(string_type)]], [], [], [], [], [], [], [], [["pattern", string_type]], [["min", int32_type], ["max", int32_type]]]);
+}
+
+export type ClinicalPathway_StateEvaluator_$union = 
+    | ClinicalPathway_StateEvaluator<0>
+    | ClinicalPathway_StateEvaluator<1>
+    | ClinicalPathway_StateEvaluator<2>
+    | ClinicalPathway_StateEvaluator<3>
+
+export type ClinicalPathway_StateEvaluator_$cases = {
+    0: ["Completed", []],
+    1: ["HasValue", []],
+    2: ["HasError", []],
+    3: ["WasSkipped", []]
+}
+
+export function ClinicalPathway_StateEvaluator_Completed() {
+    return new ClinicalPathway_StateEvaluator<0>(0, []);
+}
+
+export function ClinicalPathway_StateEvaluator_HasValue() {
+    return new ClinicalPathway_StateEvaluator<1>(1, []);
+}
+
+export function ClinicalPathway_StateEvaluator_HasError() {
+    return new ClinicalPathway_StateEvaluator<2>(2, []);
+}
+
+export function ClinicalPathway_StateEvaluator_WasSkipped() {
+    return new ClinicalPathway_StateEvaluator<3>(3, []);
+}
+
+export class ClinicalPathway_StateEvaluator<Tag extends keyof ClinicalPathway_StateEvaluator_$cases> extends Union<Tag, ClinicalPathway_StateEvaluator_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_StateEvaluator_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Completed", "HasValue", "HasError", "WasSkipped"];
+    }
+}
+
+export function ClinicalPathway_StateEvaluator_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.StateEvaluator", [], ClinicalPathway_StateEvaluator, () => [[], [], [], []]);
+}
+
+export type ClinicalPathway_LogicalOp_$union = 
+    | ClinicalPathway_LogicalOp<0>
+    | ClinicalPathway_LogicalOp<1>
+    | ClinicalPathway_LogicalOp<2>
+
+export type ClinicalPathway_LogicalOp_$cases = {
+    0: ["And", []],
+    1: ["Or", []],
+    2: ["Not", []]
+}
+
+export function ClinicalPathway_LogicalOp_And() {
+    return new ClinicalPathway_LogicalOp<0>(0, []);
+}
+
+export function ClinicalPathway_LogicalOp_Or() {
+    return new ClinicalPathway_LogicalOp<1>(1, []);
+}
+
+export function ClinicalPathway_LogicalOp_Not() {
+    return new ClinicalPathway_LogicalOp<2>(2, []);
+}
+
+export class ClinicalPathway_LogicalOp<Tag extends keyof ClinicalPathway_LogicalOp_$cases> extends Union<Tag, ClinicalPathway_LogicalOp_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_LogicalOp_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["And", "Or", "Not"];
+    }
+}
+
+export function ClinicalPathway_LogicalOp_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.LogicalOp", [], ClinicalPathway_LogicalOp, () => [[], [], []]);
+}
+
+export class ClinicalPathway_TransitionDefinition extends Record implements IEquatable<ClinicalPathway_TransitionDefinition>, IComparable<ClinicalPathway_TransitionDefinition> {
+    readonly TransitionKey: Shared_TransitionKey;
+    readonly FromState: Shared_StateKey;
+    readonly ToState: Shared_StateKey;
+    readonly Condition: ClinicalPathway_TransitionCondition_$union;
+    readonly Priority: Option<int32>;
+    constructor(TransitionKey: Shared_TransitionKey, FromState: Shared_StateKey, ToState: Shared_StateKey, Condition: ClinicalPathway_TransitionCondition_$union, Priority: Option<int32>) {
+        super();
+        this.TransitionKey = TransitionKey;
+        this.FromState = FromState;
+        this.ToState = ToState;
+        this.Condition = Condition;
+        this.Priority = Priority;
+    }
+}
+
+export function ClinicalPathway_TransitionDefinition_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.TransitionDefinition", [], ClinicalPathway_TransitionDefinition, () => [["TransitionKey", Shared_TransitionKey_$reflection()], ["FromState", Shared_StateKey_$reflection()], ["ToState", Shared_StateKey_$reflection()], ["Condition", ClinicalPathway_TransitionCondition_$reflection()], ["Priority", option_type(int32_type)]]);
+}
+
+export type ClinicalPathway_ConstraintType_$union = 
+    | ClinicalPathway_ConstraintType<0>
+    | ClinicalPathway_ConstraintType<1>
+    | ClinicalPathway_ConstraintType<2>
+    | ClinicalPathway_ConstraintType<3>
+
+export type ClinicalPathway_ConstraintType_$cases = {
+    0: ["VitalSignThreshold", [string, Option<float64>, Option<float64>]],
+    1: ["MedicationContraindication", [string, FSharpList<string>]],
+    2: ["TimeConstraint", [number]],
+    3: ["RequiredField", [Shared_FieldKey]]
+}
+
+export function ClinicalPathway_ConstraintType_VitalSignThreshold(parameter: string, min: Option<float64>, max: Option<float64>) {
+    return new ClinicalPathway_ConstraintType<0>(0, [parameter, min, max]);
+}
+
+export function ClinicalPathway_ConstraintType_MedicationContraindication(medication: string, conditions: FSharpList<string>) {
+    return new ClinicalPathway_ConstraintType<1>(1, [medication, conditions]);
+}
+
+export function ClinicalPathway_ConstraintType_TimeConstraint(maxDuration: number) {
+    return new ClinicalPathway_ConstraintType<2>(2, [maxDuration]);
+}
+
+export function ClinicalPathway_ConstraintType_RequiredField(fieldKey: Shared_FieldKey) {
+    return new ClinicalPathway_ConstraintType<3>(3, [fieldKey]);
+}
+
+export class ClinicalPathway_ConstraintType<Tag extends keyof ClinicalPathway_ConstraintType_$cases> extends Union<Tag, ClinicalPathway_ConstraintType_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_ConstraintType_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["VitalSignThreshold", "MedicationContraindication", "TimeConstraint", "RequiredField"];
+    }
+}
+
+export function ClinicalPathway_ConstraintType_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.ConstraintType", [], ClinicalPathway_ConstraintType, () => [[["parameter", string_type], ["min", option_type(float64_type)], ["max", option_type(float64_type)]], [["medication", string_type], ["conditions", list_type(string_type)]], [["maxDuration", class_type("System.TimeSpan")]], [["fieldKey", Shared_FieldKey_$reflection()]]]);
+}
+
+export class ClinicalPathway_ConstraintDefinition extends Record implements IEquatable<ClinicalPathway_ConstraintDefinition>, IComparable<ClinicalPathway_ConstraintDefinition> {
+    readonly ConstraintKey: string;
+    readonly AppliesTo: FSharpList<Shared_StateKey>;
+    readonly ConstraintType: ClinicalPathway_ConstraintType_$union;
+    readonly Severity: string;
+    constructor(ConstraintKey: string, AppliesTo: FSharpList<Shared_StateKey>, ConstraintType: ClinicalPathway_ConstraintType_$union, Severity: string) {
+        super();
+        this.ConstraintKey = ConstraintKey;
+        this.AppliesTo = AppliesTo;
+        this.ConstraintType = ConstraintType;
+        this.Severity = Severity;
+    }
+}
+
+export function ClinicalPathway_ConstraintDefinition_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.ConstraintDefinition", [], ClinicalPathway_ConstraintDefinition, () => [["ConstraintKey", string_type], ["AppliesTo", list_type(Shared_StateKey_$reflection())], ["ConstraintType", ClinicalPathway_ConstraintType_$reflection()], ["Severity", string_type]]);
+}
+
+export class ClinicalPathway_PathRequirement extends Record implements IEquatable<ClinicalPathway_PathRequirement>, IComparable<ClinicalPathway_PathRequirement> {
+    readonly RequirementKey: string;
+    readonly Description: string;
+    readonly MustVisitStates: FSharpList<Shared_StateKey>;
+    readonly MustAvoidStates: Option<FSharpList<Shared_StateKey>>;
+    readonly ValidationRule: Option<string>;
+    constructor(RequirementKey: string, Description: string, MustVisitStates: FSharpList<Shared_StateKey>, MustAvoidStates: Option<FSharpList<Shared_StateKey>>, ValidationRule: Option<string>) {
+        super();
+        this.RequirementKey = RequirementKey;
+        this.Description = Description;
+        this.MustVisitStates = MustVisitStates;
+        this.MustAvoidStates = MustAvoidStates;
+        this.ValidationRule = ValidationRule;
+    }
+}
+
+export function ClinicalPathway_PathRequirement_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.PathRequirement", [], ClinicalPathway_PathRequirement, () => [["RequirementKey", string_type], ["Description", string_type], ["MustVisitStates", list_type(Shared_StateKey_$reflection())], ["MustAvoidStates", option_type(list_type(Shared_StateKey_$reflection()))], ["ValidationRule", option_type(string_type)]]);
+}
+
+export type ClinicalPathway_SelectionStrategy_$union = 
+    | ClinicalPathway_SelectionStrategy<0>
+    | ClinicalPathway_SelectionStrategy<1>
+    | ClinicalPathway_SelectionStrategy<2>
+
+export type ClinicalPathway_SelectionStrategy_$cases = {
+    0: ["HighestPriority", []],
+    1: ["MostSpecific", []],
+    2: ["ClinicalSeverity", []]
+}
+
+export function ClinicalPathway_SelectionStrategy_HighestPriority() {
+    return new ClinicalPathway_SelectionStrategy<0>(0, []);
+}
+
+export function ClinicalPathway_SelectionStrategy_MostSpecific() {
+    return new ClinicalPathway_SelectionStrategy<1>(1, []);
+}
+
+export function ClinicalPathway_SelectionStrategy_ClinicalSeverity() {
+    return new ClinicalPathway_SelectionStrategy<2>(2, []);
+}
+
+export class ClinicalPathway_SelectionStrategy<Tag extends keyof ClinicalPathway_SelectionStrategy_$cases> extends Union<Tag, ClinicalPathway_SelectionStrategy_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_SelectionStrategy_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["HighestPriority", "MostSpecific", "ClinicalSeverity"];
+    }
+}
+
+export function ClinicalPathway_SelectionStrategy_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.SelectionStrategy", [], ClinicalPathway_SelectionStrategy, () => [[], [], []]);
+}
+
+export type ClinicalPathway_CombinationStrategy_$union = 
+    | ClinicalPathway_CombinationStrategy<0>
+    | ClinicalPathway_CombinationStrategy<1>
+    | ClinicalPathway_CombinationStrategy<2>
+
+export type ClinicalPathway_CombinationStrategy_$cases = {
+    0: ["AllMatching", []],
+    1: ["NonConflicting", []],
+    2: ["Complementary", []]
+}
+
+export function ClinicalPathway_CombinationStrategy_AllMatching() {
+    return new ClinicalPathway_CombinationStrategy<0>(0, []);
+}
+
+export function ClinicalPathway_CombinationStrategy_NonConflicting() {
+    return new ClinicalPathway_CombinationStrategy<1>(1, []);
+}
+
+export function ClinicalPathway_CombinationStrategy_Complementary() {
+    return new ClinicalPathway_CombinationStrategy<2>(2, []);
+}
+
+export class ClinicalPathway_CombinationStrategy<Tag extends keyof ClinicalPathway_CombinationStrategy_$cases> extends Union<Tag, ClinicalPathway_CombinationStrategy_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_CombinationStrategy_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["AllMatching", "NonConflicting", "Complementary"];
+    }
+}
+
+export function ClinicalPathway_CombinationStrategy_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.CombinationStrategy", [], ClinicalPathway_CombinationStrategy, () => [[], [], []]);
+}
+
+export type ClinicalPathway_ConflictResolution_$union = 
+    | ClinicalPathway_ConflictResolution<0>
+    | ClinicalPathway_ConflictResolution<1>
+    | ClinicalPathway_ConflictResolution<2>
+
+export type ClinicalPathway_ConflictResolution_$cases = {
+    0: ["CombineActions", []],
+    1: ["PreferHigherPriority", []],
+    2: ["RequireManualReview", []]
+}
+
+export function ClinicalPathway_ConflictResolution_CombineActions() {
+    return new ClinicalPathway_ConflictResolution<0>(0, []);
+}
+
+export function ClinicalPathway_ConflictResolution_PreferHigherPriority() {
+    return new ClinicalPathway_ConflictResolution<1>(1, []);
+}
+
+export function ClinicalPathway_ConflictResolution_RequireManualReview() {
+    return new ClinicalPathway_ConflictResolution<2>(2, []);
+}
+
+export class ClinicalPathway_ConflictResolution<Tag extends keyof ClinicalPathway_ConflictResolution_$cases> extends Union<Tag, ClinicalPathway_ConflictResolution_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_ConflictResolution_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["CombineActions", "PreferHigherPriority", "RequireManualReview"];
+    }
+}
+
+export function ClinicalPathway_ConflictResolution_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.ConflictResolution", [], ClinicalPathway_ConflictResolution, () => [[], [], []]);
+}
+
+export class ClinicalPathway_SinglePathwayConfig extends Record implements IEquatable<ClinicalPathway_SinglePathwayConfig>, IComparable<ClinicalPathway_SinglePathwayConfig> {
+    readonly SelectionStrategy: ClinicalPathway_SelectionStrategy_$union;
+    readonly RequiresFullEvaluation: boolean;
+    constructor(SelectionStrategy: ClinicalPathway_SelectionStrategy_$union, RequiresFullEvaluation: boolean) {
+        super();
+        this.SelectionStrategy = SelectionStrategy;
+        this.RequiresFullEvaluation = RequiresFullEvaluation;
+    }
+}
+
+export function ClinicalPathway_SinglePathwayConfig_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.SinglePathwayConfig", [], ClinicalPathway_SinglePathwayConfig, () => [["SelectionStrategy", ClinicalPathway_SelectionStrategy_$reflection()], ["RequiresFullEvaluation", bool_type]]);
+}
+
+export class ClinicalPathway_MultiPathwayConfig extends Record implements IEquatable<ClinicalPathway_MultiPathwayConfig>, IComparable<ClinicalPathway_MultiPathwayConfig> {
+    readonly CombinationStrategy: ClinicalPathway_CombinationStrategy_$union;
+    readonly ConflictResolution: ClinicalPathway_ConflictResolution_$union;
+    readonly MaxSelections: Option<int32>;
+    constructor(CombinationStrategy: ClinicalPathway_CombinationStrategy_$union, ConflictResolution: ClinicalPathway_ConflictResolution_$union, MaxSelections: Option<int32>) {
+        super();
+        this.CombinationStrategy = CombinationStrategy;
+        this.ConflictResolution = ConflictResolution;
+        this.MaxSelections = MaxSelections;
+    }
+}
+
+export function ClinicalPathway_MultiPathwayConfig_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.MultiPathwayConfig", [], ClinicalPathway_MultiPathwayConfig, () => [["CombinationStrategy", ClinicalPathway_CombinationStrategy_$reflection()], ["ConflictResolution", ClinicalPathway_ConflictResolution_$reflection()], ["MaxSelections", option_type(int32_type)]]);
+}
+
+export type ClinicalPathway_PathwayExecutionMode_$union = 
+    | ClinicalPathway_PathwayExecutionMode<0>
+    | ClinicalPathway_PathwayExecutionMode<1>
+    | ClinicalPathway_PathwayExecutionMode<2>
+
+export type ClinicalPathway_PathwayExecutionMode_$cases = {
+    0: ["SinglePathway", [ClinicalPathway_SinglePathwayConfig]],
+    1: ["MultiPathway", [ClinicalPathway_MultiPathwayConfig]],
+    2: ["TriggerBased", [ClinicalPathway_TriggerBasedConfig]]
+}
+
+export function ClinicalPathway_PathwayExecutionMode_SinglePathway(Item: ClinicalPathway_SinglePathwayConfig) {
+    return new ClinicalPathway_PathwayExecutionMode<0>(0, [Item]);
+}
+
+export function ClinicalPathway_PathwayExecutionMode_MultiPathway(Item: ClinicalPathway_MultiPathwayConfig) {
+    return new ClinicalPathway_PathwayExecutionMode<1>(1, [Item]);
+}
+
+export function ClinicalPathway_PathwayExecutionMode_TriggerBased(Item: ClinicalPathway_TriggerBasedConfig) {
+    return new ClinicalPathway_PathwayExecutionMode<2>(2, [Item]);
+}
+
+export class ClinicalPathway_PathwayExecutionMode<Tag extends keyof ClinicalPathway_PathwayExecutionMode_$cases> extends Union<Tag, ClinicalPathway_PathwayExecutionMode_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_PathwayExecutionMode_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["SinglePathway", "MultiPathway", "TriggerBased"];
+    }
+}
+
+export function ClinicalPathway_PathwayExecutionMode_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.PathwayExecutionMode", [], ClinicalPathway_PathwayExecutionMode, () => [[["Item", ClinicalPathway_SinglePathwayConfig_$reflection()]], [["Item", ClinicalPathway_MultiPathwayConfig_$reflection()]], [["Item", ClinicalPathway_TriggerBasedConfig_$reflection()]]]);
+}
+
+export type ClinicalPathway_TriggerTiming_$union = 
+    | ClinicalPathway_TriggerTiming<0>
+    | ClinicalPathway_TriggerTiming<1>
+    | ClinicalPathway_TriggerTiming<2>
+    | ClinicalPathway_TriggerTiming<3>
+
+export type ClinicalPathway_TriggerTiming_$cases = {
+    0: ["OnFormSave", []],
+    1: ["OnFormLoad", []],
+    2: ["OnFormSubmit", []],
+    3: ["OnFieldChange", [Shared_FieldKey]]
+}
+
+export function ClinicalPathway_TriggerTiming_OnFormSave() {
+    return new ClinicalPathway_TriggerTiming<0>(0, []);
+}
+
+export function ClinicalPathway_TriggerTiming_OnFormLoad() {
+    return new ClinicalPathway_TriggerTiming<1>(1, []);
+}
+
+export function ClinicalPathway_TriggerTiming_OnFormSubmit() {
+    return new ClinicalPathway_TriggerTiming<2>(2, []);
+}
+
+export function ClinicalPathway_TriggerTiming_OnFieldChange(Item: Shared_FieldKey) {
+    return new ClinicalPathway_TriggerTiming<3>(3, [Item]);
+}
+
+export class ClinicalPathway_TriggerTiming<Tag extends keyof ClinicalPathway_TriggerTiming_$cases> extends Union<Tag, ClinicalPathway_TriggerTiming_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ClinicalPathway_TriggerTiming_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["OnFormSave", "OnFormLoad", "OnFormSubmit", "OnFieldChange"];
+    }
+}
+
+export function ClinicalPathway_TriggerTiming_$reflection(): TypeInfo {
+    return union_type("F1.Studio.ClinicalPathway.TriggerTiming", [], ClinicalPathway_TriggerTiming, () => [[], [], [], [["Item", Shared_FieldKey_$reflection()]]]);
+}
+
+export class ClinicalPathway_TriggerBasedConfig extends Record implements IEquatable<ClinicalPathway_TriggerBasedConfig>, IComparable<ClinicalPathway_TriggerBasedConfig> {
+    readonly Timing: ClinicalPathway_TriggerTiming_$union;
+    readonly AutoExecute: boolean;
+    constructor(Timing: ClinicalPathway_TriggerTiming_$union, AutoExecute: boolean) {
+        super();
+        this.Timing = Timing;
+        this.AutoExecute = AutoExecute;
+    }
+}
+
+export function ClinicalPathway_TriggerBasedConfig_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.TriggerBasedConfig", [], ClinicalPathway_TriggerBasedConfig, () => [["Timing", ClinicalPathway_TriggerTiming_$reflection()], ["AutoExecute", bool_type]]);
+}
+
+export class ClinicalPathway_ClinicalPathwaySpec extends Record implements IEquatable<ClinicalPathway_ClinicalPathwaySpec>, IComparable<ClinicalPathway_ClinicalPathwaySpec> {
+    readonly PathwayId: string;
+    readonly PathwayName: string;
+    readonly Version: string;
+    readonly ProtocolSource: string;
+    readonly ExecutionMode: ClinicalPathway_PathwayExecutionMode_$union;
+    readonly InitialState: Option<Shared_StateKey>;
+    readonly States: FSharpList<ClinicalPathway_StateDefinition>;
+    readonly Transitions: FSharpList<ClinicalPathway_TransitionDefinition>;
+    readonly Constraints: FSharpList<ClinicalPathway_ConstraintDefinition>;
+    readonly RequiredPaths: FSharpList<ClinicalPathway_PathRequirement>;
+    readonly CreatedDate: Date;
+    readonly ValidatedBy: Option<string>;
+    readonly ValidationDate: Option<Date>;
+    readonly ConfidenceScore: Option<float64>;
+    constructor(PathwayId: string, PathwayName: string, Version: string, ProtocolSource: string, ExecutionMode: ClinicalPathway_PathwayExecutionMode_$union, InitialState: Option<Shared_StateKey>, States: FSharpList<ClinicalPathway_StateDefinition>, Transitions: FSharpList<ClinicalPathway_TransitionDefinition>, Constraints: FSharpList<ClinicalPathway_ConstraintDefinition>, RequiredPaths: FSharpList<ClinicalPathway_PathRequirement>, CreatedDate: Date, ValidatedBy: Option<string>, ValidationDate: Option<Date>, ConfidenceScore: Option<float64>) {
+        super();
+        this.PathwayId = PathwayId;
+        this.PathwayName = PathwayName;
+        this.Version = Version;
+        this.ProtocolSource = ProtocolSource;
+        this.ExecutionMode = ExecutionMode;
+        this.InitialState = InitialState;
+        this.States = States;
+        this.Transitions = Transitions;
+        this.Constraints = Constraints;
+        this.RequiredPaths = RequiredPaths;
+        this.CreatedDate = CreatedDate;
+        this.ValidatedBy = ValidatedBy;
+        this.ValidationDate = ValidationDate;
+        this.ConfidenceScore = ConfidenceScore;
+    }
+}
+
+export function ClinicalPathway_ClinicalPathwaySpec_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.ClinicalPathwaySpec", [], ClinicalPathway_ClinicalPathwaySpec, () => [["PathwayId", string_type], ["PathwayName", string_type], ["Version", string_type], ["ProtocolSource", string_type], ["ExecutionMode", ClinicalPathway_PathwayExecutionMode_$reflection()], ["InitialState", option_type(Shared_StateKey_$reflection())], ["States", list_type(ClinicalPathway_StateDefinition_$reflection())], ["Transitions", list_type(ClinicalPathway_TransitionDefinition_$reflection())], ["Constraints", list_type(ClinicalPathway_ConstraintDefinition_$reflection())], ["RequiredPaths", list_type(ClinicalPathway_PathRequirement_$reflection())], ["CreatedDate", class_type("System.DateTimeOffset")], ["ValidatedBy", option_type(string_type)], ["ValidationDate", option_type(class_type("System.DateTimeOffset"))], ["ConfidenceScore", option_type(float64_type)]]);
+}
+
+export class ClinicalPathway_PathExecutionContext extends Record implements IEquatable<ClinicalPathway_PathExecutionContext> {
+    readonly PathwayId: string;
+    readonly CurrentState: Shared_StateKey;
+    readonly VisitedStates: FSharpList<Shared_StateKey>;
+    readonly CollectedData: FSharpMap<Shared_FieldKey, any>;
+    readonly TestResults: FSharpMap<string, string>;
+    readonly CompletedActions: FSharpList<ClinicalPathway_ActionInfo_$union>;
+    readonly Timestamp: Date;
+    constructor(PathwayId: string, CurrentState: Shared_StateKey, VisitedStates: FSharpList<Shared_StateKey>, CollectedData: FSharpMap<Shared_FieldKey, any>, TestResults: FSharpMap<string, string>, CompletedActions: FSharpList<ClinicalPathway_ActionInfo_$union>, Timestamp: Date) {
+        super();
+        this.PathwayId = PathwayId;
+        this.CurrentState = CurrentState;
+        this.VisitedStates = VisitedStates;
+        this.CollectedData = CollectedData;
+        this.TestResults = TestResults;
+        this.CompletedActions = CompletedActions;
+        this.Timestamp = Timestamp;
+    }
+}
+
+export function ClinicalPathway_PathExecutionContext_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.PathExecutionContext", [], ClinicalPathway_PathExecutionContext, () => [["PathwayId", string_type], ["CurrentState", Shared_StateKey_$reflection()], ["VisitedStates", list_type(Shared_StateKey_$reflection())], ["CollectedData", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [Shared_FieldKey_$reflection(), obj_type])], ["TestResults", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, string_type])], ["CompletedActions", list_type(ClinicalPathway_ActionInfo_$reflection())], ["Timestamp", class_type("System.DateTime")]]);
+}
+
+export class ClinicalPathway_ValidationIssue extends Record implements IEquatable<ClinicalPathway_ValidationIssue>, IComparable<ClinicalPathway_ValidationIssue> {
+    readonly IssueType: string;
+    readonly Severity: string;
+    readonly Location: string;
+    readonly Description: string;
+    constructor(IssueType: string, Severity: string, Location: string, Description: string) {
+        super();
+        this.IssueType = IssueType;
+        this.Severity = Severity;
+        this.Location = Location;
+        this.Description = Description;
+    }
+}
+
+export function ClinicalPathway_ValidationIssue_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.ValidationIssue", [], ClinicalPathway_ValidationIssue, () => [["IssueType", string_type], ["Severity", string_type], ["Location", string_type], ["Description", string_type]]);
+}
+
+export class ClinicalPathway_PathwayValidationResult extends Record implements IEquatable<ClinicalPathway_PathwayValidationResult>, IComparable<ClinicalPathway_PathwayValidationResult> {
+    readonly IsValid: boolean;
+    readonly Issues: FSharpList<ClinicalPathway_ValidationIssue>;
+    readonly Coverage: float64;
+    readonly CompileStatus: string;
+    constructor(IsValid: boolean, Issues: FSharpList<ClinicalPathway_ValidationIssue>, Coverage: float64, CompileStatus: string) {
+        super();
+        this.IsValid = IsValid;
+        this.Issues = Issues;
+        this.Coverage = Coverage;
+        this.CompileStatus = CompileStatus;
+    }
+}
+
+export function ClinicalPathway_PathwayValidationResult_$reflection(): TypeInfo {
+    return record_type("F1.Studio.ClinicalPathway.PathwayValidationResult", [], ClinicalPathway_PathwayValidationResult, () => [["IsValid", bool_type], ["Issues", list_type(ClinicalPathway_ValidationIssue_$reflection())], ["Coverage", float64_type], ["CompileStatus", string_type]]);
+}
+
+export class Values_StepOrder extends Union<0, "StepOrder"> {
+    constructor(Item: int32) {
+        super();
+        this.tag = 0;
+        this.fields = [Item];
+    }
+    readonly tag: 0;
+    readonly fields: [int32];
+    cases() {
+        return ["StepOrder"];
+    }
+}
+
+export function Values_StepOrder_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Values.StepOrder", [], Values_StepOrder, () => [[["Item", int32_type]]]);
+}
+
+export class Values_FieldDetails$1<FieldType> extends Record implements IEquatable<Values_FieldDetails$1<FieldType>>, IComparable<Values_FieldDetails$1<FieldType>> {
+    readonly FieldOrder: int32;
+    readonly Key: Shared_FieldKey;
+    readonly Label: string;
+    readonly FieldValue: Shared_FieldValue_$union;
+    readonly FieldType: FieldType;
+    readonly Options: FSharpList<Shared_FieldOption>;
+    constructor(FieldOrder: int32, Key: Shared_FieldKey, Label: string, FieldValue: Shared_FieldValue_$union, FieldType: FieldType, Options: FSharpList<Shared_FieldOption>) {
+        super();
+        this.FieldOrder = (FieldOrder | 0);
+        this.Key = Key;
+        this.Label = Label;
+        this.FieldValue = FieldValue;
+        this.FieldType = FieldType;
+        this.Options = Options;
+    }
+}
+
+export function Values_FieldDetails$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return record_type("F1.Studio.Values.FieldDetails`1", [gen0], Values_FieldDetails$1, () => [["FieldOrder", int32_type], ["Key", Shared_FieldKey_$reflection()], ["Label", string_type], ["FieldValue", Shared_FieldValue_$reflection()], ["FieldType", gen0], ["Options", list_type(Shared_FieldOption_$reflection())]]);
+}
+
+export type Values_FormStatus_$union = 
+    | Values_FormStatus<0>
+    | Values_FormStatus<1>
+    | Values_FormStatus<2>
+    | Values_FormStatus<3>
+    | Values_FormStatus<4>
+
+export type Values_FormStatus_$cases = {
+    0: ["Pending", []],
+    1: ["Draft", [string]],
+    2: ["WaitingForReview", []],
+    3: ["WaitingForApproval", []],
+    4: ["Complete", []]
+}
+
+export function Values_FormStatus_Pending() {
+    return new Values_FormStatus<0>(0, []);
+}
+
+export function Values_FormStatus_Draft(Item: string) {
+    return new Values_FormStatus<1>(1, [Item]);
+}
+
+export function Values_FormStatus_WaitingForReview() {
+    return new Values_FormStatus<2>(2, []);
+}
+
+export function Values_FormStatus_WaitingForApproval() {
+    return new Values_FormStatus<3>(3, []);
+}
+
+export function Values_FormStatus_Complete() {
+    return new Values_FormStatus<4>(4, []);
+}
+
+export class Values_FormStatus<Tag extends keyof Values_FormStatus_$cases> extends Union<Tag, Values_FormStatus_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: Values_FormStatus_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Pending", "Draft", "WaitingForReview", "WaitingForApproval", "Complete"];
+    }
+}
+
+export function Values_FormStatus_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Values.FormStatus", [], Values_FormStatus, () => [[], [["Item", class_type("System.Guid")]], [], [], []]);
+}
+
+export type Values_SignatureType_$union = 
+    | Values_SignatureType<0>
+    | Values_SignatureType<1>
+
+export type Values_SignatureType_$cases = {
+    0: ["Review", []],
+    1: ["Approval", []]
+}
+
+export function Values_SignatureType_Review() {
+    return new Values_SignatureType<0>(0, []);
+}
+
+export function Values_SignatureType_Approval() {
+    return new Values_SignatureType<1>(1, []);
+}
+
+export class Values_SignatureType<Tag extends keyof Values_SignatureType_$cases> extends Union<Tag, Values_SignatureType_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: Values_SignatureType_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Review", "Approval"];
+    }
+}
+
+export function Values_SignatureType_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Values.SignatureType", [], Values_SignatureType, () => [[], []]);
+}
+
+export class Values_Signature extends Record implements IEquatable<Values_Signature>, IComparable<Values_Signature> {
+    readonly ApprovedById: string;
+    readonly ApprovedByFullName: string;
+    readonly ApprovedByDate: Date;
+    readonly ApprovalSignature: string;
+    readonly SignatureType: Values_SignatureType_$union;
+    constructor(ApprovedById: string, ApprovedByFullName: string, ApprovedByDate: Date, ApprovalSignature: string, SignatureType: Values_SignatureType_$union) {
+        super();
+        this.ApprovedById = ApprovedById;
+        this.ApprovedByFullName = ApprovedByFullName;
+        this.ApprovedByDate = ApprovedByDate;
+        this.ApprovalSignature = ApprovalSignature;
+        this.SignatureType = SignatureType;
+    }
+}
+
+export function Values_Signature_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Values.Signature", [], Values_Signature, () => [["ApprovedById", class_type("System.Guid")], ["ApprovedByFullName", string_type], ["ApprovedByDate", class_type("System.DateTime")], ["ApprovalSignature", string_type], ["SignatureType", Values_SignatureType_$reflection()]]);
+}
+
+export class Values_DynamicFormSpecDetails extends Record implements IEquatable<Values_DynamicFormSpecDetails>, IComparable<Values_DynamicFormSpecDetails> {
+    readonly FormSpecId: string;
+    readonly FormSpecCode: Option<string>;
+    readonly FormSpecVersion: string;
+    readonly DynamicVersion: string;
+    readonly MaxScore: Option<Spec_Score>;
+    readonly Status: Values_FormStatus_$union;
+    readonly Signatures: FSharpList<Values_Signature>;
+    constructor(FormSpecId: string, FormSpecCode: Option<string>, FormSpecVersion: string, DynamicVersion: string, MaxScore: Option<Spec_Score>, Status: Values_FormStatus_$union, Signatures: FSharpList<Values_Signature>) {
+        super();
+        this.FormSpecId = FormSpecId;
+        this.FormSpecCode = FormSpecCode;
+        this.FormSpecVersion = FormSpecVersion;
+        this.DynamicVersion = DynamicVersion;
+        this.MaxScore = MaxScore;
+        this.Status = Status;
+        this.Signatures = Signatures;
+    }
+}
+
+export function Values_DynamicFormSpecDetails_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Values.DynamicFormSpecDetails", [], Values_DynamicFormSpecDetails, () => [["FormSpecId", class_type("System.Guid")], ["FormSpecCode", option_type(string_type)], ["FormSpecVersion", string_type], ["DynamicVersion", string_type], ["MaxScore", option_type(Spec_Score_$reflection())], ["Status", Values_FormStatus_$reflection()], ["Signatures", list_type(Values_Signature_$reflection())]]);
+}
+
+export class Values_DynamicForm$1<FableFormModel> extends Record implements IEquatable<Values_DynamicForm$1<FableFormModel>>, IComparable<Values_DynamicForm$1<FableFormModel>> {
+    readonly DynamicFormSpecDetails: Values_DynamicFormSpecDetails;
+    readonly Steps: FSharpMap<Values_StepOrder, FableFormModel>;
+    constructor(DynamicFormSpecDetails: Values_DynamicFormSpecDetails, Steps: FSharpMap<Values_StepOrder, FableFormModel>) {
+        super();
+        this.DynamicFormSpecDetails = DynamicFormSpecDetails;
+        this.Steps = Steps;
+    }
+}
+
+export function Values_DynamicForm$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return record_type("F1.Studio.Values.DynamicForm`1", [gen0], Values_DynamicForm$1, () => [["DynamicFormSpecDetails", Values_DynamicFormSpecDetails_$reflection()], ["Steps", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [Values_StepOrder_$reflection(), gen0])]]);
+}
+
+export class Values_DynamicFormResultData$1<FieldType> extends Record implements IEquatable<Values_DynamicFormResultData$1<FieldType>>, IComparable<Values_DynamicFormResultData$1<FieldType>> {
+    readonly ResultFormSpecDetails: Values_DynamicFormSpecDetails;
+    readonly ResultSteps: FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<FieldType>>>;
+    constructor(ResultFormSpecDetails: Values_DynamicFormSpecDetails, ResultSteps: FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<FieldType>>>) {
+        super();
+        this.ResultFormSpecDetails = ResultFormSpecDetails;
+        this.ResultSteps = ResultSteps;
+    }
+}
+
+export function Values_DynamicFormResultData$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return record_type("F1.Studio.Values.DynamicFormResultData`1", [gen0], Values_DynamicFormResultData$1, () => [["ResultFormSpecDetails", Values_DynamicFormSpecDetails_$reflection()], ["ResultSteps", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [Values_StepOrder_$reflection(), class_type("Microsoft.FSharp.Collections.FSharpMap`2", [Shared_FieldKey_$reflection(), Values_FieldDetails$1_$reflection(gen0)])])]]);
+}
+
+export function Values_FormStatus__get_toString(x: Values_FormStatus_$union): string {
+    switch (x.tag) {
+        case /* Draft */ 1:
+            return `Draft ${x.fields[0]}`;
+        case /* WaitingForReview */ 2:
+            return "RequiresReview";
+        case /* WaitingForApproval */ 3:
+            return "RequiresApproval";
+        case /* Complete */ 4:
+            return "Complete";
+        default:
+            return "Pending";
+    }
+}
+
+export function Values_formStatusFromString(formStatusString: string): Values_FormStatus_$union {
+    if (formStatusString.startsWith("Draft ")) {
+        let matchValue: [boolean, string];
+        let outArg = "00000000-0000-0000-0000-000000000000";
+        matchValue = ([tryParse(item(1, split(formStatusString, [" "], undefined, 1)), new FSharpRef<string>((): string => outArg, (v: string): void => {
+            outArg = v;
+        })), outArg] as [boolean, string]);
+        if (matchValue[0]) {
+            return Values_FormStatus_Draft(matchValue[1]);
+        }
+        else {
+            throw new Error("NYI: NEED TO HANDLE UNPARSED GUID FOR DRAFT FORMS");
+        }
+    }
+    else {
+        switch (formStatusString) {
+            case "RequiresReview":
+                return Values_FormStatus_WaitingForReview();
+            case "RequiresApproval":
+                return Values_FormStatus_WaitingForApproval();
+            case "Complete":
+                return Values_FormStatus_Complete();
+            case "Pending":
+                return Values_FormStatus_Pending();
+            case "Draft":
+                return Values_FormStatus_Draft(newGuid());
+            default:
+                throw new Error(`Unhandled Signature Type String ${formStatusString}`);
+        }
+    }
+}
+
+//# sourceMappingURL=FormSpec.ts.map