@f1studio/form-spec 5.0.0-alpha.124 → 5.0.0-alpha.125

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

@@ -0,0 +1,431 @@
+import { Record } from "@fable-org/fable-library-js/Types.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { toInt32, int64 } from "@fable-org/fable-library-js/BigInt.js";
+import { map as map_1, defaultArg, Option } from "@fable-org/fable-library-js/Option.js";
+import { int32ToString, uncurry2, comparePrimitives, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { class_type, list_type, bool_type, record_type, option_type, string_type, int64_type, int32_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { empty as empty_1, collect, map as map_2, isEmpty, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { ofList, add, FSharpMap } from "@fable-org/fable-library-js/Map.js";
+import { newGuid } from "@fable-org/fable-library-js/Guid.js";
+import { int64 as int64_1 } from "../../../fable_modules/Thoth.Json.10.4.1/Encode.fs.js";
+import { Auto_generateBoxedDecoder_Z6670B51, int64 as int64_2 } from "../../../fable_modules/Thoth.Json.10.4.1/Decode.fs.js";
+import { FSharpResult$2_$union } from "@fable-org/fable-library-js/Result.js";
+import { ExtraCoders, ErrorReason_$union } from "../../../fable_modules/Thoth.Json.10.4.1/Types.fs.js";
+import { empty } from "../../../fable_modules/Thoth.Json.10.4.1/Extra.fs.js";
+import { fromString, list as list_3, bool, IOptionalGetter, IRequiredGetter, IGetters, string, int, object, map, keyValuePairs } from "../../../fable_modules/Thoth.Json.10.4.1/Decode.fs.js";
+import { CoreMRFormData, CoreMRTag, CoreMRTrigger, CoreMRFormMetadata, CoreMRItem, CoreMRChoice } from "./CoreMRTypes.js";
+import { isNullOrEmpty } from "@fable-org/fable-library-js/String.js";
+
+export class TemplateChoice extends Record implements IEquatable<TemplateChoice>, IComparable<TemplateChoice> {
+    readonly ChoiceId: int32;
+    readonly Sequence: int32;
+    readonly Score: int64;
+    readonly Text: string;
+    readonly BitPosition: Option<int32>;
+    readonly Code: Option<string>;
+    readonly Highlight: Option<int32>;
+    constructor(ChoiceId: int32, Sequence: int32, Score: int64, Text$: string, BitPosition: Option<int32>, Code: Option<string>, Highlight: Option<int32>) {
+        super();
+        this.ChoiceId = (ChoiceId | 0);
+        this.Sequence = (Sequence | 0);
+        this.Score = Score;
+        this.Text = Text$;
+        this.BitPosition = BitPosition;
+        this.Code = Code;
+        this.Highlight = Highlight;
+    }
+}
+
+export function TemplateChoice_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.TemplateManifestDecoder.TemplateChoice", [], TemplateChoice, () => [["ChoiceId", int32_type], ["Sequence", int32_type], ["Score", int64_type], ["Text", string_type], ["BitPosition", option_type(int32_type)], ["Code", option_type(string_type)], ["Highlight", option_type(int32_type)]]);
+}
+
+export class TemplateItem extends Record implements IEquatable<TemplateItem>, IComparable<TemplateItem> {
+    readonly ItemId: int32;
+    readonly Sequence: int32;
+    readonly Type: int32;
+    readonly NestingLevel: int32;
+    readonly IsRequired: boolean;
+    readonly Text: string;
+    readonly SequenceText: Option<string>;
+    readonly Code: Option<string>;
+    readonly Uuid: Option<string>;
+    readonly GenderRequired: Option<string>;
+    readonly Highlight: Option<int32>;
+    readonly Choices: FSharpList<TemplateChoice>;
+    constructor(ItemId: int32, Sequence: int32, Type: int32, NestingLevel: int32, IsRequired: boolean, Text$: string, SequenceText: Option<string>, Code: Option<string>, Uuid: Option<string>, GenderRequired: Option<string>, Highlight: Option<int32>, Choices: FSharpList<TemplateChoice>) {
+        super();
+        this.ItemId = (ItemId | 0);
+        this.Sequence = (Sequence | 0);
+        this.Type = (Type | 0);
+        this.NestingLevel = (NestingLevel | 0);
+        this.IsRequired = IsRequired;
+        this.Text = Text$;
+        this.SequenceText = SequenceText;
+        this.Code = Code;
+        this.Uuid = Uuid;
+        this.GenderRequired = GenderRequired;
+        this.Highlight = Highlight;
+        this.Choices = Choices;
+    }
+}
+
+export function TemplateItem_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.TemplateManifestDecoder.TemplateItem", [], TemplateItem, () => [["ItemId", int32_type], ["Sequence", int32_type], ["Type", int32_type], ["NestingLevel", int32_type], ["IsRequired", bool_type], ["Text", string_type], ["SequenceText", option_type(string_type)], ["Code", option_type(string_type)], ["Uuid", option_type(string_type)], ["GenderRequired", option_type(string_type)], ["Highlight", option_type(int32_type)], ["Choices", list_type(TemplateChoice_$reflection())]]);
+}
+
+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.TemplateManifestDecoder.EncounterTypes", [], EncounterTypes, () => [["Medical", bool_type], ["Mental", bool_type], ["Dental", bool_type], ["Other", bool_type]]);
+}
+
+export class ScoringLabel extends Record implements IEquatable<ScoringLabel>, IComparable<ScoringLabel> {
+    readonly Name: string;
+    readonly Min: int32;
+    constructor(Name: string, Min: int32) {
+        super();
+        this.Name = Name;
+        this.Min = (Min | 0);
+    }
+}
+
+export function ScoringLabel_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.TemplateManifestDecoder.ScoringLabel", [], ScoringLabel, () => [["Name", string_type], ["Min", int32_type]]);
+}
+
+export class FormScoring extends Record implements IEquatable<FormScoring>, IComparable<FormScoring> {
+    readonly ScoreId: int32;
+    readonly ScoreName: string;
+    readonly Labels: FSharpList<ScoringLabel>;
+    readonly ChoiceScores: FSharpMap<string, int32>;
+    constructor(ScoreId: int32, ScoreName: string, Labels: FSharpList<ScoringLabel>, ChoiceScores: FSharpMap<string, int32>) {
+        super();
+        this.ScoreId = (ScoreId | 0);
+        this.ScoreName = ScoreName;
+        this.Labels = Labels;
+        this.ChoiceScores = ChoiceScores;
+    }
+}
+
+export function FormScoring_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.TemplateManifestDecoder.FormScoring", [], FormScoring, () => [["ScoreId", int32_type], ["ScoreName", string_type], ["Labels", list_type(ScoringLabel_$reflection())], ["ChoiceScores", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])]]);
+}
+
+export class TemplateForm extends Record implements IEquatable<TemplateForm>, IComparable<TemplateForm> {
+    readonly FormId: int32;
+    readonly Name: string;
+    readonly FormCode: string;
+    readonly FormCodeSource: string;
+    readonly Description: string;
+    readonly CurrentVersionId: int64;
+    readonly IsIntake: boolean;
+    readonly Usage: string;
+    readonly RequiresSignature: boolean;
+    readonly EncounterTypes: EncounterTypes;
+    readonly OnceAYear: boolean;
+    readonly StructureHash: string;
+    readonly ClinicalHash: string;
+    readonly CosmeticHash: string;
+    readonly Hash: string;
+    readonly Items: FSharpList<TemplateItem>;
+    readonly Scoring: Option<FormScoring>;
+    constructor(FormId: int32, Name: string, FormCode: string, FormCodeSource: string, Description: string, CurrentVersionId: int64, IsIntake: boolean, Usage: string, RequiresSignature: boolean, EncounterTypes: EncounterTypes, OnceAYear: boolean, StructureHash: string, ClinicalHash: string, CosmeticHash: string, Hash: string, Items: FSharpList<TemplateItem>, Scoring: Option<FormScoring>) {
+        super();
+        this.FormId = (FormId | 0);
+        this.Name = Name;
+        this.FormCode = FormCode;
+        this.FormCodeSource = FormCodeSource;
+        this.Description = Description;
+        this.CurrentVersionId = CurrentVersionId;
+        this.IsIntake = IsIntake;
+        this.Usage = Usage;
+        this.RequiresSignature = RequiresSignature;
+        this.EncounterTypes = EncounterTypes;
+        this.OnceAYear = OnceAYear;
+        this.StructureHash = StructureHash;
+        this.ClinicalHash = ClinicalHash;
+        this.CosmeticHash = CosmeticHash;
+        this.Hash = Hash;
+        this.Items = Items;
+        this.Scoring = Scoring;
+    }
+}
+
+export function TemplateForm_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.TemplateManifestDecoder.TemplateForm", [], TemplateForm, () => [["FormId", int32_type], ["Name", string_type], ["FormCode", string_type], ["FormCodeSource", string_type], ["Description", string_type], ["CurrentVersionId", int64_type], ["IsIntake", bool_type], ["Usage", string_type], ["RequiresSignature", bool_type], ["EncounterTypes", EncounterTypes_$reflection()], ["OnceAYear", bool_type], ["StructureHash", string_type], ["ClinicalHash", string_type], ["CosmeticHash", string_type], ["Hash", string_type], ["Items", list_type(TemplateItem_$reflection())], ["Scoring", option_type(FormScoring_$reflection())]]);
+}
+
+export class ElementTypeEntry extends Record implements IEquatable<ElementTypeEntry>, IComparable<ElementTypeEntry> {
+    readonly 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 ElementTypeEntry_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.TemplateManifestDecoder.ElementTypeEntry", [], ElementTypeEntry, () => [["Code", string_type], ["ValueEncoding", string_type], ["TextField", string_type]]);
+}
+
+export class InstrumentMapEntry extends Record implements IEquatable<InstrumentMapEntry>, IComparable<InstrumentMapEntry> {
+    readonly InstrumentType: string;
+    readonly FormCode: string;
+    readonly MaxScore: Option<int32>;
+    readonly Source: string;
+    readonly Archived: boolean;
+    readonly FormName: string;
+    constructor(InstrumentType: string, FormCode: string, MaxScore: Option<int32>, Source: string, Archived: boolean, FormName: string) {
+        super();
+        this.InstrumentType = InstrumentType;
+        this.FormCode = FormCode;
+        this.MaxScore = MaxScore;
+        this.Source = Source;
+        this.Archived = Archived;
+        this.FormName = FormName;
+    }
+}
+
+export function InstrumentMapEntry_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.TemplateManifestDecoder.InstrumentMapEntry", [], InstrumentMapEntry, () => [["InstrumentType", string_type], ["FormCode", string_type], ["MaxScore", option_type(int32_type)], ["Source", string_type], ["Archived", bool_type], ["FormName", string_type]]);
+}
+
+export class CodeExtractionStats extends Record implements IEquatable<CodeExtractionStats>, IComparable<CodeExtractionStats> {
+    readonly Extracted: int32;
+    readonly Generated: int32;
+    readonly BySource: FSharpMap<string, int32>;
+    readonly Regex: string;
+    constructor(Extracted: int32, Generated: int32, BySource: FSharpMap<string, int32>, Regex: string) {
+        super();
+        this.Extracted = (Extracted | 0);
+        this.Generated = (Generated | 0);
+        this.BySource = BySource;
+        this.Regex = Regex;
+    }
+}
+
+export function CodeExtractionStats_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.TemplateManifestDecoder.CodeExtractionStats", [], CodeExtractionStats, () => [["Extracted", int32_type], ["Generated", int32_type], ["BySource", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])], ["Regex", string_type]]);
+}
+
+export class TemplateStats extends Record implements IEquatable<TemplateStats>, IComparable<TemplateStats> {
+    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: CodeExtractionStats;
+    constructor(TotalForms: int32, WithCodes: int32, WithSyntheticCodes: int32, WithScoring: int32, WithSignature: int32, ByUsage: FSharpMap<string, int32>, ByElementType: FSharpMap<string, int32>, CodeExtraction: CodeExtractionStats) {
+        super();
+        this.TotalForms = (TotalForms | 0);
+        this.WithCodes = (WithCodes | 0);
+        this.WithSyntheticCodes = (WithSyntheticCodes | 0);
+        this.WithScoring = (WithScoring | 0);
+        this.WithSignature = (WithSignature | 0);
+        this.ByUsage = ByUsage;
+        this.ByElementType = ByElementType;
+        this.CodeExtraction = CodeExtraction;
+    }
+}
+
+export function TemplateStats_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.TemplateManifestDecoder.TemplateStats", [], TemplateStats, () => [["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", CodeExtractionStats_$reflection()]]);
+}
+
+export class CoreEmrInfo extends Record implements IEquatable<CoreEmrInfo>, IComparable<CoreEmrInfo> {
+    readonly AppVersion: string;
+    readonly SchemaVersion: string;
+    readonly SchemaRevision: int32;
+    constructor(AppVersion: string, SchemaVersion: string, SchemaRevision: int32) {
+        super();
+        this.AppVersion = AppVersion;
+        this.SchemaVersion = SchemaVersion;
+        this.SchemaRevision = (SchemaRevision | 0);
+    }
+}
+
+export function CoreEmrInfo_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.TemplateManifestDecoder.CoreEmrInfo", [], CoreEmrInfo, () => [["AppVersion", string_type], ["SchemaVersion", string_type], ["SchemaRevision", int32_type]]);
+}
+
+export class InstrumentMapStats extends Record implements IEquatable<InstrumentMapStats>, IComparable<InstrumentMapStats> {
+    readonly Total: int32;
+    readonly Current: int32;
+    readonly Archived: int32;
+    readonly BySource: FSharpMap<string, int32>;
+    readonly ByType: FSharpMap<string, int32>;
+    constructor(Total: int32, Current: int32, Archived: int32, BySource: FSharpMap<string, int32>, ByType: FSharpMap<string, int32>) {
+        super();
+        this.Total = (Total | 0);
+        this.Current = (Current | 0);
+        this.Archived = (Archived | 0);
+        this.BySource = BySource;
+        this.ByType = ByType;
+    }
+}
+
+export function InstrumentMapStats_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.TemplateManifestDecoder.InstrumentMapStats", [], InstrumentMapStats, () => [["Total", int32_type], ["Current", int32_type], ["Archived", int32_type], ["BySource", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])], ["ByType", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])]]);
+}
+
+export class TemplateManifest extends Record implements IEquatable<TemplateManifest>, IComparable<TemplateManifest> {
+    readonly Schema: Option<string>;
+    readonly Version: int32;
+    readonly GeneratedAt: string;
+    readonly GeneratedFrom: string;
+    readonly CoreEmr: CoreEmrInfo;
+    readonly Stats: TemplateStats;
+    readonly ElementTypes: FSharpMap<string, ElementTypeEntry>;
+    readonly Forms: FSharpMap<string, TemplateForm>;
+    readonly InstrumentMap: FSharpMap<string, InstrumentMapEntry>;
+    readonly InstrumentMapStats: InstrumentMapStats;
+    constructor(Schema: Option<string>, Version: int32, GeneratedAt: string, GeneratedFrom: string, CoreEmr: CoreEmrInfo, Stats: TemplateStats, ElementTypes: FSharpMap<string, ElementTypeEntry>, Forms: FSharpMap<string, TemplateForm>, InstrumentMap: FSharpMap<string, InstrumentMapEntry>, InstrumentMapStats: InstrumentMapStats) {
+        super();
+        this.Schema = Schema;
+        this.Version = (Version | 0);
+        this.GeneratedAt = GeneratedAt;
+        this.GeneratedFrom = GeneratedFrom;
+        this.CoreEmr = CoreEmr;
+        this.Stats = Stats;
+        this.ElementTypes = ElementTypes;
+        this.Forms = Forms;
+        this.InstrumentMap = InstrumentMap;
+        this.InstrumentMapStats = InstrumentMapStats;
+    }
+}
+
+export function TemplateManifest_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.TemplateManifestDecoder.TemplateManifest", [], TemplateManifest, () => [["Schema", option_type(string_type)], ["Version", int32_type], ["GeneratedAt", string_type], ["GeneratedFrom", string_type], ["CoreEmr", CoreEmrInfo_$reflection()], ["Stats", TemplateStats_$reflection()], ["ElementTypes", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, ElementTypeEntry_$reflection()])], ["Forms", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, TemplateForm_$reflection()])], ["InstrumentMap", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, InstrumentMapEntry_$reflection()])], ["InstrumentMapStats", InstrumentMapStats_$reflection()]]);
+}
+
+const extraWithInt64: ExtraCoders = new ExtraCoders((() => {
+    let copyOfStruct: string = newGuid();
+    return copyOfStruct;
+})(), add<string, [((arg0: any) => any), ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<any, [string, ErrorReason_$union]>))]>("System.Int64", [int64_1, int64_2] as [((arg0: any) => any), ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<any, [string, ErrorReason_$union]>))], empty.Coders));
+
+const int64Decoder: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<int64, [string, ErrorReason_$union]>)) = Auto_generateBoxedDecoder_Z6670B51(int64_type, undefined, extraWithInt64);
+
+function dictDecoder<T>(decoder: ((arg0: string, arg1: any) => FSharpResult$2_$union<T, [string, ErrorReason_$union]>)): ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, T>, [string, ErrorReason_$union]>)) {
+    let d: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpList<[string, T]>, [string, ErrorReason_$union]>));
+    const decoder_1: ((arg0: string, arg1: any) => FSharpResult$2_$union<T, [string, ErrorReason_$union]>) = decoder;
+    d = ((path: string): ((arg0: any) => FSharpResult$2_$union<FSharpList<[string, T]>, [string, ErrorReason_$union]>) => ((value: any): FSharpResult$2_$union<FSharpList<[string, T]>, [string, ErrorReason_$union]> => keyValuePairs<T>(decoder_1, path, value)));
+    return (path_1: string): ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, T>, [string, ErrorReason_$union]>) => ((value_1: any): FSharpResult$2_$union<FSharpMap<string, T>, [string, ErrorReason_$union]> => map<FSharpList<[string, T]>, FSharpMap<string, T>>((elements: FSharpList<[string, T]>): FSharpMap<string, T> => ofList<string, T>(elements, {
+        Compare: comparePrimitives,
+    }), uncurry2(d), path_1, value_1));
+}
+
+const choiceDecoder = (path_2: string): ((arg0: any) => FSharpResult$2_$union<TemplateChoice, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<TemplateChoice, [string, ErrorReason_$union]> => object<TemplateChoice>((get$: IGetters): TemplateChoice => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, objectArg_3: IOptionalGetter, objectArg_4: IOptionalGetter, objectArg_5: IOptionalGetter;
+    return new TemplateChoice((objectArg = get$.Required, objectArg.Field<int32>("choiceId", uncurry2(int))), (objectArg_1 = get$.Required, objectArg_1.Field<int32>("sequence", uncurry2(int))), 0n, (objectArg_2 = get$.Required, objectArg_2.Field<string>("text", string)), (objectArg_3 = get$.Optional, objectArg_3.Field<int32>("bitPosition", uncurry2(int))), (objectArg_4 = get$.Optional, objectArg_4.Field<string>("code", string)), (objectArg_5 = get$.Optional, objectArg_5.Field<int32>("highlight", uncurry2(int))));
+}, path_2, v));
+
+const itemDecoder = (path_7: string): ((arg0: any) => FSharpResult$2_$union<TemplateItem, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<TemplateItem, [string, ErrorReason_$union]> => object<TemplateItem>((get$: IGetters): TemplateItem => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter, objectArg_4: IRequiredGetter, objectArg_5: IRequiredGetter, objectArg_6: IOptionalGetter, objectArg_7: IOptionalGetter, objectArg_8: IOptionalGetter, objectArg_9: IOptionalGetter, objectArg_10: IOptionalGetter, objectArg_11: IRequiredGetter;
+    return new TemplateItem((objectArg = get$.Required, objectArg.Field<int32>("itemId", uncurry2(int))), (objectArg_1 = get$.Required, objectArg_1.Field<int32>("sequence", uncurry2(int))), (objectArg_2 = get$.Required, objectArg_2.Field<int32>("type", uncurry2(int))), (objectArg_3 = get$.Required, objectArg_3.Field<int32>("nestingLevel", uncurry2(int))), (objectArg_4 = get$.Required, objectArg_4.Field<boolean>("isRequired", bool)), (objectArg_5 = get$.Required, objectArg_5.Field<string>("text", string)), (objectArg_6 = get$.Optional, objectArg_6.Field<string>("sequenceText", string)), (objectArg_7 = get$.Optional, objectArg_7.Field<string>("code", string)), (objectArg_8 = get$.Optional, objectArg_8.Field<string>("uuid", string)), (objectArg_9 = get$.Optional, objectArg_9.Field<string>("genderRequired", string)), (objectArg_10 = get$.Optional, objectArg_10.Field<int32>("highlight", uncurry2(int))), (objectArg_11 = get$.Required, objectArg_11.Field<FSharpList<TemplateChoice>>("choices", (path_6: string, value_6: any): FSharpResult$2_$union<FSharpList<TemplateChoice>, [string, ErrorReason_$union]> => list_3<TemplateChoice>(uncurry2(choiceDecoder), path_6, value_6))));
+}, path_7, v));
+
+const encounterTypesDecoder = (path_4: string): ((arg0: any) => FSharpResult$2_$union<EncounterTypes, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<EncounterTypes, [string, ErrorReason_$union]> => object<EncounterTypes>((get$: IGetters): EncounterTypes => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter;
+    return new EncounterTypes((objectArg = get$.Required, objectArg.Field<boolean>("medical", bool)), (objectArg_1 = get$.Required, objectArg_1.Field<boolean>("mental", bool)), (objectArg_2 = get$.Required, objectArg_2.Field<boolean>("dental", bool)), (objectArg_3 = get$.Required, objectArg_3.Field<boolean>("other", bool)));
+}, path_4, v));
+
+const scoringLabelDecoder = (path_1: string): ((arg0: any) => FSharpResult$2_$union<ScoringLabel, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<ScoringLabel, [string, ErrorReason_$union]> => object<ScoringLabel>((get$: IGetters): ScoringLabel => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter;
+    return new ScoringLabel((objectArg = get$.Required, objectArg.Field<string>("name", string)), (objectArg_1 = get$.Required, objectArg_1.Field<int32>("min", uncurry2(int))));
+}, path_1, v));
+
+const formScoringDecoder = (path_2: string): ((arg0: any) => FSharpResult$2_$union<FormScoring, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<FormScoring, [string, ErrorReason_$union]> => object<FormScoring>((get$: IGetters): FormScoring => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, arg_7: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, int32>, [string, ErrorReason_$union]>)), objectArg_3: IRequiredGetter;
+    return new FormScoring((objectArg = get$.Required, objectArg.Field<int32>("scoreId", uncurry2(int))), (objectArg_1 = get$.Required, objectArg_1.Field<string>("scoreName", string)), (objectArg_2 = get$.Required, objectArg_2.Field<FSharpList<ScoringLabel>>("labels", (path_1: string, value_1: any): FSharpResult$2_$union<FSharpList<ScoringLabel>, [string, ErrorReason_$union]> => list_3<ScoringLabel>(uncurry2(scoringLabelDecoder), path_1, value_1))), (arg_7 = dictDecoder<int32>(uncurry2(int)), (objectArg_3 = get$.Required, objectArg_3.Field<FSharpMap<string, int32>>("choiceScores", uncurry2(arg_7)))));
+}, path_2, v));
+
+const formDecoder = (path_13: string): ((arg0: any) => FSharpResult$2_$union<TemplateForm, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<TemplateForm, [string, ErrorReason_$union]> => object<TemplateForm>((get$: IGetters): TemplateForm => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter, objectArg_4: IRequiredGetter, objectArg_5: IRequiredGetter, objectArg_6: IRequiredGetter, objectArg_7: IRequiredGetter, objectArg_8: IRequiredGetter, objectArg_9: IRequiredGetter, objectArg_10: IRequiredGetter, objectArg_11: IRequiredGetter, objectArg_12: IRequiredGetter, objectArg_13: IRequiredGetter, objectArg_14: IRequiredGetter, objectArg_15: IRequiredGetter, objectArg_16: IOptionalGetter;
+    return new TemplateForm((objectArg = get$.Required, objectArg.Field<int32>("formId", uncurry2(int))), (objectArg_1 = get$.Required, objectArg_1.Field<string>("name", string)), (objectArg_2 = get$.Required, objectArg_2.Field<string>("formCode", string)), (objectArg_3 = get$.Required, objectArg_3.Field<string>("formCodeSource", string)), (objectArg_4 = get$.Required, objectArg_4.Field<string>("description", string)), (objectArg_5 = get$.Required, objectArg_5.Field<int64>("currentVersionId", uncurry2(int64Decoder))), (objectArg_6 = get$.Required, objectArg_6.Field<boolean>("isIntake", bool)), (objectArg_7 = get$.Required, objectArg_7.Field<string>("usage", string)), (objectArg_8 = get$.Required, objectArg_8.Field<boolean>("requiresSignature", bool)), (objectArg_9 = get$.Required, objectArg_9.Field<EncounterTypes>("encounterTypes", uncurry2(encounterTypesDecoder))), (objectArg_10 = get$.Required, objectArg_10.Field<boolean>("onceAYear", bool)), (objectArg_11 = get$.Required, objectArg_11.Field<string>("structureHash", string)), (objectArg_12 = get$.Required, objectArg_12.Field<string>("clinicalHash", string)), (objectArg_13 = get$.Required, objectArg_13.Field<string>("cosmeticHash", string)), (objectArg_14 = get$.Required, objectArg_14.Field<string>("hash", string)), (objectArg_15 = get$.Required, objectArg_15.Field<FSharpList<TemplateItem>>("items", (path_12: string, value_12: any): FSharpResult$2_$union<FSharpList<TemplateItem>, [string, ErrorReason_$union]> => list_3<TemplateItem>(uncurry2(itemDecoder), path_12, value_12))), (objectArg_16 = get$.Optional, objectArg_16.Field<FormScoring>("scoring", uncurry2(formScoringDecoder))));
+}, path_13, v));
+
+const elementTypeDecoder = (path_3: string): ((arg0: any) => FSharpResult$2_$union<ElementTypeEntry, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<ElementTypeEntry, [string, ErrorReason_$union]> => object<ElementTypeEntry>((get$: IGetters): ElementTypeEntry => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter;
+    return new ElementTypeEntry((objectArg = get$.Required, objectArg.Field<string>("code", string)), (objectArg_1 = get$.Required, objectArg_1.Field<string>("valueEncoding", string)), (objectArg_2 = get$.Required, objectArg_2.Field<string>("textField", string)));
+}, path_3, v));
+
+const instrumentMapEntryDecoder = (path_5: string): ((arg0: any) => FSharpResult$2_$union<InstrumentMapEntry, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<InstrumentMapEntry, [string, ErrorReason_$union]> => object<InstrumentMapEntry>((get$: IGetters): InstrumentMapEntry => {
+    let objectArg: IRequiredGetter, objectArg_1: IOptionalGetter, objectArg_2: IOptionalGetter, objectArg_3: IRequiredGetter, objectArg_4: IRequiredGetter, objectArg_5: IRequiredGetter;
+    return new InstrumentMapEntry((objectArg = get$.Required, objectArg.Field<string>("instrumentType", string)), defaultArg((objectArg_1 = get$.Optional, objectArg_1.Field<string>("formCode", string)), ""), (objectArg_2 = get$.Optional, objectArg_2.Field<int32>("maxScore", uncurry2(int))), (objectArg_3 = get$.Required, objectArg_3.Field<string>("source", string)), (objectArg_4 = get$.Required, objectArg_4.Field<boolean>("archived", bool)), (objectArg_5 = get$.Required, objectArg_5.Field<string>("formName", string)));
+}, path_5, v));
+
+const codeExtractionStatsDecoder = (path_1: string): ((arg0: any) => FSharpResult$2_$union<CodeExtractionStats, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<CodeExtractionStats, [string, ErrorReason_$union]> => object<CodeExtractionStats>((get$: IGetters): CodeExtractionStats => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, arg_5: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, int32>, [string, ErrorReason_$union]>)), objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter;
+    return new CodeExtractionStats((objectArg = get$.Required, objectArg.Field<int32>("extracted", uncurry2(int))), (objectArg_1 = get$.Required, objectArg_1.Field<int32>("generated", uncurry2(int))), (arg_5 = dictDecoder<int32>(uncurry2(int)), (objectArg_2 = get$.Required, objectArg_2.Field<FSharpMap<string, int32>>("bySource", uncurry2(arg_5)))), (objectArg_3 = get$.Required, objectArg_3.Field<string>("regex", string)));
+}, path_1, v));
+
+const statsDecoder = (path: string): ((arg0: any) => FSharpResult$2_$union<TemplateStats, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<TemplateStats, [string, ErrorReason_$union]> => object<TemplateStats>((get$: IGetters): TemplateStats => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter, objectArg_4: IRequiredGetter, arg_11: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, int32>, [string, ErrorReason_$union]>)), objectArg_5: IRequiredGetter, arg_13: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, int32>, [string, ErrorReason_$union]>)), objectArg_6: IRequiredGetter, objectArg_7: IRequiredGetter;
+    return new TemplateStats((objectArg = get$.Required, objectArg.Field<int32>("totalForms", uncurry2(int))), (objectArg_1 = get$.Required, objectArg_1.Field<int32>("withCodes", uncurry2(int))), (objectArg_2 = get$.Required, objectArg_2.Field<int32>("withSyntheticCodes", uncurry2(int))), (objectArg_3 = get$.Required, objectArg_3.Field<int32>("withScoring", uncurry2(int))), (objectArg_4 = get$.Required, objectArg_4.Field<int32>("withSignature", uncurry2(int))), (arg_11 = dictDecoder<int32>(uncurry2(int)), (objectArg_5 = get$.Required, objectArg_5.Field<FSharpMap<string, int32>>("byUsage", uncurry2(arg_11)))), (arg_13 = dictDecoder<int32>(uncurry2(int)), (objectArg_6 = get$.Required, objectArg_6.Field<FSharpMap<string, int32>>("byElementType", uncurry2(arg_13)))), (objectArg_7 = get$.Required, objectArg_7.Field<CodeExtractionStats>("codeExtraction", uncurry2(codeExtractionStatsDecoder))));
+}, path, v));
+
+const coreEmrDecoder = (path_2: string): ((arg0: any) => FSharpResult$2_$union<CoreEmrInfo, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<CoreEmrInfo, [string, ErrorReason_$union]> => object<CoreEmrInfo>((get$: IGetters): CoreEmrInfo => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter;
+    return new CoreEmrInfo((objectArg = get$.Required, objectArg.Field<string>("appVersion", string)), (objectArg_1 = get$.Required, objectArg_1.Field<string>("schemaVersion", string)), (objectArg_2 = get$.Required, objectArg_2.Field<int32>("schemaRevision", uncurry2(int))));
+}, path_2, v));
+
+const instrumentMapStatsDecoder = (path: string): ((arg0: any) => FSharpResult$2_$union<InstrumentMapStats, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<InstrumentMapStats, [string, ErrorReason_$union]> => object<InstrumentMapStats>((get$: IGetters): InstrumentMapStats => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, arg_7: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, int32>, [string, ErrorReason_$union]>)), objectArg_3: IRequiredGetter, arg_9: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, int32>, [string, ErrorReason_$union]>)), objectArg_4: IRequiredGetter;
+    return new InstrumentMapStats((objectArg = get$.Required, objectArg.Field<int32>("total", uncurry2(int))), (objectArg_1 = get$.Required, objectArg_1.Field<int32>("current", uncurry2(int))), (objectArg_2 = get$.Required, objectArg_2.Field<int32>("archived", uncurry2(int))), (arg_7 = dictDecoder<int32>(uncurry2(int)), (objectArg_3 = get$.Required, objectArg_3.Field<FSharpMap<string, int32>>("bySource", uncurry2(arg_7)))), (arg_9 = dictDecoder<int32>(uncurry2(int)), (objectArg_4 = get$.Required, objectArg_4.Field<FSharpMap<string, int32>>("byType", uncurry2(arg_9)))));
+}, path, v));
+
+const manifestDecoder = (path_3: string): ((arg0: any) => FSharpResult$2_$union<TemplateManifest, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<TemplateManifest, [string, ErrorReason_$union]> => object<TemplateManifest>((get$: IGetters): TemplateManifest => {
+    let objectArg: IOptionalGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter, objectArg_4: IRequiredGetter, objectArg_5: IRequiredGetter, arg_13: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, ElementTypeEntry>, [string, ErrorReason_$union]>)), objectArg_6: IRequiredGetter, arg_15: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, TemplateForm>, [string, ErrorReason_$union]>)), objectArg_7: IRequiredGetter, arg_17: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<FSharpMap<string, InstrumentMapEntry>, [string, ErrorReason_$union]>)), objectArg_8: IRequiredGetter, objectArg_9: IRequiredGetter;
+    return new TemplateManifest((objectArg = get$.Optional, objectArg.Field<string>("$schema", string)), (objectArg_1 = get$.Required, objectArg_1.Field<int32>("version", uncurry2(int))), (objectArg_2 = get$.Required, objectArg_2.Field<string>("generatedAt", string)), (objectArg_3 = get$.Required, objectArg_3.Field<string>("generatedFrom", string)), (objectArg_4 = get$.Required, objectArg_4.Field<CoreEmrInfo>("coreEmr", uncurry2(coreEmrDecoder))), (objectArg_5 = get$.Required, objectArg_5.Field<TemplateStats>("stats", uncurry2(statsDecoder))), (arg_13 = dictDecoder<ElementTypeEntry>(uncurry2(elementTypeDecoder)), (objectArg_6 = get$.Required, objectArg_6.Field<FSharpMap<string, ElementTypeEntry>>("elementTypes", uncurry2(arg_13)))), (arg_15 = dictDecoder<TemplateForm>(uncurry2(formDecoder)), (objectArg_7 = get$.Required, objectArg_7.Field<FSharpMap<string, TemplateForm>>("forms", uncurry2(arg_15)))), (arg_17 = dictDecoder<InstrumentMapEntry>(uncurry2(instrumentMapEntryDecoder)), (objectArg_8 = get$.Required, objectArg_8.Field<FSharpMap<string, InstrumentMapEntry>>("instrumentMap", uncurry2(arg_17)))), (objectArg_9 = get$.Required, objectArg_9.Field<InstrumentMapStats>("instrumentMapStats", uncurry2(instrumentMapStatsDecoder))));
+}, path_3, v));
+
+function toCoreMRChoice(itemId: int32, c: TemplateChoice): CoreMRChoice {
+    return new CoreMRChoice(c.ChoiceId, itemId, c.Sequence, c.Text, c.Score, c.BitPosition, c.Code, map_1<int32, string>(int32ToString, c.Highlight));
+}
+
+function toCoreMRItem(item: TemplateItem): CoreMRItem {
+    return new CoreMRItem(item.ItemId, item.Sequence, item.NestingLevel, item.SequenceText, item.Type, int32ToString(item.Type), !isEmpty(item.Choices), true, false, item.Text, item.IsRequired, item.GenderRequired, map_1<int32, string>(int32ToString, item.Highlight), item.Code, item.Uuid, undefined, undefined, 0, 0, undefined);
+}
+
+/**
+ * Convert a TemplateForm to CoreMRFormData — the universal pipeline input.
+ */
+export function toCoreMRFormData(form: TemplateForm): CoreMRFormData {
+    return new CoreMRFormData(new CoreMRFormMetadata(form.FormId, form.Name, isNullOrEmpty(form.Description) ? undefined : form.Description, ~~toInt32(form.CurrentVersionId), 1, undefined, form.RequiresSignature, form.IsIntake, "", ""), map_2<TemplateItem, CoreMRItem>(toCoreMRItem, form.Items), collect<TemplateItem, CoreMRChoice>((item_1: TemplateItem): FSharpList<CoreMRChoice> => map_2<TemplateChoice, CoreMRChoice>((c: TemplateChoice): CoreMRChoice => toCoreMRChoice(item_1.ItemId, c), item_1.Choices), form.Items), empty_1<CoreMRTrigger>(), empty_1<CoreMRTag>());
+}
+
+/**
+ * Decode templates.json manifest. Strict (all-or-nothing).
+ */
+export function decodeManifest(json: string): FSharpResult$2_$union<TemplateManifest, string> {
+    return fromString<TemplateManifest>(uncurry2(manifestDecoder), json);
+}
+
+/**
+ * Decode a single TemplateForm from JSON (bridge API single-form response).
+ */
+export function decodeTemplateForm(json: string): FSharpResult$2_$union<TemplateForm, string> {
+    return fromString<TemplateForm>(uncurry2(formDecoder), json);
+}
+
+export const templateFormDecoder: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<TemplateForm, [string, ErrorReason_$union]>)) = formDecoder;
+
+//# sourceMappingURL=TemplateManifestDecoder.ts.map

