@f1studio/form-spec 5.0.0-alpha.101

package/FormSpec.d.ts

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