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

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

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