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

package/src/FormSpec.FS/Integrations/CorEMR/FormTemplateDecoder.ts

@@ -0,0 +1,1284 @@
+import { Record, Union } from "@fable-org/fable-library-js/Types.js";
+import { collect, tryPick, map as map_1, isEmpty, choose, ofArray, empty, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { bool_type, class_type, record_type, option_type, int64_type, int32_type, union_type, list_type, string_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { value as value_15, Option } from "@fable-org/fable-library-js/Option.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { join as join_1, printf, toText } from "@fable-org/fable-library-js/String.js";
+import { int64 } from "@fable-org/fable-library-js/BigInt.js";
+import { equals, uncurry3, uncurry2, comparePrimitives, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { FSharpMap__TryFind, toList, ofList, FSharpMap } from "@fable-org/fable-library-js/Map.js";
+import { Auto_generateBoxedDecoder_Z6670B51 } from "../../../Thoth.Json/packages/Thoth.Json/Decode.js";
+import { Result_Bind, FSharpResult$2_Error, FSharpResult$2_Ok, FSharpResult$2_$union } from "@fable-org/fable-library-js/Result.js";
+import { ErrorReason_$union } from "../../../Thoth.Json/packages/Thoth.Json/Types.js";
+import { at, fromString, bool, map3, field as field_1, oneOf, IOptionalGetter, option, int, IGetters, list as list_7, string, IRequiredGetter, object, succeed, fail, andThen, map, keyValuePairs } from "../../../Thoth.Json/packages/Thoth.Json/Decode.js";
+import { empty as empty_1, singleton, append, delay, toList as toList_1 } from "@fable-org/fable-library-js/Seq.js";
+import { StatedCondition, StatedAction, Trigger_$reflection, Trigger } from "../../../vye-os-contracts-fs/src/CoreMR/FormTemplate.js";
+import { triggers as triggers_1 } from "./FormTemplateDomainDecoder.js";
+import { toList as toList_2, FSharpSet, ofList as ofList_1 } from "@fable-org/fable-library-js/Set.js";
+
+export type ReleaseAvailability$1_$union<T> = 
+    | ReleaseAvailability$1<T, 0>
+    | ReleaseAvailability$1<T, 1>
+    | ReleaseAvailability$1<T, 2>
+
+export type ReleaseAvailability$1_$cases<T> = {
+    0: ["Stated", [T]],
+    1: ["NotInRelease", [string]],
+    2: ["NotReadYet", [string, FSharpList<string>]]
+}
+
+export function ReleaseAvailability$1_Stated<T>(Item: T) {
+    return new ReleaseAvailability$1<T, 0>(0, [Item]);
+}
+
+export function ReleaseAvailability$1_NotInRelease<T>(because: string) {
+    return new ReleaseAvailability$1<T, 1>(1, [because]);
+}
+
+export function ReleaseAvailability$1_NotReadYet<T>(because: string, witness: FSharpList<string>) {
+    return new ReleaseAvailability$1<T, 2>(2, [because, witness]);
+}
+
+export class ReleaseAvailability$1<T, Tag extends keyof ReleaseAvailability$1_$cases<T>> extends Union<Tag, ReleaseAvailability$1_$cases<T>[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ReleaseAvailability$1_$cases<T>[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Stated", "NotInRelease", "NotReadYet"];
+    }
+}
+
+export function ReleaseAvailability$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return union_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.ReleaseAvailability`1", [gen0], ReleaseAvailability$1, () => [[["Item", gen0]], [["because", string_type]], [["because", string_type], ["witness", list_type(string_type)]]]);
+}
+
+/**
+ * The `kind` tag this crossed the wire under. ⭐ ONE home for the three spellings, so conduit's
+ * emission and this build's narrowing cannot drift.
+ */
+export function ReleaseAvailability_kind<T>(a: ReleaseAvailability$1_$union<T>): string {
+    switch (a.tag) {
+        case /* NotInRelease */ 1:
+            return "notInRelease";
+        case /* NotReadYet */ 2:
+            return "notReadYet";
+        default:
+            return "stated";
+    }
+}
+
+/**
+ * Conduit's own reason, where there is one. `None` means it is stated and read.
+ */
+export function ReleaseAvailability_because<T>(a: ReleaseAvailability$1_$union<T>): Option<string> {
+    switch (a.tag) {
+        case /* NotInRelease */ 1:
+            return a.fields[0];
+        case /* NotReadYet */ 2:
+            return a.fields[0];
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * The objects that DO state it — only `NotReadYet` names any. ⛔ An empty list here is not evidence
+ * of absence; it means this case does not carry witnesses.
+ */
+export function ReleaseAvailability_witness<T>(a: ReleaseAvailability$1_$union<T>): FSharpList<string> {
+    switch (a.tag) {
+        case /* Stated */ 0:
+        case /* NotInRelease */ 1:
+            return empty<string>();
+        default:
+            return a.fields[1];
+    }
+}
+
+/**
+ * The same release fact over a differently-shaped value. ⭐ The two absences pass through untouched —
+ * ⛔ there is no case here that could turn one into the other.
+ */
+export function ReleaseAvailability_map<a, b>(f: ((arg0: a) => b), a: ReleaseAvailability$1_$union<a>): ReleaseAvailability$1_$union<b> {
+    switch (a.tag) {
+        case /* NotInRelease */ 1:
+            return ReleaseAvailability$1_NotInRelease<b>(a.fields[0]);
+        case /* NotReadYet */ 2:
+            return ReleaseAvailability$1_NotReadYet<b>(a.fields[0], a.fields[1]);
+        default:
+            return ReleaseAvailability$1_Stated<b>(f(a.fields[0]));
+    }
+}
+
+/**
+ * ⚠️ WHAT THIS BUILD READ, and nothing more. Both absences give `[]`, meaning **"nothing was read"** —
+ * ⛔ NEVER "there is none". At 5.5.0+9704 this returns `[]` over 2,606 stated triggers.
+ */
+export function ReleaseAvailability_readList<T>(a: ReleaseAvailability$1_$union<FSharpList<T>>): FSharpList<T> {
+    switch (a.tag) {
+        case /* NotInRelease */ 1:
+        case /* NotReadYet */ 2:
+            return empty<T>();
+        default:
+            return a.fields[0];
+    }
+}
+
+/**
+ * ⚠️ `true` ONLY where the release states it AND states `true`. Both absences give `false`, meaning
+ * **"not listed"** — ⛔ never "the site denies it". 5.5.0+9704 cannot say either way about `other`.
+ */
+export function ReleaseAvailability_statedTrue(a: ReleaseAvailability$1_$union<boolean>): boolean {
+    switch (a.tag) {
+        case /* NotInRelease */ 1:
+        case /* NotReadYet */ 2:
+            return false;
+        default:
+            return a.fields[0];
+    }
+}
+
+/**
+ * ⚠️ A LAYOUT DEPTH ONLY. Both absences render UNINDENTED — a rendering decision, ⛔ never a claim that
+ * the item sits at the root of a hierarchy this release states differently.
+ */
+export function ReleaseAvailability_renderDepth(a: ReleaseAvailability$1_$union<int32>): int32 {
+    switch (a.tag) {
+        case /* NotInRelease */ 1:
+        case /* NotReadYet */ 2:
+            return 0;
+        default:
+            return a.fields[0] | 0;
+    }
+}
+
+/**
+ * ⭐ ONE SENTENCE A HUMAN CAN READ, for a UI that must show WHY a number is not there. It keeps the
+ * two absences apart in words as well as in the type.
+ */
+export function ReleaseAvailability_describe<T>(a: ReleaseAvailability$1_$union<T>): string {
+    switch (a.tag) {
+        case /* NotInRelease */ 1: {
+            const b: string = a.fields[0];
+            return toText(printf("not in this release: %s"))(b);
+        }
+        case /* NotReadYet */ 2: {
+            const b_1: string = a.fields[0];
+            const arg_2: string = join_1(", ", a.fields[1]);
+            return toText(printf("stated by this release, NOT READ YET: %s (stated by: %s)"))(b_1)(arg_2);
+        }
+        default:
+            return "stated by this release, and read";
+    }
+}
+
+export class TemplateChoice extends Record implements IEquatable<TemplateChoice>, IComparable<TemplateChoice> {
+    readonly ChoiceId: int32;
+    readonly Sequence: int32;
+    readonly Score: int64;
+    readonly Text: string;
+    readonly BitPosition: Option<int32>;
+    readonly Code: Option<string>;
+    readonly Highlight: Option<int32>;
+    constructor(ChoiceId: int32, Sequence: int32, Score: int64, Text$: string, BitPosition: Option<int32>, Code: Option<string>, Highlight: Option<int32>) {
+        super();
+        this.ChoiceId = (ChoiceId | 0);
+        this.Sequence = (Sequence | 0);
+        this.Score = Score;
+        this.Text = Text$;
+        this.BitPosition = BitPosition;
+        this.Code = Code;
+        this.Highlight = Highlight;
+    }
+}
+
+export function TemplateChoice_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.TemplateChoice", [], TemplateChoice, () => [["ChoiceId", int32_type], ["Sequence", int32_type], ["Score", int64_type], ["Text", string_type], ["BitPosition", option_type(int32_type)], ["Code", option_type(string_type)], ["Highlight", option_type(int32_type)]]);
+}
+
+export class TriggerCondition extends Record implements IEquatable<TriggerCondition>, IComparable<TriggerCondition> {
+    readonly ConditionId: int32;
+    readonly SourceFieldId: Option<int32>;
+    readonly Source: string;
+    readonly Operator: string;
+    readonly Values: FSharpList<string>;
+    readonly RawChoiceIds: FSharpList<int32>;
+    readonly BooleanOperator: Option<string>;
+    constructor(ConditionId: int32, SourceFieldId: Option<int32>, Source: string, Operator: string, Values: FSharpList<string>, RawChoiceIds: FSharpList<int32>, BooleanOperator: Option<string>) {
+        super();
+        this.ConditionId = (ConditionId | 0);
+        this.SourceFieldId = SourceFieldId;
+        this.Source = Source;
+        this.Operator = Operator;
+        this.Values = Values;
+        this.RawChoiceIds = RawChoiceIds;
+        this.BooleanOperator = BooleanOperator;
+    }
+}
+
+export function TriggerCondition_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.TriggerCondition", [], TriggerCondition, () => [["ConditionId", int32_type], ["SourceFieldId", option_type(int32_type)], ["Source", string_type], ["Operator", string_type], ["Values", list_type(string_type)], ["RawChoiceIds", list_type(int32_type)], ["BooleanOperator", option_type(string_type)]]);
+}
+
+export class TriggerAction extends Record implements IEquatable<TriggerAction>, IComparable<TriggerAction> {
+    readonly ActionId: int32;
+    readonly ActionType: string;
+    readonly Params: FSharpMap<string, string>;
+    readonly ListParams: Option<FSharpMap<string, FSharpList<string>>>;
+    constructor(ActionId: int32, ActionType: string, Params: FSharpMap<string, string>, ListParams: Option<FSharpMap<string, FSharpList<string>>>) {
+        super();
+        this.ActionId = (ActionId | 0);
+        this.ActionType = ActionType;
+        this.Params = Params;
+        this.ListParams = ListParams;
+    }
+}
+
+export function TriggerAction_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.TriggerAction", [], TriggerAction, () => [["ActionId", int32_type], ["ActionType", string_type], ["Params", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, string_type])], ["ListParams", option_type(class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, list_type(string_type)]))]]);
+}
+
+export class ItemTrigger extends Record implements IEquatable<ItemTrigger>, IComparable<ItemTrigger> {
+    readonly TriggerId: int32;
+    readonly EventName: string;
+    readonly Enabled: boolean;
+    readonly ExclusiveTag: Option<string>;
+    readonly Conditions: FSharpList<TriggerCondition>;
+    readonly Actions: FSharpList<TriggerAction>;
+    constructor(TriggerId: int32, EventName: string, Enabled: boolean, ExclusiveTag: Option<string>, Conditions: FSharpList<TriggerCondition>, Actions: FSharpList<TriggerAction>) {
+        super();
+        this.TriggerId = (TriggerId | 0);
+        this.EventName = EventName;
+        this.Enabled = Enabled;
+        this.ExclusiveTag = ExclusiveTag;
+        this.Conditions = Conditions;
+        this.Actions = Actions;
+    }
+}
+
+export function ItemTrigger_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.ItemTrigger", [], ItemTrigger, () => [["TriggerId", int32_type], ["EventName", string_type], ["Enabled", bool_type], ["ExclusiveTag", option_type(string_type)], ["Conditions", list_type(TriggerCondition_$reflection())], ["Actions", list_type(TriggerAction_$reflection())]]);
+}
+
+export class TemplateItem extends Record implements IEquatable<TemplateItem>, IComparable<TemplateItem> {
+    readonly ItemId: int32;
+    readonly Sequence: int32;
+    readonly Type: int32;
+    readonly NestingLevel: ReleaseAvailability$1_$union<int32>;
+    readonly IsRequired: boolean;
+    readonly Text: string;
+    readonly SequenceText: Option<string>;
+    readonly Code: Option<string>;
+    readonly Uuid: Option<string>;
+    readonly GenderRequired: Option<string>;
+    readonly Highlight: Option<int32>;
+    readonly Choices: FSharpList<TemplateChoice>;
+    readonly Triggers: ReleaseAvailability$1_$union<FSharpList<ItemTrigger>>;
+    constructor(ItemId: int32, Sequence: int32, Type: int32, NestingLevel: ReleaseAvailability$1_$union<int32>, IsRequired: boolean, Text$: string, SequenceText: Option<string>, Code: Option<string>, Uuid: Option<string>, GenderRequired: Option<string>, Highlight: Option<int32>, Choices: FSharpList<TemplateChoice>, Triggers: ReleaseAvailability$1_$union<FSharpList<ItemTrigger>>) {
+        super();
+        this.ItemId = (ItemId | 0);
+        this.Sequence = (Sequence | 0);
+        this.Type = (Type | 0);
+        this.NestingLevel = NestingLevel;
+        this.IsRequired = IsRequired;
+        this.Text = Text$;
+        this.SequenceText = SequenceText;
+        this.Code = Code;
+        this.Uuid = Uuid;
+        this.GenderRequired = GenderRequired;
+        this.Highlight = Highlight;
+        this.Choices = Choices;
+        this.Triggers = Triggers;
+    }
+}
+
+export function TemplateItem_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.TemplateItem", [], TemplateItem, () => [["ItemId", int32_type], ["Sequence", int32_type], ["Type", int32_type], ["NestingLevel", ReleaseAvailability$1_$reflection(int32_type)], ["IsRequired", bool_type], ["Text", string_type], ["SequenceText", option_type(string_type)], ["Code", option_type(string_type)], ["Uuid", option_type(string_type)], ["GenderRequired", option_type(string_type)], ["Highlight", option_type(int32_type)], ["Choices", list_type(TemplateChoice_$reflection())], ["Triggers", ReleaseAvailability$1_$reflection(list_type(ItemTrigger_$reflection()))]]);
+}
+
+export class EncounterTypes extends Record implements IEquatable<EncounterTypes>, IComparable<EncounterTypes> {
+    readonly Medical: boolean;
+    readonly Mental: boolean;
+    readonly Dental: boolean;
+    readonly Other: ReleaseAvailability$1_$union<boolean>;
+    constructor(Medical: boolean, Mental: boolean, Dental: boolean, Other: ReleaseAvailability$1_$union<boolean>) {
+        super();
+        this.Medical = Medical;
+        this.Mental = Mental;
+        this.Dental = Dental;
+        this.Other = Other;
+    }
+}
+
+export function EncounterTypes_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.EncounterTypes", [], EncounterTypes, () => [["Medical", bool_type], ["Mental", bool_type], ["Dental", bool_type], ["Other", ReleaseAvailability$1_$reflection(bool_type)]]);
+}
+
+export class ScoringLabel extends Record implements IEquatable<ScoringLabel>, IComparable<ScoringLabel> {
+    readonly Name: string;
+    readonly Min: int32;
+    constructor(Name: string, Min: int32) {
+        super();
+        this.Name = Name;
+        this.Min = (Min | 0);
+    }
+}
+
+export function ScoringLabel_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.ScoringLabel", [], ScoringLabel, () => [["Name", string_type], ["Min", int32_type]]);
+}
+
+export class FormScoring extends Record implements IEquatable<FormScoring>, IComparable<FormScoring> {
+    readonly ScoreId: int32;
+    readonly ScoreName: string;
+    readonly Labels: FSharpList<ScoringLabel>;
+    readonly ChoiceScores: FSharpMap<string, int32>;
+    constructor(ScoreId: int32, ScoreName: string, Labels: FSharpList<ScoringLabel>, ChoiceScores: FSharpMap<string, int32>) {
+        super();
+        this.ScoreId = (ScoreId | 0);
+        this.ScoreName = ScoreName;
+        this.Labels = Labels;
+        this.ChoiceScores = ChoiceScores;
+    }
+}
+
+export function FormScoring_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.FormScoring", [], FormScoring, () => [["ScoreId", int32_type], ["ScoreName", string_type], ["Labels", list_type(ScoringLabel_$reflection())], ["ChoiceScores", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])]]);
+}
+
+export class TemplateForm extends Record implements IEquatable<TemplateForm>, IComparable<TemplateForm> {
+    readonly FormId: int32;
+    readonly Name: string;
+    readonly FormCode: string;
+    readonly FormCodeSource: string;
+    readonly Description: string;
+    readonly CurrentVersionId: int64;
+    readonly IsIntake: boolean;
+    readonly Usage: Option<string>;
+    readonly RequiresSignature: boolean;
+    readonly EncounterTypes: EncounterTypes;
+    readonly OnceAYear: boolean;
+    readonly StructureHash: string;
+    readonly ClinicalHash: string;
+    readonly CosmeticHash: string;
+    readonly Hash: string;
+    readonly Items: FSharpList<TemplateItem>;
+    readonly Scoring: Option<FormScoring>;
+    constructor(FormId: int32, Name: string, FormCode: string, FormCodeSource: string, Description: string, CurrentVersionId: int64, IsIntake: boolean, Usage: Option<string>, RequiresSignature: boolean, EncounterTypes: EncounterTypes, OnceAYear: boolean, StructureHash: string, ClinicalHash: string, CosmeticHash: string, Hash: string, Items: FSharpList<TemplateItem>, Scoring: Option<FormScoring>) {
+        super();
+        this.FormId = (FormId | 0);
+        this.Name = Name;
+        this.FormCode = FormCode;
+        this.FormCodeSource = FormCodeSource;
+        this.Description = Description;
+        this.CurrentVersionId = CurrentVersionId;
+        this.IsIntake = IsIntake;
+        this.Usage = Usage;
+        this.RequiresSignature = RequiresSignature;
+        this.EncounterTypes = EncounterTypes;
+        this.OnceAYear = OnceAYear;
+        this.StructureHash = StructureHash;
+        this.ClinicalHash = ClinicalHash;
+        this.CosmeticHash = CosmeticHash;
+        this.Hash = Hash;
+        this.Items = Items;
+        this.Scoring = Scoring;
+    }
+}
+
+export function TemplateForm_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.TemplateForm", [], TemplateForm, () => [["FormId", int32_type], ["Name", string_type], ["FormCode", string_type], ["FormCodeSource", string_type], ["Description", string_type], ["CurrentVersionId", int64_type], ["IsIntake", bool_type], ["Usage", option_type(string_type)], ["RequiresSignature", bool_type], ["EncounterTypes", EncounterTypes_$reflection()], ["OnceAYear", bool_type], ["StructureHash", string_type], ["ClinicalHash", string_type], ["CosmeticHash", string_type], ["Hash", string_type], ["Items", list_type(TemplateItem_$reflection())], ["Scoring", option_type(FormScoring_$reflection())]]);
+}
+
+export class ElementTypeEntry extends Record implements IEquatable<ElementTypeEntry>, IComparable<ElementTypeEntry> {
+    readonly Label: string;
+    readonly Control: string;
+    constructor(Label: string, Control: string) {
+        super();
+        this.Label = Label;
+        this.Control = Control;
+    }
+}
+
+export function ElementTypeEntry_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.ElementTypeEntry", [], ElementTypeEntry, () => [["Label", string_type], ["Control", string_type]]);
+}
+
+export type ElementTypesFrom_$union = 
+    | ElementTypesFrom<0>
+    | ElementTypesFrom<1>
+    | ElementTypesFrom<2>
+
+export type ElementTypesFrom_$cases = {
+    0: ["StatedBy", [string, string, string]],
+    1: ["DeclaredByConduit", [string]],
+    2: ["NotInRelease", [string]]
+}
+
+export function ElementTypesFrom_StatedBy(table: string, key: string, label: string) {
+    return new ElementTypesFrom<0>(0, [table, key, label]);
+}
+
+export function ElementTypesFrom_DeclaredByConduit(because: string) {
+    return new ElementTypesFrom<1>(1, [because]);
+}
+
+export function ElementTypesFrom_NotInRelease(because: string) {
+    return new ElementTypesFrom<2>(2, [because]);
+}
+
+export class ElementTypesFrom<Tag extends keyof ElementTypesFrom_$cases> extends Union<Tag, ElementTypesFrom_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ElementTypesFrom_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["StatedBy", "DeclaredByConduit", "NotInRelease"];
+    }
+}
+
+export function ElementTypesFrom_$reflection(): TypeInfo {
+    return union_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.ElementTypesFrom", [], ElementTypesFrom, () => [[["table", string_type], ["key", string_type], ["label", string_type]], [["because", string_type]], [["because", string_type]]]);
+}
+
+export class InstrumentMapEntry extends Record implements IEquatable<InstrumentMapEntry>, IComparable<InstrumentMapEntry> {
+    readonly InstrumentType: string;
+    readonly FormCode: string;
+    readonly MaxScore: Option<int32>;
+    readonly Source: string;
+    readonly Archived: boolean;
+    readonly FormName: string;
+    constructor(InstrumentType: string, FormCode: string, MaxScore: Option<int32>, Source: string, Archived: boolean, FormName: string) {
+        super();
+        this.InstrumentType = InstrumentType;
+        this.FormCode = FormCode;
+        this.MaxScore = MaxScore;
+        this.Source = Source;
+        this.Archived = Archived;
+        this.FormName = FormName;
+    }
+}
+
+export function InstrumentMapEntry_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.InstrumentMapEntry", [], InstrumentMapEntry, () => [["InstrumentType", string_type], ["FormCode", string_type], ["MaxScore", option_type(int32_type)], ["Source", string_type], ["Archived", bool_type], ["FormName", string_type]]);
+}
+
+export class CodeExtractionStats extends Record implements IEquatable<CodeExtractionStats>, IComparable<CodeExtractionStats> {
+    readonly Extracted: int32;
+    readonly Generated: int32;
+    readonly BySource: FSharpMap<string, int32>;
+    readonly Regex: string;
+    constructor(Extracted: int32, Generated: int32, BySource: FSharpMap<string, int32>, Regex: string) {
+        super();
+        this.Extracted = (Extracted | 0);
+        this.Generated = (Generated | 0);
+        this.BySource = BySource;
+        this.Regex = Regex;
+    }
+}
+
+export function CodeExtractionStats_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.CodeExtractionStats", [], CodeExtractionStats, () => [["Extracted", int32_type], ["Generated", int32_type], ["BySource", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])], ["Regex", string_type]]);
+}
+
+export class TriggerStats extends Record implements IEquatable<TriggerStats>, IComparable<TriggerStats> {
+    readonly FormsWithTriggers: int32;
+    readonly TotalTriggers: int32;
+    readonly ByActionType: FSharpMap<string, int32>;
+    constructor(FormsWithTriggers: int32, TotalTriggers: int32, ByActionType: FSharpMap<string, int32>) {
+        super();
+        this.FormsWithTriggers = (FormsWithTriggers | 0);
+        this.TotalTriggers = (TotalTriggers | 0);
+        this.ByActionType = ByActionType;
+    }
+}
+
+export function TriggerStats_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.TriggerStats", [], TriggerStats, () => [["FormsWithTriggers", int32_type], ["TotalTriggers", int32_type], ["ByActionType", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])]]);
+}
+
+export class TemplateStats extends Record implements IEquatable<TemplateStats>, IComparable<TemplateStats> {
+    readonly TotalForms: int32;
+    readonly WithCodes: int32;
+    readonly WithSyntheticCodes: int32;
+    readonly WithSignature: int32;
+    readonly ByUsage: FSharpMap<string, int32>;
+    readonly ByElementType: FSharpMap<string, int32>;
+    readonly CodeExtraction: CodeExtractionStats;
+    constructor(TotalForms: int32, WithCodes: int32, WithSyntheticCodes: int32, WithSignature: int32, ByUsage: FSharpMap<string, int32>, ByElementType: FSharpMap<string, int32>, CodeExtraction: CodeExtractionStats) {
+        super();
+        this.TotalForms = (TotalForms | 0);
+        this.WithCodes = (WithCodes | 0);
+        this.WithSyntheticCodes = (WithSyntheticCodes | 0);
+        this.WithSignature = (WithSignature | 0);
+        this.ByUsage = ByUsage;
+        this.ByElementType = ByElementType;
+        this.CodeExtraction = CodeExtraction;
+    }
+}
+
+export function TemplateStats_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.TemplateStats", [], TemplateStats, () => [["TotalForms", int32_type], ["WithCodes", int32_type], ["WithSyntheticCodes", int32_type], ["WithSignature", int32_type], ["ByUsage", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])], ["ByElementType", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])], ["CodeExtraction", CodeExtractionStats_$reflection()]]);
+}
+
+export class CoreEmrInfo extends Record implements IEquatable<CoreEmrInfo>, IComparable<CoreEmrInfo> {
+    readonly AppVersion: string;
+    readonly SchemaVersion: string;
+    readonly SchemaRevision: int32;
+    constructor(AppVersion: string, SchemaVersion: string, SchemaRevision: int32) {
+        super();
+        this.AppVersion = AppVersion;
+        this.SchemaVersion = SchemaVersion;
+        this.SchemaRevision = (SchemaRevision | 0);
+    }
+}
+
+export function CoreEmrInfo_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.CoreEmrInfo", [], CoreEmrInfo, () => [["AppVersion", string_type], ["SchemaVersion", string_type], ["SchemaRevision", int32_type]]);
+}
+
+export class InstrumentMapStats extends Record implements IEquatable<InstrumentMapStats>, IComparable<InstrumentMapStats> {
+    readonly Total: int32;
+    readonly Current: int32;
+    readonly Archived: int32;
+    readonly BySource: FSharpMap<string, int32>;
+    readonly ByType: FSharpMap<string, int32>;
+    constructor(Total: int32, Current: int32, Archived: int32, BySource: FSharpMap<string, int32>, ByType: FSharpMap<string, int32>) {
+        super();
+        this.Total = (Total | 0);
+        this.Current = (Current | 0);
+        this.Archived = (Archived | 0);
+        this.BySource = BySource;
+        this.ByType = ByType;
+    }
+}
+
+export function InstrumentMapStats_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.InstrumentMapStats", [], InstrumentMapStats, () => [["Total", int32_type], ["Current", int32_type], ["Archived", int32_type], ["BySource", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])], ["ByType", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])]]);
+}
+
+export class ScoringCatalog extends Record implements IEquatable<ScoringCatalog>, IComparable<ScoringCatalog> {
+    readonly InstrumentMap: FSharpMap<string, InstrumentMapEntry>;
+    readonly InstrumentMapStats: InstrumentMapStats;
+    readonly FormsWithScoring: int32;
+    constructor(InstrumentMap: FSharpMap<string, InstrumentMapEntry>, InstrumentMapStats: InstrumentMapStats, FormsWithScoring: int32) {
+        super();
+        this.InstrumentMap = InstrumentMap;
+        this.InstrumentMapStats = InstrumentMapStats;
+        this.FormsWithScoring = (FormsWithScoring | 0);
+    }
+}
+
+export function ScoringCatalog_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.ScoringCatalog", [], ScoringCatalog, () => [["InstrumentMap", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, InstrumentMapEntry_$reflection()])], ["InstrumentMapStats", InstrumentMapStats_$reflection()], ["FormsWithScoring", int32_type]]);
+}
+
+const liberatedInt64Decoder: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<int64, [string, ErrorReason_$union]>)) = Auto_generateBoxedDecoder_Z6670B51(int64_type, undefined, undefined);
+
+function dictDecoder<T>(decoder: ((arg0: string, arg1: any) => FSharpResult$2_$union<T, [string, ErrorReason_$union]>)): ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, T>, [string, ErrorReason_$union]>)) {
+    let d: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpList<[string, T]>, [string, ErrorReason_$union]>));
+    const decoder_1: ((arg0: string, arg1: any) => FSharpResult$2_$union<T, [string, ErrorReason_$union]>) = decoder;
+    d = ((path: string): ((arg0: any) => FSharpResult$2_$union<FSharpList<[string, T]>, [string, ErrorReason_$union]>) => ((value: any): FSharpResult$2_$union<FSharpList<[string, T]>, [string, ErrorReason_$union]> => keyValuePairs<T>(decoder_1, path, value)));
+    return (path_1: string): ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, T>, [string, ErrorReason_$union]>) => ((value_1: any): FSharpResult$2_$union<FSharpMap<string, T>, [string, ErrorReason_$union]> => map<FSharpList<[string, T]>, FSharpMap<string, T>>((elements: FSharpList<[string, T]>): FSharpMap<string, T> => ofList<string, T>(elements, {
+        Compare: comparePrimitives,
+    }), uncurry2(d), path_1, value_1));
+}
+
+function orFail<T>(d: ((arg0: string, arg1: any) => FSharpResult$2_$union<FSharpResult$2_$union<T, string>, [string, ErrorReason_$union]>)): ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<T, [string, ErrorReason_$union]>)) {
+    const decoder: ((arg0: string, arg1: any) => FSharpResult$2_$union<FSharpResult$2_$union<T, string>, [string, ErrorReason_$union]>) = d;
+    return (path_1: string): ((arg0: any) => FSharpResult$2_$union<T, [string, ErrorReason_$union]>) => ((value: any): FSharpResult$2_$union<T, [string, ErrorReason_$union]> => andThen<FSharpResult$2_$union<T, string>, T>(uncurry3((r: FSharpResult$2_$union<T, string>): ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<T, [string, ErrorReason_$union]>)) => {
+        if (r.tag === /* Error */ 1) {
+            const msg: string = r.fields[0];
+            return (path: string): ((arg0: any) => FSharpResult$2_$union<T, [string, ErrorReason_$union]>) => ((arg20$0040_1: any): FSharpResult$2_$union<T, [string, ErrorReason_$union]> => fail<T>(msg, path, arg20$0040_1));
+        }
+        else {
+            const v: T = r.fields[0];
+            return (arg10$0040: string): ((arg0: any) => FSharpResult$2_$union<T, [string, ErrorReason_$union]>) => ((arg20$0040: any): FSharpResult$2_$union<T, [string, ErrorReason_$union]> => succeed<T>(v, arg10$0040, arg20$0040));
+        }
+    }), decoder, path_1, value));
+}
+
+function availabilityRowDecoder(field: string): ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<ReleaseAvailability$1_$union<FSharpList<string>>, [string, ErrorReason_$union]>)) {
+    return orFail<ReleaseAvailability$1_$union<FSharpList<string>>>((path_7: string, v: any): FSharpResult$2_$union<FSharpResult$2_$union<ReleaseAvailability$1_$union<FSharpList<string>>, string>, [string, ErrorReason_$union]> => object<FSharpResult$2_$union<ReleaseAvailability$1_$union<FSharpList<string>>, string>>((get$: IGetters): FSharpResult$2_$union<ReleaseAvailability$1_$union<FSharpList<string>>, string> => {
+        let objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter, objectArg_4: IRequiredGetter;
+        let matchValue: string;
+        const objectArg: IRequiredGetter = get$.Required;
+        matchValue = objectArg.Field<string>("kind", string);
+        switch (matchValue) {
+            case "stated":
+                return FSharpResult$2_Ok<ReleaseAvailability$1_$union<FSharpList<string>>, string>(ReleaseAvailability$1_Stated<FSharpList<string>>((objectArg_1 = get$.Required, objectArg_1.Field<FSharpList<string>>("states", (path_2: string, value_2: any): FSharpResult$2_$union<FSharpList<string>, [string, ErrorReason_$union]> => list_7<string>(string, path_2, value_2)))));
+            case "notInRelease":
+                return FSharpResult$2_Ok<ReleaseAvailability$1_$union<FSharpList<string>>, string>(ReleaseAvailability$1_NotInRelease<FSharpList<string>>((objectArg_2 = get$.Required, objectArg_2.Field<string>("because", string))));
+            case "notReadYet":
+                return FSharpResult$2_Ok<ReleaseAvailability$1_$union<FSharpList<string>>, string>(ReleaseAvailability$1_NotReadYet<FSharpList<string>>((objectArg_3 = get$.Required, objectArg_3.Field<string>("because", string)), (objectArg_4 = get$.Required, objectArg_4.Field<FSharpList<string>>("witness", (path_6: string, value_6: any): FSharpResult$2_$union<FSharpList<string>, [string, ErrorReason_$union]> => list_7<string>(string, path_6, value_6)))));
+            default:
+                return FSharpResult$2_Error<ReleaseAvailability$1_$union<FSharpList<string>>, string>(toText(printf("`%s.kind` = `%s` is not a kind this build understands (stated | notInRelease | notReadYet). ⛔ It is NOT read as an absence: a word this build does not know might mean the release DOES state it"))(field)(matchValue));
+        }
+    }, path_7, v));
+}
+
+function join<T>(field: string, row: ReleaseAvailability$1_$union<FSharpList<string>>, datum: Option<T>): FSharpResult$2_$union<ReleaseAvailability$1_$union<T>, string> {
+    switch (row.tag) {
+        case /* NotInRelease */ 1:
+            if (datum == null) {
+                const because_2: string = row.fields[0];
+                return FSharpResult$2_Ok<ReleaseAvailability$1_$union<T>, string>(ReleaseAvailability$1_NotInRelease<T>(because_2));
+            }
+            else {
+                const because: string = row.fields[0];
+                return FSharpResult$2_Error<ReleaseAvailability$1_$union<T>, string>(toText(printf("the answer declares `%s` NOT IN THIS RELEASE (%s) and carries a value for it anyway"))(field)(because));
+            }
+        case /* NotReadYet */ 2:
+            if (datum == null) {
+                const because_3: string = row.fields[0];
+                const witness: FSharpList<string> = row.fields[1];
+                return FSharpResult$2_Ok<ReleaseAvailability$1_$union<T>, string>(ReleaseAvailability$1_NotReadYet<T>(because_3, witness));
+            }
+            else {
+                const because_1: string = row.fields[0];
+                return FSharpResult$2_Error<ReleaseAvailability$1_$union<T>, string>(toText(printf("the answer declares `%s` NOT READ YET (%s) and carries a value for it anyway"))(field)(because_1));
+            }
+        default:
+            if (datum == null) {
+                return FSharpResult$2_Error<ReleaseAvailability$1_$union<T>, string>(toText(printf("the answer declares `%s` STATED by this release, but carries no `%s`"))(field)(field));
+            }
+            else {
+                const v: T = value_15(datum);
+                return FSharpResult$2_Ok<ReleaseAvailability$1_$union<T>, string>(ReleaseAvailability$1_Stated<T>(v));
+            }
+    }
+}
+
+class FormDeclarations extends Record implements IEquatable<FormDeclarations>, IComparable<FormDeclarations> {
+    readonly ItemNesting: ReleaseAvailability$1_$union<FSharpList<string>>;
+    readonly Triggers: ReleaseAvailability$1_$union<FSharpList<string>>;
+    readonly EncounterOther: ReleaseAvailability$1_$union<FSharpList<string>>;
+    readonly Scoring: ReleaseAvailability$1_$union<FSharpList<string>>;
+    constructor(ItemNesting: ReleaseAvailability$1_$union<FSharpList<string>>, Triggers: ReleaseAvailability$1_$union<FSharpList<string>>, EncounterOther: ReleaseAvailability$1_$union<FSharpList<string>>, Scoring: ReleaseAvailability$1_$union<FSharpList<string>>) {
+        super();
+        this.ItemNesting = ItemNesting;
+        this.Triggers = Triggers;
+        this.EncounterOther = EncounterOther;
+        this.Scoring = Scoring;
+    }
+}
+
+function FormDeclarations_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.FormDeclarations", [], FormDeclarations, () => [["ItemNesting", ReleaseAvailability$1_$reflection(list_type(string_type))], ["Triggers", ReleaseAvailability$1_$reflection(list_type(string_type))], ["EncounterOther", ReleaseAvailability$1_$reflection(list_type(string_type))], ["Scoring", ReleaseAvailability$1_$reflection(list_type(string_type))]]);
+}
+
+const choiceDecoder = (path_4: string): ((arg0: any) => FSharpResult$2_$union<TemplateChoice, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<TemplateChoice, [string, ErrorReason_$union]> => object<TemplateChoice>((get$: IGetters): TemplateChoice => {
+    let objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter, objectArg_4: IRequiredGetter, objectArg_5: IRequiredGetter, objectArg_6: IOptionalGetter;
+    let score: int64;
+    const objectArg: IRequiredGetter = get$.Required;
+    score = objectArg.Field<int64>("score", uncurry2(liberatedInt64Decoder));
+    return new TemplateChoice((objectArg_1 = get$.Required, objectArg_1.Field<int32>("choiceId", uncurry2(int))), (objectArg_2 = get$.Required, objectArg_2.Field<int32>("sequence", uncurry2(int))), score, (objectArg_3 = get$.Required, objectArg_3.Field<string>("text", string)), (objectArg_4 = get$.Required, objectArg_4.Field<Option<int32>>("bitPosition", (path_1: string, value_1: any): FSharpResult$2_$union<Option<int32>, [string, ErrorReason_$union]> => option<int32>(uncurry2(int), path_1, value_1))), (objectArg_5 = get$.Required, objectArg_5.Field<Option<string>>("code", (path_3: string, value_3: any): FSharpResult$2_$union<Option<string>, [string, ErrorReason_$union]> => option<string>(string, path_3, value_3))), (objectArg_6 = get$.Optional, objectArg_6.Field<int32>("highlight", uncurry2(int))));
+}, path_4, v));
+
+const triggerConditionDecoder = (path_8: string): ((arg0: any) => FSharpResult$2_$union<TriggerCondition, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<TriggerCondition, [string, ErrorReason_$union]> => object<TriggerCondition>((get$: IGetters): TriggerCondition => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter, objectArg_4: IRequiredGetter, objectArg_5: IRequiredGetter, objectArg_6: IRequiredGetter;
+    return new TriggerCondition((objectArg = get$.Required, objectArg.Field<int32>("conditionId", uncurry2(int))), (objectArg_1 = get$.Required, objectArg_1.Field<Option<int32>>("sourceFieldId", (path: string, value: any): FSharpResult$2_$union<Option<int32>, [string, ErrorReason_$union]> => option<int32>(uncurry2(int), path, value))), (objectArg_2 = get$.Required, objectArg_2.Field<string>("source", string)), (objectArg_3 = get$.Required, objectArg_3.Field<string>("operator", string)), (objectArg_4 = get$.Required, objectArg_4.Field<FSharpList<string>>("values", (path_4: string, value_4: any): FSharpResult$2_$union<FSharpList<string>, [string, ErrorReason_$union]> => list_7<string>(string, path_4, value_4))), (objectArg_5 = get$.Required, objectArg_5.Field<FSharpList<int32>>("rawChoiceIds", (path_5: string, value_5: any): FSharpResult$2_$union<FSharpList<int32>, [string, ErrorReason_$union]> => list_7<int32>(uncurry2(int), path_5, value_5))), (objectArg_6 = get$.Required, objectArg_6.Field<Option<string>>("booleanOperator", (path_7: string, value_7: any): FSharpResult$2_$union<Option<string>, [string, ErrorReason_$union]> => option<string>(string, path_7, value_7))));
+}, path_8, v));
+
+type ParamValue_$union = 
+    | ParamValue<0>
+    | ParamValue<1>
+
+type ParamValue_$cases = {
+    0: ["ScalarParam", [string]],
+    1: ["ListParam", [FSharpList<string>]]
+}
+
+function ParamValue_ScalarParam(Item: string) {
+    return new ParamValue<0>(0, [Item]);
+}
+
+function ParamValue_ListParam(Item: FSharpList<string>) {
+    return new ParamValue<1>(1, [Item]);
+}
+
+class ParamValue<Tag extends keyof ParamValue_$cases> extends Union<Tag, ParamValue_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ParamValue_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["ScalarParam", "ListParam"];
+    }
+}
+
+function ParamValue_$reflection(): TypeInfo {
+    return union_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.ParamValue", [], ParamValue, () => [[["Item", string_type]], [["Item", list_type(string_type)]]]);
+}
+
+const paramValueDecoder = (path_5: string): ((arg0: any) => FSharpResult$2_$union<ParamValue_$union, [string, ErrorReason_$union]>) => ((value_5: any): FSharpResult$2_$union<ParamValue_$union, [string, ErrorReason_$union]> => oneOf<ParamValue_$union>(ofArray([(path_1: string): ((arg0: any) => FSharpResult$2_$union<ParamValue_$union, [string, ErrorReason_$union]>) => ((value_1: any): FSharpResult$2_$union<ParamValue_$union, [string, ErrorReason_$union]> => map<string, ParamValue_$union>(ParamValue_ScalarParam, string, path_1, value_1)), (path_4: string): ((arg0: any) => FSharpResult$2_$union<ParamValue_$union, [string, ErrorReason_$union]>) => ((value_4: any): FSharpResult$2_$union<ParamValue_$union, [string, ErrorReason_$union]> => map<FSharpList<string>, ParamValue_$union>(ParamValue_ListParam, (path_3: string, value_3: any): FSharpResult$2_$union<FSharpList<string>, [string, ErrorReason_$union]> => list_7<string>(string, path_3, value_3), path_4, value_4))]), path_5, value_5));
+
+const triggerActionDecoder: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<TriggerAction, [string, ErrorReason_$union]>)) = (() => {
+    let d_2: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, ParamValue_$union>, [string, ErrorReason_$union]>));
+    const decoder_2: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, ParamValue_$union>, [string, ErrorReason_$union]>)) = dictDecoder<ParamValue_$union>(uncurry2(paramValueDecoder));
+    d_2 = ((path_3: string): ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, ParamValue_$union>, [string, ErrorReason_$union]>) => ((value_3: any): FSharpResult$2_$union<FSharpMap<string, ParamValue_$union>, [string, ErrorReason_$union]> => field_1<FSharpMap<string, ParamValue_$union>>("params", uncurry2(decoder_2), path_3, value_3)));
+    return (path_4: string): ((arg0: any) => FSharpResult$2_$union<TriggerAction, [string, ErrorReason_$union]>) => ((value_4: any): FSharpResult$2_$union<TriggerAction, [string, ErrorReason_$union]> => map3<int32, string, FSharpMap<string, ParamValue_$union>, TriggerAction>((actionId: int32, actionType: string, raw: FSharpMap<string, ParamValue_$union>): TriggerAction => {
+        let matchValue: FSharpList<[string, FSharpList<string>]>;
+        return new TriggerAction(actionId, actionType, ofList<string, string>(choose<[string, ParamValue_$union], [string, string]>((_arg: [string, ParamValue_$union]): Option<[string, string]> => {
+            if (_arg[1].tag === /* ListParam */ 1) {
+                return undefined;
+            }
+            else {
+                return [_arg[0], (_arg[1] as ParamValue<0>).fields[0]] as [string, string];
+            }
+        }, toList<string, ParamValue_$union>(raw)), {
+            Compare: comparePrimitives,
+        }), (matchValue = choose<[string, ParamValue_$union], [string, FSharpList<string>]>((_arg_1: [string, ParamValue_$union]): Option<[string, FSharpList<string>]> => {
+            if (_arg_1[1].tag === /* ScalarParam */ 0) {
+                return undefined;
+            }
+            else {
+                return [_arg_1[0], (_arg_1[1] as ParamValue<1>).fields[0]] as [string, FSharpList<string>];
+            }
+        }, toList<string, ParamValue_$union>(raw)), isEmpty(matchValue) ? undefined : ofList<string, FSharpList<string>>(matchValue, {
+            Compare: comparePrimitives,
+        })));
+    }, (path: string, value: any): FSharpResult$2_$union<int32, [string, ErrorReason_$union]> => field_1<int32>("actionId", uncurry2(int), path, value), (path_2: string, value_2: any): FSharpResult$2_$union<string, [string, ErrorReason_$union]> => field_1<string>("actionType", string, path_2, value_2), uncurry2(d_2), path_4, value_4));
+})();
+
+const itemTriggerDecoder = (path_6: string): ((arg0: any) => FSharpResult$2_$union<ItemTrigger, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<ItemTrigger, [string, ErrorReason_$union]> => object<ItemTrigger>((get$: IGetters): ItemTrigger => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter, objectArg_4: IRequiredGetter, objectArg_5: IRequiredGetter;
+    return new ItemTrigger((objectArg = get$.Required, objectArg.Field<int32>("triggerId", uncurry2(int))), (objectArg_1 = get$.Required, objectArg_1.Field<string>("eventName", string)), (objectArg_2 = get$.Required, objectArg_2.Field<boolean>("enabled", bool)), (objectArg_3 = get$.Required, objectArg_3.Field<Option<string>>("exclusiveTag", (path_3: string, value_3: any): FSharpResult$2_$union<Option<string>, [string, ErrorReason_$union]> => option<string>(string, path_3, value_3))), (objectArg_4 = get$.Required, objectArg_4.Field<FSharpList<TriggerCondition>>("conditions", (path_4: string, value_4: any): FSharpResult$2_$union<FSharpList<TriggerCondition>, [string, ErrorReason_$union]> => list_7<TriggerCondition>(uncurry2(triggerConditionDecoder), path_4, value_4))), (objectArg_5 = get$.Required, objectArg_5.Field<FSharpList<TriggerAction>>("actions", (path_5: string, value_5: any): FSharpResult$2_$union<FSharpList<TriggerAction>, [string, ErrorReason_$union]> => list_7<TriggerAction>(uncurry2(triggerActionDecoder), path_5, value_5))));
+}, path_6, v));
+
+function itemDecoder(declared: FormDeclarations): ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<TemplateItem, [string, ErrorReason_$union]>)) {
+    return orFail<TemplateItem>((path_13: string, v: any): FSharpResult$2_$union<FSharpResult$2_$union<TemplateItem, string>, [string, ErrorReason_$union]> => object<FSharpResult$2_$union<TemplateItem, string>>((get$: IGetters): FSharpResult$2_$union<TemplateItem, string> => {
+        let objectArg_1: IOptionalGetter, objectArg_2: IOptionalGetter, objectArg_3: IRequiredGetter, objectArg_4: IRequiredGetter, objectArg_5: IRequiredGetter, objectArg_6: IRequiredGetter, objectArg_7: IRequiredGetter, objectArg_8: IRequiredGetter, objectArg_9: IRequiredGetter, objectArg_10: IRequiredGetter, objectArg_11: IOptionalGetter, objectArg_12: IRequiredGetter;
+        let itemId: int32;
+        const objectArg: IRequiredGetter = get$.Required;
+        itemId = objectArg.Field<int32>("itemId", uncurry2(int));
+        const path = (f: string): string => toText(printf("forms[].items[itemId=%d].%s"))(itemId)(f);
+        const nesting: FSharpResult$2_$union<ReleaseAvailability$1_$union<int32>, string> = join<int32>(path("nestingLevel"), declared.ItemNesting, (objectArg_1 = get$.Optional, objectArg_1.Field<int32>("nestingLevel", uncurry2(int))));
+        const triggers: FSharpResult$2_$union<ReleaseAvailability$1_$union<FSharpList<ItemTrigger>>, string> = join<FSharpList<ItemTrigger>>(path("triggers"), declared.Triggers, (objectArg_2 = get$.Optional, objectArg_2.Field<FSharpList<ItemTrigger>>("triggers", (path_1: string, value: any): FSharpResult$2_$union<FSharpList<ItemTrigger>, [string, ErrorReason_$union]> => list_7<ItemTrigger>(uncurry2(itemTriggerDecoder), path_1, value))));
+        let matchResult: int32, itemTriggers: ReleaseAvailability$1_$union<FSharpList<ItemTrigger>>, nestingLevel: ReleaseAvailability$1_$union<int32>, e: string;
+        const copyOfStruct: FSharpResult$2_$union<ReleaseAvailability$1_$union<int32>, string> = nesting;
+        if (copyOfStruct.tag === /* Error */ 1) {
+            matchResult = 1;
+            e = copyOfStruct.fields[0];
+        }
+        else {
+            const copyOfStruct_1: FSharpResult$2_$union<ReleaseAvailability$1_$union<FSharpList<ItemTrigger>>, string> = triggers;
+            if (copyOfStruct_1.tag === /* Error */ 1) {
+                matchResult = 1;
+                e = copyOfStruct_1.fields[0];
+            }
+            else {
+                matchResult = 0;
+                itemTriggers = copyOfStruct_1.fields[0];
+                nestingLevel = copyOfStruct.fields[0];
+            }
+        }
+        switch (matchResult) {
+            case 0:
+                return FSharpResult$2_Ok<TemplateItem, string>(new TemplateItem(itemId, (objectArg_3 = get$.Required, objectArg_3.Field<int32>("sequence", uncurry2(int))), (objectArg_4 = get$.Required, objectArg_4.Field<int32>("type", uncurry2(int))), nestingLevel!, (objectArg_5 = get$.Required, objectArg_5.Field<boolean>("isRequired", bool)), (objectArg_6 = get$.Required, objectArg_6.Field<string>("text", string)), (objectArg_7 = get$.Required, objectArg_7.Field<Option<string>>("sequenceText", (path_5: string, value_4: any): FSharpResult$2_$union<Option<string>, [string, ErrorReason_$union]> => option<string>(string, path_5, value_4))), (objectArg_8 = get$.Required, objectArg_8.Field<Option<string>>("code", (path_7: string, value_6: any): FSharpResult$2_$union<Option<string>, [string, ErrorReason_$union]> => option<string>(string, path_7, value_6))), (objectArg_9 = get$.Required, objectArg_9.Field<Option<string>>("uuid", (path_9: string, value_8: any): FSharpResult$2_$union<Option<string>, [string, ErrorReason_$union]> => option<string>(string, path_9, value_8))), (objectArg_10 = get$.Required, objectArg_10.Field<Option<string>>("genderRequired", (path_11: string, value_10: any): FSharpResult$2_$union<Option<string>, [string, ErrorReason_$union]> => option<string>(string, path_11, value_10))), (objectArg_11 = get$.Optional, objectArg_11.Field<int32>("highlight", uncurry2(int))), (objectArg_12 = get$.Required, objectArg_12.Field<FSharpList<TemplateChoice>>("choices", (path_12: string, value_11: any): FSharpResult$2_$union<FSharpList<TemplateChoice>, [string, ErrorReason_$union]> => list_7<TemplateChoice>(uncurry2(choiceDecoder), path_12, value_11))), itemTriggers!));
+            default:
+                return FSharpResult$2_Error<TemplateItem, string>(e!);
+        }
+    }, path_13, v));
+}
+
+function encounterTypesDecoder(declared: FormDeclarations): ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<EncounterTypes, [string, ErrorReason_$union]>)) {
+    return orFail<EncounterTypes>((path_4: string, v: any): FSharpResult$2_$union<FSharpResult$2_$union<EncounterTypes, string>, [string, ErrorReason_$union]> => object<FSharpResult$2_$union<EncounterTypes, string>>((get$: IGetters): FSharpResult$2_$union<EncounterTypes, string> => {
+        let objectArg: IOptionalGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter;
+        const matchValue: FSharpResult$2_$union<ReleaseAvailability$1_$union<boolean>, string> = join<boolean>("forms[].encounterTypes.other", declared.EncounterOther, (objectArg = get$.Optional, objectArg.Field<boolean>("other", bool)));
+        if (matchValue.tag === /* Error */ 1) {
+            return FSharpResult$2_Error<EncounterTypes, string>(matchValue.fields[0]);
+        }
+        else {
+            const other: ReleaseAvailability$1_$union<boolean> = matchValue.fields[0];
+            return FSharpResult$2_Ok<EncounterTypes, string>(new EncounterTypes((objectArg_1 = get$.Required, objectArg_1.Field<boolean>("medical", bool)), (objectArg_2 = get$.Required, objectArg_2.Field<boolean>("mental", bool)), (objectArg_3 = get$.Required, objectArg_3.Field<boolean>("dental", bool)), other));
+        }
+    }, path_4, v));
+}
+
+const scoringLabelDecoder = (path_1: string): ((arg0: any) => FSharpResult$2_$union<ScoringLabel, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<ScoringLabel, [string, ErrorReason_$union]> => object<ScoringLabel>((get$: IGetters): ScoringLabel => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter;
+    return new ScoringLabel((objectArg = get$.Required, objectArg.Field<string>("name", string)), (objectArg_1 = get$.Required, objectArg_1.Field<int32>("min", uncurry2(int))));
+}, path_1, v));
+
+const formScoringDecoder = (path_2: string): ((arg0: any) => FSharpResult$2_$union<FormScoring, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<FormScoring, [string, ErrorReason_$union]> => object<FormScoring>((get$: IGetters): FormScoring => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, arg_7: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, int32>, [string, ErrorReason_$union]>)), objectArg_3: IRequiredGetter;
+    return new FormScoring((objectArg = get$.Required, objectArg.Field<int32>("scoreId", uncurry2(int))), (objectArg_1 = get$.Required, objectArg_1.Field<string>("scoreName", string)), (objectArg_2 = get$.Required, objectArg_2.Field<FSharpList<ScoringLabel>>("labels", (path_1: string, value_1: any): FSharpResult$2_$union<FSharpList<ScoringLabel>, [string, ErrorReason_$union]> => list_7<ScoringLabel>(uncurry2(scoringLabelDecoder), path_1, value_1))), (arg_7 = dictDecoder<int32>(uncurry2(int)), (objectArg_3 = get$.Required, objectArg_3.Field<FSharpMap<string, int32>>("choiceScores", uncurry2(arg_7)))));
+}, path_2, v));
+
+function formDecoder(declared: FormDeclarations): ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<TemplateForm, [string, ErrorReason_$union]>)) {
+    return orFail<TemplateForm>((path_15: string, v: any): FSharpResult$2_$union<FSharpResult$2_$union<TemplateForm, string>, [string, ErrorReason_$union]> => object<FSharpResult$2_$union<TemplateForm, string>>((get$: IGetters): FSharpResult$2_$union<TemplateForm, string> => {
+        let objectArg: IRequiredGetter, objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter, objectArg_4: IRequiredGetter, objectArg_5: IRequiredGetter, objectArg_6: IRequiredGetter, objectArg_7: IRequiredGetter, objectArg_8: IRequiredGetter, objectArg_9: IRequiredGetter, objectArg_10: IRequiredGetter, arg_24: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<EncounterTypes, [string, ErrorReason_$union]>)), objectArg_11: IRequiredGetter, objectArg_12: IRequiredGetter, objectArg_13: IRequiredGetter, objectArg_14: IRequiredGetter, objectArg_15: IRequiredGetter, objectArg_16: IRequiredGetter, arg_36: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpList<TemplateItem>, [string, ErrorReason_$union]>)), decoder_2: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<TemplateItem, [string, ErrorReason_$union]>)), objectArg_17: IRequiredGetter;
+        let scoring: FSharpResult$2_$union<Option<FormScoring>, string>;
+        const matchValue: ReleaseAvailability$1_$union<FSharpList<string>> = declared.Scoring;
+        let matchResult: int32, because: string;
+        switch (matchValue.tag) {
+            case /* NotInRelease */ 1: {
+                matchResult = 1;
+                because = matchValue.fields[0];
+                break;
+            }
+            case /* NotReadYet */ 2: {
+                matchResult = 1;
+                because = matchValue.fields[0];
+                break;
+            }
+            default:
+                matchResult = 0;
+        }
+        switch (matchResult) {
+            case 0: {
+                scoring = FSharpResult$2_Ok<Option<FormScoring>, string>((objectArg = get$.Required, objectArg.Field<Option<FormScoring>>("scoring", (path: string, value: any): FSharpResult$2_$union<Option<FormScoring>, [string, ErrorReason_$union]> => option<FormScoring>(uncurry2(formScoringDecoder), path, value))));
+                break;
+            }
+            default: {
+                let matchValue_1: Option<FormScoring>;
+                const objectArg_1: IOptionalGetter = get$.Optional;
+                matchValue_1 = objectArg_1.Field<FormScoring>("scoring", uncurry2(formScoringDecoder));
+                scoring = ((matchValue_1 != null) ? FSharpResult$2_Error<Option<FormScoring>, string>(toText(printf("the answer declares scoring NOT stated by this release (%s) and the form carries a `scoring` anyway"))(because!)) : FSharpResult$2_Ok<Option<FormScoring>, string>(undefined));
+            }
+        }
+        if (scoring.tag === /* Ok */ 0) {
+            const formScoring: Option<FormScoring> = scoring.fields[0];
+            return FSharpResult$2_Ok<TemplateForm, string>(new TemplateForm((objectArg_2 = get$.Required, objectArg_2.Field<int32>("formId", uncurry2(int))), (objectArg_3 = get$.Required, objectArg_3.Field<string>("name", string)), (objectArg_4 = get$.Required, objectArg_4.Field<string>("formCode", string)), (objectArg_5 = get$.Required, objectArg_5.Field<string>("formCodeSource", string)), (objectArg_6 = get$.Required, objectArg_6.Field<string>("description", string)), (objectArg_7 = get$.Required, objectArg_7.Field<int64>("currentVersionId", uncurry2(liberatedInt64Decoder))), (objectArg_8 = get$.Required, objectArg_8.Field<boolean>("isIntake", bool)), (objectArg_9 = get$.Required, objectArg_9.Field<Option<string>>("usage", (path_7: string, value_7: any): FSharpResult$2_$union<Option<string>, [string, ErrorReason_$union]> => option<string>(string, path_7, value_7))), (objectArg_10 = get$.Required, objectArg_10.Field<boolean>("requiresSignature", bool)), (arg_24 = encounterTypesDecoder(declared), (objectArg_11 = get$.Required, objectArg_11.Field<EncounterTypes>("encounterTypes", uncurry2(arg_24)))), (objectArg_12 = get$.Required, objectArg_12.Field<boolean>("onceAYear", bool)), (objectArg_13 = get$.Required, objectArg_13.Field<string>("structureHash", string)), (objectArg_14 = get$.Required, objectArg_14.Field<string>("clinicalHash", string)), (objectArg_15 = get$.Required, objectArg_15.Field<string>("cosmeticHash", string)), (objectArg_16 = get$.Required, objectArg_16.Field<string>("hash", string)), (arg_36 = ((decoder_2 = itemDecoder(declared), (path_14: string): ((arg0: any) => FSharpResult$2_$union<FSharpList<TemplateItem>, [string, ErrorReason_$union]>) => ((value_14: any): FSharpResult$2_$union<FSharpList<TemplateItem>, [string, ErrorReason_$union]> => list_7<TemplateItem>(uncurry2(decoder_2), path_14, value_14)))), (objectArg_17 = get$.Required, objectArg_17.Field<FSharpList<TemplateItem>>("items", uncurry2(arg_36)))), formScoring));
+        }
+        else {
+            return FSharpResult$2_Error<TemplateForm, string>(scoring.fields[0]);
+        }
+    }, path_15, v));
+}
+
+const elementTypeDecoder = (path_2: string): ((arg0: any) => FSharpResult$2_$union<ElementTypeEntry, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<ElementTypeEntry, [string, ErrorReason_$union]> => object<ElementTypeEntry>((get$: IGetters): ElementTypeEntry => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter;
+    return new ElementTypeEntry((objectArg = get$.Required, objectArg.Field<string>("label", string)), (objectArg_1 = get$.Required, objectArg_1.Field<string>("control", string)));
+}, path_2, v));
+
+const elementTypesFromDecoder: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<ElementTypesFrom_$union, [string, ErrorReason_$union]>)) = orFail<ElementTypesFrom_$union>((path_6: string, v: any): FSharpResult$2_$union<FSharpResult$2_$union<ElementTypesFrom_$union, string>, [string, ErrorReason_$union]> => object<FSharpResult$2_$union<ElementTypesFrom_$union, string>>((get$: IGetters): FSharpResult$2_$union<ElementTypesFrom_$union, string> => {
+    let objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter, objectArg_4: IRequiredGetter, objectArg_5: IRequiredGetter;
+    let matchValue: string;
+    const objectArg: IRequiredGetter = get$.Required;
+    matchValue = objectArg.Field<string>("statedBy", string);
+    switch (matchValue) {
+        case "site":
+            return FSharpResult$2_Ok<ElementTypesFrom_$union, string>(ElementTypesFrom_StatedBy((objectArg_1 = get$.Required, objectArg_1.Field<string>("table", string)), (objectArg_2 = get$.Required, objectArg_2.Field<string>("key", string)), (objectArg_3 = get$.Required, objectArg_3.Field<string>("label", string))));
+        case "conduit":
+            return FSharpResult$2_Ok<ElementTypesFrom_$union, string>(ElementTypesFrom_DeclaredByConduit((objectArg_4 = get$.Required, objectArg_4.Field<string>("because", string))));
+        case "nobody":
+            return FSharpResult$2_Ok<ElementTypesFrom_$union, string>(ElementTypesFrom_NotInRelease((objectArg_5 = get$.Required, objectArg_5.Field<string>("because", string))));
+        default:
+            return FSharpResult$2_Error<ElementTypesFrom_$union, string>(toText(printf("`elementTypesFrom.statedBy` = `%s` is not a provenance this build understands (site | conduit | nobody)"))(matchValue));
+    }
+}, path_6, v));
+
+const instrumentMapEntryDecoder = (path_6: string): ((arg0: any) => FSharpResult$2_$union<InstrumentMapEntry, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<InstrumentMapEntry, [string, ErrorReason_$union]> => object<InstrumentMapEntry>((get$: IGetters): InstrumentMapEntry => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter, objectArg_4: IRequiredGetter, objectArg_5: IRequiredGetter;
+    return new InstrumentMapEntry((objectArg = get$.Required, objectArg.Field<string>("instrumentType", string)), (objectArg_1 = get$.Required, objectArg_1.Field<string>("formCode", string)), (objectArg_2 = get$.Required, objectArg_2.Field<Option<int32>>("maxScore", (path_2: string, value_2: any): FSharpResult$2_$union<Option<int32>, [string, ErrorReason_$union]> => option<int32>(uncurry2(int), path_2, value_2))), (objectArg_3 = get$.Required, objectArg_3.Field<string>("source", string)), (objectArg_4 = get$.Required, objectArg_4.Field<boolean>("archived", bool)), (objectArg_5 = get$.Required, objectArg_5.Field<string>("formName", string)));
+}, path_6, v));
+
+const codeExtractionStatsDecoder = (path_1: string): ((arg0: any) => FSharpResult$2_$union<CodeExtractionStats, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<CodeExtractionStats, [string, ErrorReason_$union]> => object<CodeExtractionStats>((get$: IGetters): CodeExtractionStats => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, arg_5: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, int32>, [string, ErrorReason_$union]>)), objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter;
+    return new CodeExtractionStats((objectArg = get$.Required, objectArg.Field<int32>("extracted", uncurry2(int))), (objectArg_1 = get$.Required, objectArg_1.Field<int32>("generated", uncurry2(int))), (arg_5 = dictDecoder<int32>(uncurry2(int)), (objectArg_2 = get$.Required, objectArg_2.Field<FSharpMap<string, int32>>("bySource", uncurry2(arg_5)))), (objectArg_3 = get$.Required, objectArg_3.Field<string>("regex", string)));
+}, path_1, v));
+
+const triggerStatsDecoder = (path: string): ((arg0: any) => FSharpResult$2_$union<TriggerStats, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<TriggerStats, [string, ErrorReason_$union]> => object<TriggerStats>((get$: IGetters): TriggerStats => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, arg_5: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, int32>, [string, ErrorReason_$union]>)), objectArg_2: IRequiredGetter;
+    return new TriggerStats((objectArg = get$.Required, objectArg.Field<int32>("formsWithTriggers", uncurry2(int))), (objectArg_1 = get$.Required, objectArg_1.Field<int32>("totalTriggers", uncurry2(int))), (arg_5 = dictDecoder<int32>(uncurry2(int)), (objectArg_2 = get$.Required, objectArg_2.Field<FSharpMap<string, int32>>("byActionType", uncurry2(arg_5)))));
+}, path, v));
+
+const statsDecoder = (path: string): ((arg0: any) => FSharpResult$2_$union<TemplateStats, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<TemplateStats, [string, ErrorReason_$union]> => object<TemplateStats>((get$: IGetters): TemplateStats => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter, arg_9: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, int32>, [string, ErrorReason_$union]>)), objectArg_4: IRequiredGetter, arg_11: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, int32>, [string, ErrorReason_$union]>)), objectArg_5: IRequiredGetter, objectArg_6: IRequiredGetter;
+    return new TemplateStats((objectArg = get$.Required, objectArg.Field<int32>("totalForms", uncurry2(int))), (objectArg_1 = get$.Required, objectArg_1.Field<int32>("withCodes", uncurry2(int))), (objectArg_2 = get$.Required, objectArg_2.Field<int32>("withSyntheticCodes", uncurry2(int))), (objectArg_3 = get$.Required, objectArg_3.Field<int32>("withSignature", uncurry2(int))), (arg_9 = dictDecoder<int32>(uncurry2(int)), (objectArg_4 = get$.Required, objectArg_4.Field<FSharpMap<string, int32>>("byUsage", uncurry2(arg_9)))), (arg_11 = dictDecoder<int32>(uncurry2(int)), (objectArg_5 = get$.Required, objectArg_5.Field<FSharpMap<string, int32>>("byElementType", uncurry2(arg_11)))), (objectArg_6 = get$.Required, objectArg_6.Field<CodeExtractionStats>("codeExtraction", uncurry2(codeExtractionStatsDecoder))));
+}, path, v));
+
+const coreEmrDecoder = (path_2: string): ((arg0: any) => FSharpResult$2_$union<CoreEmrInfo, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<CoreEmrInfo, [string, ErrorReason_$union]> => object<CoreEmrInfo>((get$: IGetters): CoreEmrInfo => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter;
+    return new CoreEmrInfo((objectArg = get$.Required, objectArg.Field<string>("appVersion", string)), (objectArg_1 = get$.Required, objectArg_1.Field<string>("schemaVersion", string)), (objectArg_2 = get$.Required, objectArg_2.Field<int32>("schemaRevision", uncurry2(int))));
+}, path_2, v));
+
+const instrumentMapStatsDecoder = (path: string): ((arg0: any) => FSharpResult$2_$union<InstrumentMapStats, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<InstrumentMapStats, [string, ErrorReason_$union]> => object<InstrumentMapStats>((get$: IGetters): InstrumentMapStats => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, arg_7: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, int32>, [string, ErrorReason_$union]>)), objectArg_3: IRequiredGetter, arg_9: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, int32>, [string, ErrorReason_$union]>)), objectArg_4: IRequiredGetter;
+    return new InstrumentMapStats((objectArg = get$.Required, objectArg.Field<int32>("total", uncurry2(int))), (objectArg_1 = get$.Required, objectArg_1.Field<int32>("current", uncurry2(int))), (objectArg_2 = get$.Required, objectArg_2.Field<int32>("archived", uncurry2(int))), (arg_7 = dictDecoder<int32>(uncurry2(int)), (objectArg_3 = get$.Required, objectArg_3.Field<FSharpMap<string, int32>>("bySource", uncurry2(arg_7)))), (arg_9 = dictDecoder<int32>(uncurry2(int)), (objectArg_4 = get$.Required, objectArg_4.Field<FSharpMap<string, int32>>("byType", uncurry2(arg_9)))));
+}, path, v));
+
+function scoringCatalogOf(instrumentMap: Option<FSharpMap<string, InstrumentMapEntry>>, instrumentMapStats: Option<InstrumentMapStats>, withScoring: Option<int32>): FSharpResult$2_$union<Option<ScoringCatalog>, string> {
+    let arg: string;
+    let matchResult: int32, m: FSharpMap<string, InstrumentMapEntry>, s: InstrumentMapStats, w: int32;
+    if (instrumentMap == null) {
+        if (instrumentMapStats == null) {
+            if (withScoring == null) {
+                matchResult = 1;
+            }
+            else {
+                matchResult = 2;
+            }
+        }
+        else {
+            matchResult = 2;
+        }
+    }
+    else if (instrumentMapStats != null) {
+        if (withScoring != null) {
+            matchResult = 0;
+            m = value_15(instrumentMap);
+            s = value_15(instrumentMapStats);
+            w = value_15(withScoring);
+        }
+        else {
+            matchResult = 2;
+        }
+    }
+    else {
+        matchResult = 2;
+    }
+    switch (matchResult) {
+        case 0:
+            return FSharpResult$2_Ok<Option<ScoringCatalog>, string>(new ScoringCatalog(m!, s!, w!));
+        case 1:
+            return FSharpResult$2_Ok<Option<ScoringCatalog>, string>(undefined);
+        default:
+            return FSharpResult$2_Error<Option<ScoringCatalog>, string>((arg = join_1("`, `", toList_1<string>(delay<string>((): Iterable<string> => append<string>((instrumentMap != null) ? singleton<string>("instrumentMap") : empty_1<string>(), delay<string>((): Iterable<string> => append<string>((instrumentMapStats != null) ? singleton<string>("instrumentMapStats") : empty_1<string>(), delay<string>((): Iterable<string> => ((withScoring != null) ? singleton<string>("stats.withScoring") : empty_1<string>())))))))), toText(printf("the scoring catalog is PARTIAL — `%s` present, the rest absent. One release fact governs all three; half of it cannot be read"))(arg)));
+    }
+}
+
+/**
+ * Convert a TemplateChoice to CoreMRChoice (FormSpec type).
+ * Score stays int64 — raw scores can reach 2^31 for bitmask forms.
+ * Does this control carry free text, and does it carry a date?
+ * 
+ * ⭐ THE ONE IMPLEMENTATION. It lives here because this file compiles before every adapter that needs
+ * it, so nothing downstream has an excuse to write a second one. ⛔ It follows from the CONTROL, which
+ * the site states (5.5.0+9704) or conduit declares (5.5.0+10245) — never from the invented `textField`
+ * word, which nothing publishes any more.
+ * ⚠️ It says what the UI OFFERS, not what a given item's answers contain: type 130 is a vitals widget
+ * and 35,427 of its answers carry text anyway.
+ */
+export function carriesTextOrDate(control: string): [boolean, boolean] {
+    let matchResult: int32, c_3: string;
+    switch (control) {
+        case "DateField":
+        case "DateFieldWithTime": {
+            matchResult = 0;
+            break;
+        }
+        case "SignatureAndDate":
+        case "SignatureAndDateWithTime": {
+            matchResult = 1;
+            break;
+        }
+        case "ShortAnswer":
+        case "NoteEssay": {
+            matchResult = 2;
+            break;
+        }
+        case "PatientVitals": {
+            if (control.endsWith("PlusNotes")) {
+                matchResult = 3;
+                c_3 = control;
+            }
+            else {
+                matchResult = 4;
+            }
+            break;
+        }
+        case "AllergyFinder": {
+            if (control.endsWith("PlusNotes")) {
+                matchResult = 3;
+                c_3 = control;
+            }
+            else {
+                matchResult = 4;
+            }
+            break;
+        }
+        default:
+            if (control.endsWith("PlusNotes")) {
+                matchResult = 3;
+                c_3 = control;
+            }
+            else {
+                matchResult = 5;
+            }
+    }
+    switch (matchResult) {
+        case 0:
+            return [true, true] as [boolean, boolean];
+        case 1:
+            return [true, true] as [boolean, boolean];
+        case 2:
+            return [true, false] as [boolean, boolean];
+        case 3:
+            return [true, false] as [boolean, boolean];
+        case 4:
+            return [true, false] as [boolean, boolean];
+        default:
+            return [false, false] as [boolean, boolean];
+    }
+}
+
+export class FormTemplateServed extends Record implements IEquatable<FormTemplateServed>, IComparable<FormTemplateServed> {
+    readonly Form: TemplateForm;
+    readonly ElementTypes: Option<FSharpMap<string, ElementTypeEntry>>;
+    readonly ElementTypesFrom: ElementTypesFrom_$union;
+    readonly Instrument: ReleaseAvailability$1_$union<Option<InstrumentMapEntry>>;
+    readonly GeneratedFrom: string;
+    readonly TriggersFrom: ReleaseAvailability$1_$union<FSharpList<string>>;
+    readonly ActiveAt: FSharpList<int32>;
+    readonly TriggerReads: ReleaseAvailability$1_$union<FSharpList<Trigger>>;
+    constructor(Form: TemplateForm, ElementTypes: Option<FSharpMap<string, ElementTypeEntry>>, ElementTypesFrom: ElementTypesFrom_$union, Instrument: ReleaseAvailability$1_$union<Option<InstrumentMapEntry>>, GeneratedFrom: string, TriggersFrom: ReleaseAvailability$1_$union<FSharpList<string>>, ActiveAt: FSharpList<int32>, TriggerReads: ReleaseAvailability$1_$union<FSharpList<Trigger>>) {
+        super();
+        this.Form = Form;
+        this.ElementTypes = ElementTypes;
+        this.ElementTypesFrom = ElementTypesFrom;
+        this.Instrument = Instrument;
+        this.GeneratedFrom = GeneratedFrom;
+        this.TriggersFrom = TriggersFrom;
+        this.ActiveAt = ActiveAt;
+        this.TriggerReads = TriggerReads;
+    }
+}
+
+export function FormTemplateServed_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.FormTemplateServed", [], FormTemplateServed, () => [["Form", TemplateForm_$reflection()], ["ElementTypes", option_type(class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, ElementTypeEntry_$reflection()]))], ["ElementTypesFrom", ElementTypesFrom_$reflection()], ["Instrument", ReleaseAvailability$1_$reflection(option_type(InstrumentMapEntry_$reflection()))], ["GeneratedFrom", string_type], ["TriggersFrom", ReleaseAvailability$1_$reflection(list_type(string_type))], ["ActiveAt", list_type(int32_type)], ["TriggerReads", ReleaseAvailability$1_$reflection(list_type(Trigger_$reflection()))]]);
+}
+
+export type FormTemplateAnswer_$union = 
+    | FormTemplateAnswer<0>
+    | FormTemplateAnswer<1>
+
+export type FormTemplateAnswer_$cases = {
+    0: ["Served", [FormTemplateServed]],
+    1: ["NotInCatalog", [int32, string]]
+}
+
+export function FormTemplateAnswer_Served(Item: FormTemplateServed) {
+    return new FormTemplateAnswer<0>(0, [Item]);
+}
+
+export function FormTemplateAnswer_NotInCatalog(formId: int32, because: string) {
+    return new FormTemplateAnswer<1>(1, [formId, because]);
+}
+
+export class FormTemplateAnswer<Tag extends keyof FormTemplateAnswer_$cases> extends Union<Tag, FormTemplateAnswer_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: FormTemplateAnswer_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Served", "NotInCatalog"];
+    }
+}
+
+export function FormTemplateAnswer_$reflection(): TypeInfo {
+    return union_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.FormTemplateAnswer", [], FormTemplateAnswer, () => [[["Item", FormTemplateServed_$reflection()]], [["formId", int32_type], ["because", string_type]]]);
+}
+
+const formTemplateAnswerDecoder: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FormTemplateAnswer_$union, [string, ErrorReason_$union]>)) = orFail<FormTemplateAnswer_$union>((path_6: string, v: any): FSharpResult$2_$union<FSharpResult$2_$union<FormTemplateAnswer_$union, string>, [string, ErrorReason_$union]> => object<FSharpResult$2_$union<FormTemplateAnswer_$union, string>>((get$: IGetters): FSharpResult$2_$union<FormTemplateAnswer_$union, string> => {
+    let objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, arg_11: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<ReleaseAvailability$1_$union<FSharpList<string>>, [string, ErrorReason_$union]>)), objectArg_5: IRequiredGetter, arg_13: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<ReleaseAvailability$1_$union<FSharpList<string>>, [string, ErrorReason_$union]>)), objectArg_6: IRequiredGetter, objectArg_7: IRequiredGetter, objectArg_10: IOptionalGetter, arg_24: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<TemplateForm, [string, ErrorReason_$union]>)), objectArg_11: IRequiredGetter, arg_26: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<Option<FSharpMap<string, ElementTypeEntry>>, [string, ErrorReason_$union]>)), decoder_1: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, ElementTypeEntry>, [string, ErrorReason_$union]>)), objectArg_12: IRequiredGetter, objectArg_13: IRequiredGetter, objectArg_14: IRequiredGetter, objectArg_15: IRequiredGetter;
+    let matchValue: string;
+    const objectArg: IRequiredGetter = get$.Required;
+    matchValue = objectArg.Field<string>("kind", string);
+    switch (matchValue) {
+        case "notInCatalog":
+            return FSharpResult$2_Ok<FormTemplateAnswer_$union, string>(FormTemplateAnswer_NotInCatalog((objectArg_1 = get$.Required, objectArg_1.Field<int32>("formId", uncurry2(int))), (objectArg_2 = get$.Required, objectArg_2.Field<string>("because", string))));
+        case "served": {
+            let triggersRow: ReleaseAvailability$1_$union<FSharpList<string>>;
+            const arg_7: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<ReleaseAvailability$1_$union<FSharpList<string>>, [string, ErrorReason_$union]>)) = availabilityRowDecoder("triggersFrom");
+            const objectArg_3: IRequiredGetter = get$.Required;
+            triggersRow = objectArg_3.Field<ReleaseAvailability$1_$union<FSharpList<string>>>("triggersFrom", uncurry2(arg_7));
+            let scoringRow: ReleaseAvailability$1_$union<FSharpList<string>>;
+            const arg_9: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<ReleaseAvailability$1_$union<FSharpList<string>>, [string, ErrorReason_$union]>)) = availabilityRowDecoder("scoringFrom");
+            const objectArg_4: IRequiredGetter = get$.Required;
+            scoringRow = objectArg_4.Field<ReleaseAvailability$1_$union<FSharpList<string>>>("scoringFrom", uncurry2(arg_9));
+            const declared: FormDeclarations = new FormDeclarations((arg_11 = availabilityRowDecoder("itemNestingFrom"), (objectArg_5 = get$.Required, objectArg_5.Field<ReleaseAvailability$1_$union<FSharpList<string>>>("itemNestingFrom", uncurry2(arg_11)))), triggersRow, (arg_13 = availabilityRowDecoder("encounterOtherFrom"), (objectArg_6 = get$.Required, objectArg_6.Field<ReleaseAvailability$1_$union<FSharpList<string>>>("encounterOtherFrom", uncurry2(arg_13)))), scoringRow);
+            let instrument: FSharpResult$2_$union<ReleaseAvailability$1_$union<Option<InstrumentMapEntry>>, string>;
+            const carriedAnyway = <$a>(because: string): FSharpResult$2_$union<$a, string> => FSharpResult$2_Error<$a, string>(toText(printf("the form template declares scoring NOT stated by this release (%s) and carries an `instrument` anyway"))(because));
+            switch (scoringRow.tag) {
+                case /* NotInRelease */ 1: {
+                    const because_1: string = scoringRow.fields[0];
+                    let matchValue_1: Option<InstrumentMapEntry>;
+                    const objectArg_8: IOptionalGetter = get$.Optional;
+                    matchValue_1 = objectArg_8.Field<InstrumentMapEntry>("instrument", uncurry2(instrumentMapEntryDecoder));
+                    instrument = ((matchValue_1 != null) ? carriedAnyway(because_1) : FSharpResult$2_Ok<ReleaseAvailability$1_$union<Option<InstrumentMapEntry>>, string>(ReleaseAvailability$1_NotInRelease<Option<InstrumentMapEntry>>(because_1)));
+                    break;
+                }
+                case /* NotReadYet */ 2: {
+                    const witness: FSharpList<string> = scoringRow.fields[1];
+                    const because_2: string = scoringRow.fields[0];
+                    let matchValue_2: Option<InstrumentMapEntry>;
+                    const objectArg_9: IOptionalGetter = get$.Optional;
+                    matchValue_2 = objectArg_9.Field<InstrumentMapEntry>("instrument", uncurry2(instrumentMapEntryDecoder));
+                    instrument = ((matchValue_2 != null) ? carriedAnyway(because_2) : FSharpResult$2_Ok<ReleaseAvailability$1_$union<Option<InstrumentMapEntry>>, string>(ReleaseAvailability$1_NotReadYet<Option<InstrumentMapEntry>>(because_2, witness)));
+                    break;
+                }
+                default:
+                    instrument = FSharpResult$2_Ok<ReleaseAvailability$1_$union<Option<InstrumentMapEntry>>, string>(ReleaseAvailability$1_Stated<Option<InstrumentMapEntry>>((objectArg_7 = get$.Required, objectArg_7.Field<Option<InstrumentMapEntry>>("instrument", (path_2: string, value_2: any): FSharpResult$2_$union<Option<InstrumentMapEntry>, [string, ErrorReason_$union]> => option<InstrumentMapEntry>(uncurry2(instrumentMapEntryDecoder), path_2, value_2)))));
+            }
+            const triggerReads: FSharpResult$2_$union<ReleaseAvailability$1_$union<FSharpList<Trigger>>, string> = join<FSharpList<Trigger>>("triggerReads", triggersRow, (objectArg_10 = get$.Optional, objectArg_10.Field<FSharpList<Trigger>>("triggerReads", uncurry2(triggers_1))));
+            let matchResult: int32, e: string, instrument_1: ReleaseAvailability$1_$union<Option<InstrumentMapEntry>>, triggerReads_1: ReleaseAvailability$1_$union<FSharpList<Trigger>>;
+            const copyOfStruct: FSharpResult$2_$union<ReleaseAvailability$1_$union<Option<InstrumentMapEntry>>, string> = instrument;
+            if (copyOfStruct.tag === /* Ok */ 0) {
+                const copyOfStruct_1: FSharpResult$2_$union<ReleaseAvailability$1_$union<FSharpList<Trigger>>, string> = triggerReads;
+                if (copyOfStruct_1.tag === /* Ok */ 0) {
+                    matchResult = 1;
+                    instrument_1 = copyOfStruct.fields[0];
+                    triggerReads_1 = copyOfStruct_1.fields[0];
+                }
+                else {
+                    matchResult = 0;
+                    e = copyOfStruct_1.fields[0];
+                }
+            }
+            else {
+                matchResult = 0;
+                e = copyOfStruct.fields[0];
+            }
+            switch (matchResult) {
+                case 0:
+                    return FSharpResult$2_Error<FormTemplateAnswer_$union, string>(e!);
+                default:
+                    return FSharpResult$2_Ok<FormTemplateAnswer_$union, string>(FormTemplateAnswer_Served(new FormTemplateServed((arg_24 = formDecoder(declared), (objectArg_11 = get$.Required, objectArg_11.Field<TemplateForm>("form", uncurry2(arg_24)))), (arg_26 = ((decoder_1 = dictDecoder<ElementTypeEntry>(uncurry2(elementTypeDecoder)), (path_3: string): ((arg0: any) => FSharpResult$2_$union<Option<FSharpMap<string, ElementTypeEntry>>, [string, ErrorReason_$union]>) => ((value_3: any): FSharpResult$2_$union<Option<FSharpMap<string, ElementTypeEntry>>, [string, ErrorReason_$union]> => option<FSharpMap<string, ElementTypeEntry>>(uncurry2(decoder_1), path_3, value_3)))), (objectArg_12 = get$.Required, objectArg_12.Field<Option<FSharpMap<string, ElementTypeEntry>>>("elementTypes", uncurry2(arg_26)))), (objectArg_13 = get$.Required, objectArg_13.Field<ElementTypesFrom_$union>("elementTypesFrom", uncurry2(elementTypesFromDecoder))), instrument_1!, (objectArg_14 = get$.Required, objectArg_14.Field<string>("generatedFrom", string)), triggersRow, (objectArg_15 = get$.Required, objectArg_15.Field<FSharpList<int32>>("activeAt", (path_5: string, value_5: any): FSharpResult$2_$union<FSharpList<int32>, [string, ErrorReason_$union]> => list_7<int32>(uncurry2(int), path_5, value_5))), triggerReads_1!)));
+            }
+        }
+        default:
+            return FSharpResult$2_Error<FormTemplateAnswer_$union, string>(toText(printf("`kind` = `%s` is not a form-template answer this build understands (served | notInCatalog) — it is NOT read as either"))(matchValue));
+    }
+}, path_6, v));
+
+function readsJoinRaw(answer: FormTemplateAnswer_$union): FSharpResult$2_$union<FormTemplateAnswer_$union, string> {
+    if (answer.tag === /* Served */ 0) {
+        const served: FormTemplateServed = answer.fields[0];
+        const matchValue: ReleaseAvailability$1_$union<FSharpList<Trigger>> = served.TriggerReads;
+        switch (matchValue.tag) {
+            case /* Stated */ 0: {
+                const form: TemplateForm = served.Form;
+                const byId: FSharpMap<int32, Trigger> = ofList<int32, Trigger>(map_1<Trigger, [int32, Trigger]>((t: Trigger): [int32, Trigger] => ([t.TriggerId, t] as [int32, Trigger]), matchValue.fields[0]), {
+                    Compare: comparePrimitives,
+                });
+                const _arg: Option<string> = tryPick<ItemTrigger, string>((raw: ItemTrigger): Option<string> => {
+                    let arg_8: FSharpList<int32>, arg_9: FSharpList<int32>;
+                    const matchValue_1: Option<Trigger> = FSharpMap__TryFind(byId, raw.TriggerId);
+                    if (matchValue_1 != null) {
+                        const read: Trigger = value_15(matchValue_1);
+                        const rawIds: FSharpSet<int32> = ofList_1<int32>(map_1<TriggerAction, int32>((a: TriggerAction): int32 => a.ActionId, raw.Actions), {
+                            Compare: comparePrimitives,
+                        });
+                        const readIds: FSharpSet<int32> = ofList_1<int32>(map_1<StatedAction, int32>((a_1: StatedAction): int32 => a_1.ActionId, read.Actions), {
+                            Compare: comparePrimitives,
+                        });
+                        const rawSources: FSharpList<Option<int32>> = map_1<TriggerCondition, Option<int32>>((c: TriggerCondition): Option<int32> => c.SourceFieldId, raw.Conditions);
+                        const readSources: FSharpList<Option<int32>> = map_1<StatedCondition, Option<int32>>((c_1: StatedCondition): Option<int32> => c_1.SourceItem, read.Conditions);
+                        if (!equals(rawSources, readSources)) {
+                            return toText(printf("form %d: trigger %d states conditions on items %A but its read carries %A"))(form.FormId)(raw.TriggerId)(rawSources)(readSources);
+                        }
+                        else if (!rawIds.Equals(readIds)) {
+                            return (arg_8 = toList_2<int32>(rawIds), (arg_9 = toList_2<int32>(readIds), toText(printf("form %d: trigger %d states actions %A but its read carries %A"))(form.FormId)(raw.TriggerId)(arg_8)(arg_9)));
+                        }
+                        else {
+                            return undefined;
+                        }
+                    }
+                    else {
+                        return toText(printf("form %d: trigger %d is served with no `triggerReads` entry"))(form.FormId)(raw.TriggerId);
+                    }
+                }, collect<TemplateItem, ItemTrigger>((i: TemplateItem): FSharpList<ItemTrigger> => ReleaseAvailability_readList<ItemTrigger>(i.Triggers), form.Items));
+                if (_arg == null) {
+                    return FSharpResult$2_Ok<FormTemplateAnswer_$union, string>(answer);
+                }
+                else {
+                    return FSharpResult$2_Error<FormTemplateAnswer_$union, string>(value_15(_arg));
+                }
+            }
+            default:
+                return FSharpResult$2_Ok<FormTemplateAnswer_$union, string>(answer);
+        }
+    }
+    else {
+        return FSharpResult$2_Ok<FormTemplateAnswer_$union, string>(answer);
+    }
+}
+
+const formTemplateAnswerJoined: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FormTemplateAnswer_$union, [string, ErrorReason_$union]>)) = orFail<FormTemplateAnswer_$union>((path: string, value: any): FSharpResult$2_$union<FSharpResult$2_$union<FormTemplateAnswer_$union, string>, [string, ErrorReason_$union]> => map<FormTemplateAnswer_$union, FSharpResult$2_$union<FormTemplateAnswer_$union, string>>(readsJoinRaw, uncurry2(formTemplateAnswerDecoder), path, value));
+
+/**
+ * Decode `GET /api/coremr/form-templates/{formId}` (200 `served` or 404 `notInCatalog` — the same wire).
+ */
+export function decodeFormTemplateAnswer(json: string): FSharpResult$2_$union<FormTemplateAnswer_$union, string> {
+    return fromString<FormTemplateAnswer_$union>(uncurry2(formTemplateAnswerJoined), json);
+}
+
+/**
+ * Decode `POST /api/coremr/form-templates/batch` — one answer per requested id, in request order.
+ */
+export function decodeFormTemplateBatch(json: string): FSharpResult$2_$union<FSharpList<FormTemplateAnswer_$union>, string> {
+    return fromString<FSharpList<FormTemplateAnswer_$union>>((path_1: string, value_1: any): FSharpResult$2_$union<FSharpList<FormTemplateAnswer_$union>, [string, ErrorReason_$union]> => field_1<FSharpList<FormTemplateAnswer_$union>>("answers", (path: string, value: any): FSharpResult$2_$union<FSharpList<FormTemplateAnswer_$union>, [string, ErrorReason_$union]> => list_7<FormTemplateAnswer_$union>(uncurry2(formTemplateAnswerJoined), path, value), path_1, value_1), json);
+}
+
+export class SiteCatalog extends Record implements IEquatable<SiteCatalog>, IComparable<SiteCatalog> {
+    readonly Version: int32;
+    readonly GeneratedAt: string;
+    readonly GeneratedFrom: string;
+    readonly CoreEmr: CoreEmrInfo;
+    readonly Stats: TemplateStats;
+    readonly Scoring: ReleaseAvailability$1_$union<ScoringCatalog>;
+    readonly Triggers: ReleaseAvailability$1_$union<TriggerStats>;
+    readonly FormIds: FSharpList<int32>;
+    constructor(Version: int32, GeneratedAt: string, GeneratedFrom: string, CoreEmr: CoreEmrInfo, Stats: TemplateStats, Scoring: ReleaseAvailability$1_$union<ScoringCatalog>, Triggers: ReleaseAvailability$1_$union<TriggerStats>, FormIds: FSharpList<int32>) {
+        super();
+        this.Version = (Version | 0);
+        this.GeneratedAt = GeneratedAt;
+        this.GeneratedFrom = GeneratedFrom;
+        this.CoreEmr = CoreEmr;
+        this.Stats = Stats;
+        this.Scoring = Scoring;
+        this.Triggers = Triggers;
+        this.FormIds = FormIds;
+    }
+}
+
+export function SiteCatalog_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.FormTemplateDecoder.SiteCatalog", [], SiteCatalog, () => [["Version", int32_type], ["GeneratedAt", string_type], ["GeneratedFrom", string_type], ["CoreEmr", CoreEmrInfo_$reflection()], ["Stats", TemplateStats_$reflection()], ["Scoring", ReleaseAvailability$1_$reflection(ScoringCatalog_$reflection())], ["Triggers", ReleaseAvailability$1_$reflection(TriggerStats_$reflection())], ["FormIds", list_type(int32_type)]]);
+}
+
+const siteCatalogDecoder: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<SiteCatalog, [string, ErrorReason_$union]>)) = orFail<SiteCatalog>((path_4: string, v: any): FSharpResult$2_$union<FSharpResult$2_$union<SiteCatalog, string>, [string, ErrorReason_$union]> => object<FSharpResult$2_$union<SiteCatalog, string>>((get$: IGetters): FSharpResult$2_$union<SiteCatalog, string> => {
+    let arg_5: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, InstrumentMapEntry>, [string, ErrorReason_$union]>)), objectArg_2: IOptionalGetter, objectArg_3: IOptionalGetter, objectArg_4: IRequiredGetter, objectArg_5: IRequiredGetter, objectArg_6: IRequiredGetter, objectArg_7: IRequiredGetter, objectArg_8: IRequiredGetter, objectArg_9: IRequiredGetter;
+    let triggersRow: ReleaseAvailability$1_$union<FSharpList<string>>;
+    const arg_1: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<ReleaseAvailability$1_$union<FSharpList<string>>, [string, ErrorReason_$union]>)) = availabilityRowDecoder("triggersFrom");
+    const objectArg: IRequiredGetter = get$.Required;
+    triggersRow = objectArg.Field<ReleaseAvailability$1_$union<FSharpList<string>>>("triggersFrom", uncurry2(arg_1));
+    let scoringRow: ReleaseAvailability$1_$union<FSharpList<string>>;
+    const arg_3: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<ReleaseAvailability$1_$union<FSharpList<string>>, [string, ErrorReason_$union]>)) = availabilityRowDecoder("scoringFrom");
+    const objectArg_1: IRequiredGetter = get$.Required;
+    scoringRow = objectArg_1.Field<ReleaseAvailability$1_$union<FSharpList<string>>>("scoringFrom", uncurry2(arg_3));
+    const scoring: FSharpResult$2_$union<ReleaseAvailability$1_$union<ScoringCatalog>, string> = Result_Bind<Option<ScoringCatalog>, ReleaseAvailability$1_$union<ScoringCatalog>, string>((datum: Option<ScoringCatalog>): FSharpResult$2_$union<ReleaseAvailability$1_$union<ScoringCatalog>, string> => join<ScoringCatalog>("scoringFrom (instrumentMap + instrumentMapStats + stats.withScoring)", scoringRow, datum), scoringCatalogOf((arg_5 = dictDecoder<InstrumentMapEntry>(uncurry2(instrumentMapEntryDecoder)), (objectArg_2 = get$.Optional, objectArg_2.Field<FSharpMap<string, InstrumentMapEntry>>("instrumentMap", uncurry2(arg_5)))), (objectArg_3 = get$.Optional, objectArg_3.Field<InstrumentMapStats>("instrumentMapStats", uncurry2(instrumentMapStatsDecoder))), get$.Optional.Raw<int32>((firstPath: string, firstValue: any): FSharpResult$2_$union<int32, [string, ErrorReason_$union]> => at<int32>(ofArray(["stats", "withScoring"]), uncurry2(int), firstPath, firstValue))));
+    const triggers: FSharpResult$2_$union<ReleaseAvailability$1_$union<TriggerStats>, string> = join<TriggerStats>("triggersFrom (stats.triggerStats)", triggersRow, get$.Optional.Raw<TriggerStats>((firstPath_1: string, firstValue_1: any): FSharpResult$2_$union<TriggerStats, [string, ErrorReason_$union]> => at<TriggerStats>(ofArray(["stats", "triggerStats"]), uncurry2(triggerStatsDecoder), firstPath_1, firstValue_1)));
+    let matchResult: int32, scoringAvailability: ReleaseAvailability$1_$union<ScoringCatalog>, triggerAvailability: ReleaseAvailability$1_$union<TriggerStats>, e: string;
+    const copyOfStruct: FSharpResult$2_$union<ReleaseAvailability$1_$union<ScoringCatalog>, string> = scoring;
+    if (copyOfStruct.tag === /* Error */ 1) {
+        matchResult = 1;
+        e = copyOfStruct.fields[0];
+    }
+    else {
+        const copyOfStruct_1: FSharpResult$2_$union<ReleaseAvailability$1_$union<TriggerStats>, string> = triggers;
+        if (copyOfStruct_1.tag === /* Error */ 1) {
+            matchResult = 1;
+            e = copyOfStruct_1.fields[0];
+        }
+        else {
+            matchResult = 0;
+            scoringAvailability = copyOfStruct.fields[0];
+            triggerAvailability = copyOfStruct_1.fields[0];
+        }
+    }
+    switch (matchResult) {
+        case 0:
+            return FSharpResult$2_Ok<SiteCatalog, string>(new SiteCatalog((objectArg_4 = get$.Required, objectArg_4.Field<int32>("version", uncurry2(int))), (objectArg_5 = get$.Required, objectArg_5.Field<string>("generatedAt", string)), (objectArg_6 = get$.Required, objectArg_6.Field<string>("generatedFrom", string)), (objectArg_7 = get$.Required, objectArg_7.Field<CoreEmrInfo>("coreEmr", uncurry2(coreEmrDecoder))), (objectArg_8 = get$.Required, objectArg_8.Field<TemplateStats>("stats", uncurry2(statsDecoder))), scoringAvailability!, triggerAvailability!, (objectArg_9 = get$.Required, objectArg_9.Field<FSharpList<int32>>("forms", (path_3: string, value_3: any): FSharpResult$2_$union<FSharpList<int32>, [string, ErrorReason_$union]> => list_7<int32>((path_2: string, value_2: any): FSharpResult$2_$union<int32, [string, ErrorReason_$union]> => field_1<int32>("formId", uncurry2(int), path_2, value_2), path_3, value_3)))));
+        default:
+            return FSharpResult$2_Error<SiteCatalog, string>(e!);
+    }
+}, path_4, v));
+
+/**
+ * Decode conduit's site catalog. Strict: every governed datum joined with its declaration.
+ */
+export function decodeSiteCatalog(json: string): FSharpResult$2_$union<SiteCatalog, string> {
+    return fromString<SiteCatalog>(uncurry2(siteCatalogDecoder), json);
+}
+
+//# sourceMappingURL=FormTemplateDecoder.ts.map