package/src/FormSpec.FS/Interop/FormSpec.Api.Helpers.ts

@@ -4,7 +4,7 @@ import { join, printf, toConsole } from "@fable-org/fable-library-js/String.js";
 import { Auto_generateBoxedEncoder_437914C6, toString } from "../../fable_modules/Thoth.Json.10.4.1/Encode.fs.js";
 import { array_type, string_type, union_type, TypeInfo, obj_type } from "@fable-org/fable-library-js/Reflection.js";
 import { Auto_generateBoxedDecoder_Z6670B51, fromString } from "../../fable_modules/Thoth.Json.10.4.1/Decode.fs.js";
-import { equals, createObj, stringHash, compare, IDisposable, disposeSafe, IEnumerator, getEnumerator, IMap, isArrayLike, uncurry2 } from "@fable-org/fable-library-js/Util.js";
+import { defaultOf, equals, createObj, stringHash, compare, IDisposable, disposeSafe, IEnumerator, getEnumerator, IMap, isArrayLike, uncurry2 } from "@fable-org/fable-library-js/Util.js";
 import { Spec_ClinicalInstrumentInfo, Spec_FormClassification_$union, ClinicalPathway_StateType_$union, ClinicalPathway_TaskPriority_$union, ClinicalPathway_AlertSeverity_$union, ClinicalPathway_ReferralUrgency_$union, ClinicalPathway_ActionInfo_$union, ClinicalPathway_NavigateToFormAction, ClinicalPathway_ProblemAction, ClinicalPathway_AlertAction, ClinicalPathway_EducationAction, ClinicalPathway_ProcedureAction, ClinicalPathway_TestAction, ClinicalPathway_DocumentationAction, ClinicalPathway_FieldValueSource_$union, ClinicalPathway_SetFieldValueAction, ClinicalPathway_PrescriptionAction, ClinicalPathway_MedicationAction, ClinicalPathway_ReferralAction, Shared_FieldValue, Shared_FieldValue_$union, ClinicalPathway_ClinicalPathwaySpec, ClinicalPathway_PathRequirement, ClinicalPathway_ConstraintDefinition, ClinicalPathway_PathwayExecutionMode_SinglePathway, ClinicalPathway_SinglePathwayConfig, ClinicalPathway_SelectionStrategy_HighestPriority, ClinicalPathway_TransitionDefinition, ClinicalPathway_TransitionCondition_FieldCondition, Shared_ConditionValue_Single, ClinicalPathway_FieldEvaluator_Equals, Shared_TransitionKey, ClinicalPathway_StateType_Terminal, ClinicalPathway_TerminalInfo, ClinicalPathway_StateDefinition, ClinicalPathway_StateType_Action, ClinicalPathway_ActionInfo_Task, ClinicalPathway_TaskAction, ClinicalPathway_DueDate_Today, ClinicalPathway_TaskPriority_Medium, ClinicalPathway_TaskPriority_Low, ClinicalPathway_TaskPriority_High, Shared_StateKey, Spec_FieldType_PluginField, Spec_PluginFieldConfig, Spec_FieldType_Matrix, Spec_MatrixInfo, Spec_FormClassification_General, Spec_FormLifecycle_Blueprint, Spec_FieldType_Text, Spec_TextInfo, Spec_FieldType_CheckboxList, Spec_MultiChoiceInfo, Shared_FieldOptionKey, Spec_FieldType_Checkbox, Spec_BooleanInfo, Shared_FieldKey, Shared_FieldOption, Shared_FieldValue_Single, Shared_FieldValue_PluginData, Shared_PluginDataProperty, Shared_PluginPropertyKey, Shared_FieldValue_Matrix, Shared_MatrixAnswer, Shared_MatrixItemKey, Shared_FieldValue_Multiple, Shared_FieldAnswer, Spec_FormStep$1, Spec_FormField$1, Spec_FieldType_$union, Spec_FormSpec$1, Spec_FormSpec$1_$reflection, Spec_FieldType_$reflection } from "../FormSpec.js";
 import { FSharpResult$2_Ok, FSharpResult$2_Error, FSharpResult$2_$union } from "@fable-org/fable-library-js/Result.js";
 import { newGuid, parse, tryParse } from "@fable-org/fable-library-js/Guid.js";
