@f1studio/form-spec 5.0.0-alpha.110 → 5.0.0-alpha.112

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

@@ -0,0 +1,825 @@
+import { Union, Record } from "@fable-org/fable-library-js/Types.js";
+import { IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { union_type, list_type, float64_type, obj_type, array_type, option_type, bool_type, anonRecord_type, class_type, int32_type, record_type, string_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { float64, int32 } from "@fable-org/fable-library-js/Int32.js";
+import { FSharpMap } from "@fable-org/fable-library-js/Map.js";
+import { Option } from "@fable-org/fable-library-js/Option.js";
+import { FSharpList } from "@fable-org/fable-library-js/List.js";
+
+export class ElementType extends Record implements IEquatable<ElementType>, IComparable<ElementType> {
+    readonly Code: string;
+    readonly ValueEncoding: string;
+    readonly TextField: string;
+    constructor(Code: string, ValueEncoding: string, TextField: string) {
+        super();
+        this.Code = Code;
+        this.ValueEncoding = ValueEncoding;
+        this.TextField = TextField;
+    }
+}
+
+export function ElementType_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.ElementType", [], ElementType, () => [["Code", string_type], ["ValueEncoding", string_type], ["TextField", string_type]]);
+}
+
+export class TemplateCollectionStats extends Record implements IEquatable<TemplateCollectionStats>, IComparable<TemplateCollectionStats> {
+    readonly TotalForms: int32;
+    readonly WithCodes: int32;
+    readonly WithSyntheticCodes: int32;
+    readonly WithScoring: int32;
+    readonly WithSignature: int32;
+    readonly ByUsage: FSharpMap<string, int32>;
+    readonly ByElementType: FSharpMap<string, int32>;
+    readonly CodeExtraction: { BySource: { Description: int32, Generated: int32, Name: int32 }, Extracted: int32, Generated: int32, Regex: string };
+    constructor(TotalForms: int32, WithCodes: int32, WithSyntheticCodes: int32, WithScoring: int32, WithSignature: int32, ByUsage: FSharpMap<string, int32>, ByElementType: FSharpMap<string, int32>, CodeExtraction: { BySource: { Description: int32, Generated: int32, Name: int32 }, Extracted: int32, Generated: int32, Regex: string }) {
+        super();
+        this.TotalForms = (TotalForms | 0);
+        this.WithCodes = (WithCodes | 0);
+        this.WithSyntheticCodes = (WithSyntheticCodes | 0);
+        this.WithScoring = (WithScoring | 0);
+        this.WithSignature = (WithSignature | 0);
+        this.ByUsage = ByUsage;
+        this.ByElementType = ByElementType;
+        this.CodeExtraction = CodeExtraction;
+    }
+}
+
+export function TemplateCollectionStats_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.TemplateCollectionStats", [], TemplateCollectionStats, () => [["TotalForms", int32_type], ["WithCodes", int32_type], ["WithSyntheticCodes", int32_type], ["WithScoring", 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", anonRecord_type(["BySource", anonRecord_type(["Description", int32_type], ["Generated", int32_type], ["Name", int32_type])], ["Extracted", int32_type], ["Generated", int32_type], ["Regex", string_type])]]);
+}
+
+export class EncounterTypes extends Record implements IEquatable<EncounterTypes>, IComparable<EncounterTypes> {
+    readonly Medical: boolean;
+    readonly Mental: boolean;
+    readonly Dental: boolean;
+    readonly Other: boolean;
+    constructor(Medical: boolean, Mental: boolean, Dental: boolean, Other: 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.CoreMRTypes.EncounterTypes", [], EncounterTypes, () => [["Medical", bool_type], ["Mental", bool_type], ["Dental", bool_type], ["Other", bool_type]]);
+}
+
+export class EnrichedTemplate extends Record implements IEquatable<EnrichedTemplate>, IComparable<EnrichedTemplate> {
+    readonly FormId: int32;
+    readonly FormCode: string;
+    readonly FormCodeSource: string;
+    readonly Name: string;
+    readonly Description: string;
+    readonly CurrentVersionId: int32;
+    readonly IsIntake: boolean;
+    readonly Usage: string;
+    readonly EncounterTypes: EncounterTypes;
+    readonly RequiresSignature: boolean;
+    readonly StructureHash: string;
+    readonly ClinicalHash: string;
+    readonly CosmeticHash: string;
+    readonly ItemCount: int32;
+    readonly IsScored: boolean;
+    constructor(FormId: int32, FormCode: string, FormCodeSource: string, Name: string, Description: string, CurrentVersionId: int32, IsIntake: boolean, Usage: string, EncounterTypes: EncounterTypes, RequiresSignature: boolean, StructureHash: string, ClinicalHash: string, CosmeticHash: string, ItemCount: int32, IsScored: boolean) {
+        super();
+        this.FormId = (FormId | 0);
+        this.FormCode = FormCode;
+        this.FormCodeSource = FormCodeSource;
+        this.Name = Name;
+        this.Description = Description;
+        this.CurrentVersionId = (CurrentVersionId | 0);
+        this.IsIntake = IsIntake;
+        this.Usage = Usage;
+        this.EncounterTypes = EncounterTypes;
+        this.RequiresSignature = RequiresSignature;
+        this.StructureHash = StructureHash;
+        this.ClinicalHash = ClinicalHash;
+        this.CosmeticHash = CosmeticHash;
+        this.ItemCount = (ItemCount | 0);
+        this.IsScored = IsScored;
+    }
+}
+
+export function EnrichedTemplate_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.EnrichedTemplate", [], EnrichedTemplate, () => [["FormId", int32_type], ["FormCode", string_type], ["FormCodeSource", string_type], ["Name", string_type], ["Description", string_type], ["CurrentVersionId", int32_type], ["IsIntake", bool_type], ["Usage", string_type], ["EncounterTypes", EncounterTypes_$reflection()], ["RequiresSignature", bool_type], ["StructureHash", string_type], ["ClinicalHash", string_type], ["CosmeticHash", string_type], ["ItemCount", int32_type], ["IsScored", bool_type]]);
+}
+
+export class EnrichedTemplateCollection extends Record implements IEquatable<EnrichedTemplateCollection>, IComparable<EnrichedTemplateCollection> {
+    readonly Schema: string;
+    readonly Version: int32;
+    readonly GeneratedAt: Date;
+    readonly GeneratedFrom: string;
+    readonly CoreEmr: Option<{ AppVersion: string, SchemaRevision: string, SchemaVersion: string }>;
+    readonly Filter: string;
+    readonly FilterDescription: string;
+    readonly FormCount: int32;
+    readonly Forms: EnrichedTemplate[];
+    readonly ElementTypes: FSharpMap<string, ElementType>;
+    readonly Stats: TemplateCollectionStats;
+    constructor(Schema: string, Version: int32, GeneratedAt: Date, GeneratedFrom: string, CoreEmr: Option<{ AppVersion: string, SchemaRevision: string, SchemaVersion: string }>, Filter: string, FilterDescription: string, FormCount: int32, Forms: EnrichedTemplate[], ElementTypes: FSharpMap<string, ElementType>, Stats: TemplateCollectionStats) {
+        super();
+        this.Schema = Schema;
+        this.Version = (Version | 0);
+        this.GeneratedAt = GeneratedAt;
+        this.GeneratedFrom = GeneratedFrom;
+        this.CoreEmr = CoreEmr;
+        this.Filter = Filter;
+        this.FilterDescription = FilterDescription;
+        this.FormCount = (FormCount | 0);
+        this.Forms = Forms;
+        this.ElementTypes = ElementTypes;
+        this.Stats = Stats;
+    }
+}
+
+export function EnrichedTemplateCollection_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.EnrichedTemplateCollection", [], EnrichedTemplateCollection, () => [["Schema", string_type], ["Version", int32_type], ["GeneratedAt", class_type("System.DateTimeOffset")], ["GeneratedFrom", string_type], ["CoreEmr", option_type(anonRecord_type(["AppVersion", string_type], ["SchemaRevision", string_type], ["SchemaVersion", string_type]))], ["Filter", string_type], ["FilterDescription", string_type], ["FormCount", int32_type], ["Forms", array_type(EnrichedTemplate_$reflection())], ["ElementTypes", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, ElementType_$reflection()])], ["Stats", TemplateCollectionStats_$reflection()]]);
+}
+
+export class EnrichedTemplateResponse extends Record implements IEquatable<EnrichedTemplateResponse>, IComparable<EnrichedTemplateResponse> {
+    readonly Success: boolean;
+    readonly Data: Option<EnrichedTemplateCollection>;
+    readonly Error: Option<string>;
+    readonly Timestamp: Option<Date>;
+    constructor(Success: boolean, Data: Option<EnrichedTemplateCollection>, Error$: Option<string>, Timestamp: Option<Date>) {
+        super();
+        this.Success = Success;
+        this.Data = Data;
+        this.Error = Error$;
+        this.Timestamp = Timestamp;
+    }
+}
+
+export function EnrichedTemplateResponse_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.EnrichedTemplateResponse", [], EnrichedTemplateResponse, () => [["Success", bool_type], ["Data", option_type(EnrichedTemplateCollection_$reflection())], ["Error", option_type(string_type)], ["Timestamp", option_type(class_type("System.DateTimeOffset"))]]);
+}
+
+export class FormChoice extends Record implements IEquatable<FormChoice> {
+    readonly ChoiceId: int32;
+    readonly Text: string;
+    readonly Value: any;
+    readonly Score: Option<int32>;
+    readonly IsOther: Option<boolean>;
+    constructor(ChoiceId: int32, Text$: string, Value: any, Score: Option<int32>, IsOther: Option<boolean>) {
+        super();
+        this.ChoiceId = (ChoiceId | 0);
+        this.Text = Text$;
+        this.Value = Value;
+        this.Score = Score;
+        this.IsOther = IsOther;
+    }
+}
+
+export function FormChoice_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.FormChoice", [], FormChoice, () => [["ChoiceId", int32_type], ["Text", string_type], ["Value", obj_type], ["Score", option_type(int32_type)], ["IsOther", option_type(bool_type)]]);
+}
+
+export class ItemValidation extends Record implements IEquatable<ItemValidation>, IComparable<ItemValidation> {
+    readonly Type: string;
+    readonly Pattern: Option<string>;
+    readonly Min: Option<float64>;
+    readonly Max: Option<float64>;
+    readonly Message: Option<string>;
+    constructor(Type: string, Pattern: Option<string>, Min: Option<float64>, Max: Option<float64>, Message: Option<string>) {
+        super();
+        this.Type = Type;
+        this.Pattern = Pattern;
+        this.Min = Min;
+        this.Max = Max;
+        this.Message = Message;
+    }
+}
+
+export function ItemValidation_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.ItemValidation", [], ItemValidation, () => [["Type", string_type], ["Pattern", option_type(string_type)], ["Min", option_type(float64_type)], ["Max", option_type(float64_type)], ["Message", option_type(string_type)]]);
+}
+
+export class ConditionalRule extends Record implements IEquatable<ConditionalRule> {
+    readonly ItemId: int32;
+    readonly Operator: string;
+    readonly Value: any;
+    constructor(ItemId: int32, Operator: string, Value: any) {
+        super();
+        this.ItemId = (ItemId | 0);
+        this.Operator = Operator;
+        this.Value = Value;
+    }
+}
+
+export function ConditionalRule_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.ConditionalRule", [], ConditionalRule, () => [["ItemId", int32_type], ["Operator", string_type], ["Value", obj_type]]);
+}
+
+export class FormItem extends Record implements IEquatable<FormItem> {
+    readonly ItemId: int32;
+    readonly StepId: int32;
+    readonly ItemOrder: int32;
+    readonly ItemType: int32;
+    readonly ItemTypeCode: string;
+    readonly Prompt: string;
+    readonly HelpText: Option<string>;
+    readonly Required: boolean;
+    readonly Choices: Option<FormChoice[]>;
+    readonly Validation: Option<ItemValidation>;
+    readonly ConditionalOn: Option<ConditionalRule>;
+    constructor(ItemId: int32, StepId: int32, ItemOrder: int32, ItemType: int32, ItemTypeCode: string, Prompt: string, HelpText: Option<string>, Required: boolean, Choices: Option<FormChoice[]>, Validation: Option<ItemValidation>, ConditionalOn: Option<ConditionalRule>) {
+        super();
+        this.ItemId = (ItemId | 0);
+        this.StepId = (StepId | 0);
+        this.ItemOrder = (ItemOrder | 0);
+        this.ItemType = (ItemType | 0);
+        this.ItemTypeCode = ItemTypeCode;
+        this.Prompt = Prompt;
+        this.HelpText = HelpText;
+        this.Required = Required;
+        this.Choices = Choices;
+        this.Validation = Validation;
+        this.ConditionalOn = ConditionalOn;
+    }
+}
+
+export function FormItem_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.FormItem", [], FormItem, () => [["ItemId", int32_type], ["StepId", int32_type], ["ItemOrder", int32_type], ["ItemType", int32_type], ["ItemTypeCode", string_type], ["Prompt", string_type], ["HelpText", option_type(string_type)], ["Required", bool_type], ["Choices", option_type(array_type(FormChoice_$reflection()))], ["Validation", option_type(ItemValidation_$reflection())], ["ConditionalOn", option_type(ConditionalRule_$reflection())]]);
+}
+
+export class FormStep extends Record implements IEquatable<FormStep>, IComparable<FormStep> {
+    readonly StepId: int32;
+    readonly StepOrder: int32;
+    readonly Title: string;
+    readonly Description: Option<string>;
+    readonly ItemCount: int32;
+    constructor(StepId: int32, StepOrder: int32, Title: string, Description: Option<string>, ItemCount: int32) {
+        super();
+        this.StepId = (StepId | 0);
+        this.StepOrder = (StepOrder | 0);
+        this.Title = Title;
+        this.Description = Description;
+        this.ItemCount = (ItemCount | 0);
+    }
+}
+
+export function FormStep_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.FormStep", [], FormStep, () => [["StepId", int32_type], ["StepOrder", int32_type], ["Title", string_type], ["Description", option_type(string_type)], ["ItemCount", int32_type]]);
+}
+
+export class ScoreCategory extends Record implements IEquatable<ScoreCategory>, IComparable<ScoreCategory> {
+    readonly Name: string;
+    readonly MinScore: int32;
+    readonly MaxScore: int32;
+    readonly Severity: string;
+    readonly Interpretation: string;
+    constructor(Name: string, MinScore: int32, MaxScore: int32, Severity: string, Interpretation: string) {
+        super();
+        this.Name = Name;
+        this.MinScore = (MinScore | 0);
+        this.MaxScore = (MaxScore | 0);
+        this.Severity = Severity;
+        this.Interpretation = Interpretation;
+    }
+}
+
+export function ScoreCategory_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.ScoreCategory", [], ScoreCategory, () => [["Name", string_type], ["MinScore", int32_type], ["MaxScore", int32_type], ["Severity", string_type], ["Interpretation", string_type]]);
+}
+
+export class ScoringConfig extends Record implements IEquatable<ScoringConfig>, IComparable<ScoringConfig> {
+    readonly Enabled: boolean;
+    readonly TotalPossible: int32;
+    readonly Categories: Option<ScoreCategory[]>;
+    readonly Interpretation: Option<string>;
+    constructor(Enabled: boolean, TotalPossible: int32, Categories: Option<ScoreCategory[]>, Interpretation: Option<string>) {
+        super();
+        this.Enabled = Enabled;
+        this.TotalPossible = (TotalPossible | 0);
+        this.Categories = Categories;
+        this.Interpretation = Interpretation;
+    }
+}
+
+export function ScoringConfig_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.ScoringConfig", [], ScoringConfig, () => [["Enabled", bool_type], ["TotalPossible", int32_type], ["Categories", option_type(array_type(ScoreCategory_$reflection()))], ["Interpretation", option_type(string_type)]]);
+}
+
+export class ValidationRules extends Record implements IEquatable<ValidationRules>, IComparable<ValidationRules> {
+    readonly RequireAllRequired: boolean;
+    readonly AllowPartialSubmit: boolean;
+    readonly CustomRules: Option<string[]>;
+    constructor(RequireAllRequired: boolean, AllowPartialSubmit: boolean, CustomRules: Option<string[]>) {
+        super();
+        this.RequireAllRequired = RequireAllRequired;
+        this.AllowPartialSubmit = AllowPartialSubmit;
+        this.CustomRules = CustomRules;
+    }
+}
+
+export function ValidationRules_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.ValidationRules", [], ValidationRules, () => [["RequireAllRequired", bool_type], ["AllowPartialSubmit", bool_type], ["CustomRules", option_type(array_type(string_type))]]);
+}
+
+export class CoreMRError extends Record implements IEquatable<CoreMRError> {
+    readonly Success: boolean;
+    readonly Error: string;
+    readonly Details: Option<any>;
+    readonly Timestamp: Date;
+    readonly Path: Option<string>;
+    constructor(Success: boolean, Error$: string, Details: Option<any>, Timestamp: Date, Path: Option<string>) {
+        super();
+        this.Success = Success;
+        this.Error = Error$;
+        this.Details = Details;
+        this.Timestamp = Timestamp;
+        this.Path = Path;
+    }
+}
+
+export function CoreMRError_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.CoreMRError", [], CoreMRError, () => [["Success", bool_type], ["Error", string_type], ["Details", option_type(obj_type)], ["Timestamp", class_type("System.DateTimeOffset")], ["Path", option_type(string_type)]]);
+}
+
+export class ValidationError extends Record implements IEquatable<ValidationError>, IComparable<ValidationError> {
+    readonly Field: string;
+    readonly Message: string;
+    readonly Code: string;
+    constructor(Field: string, Message: string, Code: string) {
+        super();
+        this.Field = Field;
+        this.Message = Message;
+        this.Code = Code;
+    }
+}
+
+export function ValidationError_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.ValidationError", [], ValidationError, () => [["Field", string_type], ["Message", string_type], ["Code", string_type]]);
+}
+
+export class CoreMRValidationError extends Record implements IEquatable<CoreMRValidationError>, IComparable<CoreMRValidationError> {
+    readonly Success: boolean;
+    readonly Error: string;
+    readonly ValidationErrors: ValidationError[];
+    readonly Timestamp: Date;
+    constructor(Success: boolean, Error$: string, ValidationErrors: ValidationError[], Timestamp: Date) {
+        super();
+        this.Success = Success;
+        this.Error = Error$;
+        this.ValidationErrors = ValidationErrors;
+        this.Timestamp = Timestamp;
+    }
+}
+
+export function CoreMRValidationError_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.CoreMRValidationError", [], CoreMRValidationError, () => [["Success", bool_type], ["Error", string_type], ["ValidationErrors", array_type(ValidationError_$reflection())], ["Timestamp", class_type("System.DateTimeOffset")]]);
+}
+
+export class CoreMRFormMetadata extends Record implements IEquatable<CoreMRFormMetadata>, IComparable<CoreMRFormMetadata> {
+    readonly FormId: int32;
+    readonly FormName: string;
+    readonly Description: Option<string>;
+    readonly VersionId: int32;
+    readonly VersionNumber: int32;
+    readonly DatePublished: Option<Date>;
+    readonly RequiresSignature: boolean;
+    readonly IsIntake: boolean;
+    readonly Keywords: string;
+    readonly HideDemos: string;
+    constructor(FormId: int32, FormName: string, Description: Option<string>, VersionId: int32, VersionNumber: int32, DatePublished: Option<Date>, RequiresSignature: boolean, IsIntake: boolean, Keywords: string, HideDemos: string) {
+        super();
+        this.FormId = (FormId | 0);
+        this.FormName = FormName;
+        this.Description = Description;
+        this.VersionId = (VersionId | 0);
+        this.VersionNumber = (VersionNumber | 0);
+        this.DatePublished = DatePublished;
+        this.RequiresSignature = RequiresSignature;
+        this.IsIntake = IsIntake;
+        this.Keywords = Keywords;
+        this.HideDemos = HideDemos;
+    }
+}
+
+export function CoreMRFormMetadata_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.CoreMRFormMetadata", [], CoreMRFormMetadata, () => [["FormId", int32_type], ["FormName", string_type], ["Description", option_type(string_type)], ["VersionId", int32_type], ["VersionNumber", int32_type], ["DatePublished", option_type(class_type("System.DateTime"))], ["RequiresSignature", bool_type], ["IsIntake", bool_type], ["Keywords", string_type], ["HideDemos", string_type]]);
+}
+
+export class CoreMRItem extends Record implements IEquatable<CoreMRItem>, IComparable<CoreMRItem> {
+    readonly ItemId: int32;
+    readonly Sequence: int32;
+    readonly NestingLevel: int32;
+    readonly SequenceText: Option<string>;
+    readonly ItemTypeId: int32;
+    readonly ItemTypeName: string;
+    readonly HasChoices: boolean;
+    readonly HasText: boolean;
+    readonly HasDate: boolean;
+    readonly Label: string;
+    readonly IsRequired: boolean;
+    readonly GenderRequired: Option<string>;
+    readonly Highlight: Option<string>;
+    readonly Code: Option<string>;
+    readonly Uuid: Option<string>;
+    readonly ParentId: Option<int32>;
+    readonly ChildId: Option<int32>;
+    readonly ValidatorChoices: int32;
+    readonly ValidatorText: int32;
+    readonly ValidatorMsg: Option<string>;
+    constructor(ItemId: int32, Sequence: int32, NestingLevel: int32, SequenceText: Option<string>, ItemTypeId: int32, ItemTypeName: string, HasChoices: boolean, HasText: boolean, HasDate: boolean, Label: string, IsRequired: boolean, GenderRequired: Option<string>, Highlight: Option<string>, Code: Option<string>, Uuid: Option<string>, ParentId: Option<int32>, ChildId: Option<int32>, ValidatorChoices: int32, ValidatorText: int32, ValidatorMsg: Option<string>) {
+        super();
+        this.ItemId = (ItemId | 0);
+        this.Sequence = (Sequence | 0);
+        this.NestingLevel = (NestingLevel | 0);
+        this.SequenceText = SequenceText;
+        this.ItemTypeId = (ItemTypeId | 0);
+        this.ItemTypeName = ItemTypeName;
+        this.HasChoices = HasChoices;
+        this.HasText = HasText;
+        this.HasDate = HasDate;
+        this.Label = Label;
+        this.IsRequired = IsRequired;
+        this.GenderRequired = GenderRequired;
+        this.Highlight = Highlight;
+        this.Code = Code;
+        this.Uuid = Uuid;
+        this.ParentId = ParentId;
+        this.ChildId = ChildId;
+        this.ValidatorChoices = (ValidatorChoices | 0);
+        this.ValidatorText = (ValidatorText | 0);
+        this.ValidatorMsg = ValidatorMsg;
+    }
+}
+
+export function CoreMRItem_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.CoreMRItem", [], CoreMRItem, () => [["ItemId", int32_type], ["Sequence", int32_type], ["NestingLevel", int32_type], ["SequenceText", option_type(string_type)], ["ItemTypeId", int32_type], ["ItemTypeName", string_type], ["HasChoices", bool_type], ["HasText", bool_type], ["HasDate", bool_type], ["Label", string_type], ["IsRequired", bool_type], ["GenderRequired", option_type(string_type)], ["Highlight", option_type(string_type)], ["Code", option_type(string_type)], ["Uuid", option_type(string_type)], ["ParentId", option_type(int32_type)], ["ChildId", option_type(int32_type)], ["ValidatorChoices", int32_type], ["ValidatorText", int32_type], ["ValidatorMsg", option_type(string_type)]]);
+}
+
+export class CoreMRChoice extends Record implements IEquatable<CoreMRChoice>, IComparable<CoreMRChoice> {
+    readonly ChoiceId: int32;
+    readonly ItemId: int32;
+    readonly Sequence: int32;
+    readonly Text: string;
+    readonly Score: int32;
+    readonly BitPosition: Option<int32>;
+    readonly Code: Option<string>;
+    readonly Highlight: Option<string>;
+    constructor(ChoiceId: int32, ItemId: int32, Sequence: int32, Text$: string, Score: int32, BitPosition: Option<int32>, Code: Option<string>, Highlight: Option<string>) {
+        super();
+        this.ChoiceId = (ChoiceId | 0);
+        this.ItemId = (ItemId | 0);
+        this.Sequence = (Sequence | 0);
+        this.Text = Text$;
+        this.Score = (Score | 0);
+        this.BitPosition = BitPosition;
+        this.Code = Code;
+        this.Highlight = Highlight;
+    }
+}
+
+export function CoreMRChoice_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.CoreMRChoice", [], CoreMRChoice, () => [["ChoiceId", int32_type], ["ItemId", int32_type], ["Sequence", int32_type], ["Text", string_type], ["Score", int32_type], ["BitPosition", option_type(int32_type)], ["Code", option_type(string_type)], ["Highlight", option_type(string_type)]]);
+}
+
+export class CoreMRTriggerCondition extends Record implements IEquatable<CoreMRTriggerCondition>, IComparable<CoreMRTriggerCondition> {
+    readonly ConditionId: int32;
+    readonly TriggerId: int32;
+    readonly ChangeType: Option<string>;
+    readonly Placement: Option<string>;
+    readonly Operator: string;
+    readonly Answers: FSharpList<int32>;
+    constructor(ConditionId: int32, TriggerId: int32, ChangeType: Option<string>, Placement: Option<string>, Operator: string, Answers: FSharpList<int32>) {
+        super();
+        this.ConditionId = (ConditionId | 0);
+        this.TriggerId = (TriggerId | 0);
+        this.ChangeType = ChangeType;
+        this.Placement = Placement;
+        this.Operator = Operator;
+        this.Answers = Answers;
+    }
+}
+
+export function CoreMRTriggerCondition_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.CoreMRTriggerCondition", [], CoreMRTriggerCondition, () => [["ConditionId", int32_type], ["TriggerId", int32_type], ["ChangeType", option_type(string_type)], ["Placement", option_type(string_type)], ["Operator", string_type], ["Answers", list_type(int32_type)]]);
+}
+
+export class CoreMRTriggerEvent extends Record implements IEquatable<CoreMRTriggerEvent>, IComparable<CoreMRTriggerEvent> {
+    readonly EventId: int32;
+    readonly TriggerId: int32;
+    readonly EventType: string;
+    readonly EventParams: FSharpMap<string, string>;
+    constructor(EventId: int32, TriggerId: int32, EventType: string, EventParams: FSharpMap<string, string>) {
+        super();
+        this.EventId = (EventId | 0);
+        this.TriggerId = (TriggerId | 0);
+        this.EventType = EventType;
+        this.EventParams = EventParams;
+    }
+}
+
+export function CoreMRTriggerEvent_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.CoreMRTriggerEvent", [], CoreMRTriggerEvent, () => [["EventId", int32_type], ["TriggerId", int32_type], ["EventType", string_type], ["EventParams", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, string_type])]]);
+}
+
+export class CoreMRTrigger extends Record implements IEquatable<CoreMRTrigger>, IComparable<CoreMRTrigger> {
+    readonly TriggerId: int32;
+    readonly TargetItemId: int32;
+    readonly TriggerOn: string;
+    readonly TriggerOrder: int32;
+    readonly ExclusiveTag: string;
+    readonly Active: boolean;
+    readonly Conditions: FSharpList<CoreMRTriggerCondition>;
+    readonly Events: FSharpList<CoreMRTriggerEvent>;
+    constructor(TriggerId: int32, TargetItemId: int32, TriggerOn: string, TriggerOrder: int32, ExclusiveTag: string, Active: boolean, Conditions: FSharpList<CoreMRTriggerCondition>, Events: FSharpList<CoreMRTriggerEvent>) {
+        super();
+        this.TriggerId = (TriggerId | 0);
+        this.TargetItemId = (TargetItemId | 0);
+        this.TriggerOn = TriggerOn;
+        this.TriggerOrder = (TriggerOrder | 0);
+        this.ExclusiveTag = ExclusiveTag;
+        this.Active = Active;
+        this.Conditions = Conditions;
+        this.Events = Events;
+    }
+}
+
+export function CoreMRTrigger_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.CoreMRTrigger", [], CoreMRTrigger, () => [["TriggerId", int32_type], ["TargetItemId", int32_type], ["TriggerOn", string_type], ["TriggerOrder", int32_type], ["ExclusiveTag", string_type], ["Active", bool_type], ["Conditions", list_type(CoreMRTriggerCondition_$reflection())], ["Events", list_type(CoreMRTriggerEvent_$reflection())]]);
+}
+
+export class CoreMRTag extends Record implements IEquatable<CoreMRTag>, IComparable<CoreMRTag> {
+    readonly TagId: int32;
+    readonly TagName: string;
+    readonly Facility: int32;
+    readonly Active: boolean;
+    constructor(TagId: int32, TagName: string, Facility: int32, Active: boolean) {
+        super();
+        this.TagId = (TagId | 0);
+        this.TagName = TagName;
+        this.Facility = (Facility | 0);
+        this.Active = Active;
+    }
+}
+
+export function CoreMRTag_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.CoreMRTag", [], CoreMRTag, () => [["TagId", int32_type], ["TagName", string_type], ["Facility", int32_type], ["Active", bool_type]]);
+}
+
+export class CoreMRFormData extends Record implements IEquatable<CoreMRFormData>, IComparable<CoreMRFormData> {
+    readonly Metadata: CoreMRFormMetadata;
+    readonly Items: FSharpList<CoreMRItem>;
+    readonly Choices: FSharpList<CoreMRChoice>;
+    readonly Triggers: FSharpList<CoreMRTrigger>;
+    readonly Tags: FSharpList<CoreMRTag>;
+    constructor(Metadata: CoreMRFormMetadata, Items: FSharpList<CoreMRItem>, Choices: FSharpList<CoreMRChoice>, Triggers: FSharpList<CoreMRTrigger>, Tags: FSharpList<CoreMRTag>) {
+        super();
+        this.Metadata = Metadata;
+        this.Items = Items;
+        this.Choices = Choices;
+        this.Triggers = Triggers;
+        this.Tags = Tags;
+    }
+}
+
+export function CoreMRFormData_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.CoreMRFormData", [], CoreMRFormData, () => [["Metadata", CoreMRFormMetadata_$reflection()], ["Items", list_type(CoreMRItem_$reflection())], ["Choices", list_type(CoreMRChoice_$reflection())], ["Triggers", list_type(CoreMRTrigger_$reflection())], ["Tags", list_type(CoreMRTag_$reflection())]]);
+}
+
+export class CoreMRFormDetail extends Record implements IEquatable<CoreMRFormDetail>, IComparable<CoreMRFormDetail> {
+    readonly Metadata: CoreMRFormMetadata;
+    readonly Items: FSharpList<CoreMRItem>;
+    readonly Choices: FSharpList<CoreMRChoice>;
+    readonly Triggers: FSharpList<CoreMRTrigger>;
+    readonly Tags: FSharpList<CoreMRTag>;
+    readonly SemanticReport: Option<string>;
+    constructor(Metadata: CoreMRFormMetadata, Items: FSharpList<CoreMRItem>, Choices: FSharpList<CoreMRChoice>, Triggers: FSharpList<CoreMRTrigger>, Tags: FSharpList<CoreMRTag>, SemanticReport: Option<string>) {
+        super();
+        this.Metadata = Metadata;
+        this.Items = Items;
+        this.Choices = Choices;
+        this.Triggers = Triggers;
+        this.Tags = Tags;
+        this.SemanticReport = SemanticReport;
+    }
+}
+
+export function CoreMRFormDetail_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.CoreMRFormDetail", [], CoreMRFormDetail, () => [["Metadata", CoreMRFormMetadata_$reflection()], ["Items", list_type(CoreMRItem_$reflection())], ["Choices", list_type(CoreMRChoice_$reflection())], ["Triggers", list_type(CoreMRTrigger_$reflection())], ["Tags", list_type(CoreMRTag_$reflection())], ["SemanticReport", option_type(string_type)]]);
+}
+
+export class FormDetailResponse extends Record implements IEquatable<FormDetailResponse>, IComparable<FormDetailResponse> {
+    readonly Success: boolean;
+    readonly Data: Option<CoreMRFormDetail>;
+    readonly Error: Option<string>;
+    readonly Timestamp: Option<Date>;
+    constructor(Success: boolean, Data: Option<CoreMRFormDetail>, Error$: Option<string>, Timestamp: Option<Date>) {
+        super();
+        this.Success = Success;
+        this.Data = Data;
+        this.Error = Error$;
+        this.Timestamp = Timestamp;
+    }
+}
+
+export function FormDetailResponse_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.FormDetailResponse", [], FormDetailResponse, () => [["Success", bool_type], ["Data", option_type(CoreMRFormDetail_$reflection())], ["Error", option_type(string_type)], ["Timestamp", option_type(class_type("System.DateTimeOffset"))]]);
+}
+
+export class PatientSummary extends Record implements IEquatable<PatientSummary>, IComparable<PatientSummary> {
+    readonly ExternalId: string;
+    readonly FirstName: string;
+    readonly LastName: string;
+    readonly DateOfBirth: Date;
+    readonly Status: string;
+    constructor(ExternalId: string, FirstName: string, LastName: string, DateOfBirth: Date, Status: string) {
+        super();
+        this.ExternalId = ExternalId;
+        this.FirstName = FirstName;
+        this.LastName = LastName;
+        this.DateOfBirth = DateOfBirth;
+        this.Status = Status;
+    }
+}
+
+export function PatientSummary_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.PatientSummary", [], PatientSummary, () => [["ExternalId", string_type], ["FirstName", string_type], ["LastName", string_type], ["DateOfBirth", class_type("System.DateTimeOffset")], ["Status", string_type]]);
+}
+
+export class PatientSearchResponse extends Record implements IEquatable<PatientSearchResponse>, IComparable<PatientSearchResponse> {
+    readonly Success: boolean;
+    readonly Data: PatientSummary[];
+    readonly Pagination: { HasMore: boolean, Limit: int32, Page: int32, Total: int32 };
+    constructor(Success: boolean, Data: PatientSummary[], Pagination: { HasMore: boolean, Limit: int32, Page: int32, Total: int32 }) {
+        super();
+        this.Success = Success;
+        this.Data = Data;
+        this.Pagination = Pagination;
+    }
+}
+
+export function PatientSearchResponse_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.PatientSearchResponse", [], PatientSearchResponse, () => [["Success", bool_type], ["Data", array_type(PatientSummary_$reflection())], ["Pagination", anonRecord_type(["HasMore", bool_type], ["Limit", int32_type], ["Page", int32_type], ["Total", int32_type])]]);
+}
+
+export class FormResponse extends Record implements IEquatable<FormResponse> {
+    readonly ItemId: int32;
+    readonly Value: any;
+    readonly Text: Option<string>;
+    readonly Score: Option<int32>;
+    constructor(ItemId: int32, Value: any, Text$: Option<string>, Score: Option<int32>) {
+        super();
+        this.ItemId = (ItemId | 0);
+        this.Value = Value;
+        this.Text = Text$;
+        this.Score = Score;
+    }
+}
+
+export function FormResponse_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.FormResponse", [], FormResponse, () => [["ItemId", int32_type], ["Value", obj_type], ["Text", option_type(string_type)], ["Score", option_type(int32_type)]]);
+}
+
+export class FormSubmissionRequest extends Record implements IEquatable<FormSubmissionRequest> {
+    readonly FormId: int32;
+    readonly FormName: string;
+    readonly ExternalId: string;
+    readonly Responses: FormResponse[];
+    readonly CompletedAt: Option<Date>;
+    readonly SubmittedBy: Option<string>;
+    constructor(FormId: int32, FormName: string, ExternalId: string, Responses: FormResponse[], CompletedAt: Option<Date>, SubmittedBy: Option<string>) {
+        super();
+        this.FormId = (FormId | 0);
+        this.FormName = FormName;
+        this.ExternalId = ExternalId;
+        this.Responses = Responses;
+        this.CompletedAt = CompletedAt;
+        this.SubmittedBy = SubmittedBy;
+    }
+}
+
+export function FormSubmissionRequest_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.FormSubmissionRequest", [], FormSubmissionRequest, () => [["FormId", int32_type], ["FormName", string_type], ["ExternalId", string_type], ["Responses", array_type(FormResponse_$reflection())], ["CompletedAt", option_type(class_type("System.DateTimeOffset"))], ["SubmittedBy", option_type(string_type)]]);
+}
+
+export class FormSubmissionResponse extends Record implements IEquatable<FormSubmissionResponse>, IComparable<FormSubmissionResponse> {
+    readonly Success: boolean;
+    readonly Data: Option<{ ExternalId: string, FormRecordId: string, Status: string, SubmittedAt: Date, ValidationErrors?: ValidationError[] }>;
+    constructor(Success: boolean, Data: Option<{ ExternalId: string, FormRecordId: string, Status: string, SubmittedAt: Date, ValidationErrors?: ValidationError[] }>) {
+        super();
+        this.Success = Success;
+        this.Data = Data;
+    }
+}
+
+export function FormSubmissionResponse_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.FormSubmissionResponse", [], FormSubmissionResponse, () => [["Success", bool_type], ["Data", option_type(anonRecord_type(["ExternalId", string_type], ["FormRecordId", string_type], ["Status", string_type], ["SubmittedAt", class_type("System.DateTimeOffset")], ["ValidationErrors", option_type(array_type(ValidationError_$reflection()))]))]]);
+}
+
+export class CorEmrTemplatesResponse extends Record implements IEquatable<CorEmrTemplatesResponse>, IComparable<CorEmrTemplatesResponse> {
+    readonly Success: boolean;
+    readonly Data: Option<EnrichedTemplateCollection>;
+    readonly Error: Option<string>;
+    constructor(Success: boolean, Data: Option<EnrichedTemplateCollection>, Error$: Option<string>) {
+        super();
+        this.Success = Success;
+        this.Data = Data;
+        this.Error = Error$;
+    }
+}
+
+export function CorEmrTemplatesResponse_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.CorEmrTemplatesResponse", [], CorEmrTemplatesResponse, () => [["Success", bool_type], ["Data", option_type(EnrichedTemplateCollection_$reflection())], ["Error", option_type(string_type)]]);
+}
+
+export class TemplateDetailResponse extends Record implements IEquatable<TemplateDetailResponse>, IComparable<TemplateDetailResponse> {
+    readonly Success: boolean;
+    readonly Data: Option<CoreMRFormDetail>;
+    readonly Error: Option<string>;
+    constructor(Success: boolean, Data: Option<CoreMRFormDetail>, Error$: Option<string>) {
+        super();
+        this.Success = Success;
+        this.Data = Data;
+        this.Error = Error$;
+    }
+}
+
+export function TemplateDetailResponse_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.TemplateDetailResponse", [], TemplateDetailResponse, () => [["Success", bool_type], ["Data", option_type(CoreMRFormDetail_$reflection())], ["Error", option_type(string_type)]]);
+}
+
+export class CoreMREnhancementMetadata extends Record implements IEquatable<CoreMREnhancementMetadata>, IComparable<CoreMREnhancementMetadata> {
+    readonly SourceType: string;
+    readonly FormId: int32;
+    readonly FormName: string;
+    readonly StructureHash: string;
+    readonly ClinicalHash: string;
+    readonly VersionId: int32;
+    readonly ImportedFrom: string;
+    readonly ImportedAt: Date;
+    constructor(SourceType: string, FormId: int32, FormName: string, StructureHash: string, ClinicalHash: string, VersionId: int32, ImportedFrom: string, ImportedAt: Date) {
+        super();
+        this.SourceType = SourceType;
+        this.FormId = (FormId | 0);
+        this.FormName = FormName;
+        this.StructureHash = StructureHash;
+        this.ClinicalHash = ClinicalHash;
+        this.VersionId = (VersionId | 0);
+        this.ImportedFrom = ImportedFrom;
+        this.ImportedAt = ImportedAt;
+    }
+}
+
+export function CoreMREnhancementMetadata_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.CoreMREnhancementMetadata", [], CoreMREnhancementMetadata, () => [["SourceType", string_type], ["FormId", int32_type], ["FormName", string_type], ["StructureHash", string_type], ["ClinicalHash", string_type], ["VersionId", int32_type], ["ImportedFrom", string_type], ["ImportedAt", class_type("System.DateTimeOffset")]]);
+}
+
+export class CoreMRAdapterRelationship extends Record implements IEquatable<CoreMRAdapterRelationship>, IComparable<CoreMRAdapterRelationship> {
+    readonly BlueprintId: string;
+    readonly LineageRootId: string;
+    readonly TenantId: string;
+    readonly AdapterType: string;
+    readonly CoreMRAnchors: { ClinicalHash: string, FormId: int32, StructureHash: string, VersionId: int32 };
+    readonly Enhancement: { CreatedAt: Date, CreatedBy?: string, FailureReason?: string, SessionId: string, Status: string };
+    constructor(BlueprintId: string, LineageRootId: string, TenantId: string, AdapterType: string, CoreMRAnchors: { ClinicalHash: string, FormId: int32, StructureHash: string, VersionId: int32 }, Enhancement: { CreatedAt: Date, CreatedBy?: string, FailureReason?: string, SessionId: string, Status: string }) {
+        super();
+        this.BlueprintId = BlueprintId;
+        this.LineageRootId = LineageRootId;
+        this.TenantId = TenantId;
+        this.AdapterType = AdapterType;
+        this.CoreMRAnchors = CoreMRAnchors;
+        this.Enhancement = Enhancement;
+    }
+}
+
+export function CoreMRAdapterRelationship_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRTypes.CoreMRAdapterRelationship", [], CoreMRAdapterRelationship, () => [["BlueprintId", class_type("System.Guid")], ["LineageRootId", class_type("System.Guid")], ["TenantId", class_type("System.Guid")], ["AdapterType", string_type], ["CoreMRAnchors", anonRecord_type(["ClinicalHash", string_type], ["FormId", int32_type], ["StructureHash", string_type], ["VersionId", int32_type])], ["Enhancement", anonRecord_type(["CreatedAt", class_type("System.DateTimeOffset")], ["CreatedBy", option_type(string_type)], ["FailureReason", option_type(string_type)], ["SessionId", class_type("System.Guid")], ["Status", string_type])]]);
+}
+
+export type CoreMRResult$1_$union<T> = 
+    | CoreMRResult$1<T, 0>
+    | CoreMRResult$1<T, 1>
+
+export type CoreMRResult$1_$cases<T> = {
+    0: ["Success", [T]],
+    1: ["Failure", [CoreMRError]]
+}
+
+export function CoreMRResult$1_Success<T>(Item: T) {
+    return new CoreMRResult$1<T, 0>(0, [Item]);
+}
+
+export function CoreMRResult$1_Failure<T>(Item: CoreMRError) {
+    return new CoreMRResult$1<T, 1>(1, [Item]);
+}
+
+export class CoreMRResult$1<T, Tag extends keyof CoreMRResult$1_$cases<T>> extends Union<Tag, CoreMRResult$1_$cases<T>[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: CoreMRResult$1_$cases<T>[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Success", "Failure"];
+    }
+}
+
+export function CoreMRResult$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return union_type("FormSpec.Integrations.CorEMR.CoreMRTypes.CoreMRResult`1", [gen0], CoreMRResult$1, () => [[["Item", gen0]], [["Item", CoreMRError_$reflection()]]]);
+}
+
+//# sourceMappingURL=CoreMRTypes.ts.map