@nfdi4plants/arctrl 1.0.0-alpha6

package/ISA/ISA/ArcTypes/IdentifierSetters.js

@@ -0,0 +1,26 @@
+import { checkValidCharacters } from "../Identifier.js";
+
+export function setArcTableName(newName, table) {
+    checkValidCharacters(newName);
+    table.Name = newName;
+    return table;
+}
+
+export function setAssayIdentifier(newIdentifier, assay) {
+    checkValidCharacters(newIdentifier);
+    assay.Identifier = newIdentifier;
+    return assay;
+}
+
+export function setStudyIdentifier(newIdentifier, study) {
+    checkValidCharacters(newIdentifier);
+    study.Identifier = newIdentifier;
+    return study;
+}
+
+export function setInvestigationIdentifier(newIdentifier, investigation) {
+    checkValidCharacters(newIdentifier);
+    investigation.Identifier = newIdentifier;
+    return investigation;
+}
+

package/ISA/ISA/Builder/Types.js

@@ -0,0 +1,243 @@
+import { Union } from "../../../fable_modules/fable-library.4.1.4/Types.js";
+import { list_type, union_type, string_type } from "../../../fable_modules/fable-library.4.1.4/Reflection.js";
+import { OntologyAnnotation_$reflection } from "../JsonTypes/OntologyAnnotation.js";
+import { Protocol_get_empty, Protocol } from "../JsonTypes/Protocol.js";
+import { ProcessParameterValue_$reflection } from "../JsonTypes/ProcessParameterValue.js";
+import { MaterialAttributeValue_$reflection } from "../JsonTypes/MaterialAttributeValue.js";
+import { FactorValue_$reflection } from "../JsonTypes/FactorValue.js";
+import { map as map_1, exists, fold, singleton, empty, append } from "../../../fable_modules/fable-library.4.1.4/List.js";
+import { map, value as value_4, defaultArg } from "../../../fable_modules/fable-library.4.1.4/Option.js";
+import { Process_get_empty, Process } from "../JsonTypes/Process.js";
+import { Assay_get_empty, Assay } from "../JsonTypes/Assay.js";
+import { printf, toFail } from "../../../fable_modules/fable-library.4.1.4/String.js";
+import { Study } from "../JsonTypes/Study.js";
+
+export class ProtocolTransformation extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["AddName", "AddProtocolType", "AddDescription"];
+    }
+}
+
+export function ProtocolTransformation_$reflection() {
+    return union_type("ARCtrl.ISA.Builder.ProtocolTransformation", [], ProtocolTransformation, () => [[["Item", string_type]], [["Item", OntologyAnnotation_$reflection()]], [["Item", string_type]]]);
+}
+
+export function ProtocolTransformation__Transform_Z5F51792E(this$, p) {
+    switch (this$.tag) {
+        case 1:
+            return new Protocol(p.ID, p.Name, this$.fields[0], p.Description, p.Uri, p.Version, p.Parameters, p.Components, p.Comments);
+        case 2:
+            return new Protocol(p.ID, p.Name, p.ProtocolType, this$.fields[0], p.Uri, p.Version, p.Parameters, p.Components, p.Comments);
+        default:
+            return new Protocol(p.ID, this$.fields[0], p.ProtocolType, p.Description, p.Uri, p.Version, p.Parameters, p.Components, p.Comments);
+    }
+}
+
+export function ProtocolTransformation__Equals_Z5F51792E(this$, p) {
+    const matchValue = p.Name;
+    let matchResult, n_1, n$0027_1;
+    if (this$.tag === 0) {
+        if (matchValue != null) {
+            if (this$.fields[0] === matchValue) {
+                matchResult = 0;
+                n_1 = this$.fields[0];
+                n$0027_1 = matchValue;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return true;
+        default:
+            return false;
+    }
+}
+
+export class ProcessTransformation extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["AddName", "AddParameter", "AddCharacteristic", "AddFactor", "AddProtocol"];
+    }
+}
+
+export function ProcessTransformation_$reflection() {
+    return union_type("ARCtrl.ISA.Builder.ProcessTransformation", [], ProcessTransformation, () => [[["Item", string_type]], [["Item", ProcessParameterValue_$reflection()]], [["Item", MaterialAttributeValue_$reflection()]], [["Item", FactorValue_$reflection()]], [["Item", list_type(ProtocolTransformation_$reflection())]]]);
+}
+
+export function ProcessTransformation__Transform_716E708F(this$, p) {
+    let pro;
+    switch (this$.tag) {
+        case 1: {
+            const pv = this$.fields[0];
+            const parameterValues = append(defaultArg(p.ParameterValues, empty()), singleton(pv));
+            return new Process(p.ID, p.Name, (pro = defaultArg(p.ExecutesProtocol, Protocol_get_empty()), new Protocol(pro.ID, pro.Name, pro.ProtocolType, pro.Description, pro.Uri, pro.Version, append(defaultArg(pro.Parameters, empty()), singleton(value_4(pv.Category))), pro.Components, pro.Comments)), parameterValues, p.Performer, p.Date, p.PreviousProcess, p.NextProcess, p.Inputs, p.Outputs, p.Comments);
+        }
+        case 2:
+            return new Process(p.ID, p.Name, p.ExecutesProtocol, p.ParameterValues, p.Performer, p.Date, p.PreviousProcess, p.NextProcess, map((i) => i, p.Inputs), p.Outputs, p.Comments);
+        case 3:
+            return new Process(p.ID, p.Name, p.ExecutesProtocol, p.ParameterValues, p.Performer, p.Date, p.PreviousProcess, p.NextProcess, p.Inputs, map((i_1) => i_1, p.Outputs), p.Comments);
+        case 4:
+            return new Process(p.ID, p.Name, fold((pro_2, trans) => ProtocolTransformation__Transform_Z5F51792E(trans, pro_2), defaultArg(p.ExecutesProtocol, Protocol_get_empty()), this$.fields[0]), p.ParameterValues, p.Performer, p.Date, p.PreviousProcess, p.NextProcess, p.Inputs, p.Outputs, p.Comments);
+        default:
+            return new Process(p.ID, this$.fields[0], p.ExecutesProtocol, p.ParameterValues, p.Performer, p.Date, p.PreviousProcess, p.NextProcess, p.Inputs, p.Outputs, p.Comments);
+    }
+}
+
+export function ProcessTransformation__Equals_716E708F(this$, p) {
+    const matchValue = p.Name;
+    let matchResult, n_1, n$0027_1;
+    if (this$.tag === 0) {
+        if (matchValue != null) {
+            if (this$.fields[0] === matchValue) {
+                matchResult = 0;
+                n_1 = this$.fields[0];
+                n$0027_1 = matchValue;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return true;
+        default:
+            return false;
+    }
+}
+
+export class AssayTransformation extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["AddFileName", "AddParameter", "AddCharacteristic", "AddFactor", "AddProcess"];
+    }
+}
+
+export function AssayTransformation_$reflection() {
+    return union_type("ARCtrl.ISA.Builder.AssayTransformation", [], AssayTransformation, () => [[["Item", string_type]], [["Item", ProcessParameterValue_$reflection()]], [["Item", MaterialAttributeValue_$reflection()]], [["Item", FactorValue_$reflection()]], [["Item", list_type(ProcessTransformation_$reflection())]]]);
+}
+
+export function AssayTransformation__Transform_722A269D(this$, a) {
+    switch (this$.tag) {
+        case 4: {
+            const pts = this$.fields[0];
+            const processes = defaultArg(a.ProcessSequence, empty());
+            return new Assay(a.ID, a.FileName, a.MeasurementType, a.TechnologyType, a.TechnologyPlatform, a.DataFiles, a.Materials, a.CharacteristicCategories, a.UnitCategories, exists((p) => exists((trans) => ProcessTransformation__Equals_716E708F(trans, p), pts), processes) ? map_1((p_1) => {
+                if (exists((trans_1) => ProcessTransformation__Equals_716E708F(trans_1, p_1), pts)) {
+                    return fold((p_2, trans_2) => ProcessTransformation__Transform_716E708F(trans_2, p_2), p_1, pts);
+                }
+                else {
+                    return p_1;
+                }
+            }, processes) : append(processes, singleton(fold((p_3, trans_3) => ProcessTransformation__Transform_716E708F(trans_3, p_3), Process_get_empty(), pts))), a.Comments);
+        }
+        case 0:
+            return new Assay(a.ID, this$.fields[0], a.MeasurementType, a.TechnologyType, a.TechnologyPlatform, a.DataFiles, a.Materials, a.CharacteristicCategories, a.UnitCategories, a.ProcessSequence, a.Comments);
+        default:
+            return toFail(printf("Builder failed: Case %O Not implemented"))(this$);
+    }
+}
+
+export function AssayTransformation__Equals_722A269D(this$, a) {
+    const matchValue = a.FileName;
+    let matchResult, n_1, n$0027_1;
+    if (this$.tag === 0) {
+        if (matchValue != null) {
+            if (this$.fields[0] === matchValue) {
+                matchResult = 0;
+                n_1 = this$.fields[0];
+                n$0027_1 = matchValue;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return true;
+        default:
+            return false;
+    }
+}
+
+export class StudyTransformation extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["AddParameter", "AddCharacteristic", "AddFactor", "AddProcess", "AddAssay"];
+    }
+}
+
+export function StudyTransformation_$reflection() {
+    return union_type("ARCtrl.ISA.Builder.StudyTransformation", [], StudyTransformation, () => [[["Item", ProcessParameterValue_$reflection()]], [["Item", MaterialAttributeValue_$reflection()]], [["Item", FactorValue_$reflection()]], [["Item", list_type(ProcessTransformation_$reflection())]], [["Item", list_type(AssayTransformation_$reflection())]]]);
+}
+
+export function StudyTransformation__Transform_7312BC8B(this$, s) {
+    switch (this$.tag) {
+        case 3: {
+            const pts = this$.fields[0];
+            const processes = defaultArg(s.ProcessSequence, empty());
+            return new Study(s.ID, s.FileName, s.Identifier, s.Title, s.Description, s.SubmissionDate, s.PublicReleaseDate, s.Publications, s.Contacts, s.StudyDesignDescriptors, s.Protocols, s.Materials, exists((p) => exists((trans) => ProcessTransformation__Equals_716E708F(trans, p), pts), processes) ? map_1((p_1) => {
+                if (exists((trans_1) => ProcessTransformation__Equals_716E708F(trans_1, p_1), pts)) {
+                    return fold((p_2, trans_2) => ProcessTransformation__Transform_716E708F(trans_2, p_2), p_1, pts);
+                }
+                else {
+                    return p_1;
+                }
+            }, processes) : append(processes, singleton(fold((p_3, trans_3) => ProcessTransformation__Transform_716E708F(trans_3, p_3), Process_get_empty(), pts))), s.Assays, s.Factors, s.CharacteristicCategories, s.UnitCategories, s.Comments);
+        }
+        case 4: {
+            const ats = this$.fields[0];
+            const assays = defaultArg(s.Assays, empty());
+            return new Study(s.ID, s.FileName, s.Identifier, s.Title, s.Description, s.SubmissionDate, s.PublicReleaseDate, s.Publications, s.Contacts, s.StudyDesignDescriptors, s.Protocols, s.Materials, s.ProcessSequence, exists((a) => exists((trans_4) => AssayTransformation__Equals_722A269D(trans_4, a), ats), assays) ? map_1((a_1) => {
+                if (exists((trans_5) => AssayTransformation__Equals_722A269D(trans_5, a_1), ats)) {
+                    return fold((a_2, trans_6) => AssayTransformation__Transform_722A269D(trans_6, a_2), a_1, ats);
+                }
+                else {
+                    return a_1;
+                }
+            }, assays) : append(assays, singleton(fold((a_3, trans_7) => AssayTransformation__Transform_722A269D(trans_7, a_3), Assay_get_empty(), ats))), s.Factors, s.CharacteristicCategories, s.UnitCategories, s.Comments);
+        }
+        default:
+            return toFail(printf("Builder failed: Case %O Not implemented"))(this$);
+    }
+}
+