@@ -15,12 +15,14 @@ import { count, ofSeq as ofSeq_1, toList, FSharpMap } from "@fable-org/fable-lib
 import { addToDict } from "@fable-org/fable-library-js/MapUtil.js";
 import { int32 } from "@fable-org/fable-library-js/Int32.js";
 import { getFieldDetails as getFieldDetails_1, FieldDetails$1, findStepIndexForField, updateField } from "../FormSpecValues.js";
-import { singleton as singleton_1, empty as empty_1, collect as collect_1, delay, toList as toList_1, mapIndexed, map as map_2, choose } from "@fable-org/fable-library-js/Seq.js";
+import { length, singleton as singleton_1, empty as empty_1, collect as collect_1, delay, toList as toList_1, mapIndexed, map as map_2, choose } from "@fable-org/fable-library-js/Seq.js";
 import { toArray, ofArray } from "@fable-org/fable-library-js/Set.js";
 import { map as map_1 } from "@fable-org/fable-library-js/Array.js";
 import { now } from "@fable-org/fable-library-js/DateOffset.js";
 import { initializeExecution } from "../PathwayExecutor.js";
 import { List_distinct, distinct } from "@fable-org/fable-library-js/Seq2.js";
+import { tryDecodeSourceMap as tryDecodeSourceMap_1 } from "../Integrations/Adapters/CorEMR/CoreMREncoder.js";
+import { CoreMRSourceMap } from "../Integrations/Adapters/CorEMR/CoreMRSourceMap.js";
 
 /**
  * Get value from Option or return default (SAFE - recommended)
@@ -62,6 +64,15 @@ export function listToArray<T>(list: FSharpList<T>): T[] {
     return Array.from(list);
 }
 
+/**
+ * Normalize form values for platform API (f1-api fill_form, etc.).
+ * Ensures field keys and value shapes are in the format expected by the API.
+ * TypeScript: normalizeFormValuesForPlatformApi(formValues: Record<string, unknown>) => Record<string, unknown>
+ */
+export function normalizeFormValuesForPlatformApi(formValues: any): any {
+    return formValues;
+}
+
 export function serializeFormSpec(formSpec: any): string {
     toConsole(printf("[API.Helpers] Serializing FormSpec!!"));
     toConsole(`[API.Helpers] FormSpec: ${formSpec}`);
@@ -1132,4 +1143,95 @@ export function getInstrumentConfidence(spec: Spec_FormSpec$1<Spec_FieldType_$un
     }
 }
 
