@f1studio/form-spec 5.0.0-alpha.111 → 5.0.0-alpha.113

package/src/FormSpec.FS/Integrations/Adapters/CorEMR/CoreMRSourceMap.ts

@@ -0,0 +1,371 @@
+import { Record } from "@fable-org/fable-library-js/Types.js";
+import { numberHash, comparePrimitives, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { class_type, list_type, option_type, int32_type, record_type, bool_type, string_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { getElementTypeInfo, ElementTypeInfo } from "./CorEMRElementTypeMap.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { map, value as value_2, defaultArg, Option } from "@fable-org/fable-library-js/Option.js";
+import { Spec_FormStep$1, Spec_FormField$1, Spec_MultiChoiceInfo, Spec_SingleChoiceInfo, Shared_FieldOption, Spec_FormSpec$1_$reflection, Spec_FieldType_$reflection, Spec_FieldType_$union, Spec_FormSpec$1, Shared_FieldKey_$reflection, Shared_FieldKey, Shared_MatrixItemKey_$reflection, Shared_MatrixItemKey, Shared_FieldOptionKey_$reflection, Shared_FieldOptionKey } from "../../../FormSpec.js";
+import { tryFind, choose, item as item_1, length, mapIndexed, sortBy, empty, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { CoreMRFormData, CoreMRItem, CoreMRChoice, CoreMRTag_$reflection, CoreMRTrigger_$reflection, CoreMRTag, CoreMRTrigger } from "../../CorEMR/CoreMRTypes.js";
+import { tryFind as tryFind_1, FSharpMap, ofList } from "@fable-org/fable-library-js/Map.js";
+import { List_groupBy } from "@fable-org/fable-library-js/Seq2.js";
+import { detectHeadings, groupItemsByHeadings, Section, HeadingItem } from "./CorEMRSectioning.js";
+import { convertToFormSpec } from "./CorEMRTemplateToFormSpec.js";
+import { Auto_generateBoxedEncoder_437914C6, toString } from "../../../../fable_modules/Thoth.Json.10.4.1/Encode.fs.js";
+import { IntegrationProvenance } from "../../../Provenance.js";
+
+export class ValueEncodingInfo extends Record implements IEquatable<ValueEncodingInfo>, IComparable<ValueEncodingInfo> {
+    readonly ValueEncoding: string;
+    readonly TextFieldRole: string;
+    readonly IsPlusNotes: boolean;
+    readonly IsScaffold: boolean;
+    readonly IsSkip: boolean;
+    constructor(ValueEncoding: string, TextFieldRole: string, IsPlusNotes: boolean, IsScaffold: boolean, IsSkip: boolean) {
+        super();
+        this.ValueEncoding = ValueEncoding;
+        this.TextFieldRole = TextFieldRole;
+        this.IsPlusNotes = IsPlusNotes;
+        this.IsScaffold = IsScaffold;
+        this.IsSkip = IsSkip;
+    }
+}
+
+export function ValueEncodingInfo_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRSourceMap.ValueEncodingInfo", [], ValueEncodingInfo, () => [["ValueEncoding", string_type], ["TextFieldRole", string_type], ["IsPlusNotes", bool_type], ["IsScaffold", bool_type], ["IsSkip", bool_type]]);
+}
+
+function toValueEncodingInfo(e: ElementTypeInfo): ValueEncodingInfo {
+    return new ValueEncodingInfo(e.ValueEncoding, e.TextFieldRole, e.IsPlusNotes, e.IsScaffold, e.IsSkip);
+}
+
+function getValueEncoding(itemTypeId: int32): ValueEncodingInfo {
+    return toValueEncodingInfo(getElementTypeInfo(itemTypeId));
+}
+
+export class CoreMRChoiceAnchor extends Record implements IEquatable<CoreMRChoiceAnchor>, IComparable<CoreMRChoiceAnchor> {
+    readonly ChoiceId: int32;
+    readonly Sequence: int32;
+    readonly Text: string;
+    readonly Score: int32;
+    readonly BitPosition: Option<int32>;
+    readonly Code: Option<string>;
+    readonly FieldOptionKey: Shared_FieldOptionKey;
+    constructor(ChoiceId: int32, Sequence: int32, Text$: string, Score: int32, BitPosition: Option<int32>, Code: Option<string>, FieldOptionKey: Shared_FieldOptionKey) {
+        super();
+        this.ChoiceId = (ChoiceId | 0);
+        this.Sequence = (Sequence | 0);
+        this.Text = Text$;
+        this.Score = (Score | 0);
+        this.BitPosition = BitPosition;
+        this.Code = Code;
+        this.FieldOptionKey = FieldOptionKey;
+    }
+}
+
+export function CoreMRChoiceAnchor_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRSourceMap.CoreMRChoiceAnchor", [], CoreMRChoiceAnchor, () => [["ChoiceId", int32_type], ["Sequence", int32_type], ["Text", string_type], ["Score", int32_type], ["BitPosition", option_type(int32_type)], ["Code", option_type(string_type)], ["FieldOptionKey", Shared_FieldOptionKey_$reflection()]]);
+}
+
+export class CoreMRMatrixItemAnchor extends Record implements IEquatable<CoreMRMatrixItemAnchor>, IComparable<CoreMRMatrixItemAnchor> {
+    readonly MatrixItemKey: Shared_MatrixItemKey;
+    readonly ItemId: int32;
+    readonly Sequence: int32;
+    constructor(MatrixItemKey: Shared_MatrixItemKey, ItemId: int32, Sequence: int32) {
+        super();
+        this.MatrixItemKey = MatrixItemKey;
+        this.ItemId = (ItemId | 0);
+        this.Sequence = (Sequence | 0);
+    }
+}
+
+export function CoreMRMatrixItemAnchor_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRSourceMap.CoreMRMatrixItemAnchor", [], CoreMRMatrixItemAnchor, () => [["MatrixItemKey", Shared_MatrixItemKey_$reflection()], ["ItemId", int32_type], ["Sequence", int32_type]]);
+}
+
+export class CoreMRFieldAnchor extends Record implements IEquatable<CoreMRFieldAnchor>, IComparable<CoreMRFieldAnchor> {
+    readonly ItemId: int32;
+    readonly ItemTypeId: int32;
+    readonly Sequence: int32;
+    readonly NestingLevel: int32;
+    readonly Label: string;
+    readonly IsRequired: boolean;
+    readonly SequenceText: Option<string>;
+    readonly Code: Option<string>;
+    readonly Uuid: Option<string>;
+    readonly GenderRequired: Option<string>;
+    readonly Encoding: ValueEncodingInfo;
+    readonly Choices: FSharpList<CoreMRChoiceAnchor>;
+    readonly FieldKey: Shared_FieldKey;
+    readonly MatrixItemAnchors: FSharpList<CoreMRMatrixItemAnchor>;
+    constructor(ItemId: int32, ItemTypeId: int32, Sequence: int32, NestingLevel: int32, Label: string, IsRequired: boolean, SequenceText: Option<string>, Code: Option<string>, Uuid: Option<string>, GenderRequired: Option<string>, Encoding: ValueEncodingInfo, Choices: FSharpList<CoreMRChoiceAnchor>, FieldKey: Shared_FieldKey, MatrixItemAnchors: FSharpList<CoreMRMatrixItemAnchor>) {
+        super();
+        this.ItemId = (ItemId | 0);
+        this.ItemTypeId = (ItemTypeId | 0);
+        this.Sequence = (Sequence | 0);
+        this.NestingLevel = (NestingLevel | 0);
+        this.Label = Label;
+        this.IsRequired = IsRequired;
+        this.SequenceText = SequenceText;
+        this.Code = Code;
+        this.Uuid = Uuid;
+        this.GenderRequired = GenderRequired;
+        this.Encoding = Encoding;
+        this.Choices = Choices;
+        this.FieldKey = FieldKey;
+        this.MatrixItemAnchors = MatrixItemAnchors;
+    }
+}
+
+export function CoreMRFieldAnchor_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRSourceMap.CoreMRFieldAnchor", [], CoreMRFieldAnchor, () => [["ItemId", int32_type], ["ItemTypeId", int32_type], ["Sequence", int32_type], ["NestingLevel", int32_type], ["Label", string_type], ["IsRequired", bool_type], ["SequenceText", option_type(string_type)], ["Code", option_type(string_type)], ["Uuid", option_type(string_type)], ["GenderRequired", option_type(string_type)], ["Encoding", ValueEncodingInfo_$reflection()], ["Choices", list_type(CoreMRChoiceAnchor_$reflection())], ["FieldKey", Shared_FieldKey_$reflection()], ["MatrixItemAnchors", list_type(CoreMRMatrixItemAnchor_$reflection())]]);
+}
+
+export class CoreMRStepAnchor extends Record implements IEquatable<CoreMRStepAnchor>, IComparable<CoreMRStepAnchor> {
+    readonly HeadingItemId: Option<int32>;
+    readonly HeadingSequence: int32;
+    readonly HeadingLabel: string;
+    constructor(HeadingItemId: Option<int32>, HeadingSequence: int32, HeadingLabel: string) {
+        super();
+        this.HeadingItemId = HeadingItemId;
+        this.HeadingSequence = (HeadingSequence | 0);
+        this.HeadingLabel = HeadingLabel;
+    }
+}
+
+export function CoreMRStepAnchor_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRSourceMap.CoreMRStepAnchor", [], CoreMRStepAnchor, () => [["HeadingItemId", option_type(int32_type)], ["HeadingSequence", int32_type], ["HeadingLabel", string_type]]);
+}
+
+export class CoreMRAbsorbedItem extends Record implements IEquatable<CoreMRAbsorbedItem>, IComparable<CoreMRAbsorbedItem> {
+    readonly ItemId: int32;
+    readonly ItemTypeId: int32;
+    readonly Sequence: int32;
+    readonly Text: string;
+    readonly AbsorbedIntoFieldKey: Shared_FieldKey;
+    constructor(ItemId: int32, ItemTypeId: int32, Sequence: int32, Text$: string, AbsorbedIntoFieldKey: Shared_FieldKey) {
+        super();
+        this.ItemId = (ItemId | 0);
+        this.ItemTypeId = (ItemTypeId | 0);
+        this.Sequence = (Sequence | 0);
+        this.Text = Text$;
+        this.AbsorbedIntoFieldKey = AbsorbedIntoFieldKey;
+    }
+}
+
+export function CoreMRAbsorbedItem_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRSourceMap.CoreMRAbsorbedItem", [], CoreMRAbsorbedItem, () => [["ItemId", int32_type], ["ItemTypeId", int32_type], ["Sequence", int32_type], ["Text", string_type], ["AbsorbedIntoFieldKey", Shared_FieldKey_$reflection()]]);
+}
+
+export class CoreMRStepMap extends Record implements IEquatable<CoreMRStepMap>, IComparable<CoreMRStepMap> {
+    readonly StepOrder: int32;
+    readonly Heading: CoreMRStepAnchor;
+    readonly FieldAnchors: FSharpList<CoreMRFieldAnchor>;
+    constructor(StepOrder: int32, Heading: CoreMRStepAnchor, FieldAnchors: FSharpList<CoreMRFieldAnchor>) {
+        super();
+        this.StepOrder = (StepOrder | 0);
+        this.Heading = Heading;
+        this.FieldAnchors = FieldAnchors;
+    }
+}
+
+export function CoreMRStepMap_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRSourceMap.CoreMRStepMap", [], CoreMRStepMap, () => [["StepOrder", int32_type], ["Heading", CoreMRStepAnchor_$reflection()], ["FieldAnchors", list_type(CoreMRFieldAnchor_$reflection())]]);
+}
+
+export class CoreMRSourceMap extends Record implements IEquatable<CoreMRSourceMap>, IComparable<CoreMRSourceMap> {
+    readonly FormId: int32;
+    readonly VersionId: int32;
+    readonly VersionNumber: int32;
+    readonly FormName: Option<string>;
+    readonly FormCode: string;
+    readonly FormCodeSource: string;
+    readonly Description: Option<string>;
+    readonly IsIntake: boolean;
+    readonly RequiresSignature: boolean;
+    readonly IsScored: Option<boolean>;
+    readonly EncounterTypes: FSharpList<string>;
+    readonly Usage: Option<string>;
+    readonly StructureHash: Option<string>;
+    readonly ClinicalHash: Option<string>;
+    readonly CosmeticHash: Option<string>;
+    readonly Steps: FSharpList<CoreMRStepMap>;
+    readonly AbsorbedItems: FSharpList<CoreMRAbsorbedItem>;
+    readonly Triggers: FSharpList<CoreMRTrigger>;
+    readonly Tags: FSharpList<CoreMRTag>;
+    readonly FormSpecId: string;
+    constructor(FormId: int32, VersionId: int32, VersionNumber: int32, FormName: Option<string>, FormCode: string, FormCodeSource: string, Description: Option<string>, IsIntake: boolean, RequiresSignature: boolean, IsScored: Option<boolean>, EncounterTypes: FSharpList<string>, Usage: Option<string>, StructureHash: Option<string>, ClinicalHash: Option<string>, CosmeticHash: Option<string>, Steps: FSharpList<CoreMRStepMap>, AbsorbedItems: FSharpList<CoreMRAbsorbedItem>, Triggers: FSharpList<CoreMRTrigger>, Tags: FSharpList<CoreMRTag>, FormSpecId: string) {
+        super();
+        this.FormId = (FormId | 0);
+        this.VersionId = (VersionId | 0);
+        this.VersionNumber = (VersionNumber | 0);
+        this.FormName = FormName;
+        this.FormCode = FormCode;
+        this.FormCodeSource = FormCodeSource;
+        this.Description = Description;
+        this.IsIntake = IsIntake;
+        this.RequiresSignature = RequiresSignature;
+        this.IsScored = IsScored;
+        this.EncounterTypes = EncounterTypes;
+        this.Usage = Usage;
+        this.StructureHash = StructureHash;
+        this.ClinicalHash = ClinicalHash;
+        this.CosmeticHash = CosmeticHash;
+        this.Steps = Steps;
+        this.AbsorbedItems = AbsorbedItems;
+        this.Triggers = Triggers;
+        this.Tags = Tags;
+        this.FormSpecId = FormSpecId;
+    }
+}
+
+export function CoreMRSourceMap_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRSourceMap.CoreMRSourceMap", [], CoreMRSourceMap, () => [["FormId", int32_type], ["VersionId", int32_type], ["VersionNumber", int32_type], ["FormName", option_type(string_type)], ["FormCode", string_type], ["FormCodeSource", string_type], ["Description", option_type(string_type)], ["IsIntake", bool_type], ["RequiresSignature", bool_type], ["IsScored", option_type(bool_type)], ["EncounterTypes", list_type(string_type)], ["Usage", option_type(string_type)], ["StructureHash", option_type(string_type)], ["ClinicalHash", option_type(string_type)], ["CosmeticHash", option_type(string_type)], ["Steps", list_type(CoreMRStepMap_$reflection())], ["AbsorbedItems", list_type(CoreMRAbsorbedItem_$reflection())], ["Triggers", list_type(CoreMRTrigger_$reflection())], ["Tags", list_type(CoreMRTag_$reflection())], ["FormSpecId", class_type("System.Guid")]]);
+}
+
+export class CoreMRConversionResult extends Record implements IEquatable<CoreMRConversionResult>, IComparable<CoreMRConversionResult> {
+    readonly FormSpec: Spec_FormSpec$1<Spec_FieldType_$union>;
+    readonly SourceMap: CoreMRSourceMap;
+    constructor(FormSpec: Spec_FormSpec$1<Spec_FieldType_$union>, SourceMap: CoreMRSourceMap) {
+        super();
+        this.FormSpec = FormSpec;
+        this.SourceMap = SourceMap;
+    }
+}
+
+export function CoreMRConversionResult_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRSourceMap.CoreMRConversionResult", [], CoreMRConversionResult, () => [["FormSpec", Spec_FormSpec$1_$reflection(Spec_FieldType_$reflection())], ["SourceMap", CoreMRSourceMap_$reflection()]]);
+}
+
+function getFieldOptions(field: Spec_FormField$1<Spec_FieldType_$union>): FSharpList<Shared_FieldOption> {
+    const matchValue: Spec_FieldType_$union = field.FieldType;
+    let matchResult: int32, info_1: Spec_SingleChoiceInfo, info_2: Spec_MultiChoiceInfo;
+    switch (matchValue.tag) {
+        case /* Dropdown */ 14: {
+            matchResult = 0;
+            break;
+        }
+        case /* Radio */ 12: {
+            matchResult = 1;
+            info_1 = matchValue.fields[0];
+            break;
+        }
+        case /* SingleChoice */ 13: {
+            matchResult = 1;
+            info_1 = matchValue.fields[0];
+            break;
+        }
+        case /* MultiChoice */ 15: {
+            matchResult = 2;
+            info_2 = matchValue.fields[0];
+            break;
+        }
+        case /* CheckboxList */ 16: {
+            matchResult = 2;
+            info_2 = matchValue.fields[0];
+            break;
+        }
+        case /* TagList */ 17: {
+            matchResult = 2;
+            info_2 = matchValue.fields[0];
+            break;
+        }
+        default:
+            matchResult = 3;
+    }
+    switch (matchResult) {
+        case 0:
+            return matchValue.fields[0].Options;
+        case 1:
+            return info_1!.Options;
+        case 2:
+            return info_2!.Options;
+        default:
+            return empty<Shared_FieldOption>();
+    }
+}
+
+/**
+ * Build a FieldAnchor from a CoreMR item and its mapped FormField
+ */
+export function buildFieldAnchor(item: CoreMRItem, choices: FSharpList<CoreMRChoice>, field: Spec_FormField$1<Spec_FieldType_$union>): CoreMRFieldAnchor {
+    const encoding: ValueEncodingInfo = getValueEncoding(item.ItemTypeId);
+    const sortedChoices: FSharpList<CoreMRChoice> = sortBy<CoreMRChoice, int32>((c: CoreMRChoice): int32 => c.Sequence, choices, {
+        Compare: comparePrimitives,
+    });
+    const fieldOptions: FSharpList<Shared_FieldOption> = getFieldOptions(field);
+    return new CoreMRFieldAnchor(item.ItemId, item.ItemTypeId, item.Sequence, item.NestingLevel, item.Label, item.IsRequired, item.SequenceText, item.Code, item.Uuid, item.GenderRequired, encoding, mapIndexed<CoreMRChoice, CoreMRChoiceAnchor>((i: int32, choice: CoreMRChoice): CoreMRChoiceAnchor => (new CoreMRChoiceAnchor(choice.ChoiceId, choice.Sequence, choice.Text, choice.Score, choice.BitPosition, choice.Code, (i < length(fieldOptions)) ? item_1(i, fieldOptions).OptionKey : (new Shared_FieldOptionKey("00000000-0000-0000-0000-000000000000")))), sortedChoices), field.FieldKey, empty<CoreMRMatrixItemAnchor>());
+}
+
+export class ListMetadata extends Record implements IEquatable<ListMetadata>, IComparable<ListMetadata> {
+    readonly IsIntake: Option<boolean>;
+    readonly IsScored: Option<boolean>;
+    readonly EncounterTypes: FSharpList<string>;
+    constructor(IsIntake: Option<boolean>, IsScored: Option<boolean>, EncounterTypes: FSharpList<string>) {
+        super();
+        this.IsIntake = IsIntake;
+        this.IsScored = IsScored;
+        this.EncounterTypes = EncounterTypes;
+    }
+}
+
+export function ListMetadata_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRSourceMap.ListMetadata", [], ListMetadata, () => [["IsIntake", option_type(bool_type)], ["IsScored", option_type(bool_type)], ["EncounterTypes", list_type(string_type)]]);
+}
+
+/**
+ * Build the complete SourceMap from raw CoreMR data and the resulting FormSpec.
+ * When listMetadata is Some (from FormListItem during import), IsScored and EncounterTypes are populated.
+ */
+export function buildSourceMap(formData: CoreMRFormData, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>, listMetadata: Option<ListMetadata>): CoreMRSourceMap {
+    let matchValue: Option<boolean>;
+    const formCode: string = defaultArg(formSpec.Code, `CORE-${formData.Metadata.FormId}`);
+    const choicesByItem: FSharpMap<int32, FSharpList<CoreMRChoice>> = ofList<int32, FSharpList<CoreMRChoice>>(List_groupBy<CoreMRChoice, int32>((c: CoreMRChoice): int32 => c.ItemId, formData.Choices, {
+        Equals: (x: int32, y: int32): boolean => (x === y),
+        GetHashCode: numberHash,
+    }), {
+        Compare: comparePrimitives,
+    });
+    let stepOrder = 0;
+    const stepMaps: FSharpList<CoreMRStepMap> = choose<Section, CoreMRStepMap>((section: Section): Option<CoreMRStepMap> => {
+        stepOrder = ((stepOrder + 1) | 0);
+        const formStep: Option<Spec_FormStep$1<Spec_FieldType_$union>> = tryFind<Spec_FormStep$1<Spec_FieldType_$union>>((s: Spec_FormStep$1<Spec_FieldType_$union>): boolean => (s.StepOrder === stepOrder), formSpec.Steps);
+        if (formStep != null) {
+            const step: Spec_FormStep$1<Spec_FieldType_$union> = value_2(formStep);
+            if (length(section.Items) !== length(step.Fields)) {
+                throw new Error(`CoreMR section mismatch: step ${stepOrder} has ${length(section.Items)} section items but ${length(step.Fields)} fields. Lengths must match.`);
+            }
+            const fieldAnchors: FSharpList<CoreMRFieldAnchor> = mapIndexed<CoreMRItem, CoreMRFieldAnchor>((i: int32, item: CoreMRItem): CoreMRFieldAnchor => {
+                const field: Spec_FormField$1<Spec_FieldType_$union> = item_1(i, step.Fields);
+                return buildFieldAnchor(item, defaultArg(tryFind_1<int32, FSharpList<CoreMRChoice>>(item.ItemId, choicesByItem), empty<CoreMRChoice>()), field);
+            }, section.Items);
+            const headingItemId: Option<int32> = map<HeadingItem, int32>((h: HeadingItem): int32 => h.ItemId, section.Heading);
+            return new CoreMRStepMap(stepOrder, new CoreMRStepAnchor(headingItemId, section.HeadingSequence, section.HeadingLabel), fieldAnchors);
+        }
+        else {
+            return undefined;
+        }
+    }, groupItemsByHeadings(detectHeadings(formData.Items), formData.Items));
+    const listMeta: ListMetadata = defaultArg<ListMetadata>(listMetadata, new ListMetadata(undefined, undefined, empty<string>()));
+    return new CoreMRSourceMap(formData.Metadata.FormId, formData.Metadata.VersionId, formData.Metadata.VersionNumber, formData.Metadata.FormName, formCode, "name", formData.Metadata.Description, (matchValue = listMeta.IsIntake, (matchValue == null) ? formData.Metadata.IsIntake : value_2(matchValue)), formData.Metadata.RequiresSignature, listMeta.IsScored, listMeta.EncounterTypes, undefined, undefined, undefined, undefined, stepMaps, empty<CoreMRAbsorbedItem>(), formData.Triggers, formData.Tags, formSpec.Id);
+}
+
+/**
+ * Convert CoreMR form data to FormSpec with full source mapping.
+ * When listMetadata is Some (from FormListItem during import), IsScored and EncounterTypes are populated in the SourceMap.
+ */
+export function convertWithMap(formData: CoreMRFormData, listMetadata: Option<ListMetadata>): CoreMRConversionResult {
+    const formSpec: Spec_FormSpec$1<Spec_FieldType_$union> = convertToFormSpec(formData);
+    return new CoreMRConversionResult(formSpec, buildSourceMap(formData, formSpec, listMetadata));
+}
+
+/**
+ * Convert CoreMR form data to FormSpec with Provenance attached (for persist on import).
+ * When listMetadata is Some (from FormListItem during import), IsScored and EncounterTypes are populated.
+ */
+export function convertWithMapAndProvenance(formData: CoreMRFormData, listMetadata: Option<ListMetadata>): Spec_FormSpec$1<Spec_FieldType_$union> {
+    const result: CoreMRConversionResult = convertWithMap(formData, listMetadata);
+    const bind$0040: Spec_FormSpec$1<Spec_FieldType_$union> = result.FormSpec;
+    return new Spec_FormSpec$1(bind$0040.Id, bind$0040.Code, bind$0040.Title, bind$0040.Abstract, bind$0040.Version, bind$0040.FormSpecVersion, bind$0040.Steps, bind$0040.CategoryTags, bind$0040.Score, bind$0040.AssociatedCodes, bind$0040.RequiresReview, bind$0040.RequiresReviewAndApproval, bind$0040.ClinicalPathway, bind$0040.Lifecycle, bind$0040.FilledMeta, bind$0040.CustomData, new IntegrationProvenance("coremr", toString(0, Auto_generateBoxedEncoder_437914C6(CoreMRSourceMap_$reflection(), undefined, undefined, undefined)(result.SourceMap))));
+}
+
+//# sourceMappingURL=CoreMRSourceMap.ts.map