package/ISA/ISA/Fable.js

@@ -0,0 +1,50 @@
+import { toString } from "../../fable_modules/fable-library.4.1.4/Types.js";
+import { append } from "../../fable_modules/fable-library.4.1.4/List.js";
+import { append as append_1 } from "../../fable_modules/fable-library.4.1.4/Array.js";
+import { Array_distinct, List_distinct } from "../../fable_modules/fable-library.4.1.4/Seq2.js";
+import { structuralHash, equals } from "../../fable_modules/fable-library.4.1.4/Util.js";
+
+export function isMap_generic(l1) {
+    let copyOfStruct;
+    return ((copyOfStruct = l1, toString(copyOfStruct))).indexOf("map [") === 0;
+}
+
+export function isList_generic(l1) {
+    let s;
+    let copyOfStruct = l1;
+    s = toString(copyOfStruct);
+    if (s.indexOf("[") === 0) {
+        return !(s.indexOf("seq [") === 0);
+    }
+    else {
+        return false;
+    }
+}
+
+export function append_generic(l1, l2) {
+    if (l2 == null) {
+        return l1;
+    }
+    else if (isList_generic(l1)) {
+        return append(l1, l2);
+    }
+    else {
+        return append_1(l1, l2);
+    }
+}
+
+export function distinct_generic(l1) {
+    if (isList_generic(l1)) {
+        return List_distinct(l1, {
+            Equals: equals,
+            GetHashCode: structuralHash,
+        });
+    }
+    else {
+        return Array_distinct(l1, {
+            Equals: equals,
+            GetHashCode: structuralHash,
+        });
+    }
+}
+