+/**
+ * Decode CoreMR provenance source map from JSON payload.
+ * TypeScript: tryDecodeSourceMap(payloadJson: string) => {success: boolean; sourceMap?: CoreMRSourceMap; error?: string}
+ * NO Result type - returns simple object for compatibility.
+ */
+export function tryDecodeSourceMap(payloadJson: string): any {
+    const matchValue: FSharpResult$2_$union<CoreMRSourceMap, string> = tryDecodeSourceMap_1(payloadJson);
+    if (matchValue.tag === /* Error */ 1) {
+        return {
+            error: matchValue.fields[0],
+            sourceMap: defaultOf(),
+            success: false,
+        };
+    }
+    else {
+        const sourceMap: CoreMRSourceMap = matchValue.fields[0];
+        return {
+            error: defaultOf(),
+            sourceMap: sourceMap,
+            success: true,
+        };
+    }
+}
+
+/**
+ * Validate and build FormSpec with values, collecting ALL validation errors.
+ * TypeScript: validateAndBuildFormSpec(formSpec: FormSpec, fieldData: any[]) => {isValid: boolean; formSpec?: FormSpec; errors: ValidationError[]}
+ * NO Result type - returns detailed telemetry for client-side validation.
+ */
+export function validateAndBuildFormSpec(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>, fieldData: { fieldKey: string, objectValue: any }[]): any {
+    let formSpec_1: any, totalFields_1: int32;
+    let errors: any[] = [];
+    let validFieldCount = 0;
+    let enumerator: any = getEnumerator(fieldData);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const input: { fieldKey: string, objectValue: any } = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            const matchValue: Option<Spec_FormField$1<Spec_FieldType_$union>> = findFieldByKey(formSpec, input.fieldKey);
+            if (matchValue == null) {
+                void (errors.push({
+                    errorType: "field_not_found",
+                    fieldKey: input.fieldKey,
+                    layer: "helper",
+                    message: `Field ${input.fieldKey} not found in FormSpec`,
+                }));
+            }
+            else {
+                const field: Spec_FormField$1<Spec_FieldType_$union> = value_11(matchValue);
+                try {
+                    validFieldCount = ((validFieldCount + 1) | 0);
+                }
+                catch (ex: any) {
+                    void (errors.push({
+                        errorType: "validation_error",
+                        fieldKey: input.fieldKey,
+                        layer: "helper",
+                        message: ex.message,
+                    }));
+                }
+            }
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    if (errors.length === 0) {
+        return {
+            errors: [],
+            formSpec: buildFormSpecWithValues(formSpec, fieldData),
+            isValid: true,
+            stats: {
+                errorFields: 0,
+                totalFields: length<{ fieldKey: string, objectValue: any }>(fieldData),
+                validFields: validFieldCount,
+            },
+        };
+    }
+    else {
+        return (formSpec_1 = defaultOf(), {
+            errors: errors,
+            formSpec: formSpec_1,
+            isValid: false,
+            stats: (totalFields_1 = (length<{ fieldKey: string, objectValue: any }>(fieldData) | 0), {
+                errorFields: errors.length,
+                totalFields: totalFields_1,
+                validFields: validFieldCount,
+            }),
+        });
+    }
+}
+
 //# sourceMappingURL=FormSpec.Api.Helpers.ts.map