@f1studio/form-spec 5.0.0-alpha.168 → 5.0.0-alpha.169

package/vye-os-contracts-fs/src/CoreMR/FormTemplate.js

@@ -0,0 +1,1242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get Action () {
+        return Action;
+    },
+    get ActionRead () {
+        return ActionRead;
+    },
+    get ActionRead_$reflection () {
+        return ActionRead_$reflection;
+    },
+    get ActionRead_Modelled () {
+        return ActionRead_Modelled;
+    },
+    get ActionRead_Unmodelled () {
+        return ActionRead_Unmodelled;
+    },
+    get Action_$reflection () {
+        return Action_$reflection;
+    },
+    get Action_Alert () {
+        return Action_Alert;
+    },
+    get Action_ChangeGroups () {
+        return Action_ChangeGroups;
+    },
+    get Action_Medset () {
+        return Action_Medset;
+    },
+    get Action_OneOffTask () {
+        return Action_OneOffTask;
+    },
+    get Action_Problem () {
+        return Action_Problem;
+    },
+    get Action_StandingOrder () {
+        return Action_StandingOrder;
+    },
+    get Availability$1 () {
+        return Availability$1;
+    },
+    get Availability$1_$reflection () {
+        return Availability$1_$reflection;
+    },
+    get Availability$1_NotInRelease () {
+        return Availability$1_NotInRelease;
+    },
+    get Availability$1_NotReadYet () {
+        return Availability$1_NotReadYet;
+    },
+    get Availability$1_Stated () {
+        return Availability$1_Stated;
+    },
+    get Cadence () {
+        return Cadence;
+    },
+    get Cadence_$reflection () {
+        return Cadence_$reflection;
+    },
+    get Cadence_Every () {
+        return Cadence_Every;
+    },
+    get Cadence_OnSchedule () {
+        return Cadence_OnSchedule;
+    },
+    get ChoiceId () {
+        return ChoiceId;
+    },
+    get ChoiceId_$reflection () {
+        return ChoiceId_$reflection;
+    },
+    get Comparison () {
+        return Comparison;
+    },
+    get Comparison_$reflection () {
+        return Comparison_$reflection;
+    },
+    get Comparison_Equal () {
+        return Comparison_Equal;
+    },
+    get Comparison_Greater () {
+        return Comparison_Greater;
+    },
+    get Comparison_GreaterOrEqual () {
+        return Comparison_GreaterOrEqual;
+    },
+    get Comparison_Less () {
+        return Comparison_Less;
+    },
+    get Comparison_LessOrEqual () {
+        return Comparison_LessOrEqual;
+    },
+    get Comparison_NotEqual () {
+        return Comparison_NotEqual;
+    },
+    get Condition () {
+        return Condition;
+    },
+    get Condition_$reflection () {
+        return Condition_$reflection;
+    },
+    get Condition_AllChosen () {
+        return Condition_AllChosen;
+    },
+    get Condition_AnyChosen () {
+        return Condition_AnyChosen;
+    },
+    get Condition_BooleanIs () {
+        return Condition_BooleanIs;
+    },
+    get Condition_NoneChosen () {
+        return Condition_NoneChosen;
+    },
+    get Condition_TextCompares () {
+        return Condition_TextCompares;
+    },
+    get Condition_UnmodelledCondition () {
+        return Condition_UnmodelledCondition;
+    },
+    get Condition_VitalIs () {
+        return Condition_VitalIs;
+    },
+    get FacilityAvailability () {
+        return FacilityAvailability;
+    },
+    get FacilityAvailability_$reflection () {
+        return FacilityAvailability_$reflection;
+    },
+    get Firing () {
+        return Firing;
+    },
+    get Firing_$reflection () {
+        return Firing_$reflection;
+    },
+    get Firing_EveryTime () {
+        return Firing_EveryTime;
+    },
+    get Firing_OnceOnly () {
+        return Firing_OnceOnly;
+    },
+    get GroupChange () {
+        return GroupChange;
+    },
+    get GroupChange_$reflection () {
+        return GroupChange_$reflection;
+    },
+    get GroupChange_AddTo () {
+        return GroupChange_AddTo;
+    },
+    get GroupChange_RemoveFrom () {
+        return GroupChange_RemoveFrom;
+    },
+    get Join () {
+        return Join;
+    },
+    get Join_$reflection () {
+        return Join_$reflection;
+    },
+    get Join_And () {
+        return Join_And;
+    },
+    get Join_Or () {
+        return Join_Or;
+    },
+    get Join_UnrecognisedJoin () {
+        return Join_UnrecognisedJoin;
+    },
+    get MedsetOrder () {
+        return MedsetOrder;
+    },
+    get MedsetOrder_$reflection () {
+        return MedsetOrder_$reflection;
+    },
+    get NonEmpty$1 () {
+        return NonEmpty$1;
+    },
+    get NonEmpty$1_$reflection () {
+        return NonEmpty$1_$reflection;
+    },
+    get NonEmpty_ofList () {
+        return NonEmpty_ofList;
+    },
+    get NonEmpty_toList () {
+        return NonEmpty_toList;
+    },
+    get Priority () {
+        return Priority;
+    },
+    get Priority_$reflection () {
+        return Priority_$reflection;
+    },
+    get ProblemOrder () {
+        return ProblemOrder;
+    },
+    get ProblemOrder_$reflection () {
+        return ProblemOrder_$reflection;
+    },
+    get Ref () {
+        return Ref;
+    },
+    get Ref_$reflection () {
+        return Ref_$reflection;
+    },
+    get Standing () {
+        return Standing;
+    },
+    get Standing_$reflection () {
+        return Standing_$reflection;
+    },
+    get Standing_RecurringTask () {
+        return Standing_RecurringTask;
+    },
+    get Standing_Treatment () {
+        return Standing_Treatment;
+    },
+    get StatedAction () {
+        return StatedAction;
+    },
+    get StatedAction_$reflection () {
+        return StatedAction_$reflection;
+    },
+    get StatedCondition () {
+        return StatedCondition;
+    },
+    get StatedCondition_$reflection () {
+        return StatedCondition_$reflection;
+    },
+    get TaskOrder () {
+        return TaskOrder;
+    },
+    get TaskOrder_$reflection () {
+        return TaskOrder_$reflection;
+    },
+    get Timing () {
+        return Timing;
+    },
+    get Timing_$reflection () {
+        return Timing_$reflection;
+    },
+    get Timing_OnFirstOpen () {
+        return Timing_OnFirstOpen;
+    },
+    get Timing_OnLock () {
+        return Timing_OnLock;
+    },
+    get Timing_OnSave () {
+        return Timing_OnSave;
+    },
+    get Timing_UnrecognisedTiming () {
+        return Timing_UnrecognisedTiming;
+    },
+    get TreatmentOrder () {
+        return TreatmentOrder;
+    },
+    get TreatmentOrder_$reflection () {
+        return TreatmentOrder_$reflection;
+    },
+    get Trigger () {
+        return Trigger;
+    },
+    get Trigger_$reflection () {
+        return Trigger_$reflection;
+    },
+    get VitalSign () {
+        return VitalSign;
+    },
+    get VitalSign_$reflection () {
+        return VitalSign_$reflection;
+    },
+    get VitalSign_DiastolicBP () {
+        return VitalSign_DiastolicBP;
+    },
+    get VitalSign_HeartRate () {
+        return VitalSign_HeartRate;
+    },
+    get VitalSign_Respiration () {
+        return VitalSign_Respiration;
+    },
+    get VitalSign_SpO2 () {
+        return VitalSign_SpO2;
+    },
+    get VitalSign_SystolicBP () {
+        return VitalSign_SystolicBP;
+    },
+    get VitalSign_Temperature () {
+        return VitalSign_Temperature;
+    },
+    get VitalSign_Weight () {
+        return VitalSign_Weight;
+    }
+});
+const _Types = require("@fable-org/fable-library-js/Types.js");
+const _List = require("@fable-org/fable-library-js/List.js");
+const _Reflection = require("@fable-org/fable-library-js/Reflection.js");
+class NonEmpty$1 extends _Types.Record {
+    constructor(Head, Tail){
+        super();
+        this.Head = Head;
+        this.Tail = Tail;
+    }
+}
+function NonEmpty$1_$reflection(gen0) {
+    return (0, _Reflection.record_type)("Vye.Contracts.CoreMR.NonEmpty`1", [
+        gen0
+    ], NonEmpty$1, ()=>[
+            [
+                "Head",
+                gen0
+            ],
+            [
+                "Tail",
+                (0, _Reflection.list_type)(gen0)
+            ]
+        ]);
+}
+function NonEmpty_ofList(_arg) {
+    if (!(0, _List.isEmpty)(_arg)) {
+        return new NonEmpty$1((0, _List.head)(_arg), (0, _List.tail)(_arg));
+    } else {
+        return undefined;
+    }
+}
+function NonEmpty_toList(n) {
+    return (0, _List.cons)(n.Head, n.Tail);
+}
+function Availability$1_Stated(Item) {
+    return new Availability$1(0, [
+        Item
+    ]);
+}
+function Availability$1_NotInRelease(because) {
+    return new Availability$1(1, [
+        because
+    ]);
+}
+function Availability$1_NotReadYet(because, witness) {
+    return new Availability$1(2, [
+        because,
+        witness
+    ]);
+}
+class Availability$1 extends _Types.Union {
+    cases() {
+        return [
+            "Stated",
+            "NotInRelease",
+            "NotReadYet"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function Availability$1_$reflection(gen0) {
+    return (0, _Reflection.union_type)("Vye.Contracts.CoreMR.Availability`1", [
+        gen0
+    ], Availability$1, ()=>[
+            [
+                [
+                    "Item",
+                    gen0
+                ]
+            ],
+            [
+                [
+                    "because",
+                    _Reflection.string_type
+                ]
+            ],
+            [
+                [
+                    "because",
+                    _Reflection.string_type
+                ],
+                [
+                    "witness",
+                    (0, _Reflection.list_type)(_Reflection.string_type)
+                ]
+            ]
+        ]);
+}
+class ChoiceId extends _Types.Union {
+    cases() {
+        return [
+            "ChoiceId"
+        ];
+    }
+    constructor(Item){
+        super();
+        this.tag = 0;
+        this.fields = [
+            Item
+        ];
+    }
+}
+function ChoiceId_$reflection() {
+    return (0, _Reflection.union_type)("Vye.Contracts.CoreMR.ChoiceId", [], ChoiceId, ()=>[
+            [
+                [
+                    "Item",
+                    _Reflection.int32_type
+                ]
+            ]
+        ]);
+}
+class Ref extends _Types.Record {
+    constructor(Id, Name){
+        super();
+        this.Id = Id | 0;
+        this.Name = Name;
+    }
+}
+function Ref_$reflection() {
+    return (0, _Reflection.record_type)("Vye.Contracts.CoreMR.Ref", [], Ref, ()=>[
+            [
+                "Id",
+                _Reflection.int32_type
+            ],
+            [
+                "Name",
+                (0, _Reflection.option_type)(_Reflection.string_type)
+            ]
+        ]);
+}
+function Timing_OnSave() {
+    return new Timing(0, []);
+}
+function Timing_OnLock() {
+    return new Timing(1, []);
+}
+function Timing_OnFirstOpen() {
+    return new Timing(2, []);
+}
+function Timing_UnrecognisedTiming(eventName) {
+    return new Timing(3, [
+        eventName
+    ]);
+}
+class Timing extends _Types.Union {
+    cases() {
+        return [
+            "OnSave",
+            "OnLock",
+            "OnFirstOpen",
+            "UnrecognisedTiming"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function Timing_$reflection() {
+    return (0, _Reflection.union_type)("Vye.Contracts.CoreMR.Timing", [], Timing, ()=>[
+            [],
+            [],
+            [],
+            [
+                [
+                    "eventName",
+                    _Reflection.string_type
+                ]
+            ]
+        ]);
+}
+function Firing_EveryTime() {
+    return new Firing(0, []);
+}
+function Firing_OnceOnly() {
+    return new Firing(1, []);
+}
+class Firing extends _Types.Union {
+    cases() {
+        return [
+            "EveryTime",
+            "OnceOnly"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function Firing_$reflection() {
+    return (0, _Reflection.union_type)("Vye.Contracts.CoreMR.Firing", [], Firing, ()=>[
+            [],
+            []
+        ]);
+}
+function VitalSign_SystolicBP() {
+    return new VitalSign(0, []);
+}
+function VitalSign_DiastolicBP() {
+    return new VitalSign(1, []);
+}
+function VitalSign_HeartRate() {
+    return new VitalSign(2, []);
+}
+function VitalSign_Respiration() {
+    return new VitalSign(3, []);
+}
+function VitalSign_Temperature() {
+    return new VitalSign(4, []);
+}
+function VitalSign_SpO2() {
+    return new VitalSign(5, []);
+}
+function VitalSign_Weight() {
+    return new VitalSign(6, []);
+}
+class VitalSign extends _Types.Union {
+    cases() {
+        return [
+            "SystolicBP",
+            "DiastolicBP",
+            "HeartRate",
+            "Respiration",
+            "Temperature",
+            "SpO2",
+            "Weight"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function VitalSign_$reflection() {
+    return (0, _Reflection.union_type)("Vye.Contracts.CoreMR.VitalSign", [], VitalSign, ()=>[
+            [],
+            [],
+            [],
+            [],
+            [],
+            [],
+            []
+        ]);
+}
+function Comparison_Less() {
+    return new Comparison(0, []);
+}
+function Comparison_LessOrEqual() {
+    return new Comparison(1, []);
+}
+function Comparison_Equal() {
+    return new Comparison(2, []);
+}
+function Comparison_NotEqual() {
+    return new Comparison(3, []);
+}
+function Comparison_GreaterOrEqual() {
+    return new Comparison(4, []);
+}
+function Comparison_Greater() {
+    return new Comparison(5, []);
+}
+class Comparison extends _Types.Union {
+    cases() {
+        return [
+            "Less",
+            "LessOrEqual",
+            "Equal",
+            "NotEqual",
+            "GreaterOrEqual",
+            "Greater"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function Comparison_$reflection() {
+    return (0, _Reflection.union_type)("Vye.Contracts.CoreMR.Comparison", [], Comparison, ()=>[
+            [],
+            [],
+            [],
+            [],
+            [],
+            []
+        ]);
+}
+function Condition_AnyChosen(Item) {
+    return new Condition(0, [
+        Item
+    ]);
+}
+function Condition_AllChosen(Item) {
+    return new Condition(1, [
+        Item
+    ]);
+}
+function Condition_NoneChosen(Item) {
+    return new Condition(2, [
+        Item
+    ]);
+}
+function Condition_VitalIs(Item1, Item2, Item3) {
+    return new Condition(3, [
+        Item1,
+        Item2,
+        Item3
+    ]);
+}
+function Condition_BooleanIs(Item) {
+    return new Condition(4, [
+        Item
+    ]);
+}
+function Condition_TextCompares(Item1, Item2) {
+    return new Condition(5, [
+        Item1,
+        Item2
+    ]);
+}
+function Condition_UnmodelledCondition(source, operator, because) {
+    return new Condition(6, [
+        source,
+        operator,
+        because
+    ]);
+}
+class Condition extends _Types.Union {
+    cases() {
+        return [
+            "AnyChosen",
+            "AllChosen",
+            "NoneChosen",
+            "VitalIs",
+            "BooleanIs",
+            "TextCompares",
+            "UnmodelledCondition"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function Condition_$reflection() {
+    return (0, _Reflection.union_type)("Vye.Contracts.CoreMR.Condition", [], Condition, ()=>[
+            [
+                [
+                    "Item",
+                    (0, _Reflection.list_type)(ChoiceId_$reflection())
+                ]
+            ],
+            [
+                [
+                    "Item",
+                    (0, _Reflection.list_type)(ChoiceId_$reflection())
+                ]
+            ],
+            [
+                [
+                    "Item",
+                    (0, _Reflection.list_type)(ChoiceId_$reflection())
+                ]
+            ],
+            [
+                [
+                    "Item1",
+                    VitalSign_$reflection()
+                ],
+                [
+                    "Item2",
+                    Comparison_$reflection()
+                ],
+                [
+                    "Item3",
+                    _Reflection.decimal_type
+                ]
+            ],
+            [
+                [
+                    "Item",
+                    _Reflection.bool_type
+                ]
+            ],
+            [
+                [
+                    "Item1",
+                    Comparison_$reflection()
+                ],
+                [
+                    "Item2",
+                    _Reflection.string_type
+                ]
+            ],
+            [
+                [
+                    "source",
+                    _Reflection.string_type
+                ],
+                [
+                    "operator",
+                    _Reflection.string_type
+                ],
+                [
+                    "because",
+                    _Reflection.string_type
+                ]
+            ]
+        ]);
+}
+function Join_And() {
+    return new Join(0, []);
+}
+function Join_Or() {
+    return new Join(1, []);
+}
+function Join_UnrecognisedJoin(stated) {
+    return new Join(2, [
+        stated
+    ]);
+}
+class Join extends _Types.Union {
+    cases() {
+        return [
+            "And",
+            "Or",
+            "UnrecognisedJoin"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function Join_$reflection() {
+    return (0, _Reflection.union_type)("Vye.Contracts.CoreMR.Join", [], Join, ()=>[
+            [],
+            [],
+            [
+                [
+                    "stated",
+                    _Reflection.string_type
+                ]
+            ]
+        ]);
+}
+class StatedCondition extends _Types.Record {
+    constructor(SourceItem, Join, Test){
+        super();
+        this.SourceItem = SourceItem;
+        this.Join = Join;
+        this.Test = Test;
+    }
+}
+function StatedCondition_$reflection() {
+    return (0, _Reflection.record_type)("Vye.Contracts.CoreMR.StatedCondition", [], StatedCondition, ()=>[
+            [
+                "SourceItem",
+                (0, _Reflection.option_type)(_Reflection.int32_type)
+            ],
+            [
+                "Join",
+                (0, _Reflection.option_type)(Join_$reflection())
+            ],
+            [
+                "Test",
+                Condition_$reflection()
+            ]
+        ]);
+}
+class Priority extends _Types.Union {
+    cases() {
+        return [
+            "Priority"
+        ];
+    }
+    constructor(Item){
+        super();
+        this.tag = 0;
+        this.fields = [
+            Item
+        ];
+    }
+}
+function Priority_$reflection() {
+    return (0, _Reflection.union_type)("Vye.Contracts.CoreMR.Priority", [], Priority, ()=>[
+            [
+                [
+                    "Item",
+                    _Reflection.int32_type
+                ]
+            ]
+        ]);
+}
+class TaskOrder extends _Types.Record {
+    constructor(Category, Description, Priority, Due){
+        super();
+        this.Category = Category;
+        this.Description = Description;
+        this.Priority = Priority;
+        this.Due = Due;
+    }
+}
+function TaskOrder_$reflection() {
+    return (0, _Reflection.record_type)("Vye.Contracts.CoreMR.TaskOrder", [], TaskOrder, ()=>[
+            [
+                "Category",
+                Ref_$reflection()
+            ],
+            [
+                "Description",
+                (0, _Reflection.option_type)(_Reflection.string_type)
+            ],
+            [
+                "Priority",
+                Priority_$reflection()
+            ],
+            [
+                "Due",
+                (0, _Reflection.option_type)(_Reflection.string_type)
+            ]
+        ]);
+}
+class TreatmentOrder extends _Types.Record {
+    constructor(Treatment, Provider, Start, Instructions, CanTreatImmediately){
+        super();
+        this.Treatment = Treatment;
+        this.Provider = Provider;
+        this.Start = Start;
+        this.Instructions = Instructions;
+        this.CanTreatImmediately = CanTreatImmediately;
+    }
+}
+function TreatmentOrder_$reflection() {
+    return (0, _Reflection.record_type)("Vye.Contracts.CoreMR.TreatmentOrder", [], TreatmentOrder, ()=>[
+            [
+                "Treatment",
+                Ref_$reflection()
+            ],
+            [
+                "Provider",
+                (0, _Reflection.option_type)(Ref_$reflection())
+            ],
+            [
+                "Start",
+                _Reflection.string_type
+            ],
+            [
+                "Instructions",
+                (0, _Reflection.option_type)(_Reflection.string_type)
+            ],
+            [
+                "CanTreatImmediately",
+                (0, _Reflection.option_type)(_Reflection.bool_type)
+            ]
+        ]);
+}
+function Cadence_OnSchedule(schedule, ends) {
+    return new Cadence(0, [
+        schedule,
+        ends
+    ]);
+}
+function Cadence_Every(interval, until) {
+    return new Cadence(1, [
+        interval,
+        until
+    ]);
+}
+class Cadence extends _Types.Union {
+    cases() {
+        return [
+            "OnSchedule",
+            "Every"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function Cadence_$reflection() {
+    return (0, _Reflection.union_type)("Vye.Contracts.CoreMR.Cadence", [], Cadence, ()=>[
+            [
+                [
+                    "schedule",
+                    Ref_$reflection()
+                ],
+                [
+                    "ends",
+                    (0, _Reflection.option_type)(_Reflection.string_type)
+                ]
+            ],
+            [
+                [
+                    "interval",
+                    _Reflection.string_type
+                ],
+                [
+                    "until",
+                    _Reflection.string_type
+                ]
+            ]
+        ]);
+}
+function Standing_RecurringTask(Item) {
+    return new Standing(0, [
+        Item
+    ]);
+}
+function Standing_Treatment(Item) {
+    return new Standing(1, [
+        Item
+    ]);
+}
+class Standing extends _Types.Union {
+    cases() {
+        return [
+            "RecurringTask",
+            "Treatment"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function Standing_$reflection() {
+    return (0, _Reflection.union_type)("Vye.Contracts.CoreMR.Standing", [], Standing, ()=>[
+            [
+                [
+                    "Item",
+                    TaskOrder_$reflection()
+                ]
+            ],
+            [
+                [
+                    "Item",
+                    TreatmentOrder_$reflection()
+                ]
+            ]
+        ]);
+}
+function GroupChange_AddTo(Item) {
+    return new GroupChange(0, [
+        Item
+    ]);
+}
+function GroupChange_RemoveFrom(Item) {
+    return new GroupChange(1, [
+        Item
+    ]);
+}
+class GroupChange extends _Types.Union {
+    cases() {
+        return [
+            "AddTo",
+            "RemoveFrom"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function GroupChange_$reflection() {
+    return (0, _Reflection.union_type)("Vye.Contracts.CoreMR.GroupChange", [], GroupChange, ()=>[
+            [
+                [
+                    "Item",
+                    NonEmpty$1_$reflection(Ref_$reflection())
+                ]
+            ],
+            [
+                [
+                    "Item",
+                    NonEmpty$1_$reflection(Ref_$reflection())
+                ]
+            ]
+        ]);
+}
+class MedsetOrder extends _Types.Record {
+    constructor(Medset, Prescriber, Pharmacy, Start){
+        super();
+        this.Medset = Medset;
+        this.Prescriber = Prescriber;
+        this.Pharmacy = Pharmacy;
+        this.Start = Start;
+    }
+}
+function MedsetOrder_$reflection() {
+    return (0, _Reflection.record_type)("Vye.Contracts.CoreMR.MedsetOrder", [], MedsetOrder, ()=>[
+            [
+                "Medset",
+                Ref_$reflection()
+            ],
+            [
+                "Prescriber",
+                (0, _Reflection.option_type)(Ref_$reflection())
+            ],
+            [
+                "Pharmacy",
+                (0, _Reflection.option_type)(Ref_$reflection())
+            ],
+            [
+                "Start",
+                (0, _Reflection.option_type)(_Reflection.string_type)
+            ]
+        ]);
+}
+class ProblemOrder extends _Types.Record {
+    constructor(Problem, Chronic, Severity, Inflammation){
+        super();
+        this.Problem = Problem;
+        this.Chronic = Chronic;
+        this.Severity = Severity;
+        this.Inflammation = Inflammation;
+    }
+}
+function ProblemOrder_$reflection() {
+    return (0, _Reflection.record_type)("Vye.Contracts.CoreMR.ProblemOrder", [], ProblemOrder, ()=>[
+            [
+                "Problem",
+                Ref_$reflection()
+            ],
+            [
+                "Chronic",
+                (0, _Reflection.option_type)(_Reflection.int32_type)
+            ],
+            [
+                "Severity",
+                (0, _Reflection.option_type)(_Reflection.int32_type)
+            ],
+            [
+                "Inflammation",
+                (0, _Reflection.option_type)(_Reflection.int32_type)
+            ]
+        ]);
+}
+function Action_OneOffTask(Item) {
+    return new Action(0, [
+        Item
+    ]);
+}
+function Action_StandingOrder(Item1, Item2) {
+    return new Action(1, [
+        Item1,
+        Item2
+    ]);
+}
+function Action_Alert(category) {
+    return new Action(2, [
+        category
+    ]);
+}
+function Action_Problem(Item) {
+    return new Action(3, [
+        Item
+    ]);
+}
+function Action_Medset(Item) {
+    return new Action(4, [
+        Item
+    ]);
+}
+function Action_ChangeGroups(Item) {
+    return new Action(5, [
+        Item
+    ]);
+}
+class Action extends _Types.Union {
+    cases() {
+        return [
+            "OneOffTask",
+            "StandingOrder",
+            "Alert",
+            "Problem",
+            "Medset",
+            "ChangeGroups"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function Action_$reflection() {
+    return (0, _Reflection.union_type)("Vye.Contracts.CoreMR.Action", [], Action, ()=>[
+            [
+                [
+                    "Item",
+                    TaskOrder_$reflection()
+                ]
+            ],
+            [
+                [
+                    "Item1",
+                    Cadence_$reflection()
+                ],
+                [
+                    "Item2",
+                    Standing_$reflection()
+                ]
+            ],
+            [
+                [
+                    "category",
+                    Ref_$reflection()
+                ]
+            ],
+            [
+                [
+                    "Item",
+                    ProblemOrder_$reflection()
+                ]
+            ],
+            [
+                [
+                    "Item",
+                    MedsetOrder_$reflection()
+                ]
+            ],
+            [
+                [
+                    "Item",
+                    GroupChange_$reflection()
+                ]
+            ]
+        ]);
+}
+function ActionRead_Modelled(Item) {
+    return new ActionRead(0, [
+        Item
+    ]);
+}
+function ActionRead_Unmodelled(kind, because) {
+    return new ActionRead(1, [
+        kind,
+        because
+    ]);
+}
+class ActionRead extends _Types.Union {
+    cases() {
+        return [
+            "Modelled",
+            "Unmodelled"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function ActionRead_$reflection() {
+    return (0, _Reflection.union_type)("Vye.Contracts.CoreMR.ActionRead", [], ActionRead, ()=>[
+            [
+                [
+                    "Item",
+                    Action_$reflection()
+                ]
+            ],
+            [
+                [
+                    "kind",
+                    _Reflection.string_type
+                ],
+                [
+                    "because",
+                    _Reflection.string_type
+                ]
+            ]
+        ]);
+}
+class StatedAction extends _Types.Record {
+    constructor(ActionId, Read){
+        super();
+        this.ActionId = ActionId | 0;
+        this.Read = Read;
+    }
+}
+function StatedAction_$reflection() {
+    return (0, _Reflection.record_type)("Vye.Contracts.CoreMR.StatedAction", [], StatedAction, ()=>[
+            [
+                "ActionId",
+                _Reflection.int32_type
+            ],
+            [
+                "Read",
+                ActionRead_$reflection()
+            ]
+        ]);
+}
+class Trigger extends _Types.Record {
+    constructor(TriggerId, Timing, Firing, Enabled, Conditions, Actions){
+        super();
+        this.TriggerId = TriggerId | 0;
+        this.Timing = Timing;
+        this.Firing = Firing;
+        this.Enabled = Enabled;
+        this.Conditions = Conditions;
+        this.Actions = Actions;
+    }
+}
+function Trigger_$reflection() {
+    return (0, _Reflection.record_type)("Vye.Contracts.CoreMR.Trigger", [], Trigger, ()=>[
+            [
+                "TriggerId",
+                _Reflection.int32_type
+            ],
+            [
+                "Timing",
+                Timing_$reflection()
+            ],
+            [
+                "Firing",
+                Availability$1_$reflection(Firing_$reflection())
+            ],
+            [
+                "Enabled",
+                _Reflection.bool_type
+            ],
+            [
+                "Conditions",
+                (0, _Reflection.list_type)(StatedCondition_$reflection())
+            ],
+            [
+                "Actions",
+                (0, _Reflection.list_type)(StatedAction_$reflection())
+            ]
+        ]);
+}
+class FacilityAvailability extends _Types.Record {
+    constructor(ActiveAt){
+        super();
+        this.ActiveAt = ActiveAt;
+    }
+}
+function FacilityAvailability_$reflection() {
+    return (0, _Reflection.record_type)("Vye.Contracts.CoreMR.FacilityAvailability", [], FacilityAvailability, ()=>[
+            [
+                "ActiveAt",
+                (0, _Reflection.class_type)("Microsoft.FSharp.Collections.FSharpSet`1", [
+                    _Reflection.int32_type
+                ])
+            ]
+        ]);
+} //# sourceMappingURL=FormTemplate.ts.map
+
+//# sourceMappingURL=FormTemplate.js.map