package/ISA/ISA/Helper.js

@@ -0,0 +1,326 @@
+import { isIterable, defaultOf, structuralHash, equals } from "../../fable_modules/fable-library.4.1.4/Util.js";
+import { value as value_1, some } from "../../fable_modules/fable-library.4.1.4/Option.js";
+import { empty, singleton, append, head, tail, isEmpty } from "../../fable_modules/fable-library.4.1.4/List.js";
+import { Dictionary } from "../../fable_modules/fable-library.4.1.4/MutableMap.js";
+import { isEmpty as isEmpty_1, iterate } from "../../fable_modules/fable-library.4.1.4/Seq.js";
+import { tryGetValue, addToDict } from "../../fable_modules/fable-library.4.1.4/MapUtil.js";
+import { Union, toString, FSharpRef } from "../../fable_modules/fable-library.4.1.4/Types.js";
+import { append_generic, distinct_generic, isList_generic, isMap_generic } from "./Fable.js";
+import { union_type, makeUnion, option_type, makeGenericType, getUnionCases, name, obj_type } from "../../fable_modules/fable-library.4.1.4/Reflection.js";
+import { exactlyOne, partition } from "../../fable_modules/fable-library.4.1.4/Array.js";
+
+/**
+ * If the value matches the default, a None is returned, else a Some is returned
+ */
+export function Option_fromValueWithDefault(d, v) {
+    if (equals(d, v)) {
+        return void 0;
+    }
+    else {
+        return some(v);
+    }
+}
+
+/**
+ * Applies the function f on the value of the option if it exists, else applies it on the default value. If the result value matches the default, a None is returned
+ */
+export function Option_mapDefault(d, f, o) {
+    return Option_fromValueWithDefault(d, (o == null) ? f(d) : f(value_1(o)));
+}
+
+/**
+ * Applies the function f on the value of the option if it exists, else returns the default value.
+ */
+export function Option_mapOrDefault(d, f, o) {
+    if (o == null) {
+        return d;
+    }
+    else {
+        return some(f(value_1(o)));
+    }
+}
+
+export function List_tryPickAndRemove(f, lst) {
+    const loop = (newList_mut, remainingList_mut) => {
+        loop:
+        while (true) {
+            const newList = newList_mut, remainingList = remainingList_mut;
+            if (!isEmpty(remainingList)) {
+                const t = tail(remainingList);
+                const h = head(remainingList);
+                const matchValue = f(h);
+                if (matchValue == null) {
+                    newList_mut = append(newList, singleton(h));
+                    remainingList_mut = t;
+                    continue loop;
+                }
+                else {
+                    return [some(value_1(matchValue)), append(newList, t)];
+                }
+            }
+            else {
+                return [void 0, newList];
+            }
+            break;
+        }
+    };
+    return loop(empty(), lst);
+}
+
+export function Dict_ofSeq(s) {
+    const dict = new Dictionary([], {
+        Equals: equals,
+        GetHashCode: structuralHash,
+    });
+    iterate((tupledArg) => {
+        addToDict(dict, tupledArg[0], tupledArg[1]);
+    }, s);
+    return dict;
+}
+
+export function Dict_tryFind(key, dict) {
+    let patternInput;
+    let outArg = defaultOf();
+    patternInput = [tryGetValue(dict, key, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+    })), outArg];
+    if (patternInput[0]) {
+        return some(patternInput[1]);
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function Dict_ofSeqWithMerge(merge, s) {
+    const dict = new Dictionary([], {
+        Equals: equals,
+        GetHashCode: structuralHash,
+    });
+    iterate((tupledArg) => {
+        const k = tupledArg[0];
+        const v = tupledArg[1];
+        const matchValue = Dict_tryFind(k, dict);
+        if (matchValue == null) {
+            addToDict(dict, k, v);
+        }
+        else {
+            const v$0027 = value_1(matchValue);
+            dict.delete(k);
+            addToDict(dict, k, merge(v$0027, v));
+        }
+    }, s);
+    return dict;
+}
+
+/**
+ * Get the type of the IEnumerable elements. E.g. for Array<'T> it would be 'T
+ */
+export function Update_isMapType(v) {
+    return isMap_generic(v);
+}
+
+export function Update_isListType(v) {
+    return isList_generic(v);
+}
+
+/**
+ * Get the type of the IEnumerable elements. E.g. for Array<'T> it would be 'T
+ */
+export function Update_enumGetInnerType(v) {
+    return obj_type;
+}
+
+/**
+ * updates oldRT with newRT by replacing all values, but appending all lists.
+ * 
+ * newRTList@oldRTList
+ */
+export function Update_updateAppend(oldVal, newVal) {
+    let matchResult, oldInternal, others;
+    if (typeof oldVal === "string") {
+        matchResult = 0;
+    }
+    else if (isIterable(oldVal)) {
+        let activePatternResult;
+        const a = oldVal;
+        activePatternResult = ((a == null) ? void 0 : (undefined));
+        if (activePatternResult != null) {
+            matchResult = 1;
+            oldInternal = value_1(activePatternResult);
+        }
+        else {
+            matchResult = 2;
+        }
+    }
+    else {
+        let activePatternResult_1;
+        const a_1 = oldVal;
+        activePatternResult_1 = ((a_1 == null) ? void 0 : (undefined));
+        if (activePatternResult_1 != null) {
+            matchResult = 1;
+            oldInternal = value_1(activePatternResult_1);
+        }
+        else {
+            matchResult = 3;
+            others = oldVal;
+        }
+    }
+    switch (matchResult) {
+        case 0:
+            return newVal;
+        case 1:
+            if (typeof oldInternal === "string") {
+                return newVal;
+            }
+            else if (isIterable(oldInternal)) {
+                let activePatternResult_2;
+                const a_2 = newVal;
+                activePatternResult_2 = ((a_2 == null) ? void 0 : (undefined));
+                if (activePatternResult_2 != null) {
+                    const newInternal = value_1(activePatternResult_2);
+                    const v = Update_updateAppend(oldInternal, newInternal);
+                    const cases_1 = partition((x) => (name(x) === "Some"), getUnionCases(makeGenericType(option_type(obj_type), [obj_type])));
+                    const patternInput = [exactlyOne(cases_1[0]), [v]];
+                    return makeUnion(patternInput[0], patternInput[1]);
+                }
+                else {
+                    return oldVal;
+                }
+            }
+            else {
+                return newVal;
+            }
+        case 2: {
+            const oldSeq = oldVal;
+            const newSeq = newVal;
+            const innerType = Update_enumGetInnerType(oldVal);
+            if (Update_isMapType(oldVal)) {
+                return newVal;
+            }
+            else {
+                return distinct_generic(append_generic(oldSeq, newSeq));
+            }
+        }
+        default:
+            return newVal;
+    }
+}
+
+/**
+ * updates oldRT with newRT by replacing all values, but only if the new value is not empty.
+ */
+export function Update_updateOnlyByExisting(oldVal, newVal) {
+    if (equals(newVal, defaultOf())) {
+        return oldVal;
+    }
+    else {
+        let activePatternResult;
+        const a = oldVal;
+        activePatternResult = ((a == null) ? void 0 : (undefined));
+        if (activePatternResult != null) {
+            const oldInternal = value_1(activePatternResult);
+            let activePatternResult_1;
+            const a_1 = newVal;
+            activePatternResult_1 = ((a_1 == null) ? void 0 : (undefined));
+            if (activePatternResult_1 != null) {
+                const newInternal = value_1(activePatternResult_1);
+                const v = Update_updateOnlyByExisting(oldInternal, newInternal);
+                const cases_1 = partition((x) => (name(x) === "Some"), getUnionCases(makeGenericType(option_type(obj_type), [obj_type])));
+                const patternInput = [exactlyOne(cases_1[0]), [v]];
+                return makeUnion(patternInput[0], patternInput[1]);
+            }
+            else {
+                return oldVal;
+            }
+        }
+        else if (typeof oldVal === "string") {
+            const newStr = newVal;
+            if (toString(newStr) === "") {
+                return oldVal;
+            }
+            else {
+                return newStr;
+            }
+        }
+        else if (isIterable(oldVal)) {
+            const newSeq = newVal;
+            if (isEmpty_1(newSeq)) {
+                return oldVal;
+            }
+            else {
+                return newSeq;
+            }
+        }
+        else {
+            return newVal;
+        }
+    }
+}
+
+/**
+ * updates oldRT with newRT by replacing all values, but only if the new value is not empty.
+ */
+export function Update_updateOnlyByExistingAppend(oldVal, newVal) {
+    if (equals(newVal, defaultOf())) {
+        return oldVal;
+    }
+    else {
+        let activePatternResult;
+        const a = oldVal;
+        activePatternResult = ((a == null) ? void 0 : (undefined));
+        if (activePatternResult != null) {
+            const oldInternal = value_1(activePatternResult);
+            let activePatternResult_1;
+            const a_1 = newVal;
+            activePatternResult_1 = ((a_1 == null) ? void 0 : (undefined));
+            if (activePatternResult_1 != null) {
+                const newInternal = value_1(activePatternResult_1);
+                const v = Update_updateOnlyByExistingAppend(oldInternal, newInternal);
+                const cases_1 = partition((x) => (name(x) === "Some"), getUnionCases(makeGenericType(option_type(obj_type), [obj_type])));
+                const patternInput = [exactlyOne(cases_1[0]), [v]];
+                return makeUnion(patternInput[0], patternInput[1]);
+            }
+            else {
+                return oldVal;
+            }
+        }
+        else if (typeof oldVal === "string") {
+            const newStr = newVal;
+            if (toString(newStr) === "") {
+                return oldVal;
+            }
+            else {
+                return newStr;
+            }
+        }
+        else if (isIterable(oldVal)) {
+            const innerType = Update_enumGetInnerType(oldVal);
+            if (Update_isMapType(oldVal)) {
+                return newVal;
+            }
+            else {
+                return distinct_generic(append_generic(oldVal, newVal));
+            }
+        }
+        else {
+            return newVal;
+        }
+    }
+}
+
+export class Update_UpdateOptions extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["UpdateAll", "UpdateByExisting", "UpdateAllAppendLists", "UpdateByExistingAppendLists"];
+    }
+}
+
+export function Update_UpdateOptions_$reflection() {
+    return union_type("ARCtrl.ISA.Aux.Update.UpdateOptions", [], Update_UpdateOptions, () => [[], [], [], []]);
+}
+