@nfdi4plants/arctrl 3.0.0-beta.1 → 3.0.0-beta.11

package/dist/ts/ts/Core/ArcTypes.js

@@ -0,0 +1,3708 @@
+import { defaultArg, unwrap, value, map } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { toArray, filter, contains, forAll, fold, length, toList, delay, map as map$1, item, choose, exists, tryFindIndex, iterate, removeAt, tryFind, append, collect } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { stringHash, getEnumerator, safeHash, equals, disposeSafe, defaultOf } from '../../node_modules/@fable-org/fable-library-js/Util.js';
+import { ResizeArray_map, ResizeArray_filter, ResizeArray_choose } from './Helper/Collections.js';
+import { contains as contains$1, removeInPlace, addRangeInPlace } from '../../node_modules/@fable-org/fable-library-js/Array.js';
+import { toText, printf } from '../../node_modules/@fable-org/fable-library-js/String.js';
+import { rangeDouble } from '../../node_modules/@fable-org/fable-library-js/Range.js';
+import { boxHashArray, boxHashOption, boxHashSeq } from './Helper/HashCodes.js';
+import { checkValidCharacters } from './Helper/Identifier.js';
+import { ArcTables, ArcTables_$reflection, ArcTablesAux_getIOMap, ArcTablesAux_applyIOMap } from './Table/ArcTables.js';
+import { class_type } from '../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { Array_distinct } from '../../node_modules/@fable-org/fable-library-js/Seq2.js';
+import { FSharpRef } from '../../node_modules/@fable-org/fable-library-js/Types.js';
+
+class ArcAssay extends ArcTables {
+  constructor(identifier, title, description, measurementType, technologyType, technologyPlatform, tables, datamap, performers, comments) {
+    super(defaultArg(tables, []));
+    let identifier_1;
+    const performers_1 = defaultArg(performers, []);
+    const comments_1 = defaultArg(comments, []);
+    this["identifier@129"] = (identifier_1 = identifier.trim(), checkValidCharacters(identifier_1), identifier_1);
+    this["title@133"] = title;
+    this["description@134"] = description;
+    this.investigation = void 0;
+    this["measurementType@136"] = measurementType;
+    this["technologyType@137"] = technologyType;
+    this["technologyPlatform@138"] = technologyPlatform;
+    this.dataMap = datamap;
+    this["performers@140-1"] = performers_1;
+    this["comments@141-1"] = comments_1;
+    this.staticHash = 0;
+  }
+  get Identifier() {
+    const this$ = this;
+    return this$["identifier@129"];
+  }
+  set Identifier(i) {
+    const this$ = this;
+    this$["identifier@129"] = i;
+  }
+  get Investigation() {
+    const this$ = this;
+    return unwrap(this$.investigation);
+  }
+  set Investigation(i) {
+    const this$ = this;
+    this$.investigation = i;
+  }
+  get Title() {
+    const this$ = this;
+    return unwrap(this$["title@133"]);
+  }
+  set Title(t) {
+    const this$ = this;
+    this$["title@133"] = t;
+  }
+  get Description() {
+    const this$ = this;
+    return unwrap(this$["description@134"]);
+  }
+  set Description(d) {
+    const this$ = this;
+    this$["description@134"] = d;
+  }
+  get MeasurementType() {
+    const this$ = this;
+    return unwrap(this$["measurementType@136"]);
+  }
+  set MeasurementType(n) {
+    const this$ = this;
+    this$["measurementType@136"] = n;
+  }
+  get TechnologyType() {
+    const this$ = this;
+    return unwrap(this$["technologyType@137"]);
+  }
+  set TechnologyType(n) {
+    const this$ = this;
+    this$["technologyType@137"] = n;
+  }
+  get TechnologyPlatform() {
+    const this$ = this;
+    return unwrap(this$["technologyPlatform@138"]);
+  }
+  set TechnologyPlatform(n) {
+    const this$ = this;
+    this$["technologyPlatform@138"] = n;
+  }
+  get DataMap() {
+    const this$ = this;
+    return unwrap(this$.dataMap);
+  }
+  set DataMap(n) {
+    const this$ = this;
+    this$.dataMap = n;
+  }
+  get Performers() {
+    const this$ = this;
+    return this$["performers@140-1"];
+  }
+  set Performers(n) {
+    const this$ = this;
+    this$["performers@140-1"] = n;
+  }
+  get Comments() {
+    const this$ = this;
+    return this$["comments@141-1"];
+  }
+  set Comments(n) {
+    const this$ = this;
+    this$["comments@141-1"] = n;
+  }
+  get StaticHash() {
+    const this$ = this;
+    return this$.staticHash | 0;
+  }
+  set StaticHash(h) {
+    const this$ = this;
+    this$.staticHash = h | 0;
+  }
+  static init(identifier) {
+    return new ArcAssay(identifier);
+  }
+  static create(identifier, title, description, measurementType, technologyType, technologyPlatform, tables, datamap, performers, comments) {
+    return new ArcAssay(identifier, unwrap(title), unwrap(description), unwrap(measurementType), unwrap(technologyType), unwrap(technologyPlatform), unwrap(tables), unwrap(datamap), unwrap(performers), unwrap(comments));
+  }
+  static make(identifier, title, description, measurementType, technologyType, technologyPlatform, tables, datamap, performers, comments) {
+    return new ArcAssay(identifier, unwrap(title), unwrap(description), unwrap(measurementType), unwrap(technologyType), unwrap(technologyPlatform), tables, unwrap(datamap), performers, comments);
+  }
+  static get FileName() {
+    return "isa.assay.xlsx";
+  }
+  get StudiesRegisteredIn() {
+    const this$ = this;
+    const matchValue = this$.Investigation;
+    if (matchValue == null) {
+      return [];
+    } else {
+      const i = value(matchValue);
+      return toArray(filter((s) => {
+        const source = s.RegisteredAssayIdentifiers;
+        return contains(this$.Identifier, source, {
+          Equals: (x, y) => x === y,
+          GetHashCode: stringHash
+        });
+      }, i.Studies));
+    }
+  }
+  static addTable(table, index) {
+    return (assay) => {
+      const c = assay.Copy();
+      c.AddTable(table, unwrap(index));
+      return c;
+    };
+  }
+  static addTables(tables, index) {
+    return (assay) => {
+      const c = assay.Copy();
+      c.AddTables(tables, unwrap(index));
+      return c;
+    };
+  }
+  static initTable(tableName, index) {
+    return (assay) => {
+      const c = assay.Copy();
+      return [c, c.InitTable(tableName, unwrap(index))];
+    };
+  }
+  static initTables(tableNames, index) {
+    return (assay) => {
+      const c = assay.Copy();
+      c.InitTables(tableNames, unwrap(index));
+      return c;
+    };
+  }
+  static getTableAt(index) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      return newAssay.GetTableAt(index);
+    };
+  }
+  static getTable(name) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      return newAssay.GetTable(name);
+    };
+  }
+  static updateTableAt(index, table) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.UpdateTableAt(index, table);
+      return newAssay;
+    };
+  }
+  static updateTable(name, table) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.UpdateTable(name, table);
+      return newAssay;
+    };
+  }
+  static setTableAt(index, table) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.SetTableAt(index, table);
+      return newAssay;
+    };
+  }
+  static setTable(name, table) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.SetTable(name, table);
+      return newAssay;
+    };
+  }
+  static removeTableAt(index) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.RemoveTableAt(index);
+      return newAssay;
+    };
+  }
+  static removeTable(name) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.RemoveTable(name);
+      return newAssay;
+    };
+  }
+  static mapTableAt(index, updateFun) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.MapTableAt(index, updateFun);
+      return newAssay;
+    };
+  }
+  static updateTableBy(name, updateFun) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.MapTable(name, updateFun);
+      return newAssay;
+    };
+  }
+  static renameTableAt(index, newName) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.RenameTableAt(index, newName);
+      return newAssay;
+    };
+  }
+  static renameTable(name, newName) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.RenameTable(name, newName);
+      return newAssay;
+    };
+  }
+  static addColumnAt(tableIndex, header, cells, columnIndex, forceReplace) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.AddColumnAt(tableIndex, header, unwrap(cells), unwrap(columnIndex), unwrap(forceReplace));
+      return newAssay;
+    };
+  }
+  static addColumn(tableName, header, cells, columnIndex, forceReplace) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.AddColumn(tableName, header, unwrap(cells), unwrap(columnIndex), unwrap(forceReplace));
+      return newAssay;
+    };
+  }
+  static removeColumnAt(tableIndex, columnIndex) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.RemoveColumnAt(tableIndex, columnIndex);
+      return newAssay;
+    };
+  }
+  static removeColumn(tableName, columnIndex) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.RemoveColumn(tableName, columnIndex);
+      return newAssay;
+    };
+  }
+  static updateColumnAt(tableIndex, columnIndex, header, cells) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.UpdateColumnAt(tableIndex, columnIndex, header, unwrap(cells));
+      return newAssay;
+    };
+  }
+  static updateColumn(tableName, columnIndex, header, cells) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.UpdateColumn(tableName, columnIndex, header, unwrap(cells));
+      return newAssay;
+    };
+  }
+  static getColumnAt(tableIndex, columnIndex) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      return newAssay.GetColumnAt(tableIndex, columnIndex);
+    };
+  }
+  static getColumn(tableName, columnIndex) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      return newAssay.GetColumn(tableName, columnIndex);
+    };
+  }
+  static addRowAt(tableIndex, cells, rowIndex) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.AddRowAt(tableIndex, unwrap(cells), unwrap(rowIndex));
+      return newAssay;
+    };
+  }
+  static addRow(tableName, cells, rowIndex) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.AddRow(tableName, unwrap(cells), unwrap(rowIndex));
+      return newAssay;
+    };
+  }
+  static removeRowAt(tableIndex, rowIndex) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.RemoveColumnAt(tableIndex, rowIndex);
+      return newAssay;
+    };
+  }
+  static removeRow(tableName, rowIndex) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.RemoveRow(tableName, rowIndex);
+      return newAssay;
+    };
+  }
+  static updateRowAt(tableIndex, rowIndex, cells) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.UpdateRowAt(tableIndex, rowIndex, cells);
+      return newAssay;
+    };
+  }
+  static updateRow(tableName, rowIndex, cells) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      newAssay.UpdateRow(tableName, rowIndex, cells);
+      return newAssay;
+    };
+  }
+  static getRowAt(tableIndex, rowIndex) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      return newAssay.GetRowAt(tableIndex, rowIndex);
+    };
+  }
+  static getRow(tableName, rowIndex) {
+    return (assay) => {
+      const newAssay = assay.Copy();
+      return newAssay.GetRow(tableName, rowIndex);
+    };
+  }
+  static setPerformers(performers, assay) {
+    assay.Performers = performers;
+    return assay;
+  }
+  Copy() {
+    const this$ = this;
+    const nextTables = ResizeArray_map((c) => c.Copy(), this$.Tables);
+    const nextComments = ResizeArray_map((c_1) => c_1.Copy(), this$.Comments);
+    const nextDataMap = map((d) => d.Copy(), this$.DataMap);
+    const nextPerformers = ResizeArray_map((c_2) => c_2.Copy(), this$.Performers);
+    const identifier = this$.Identifier;
+    const title = this$.Title;
+    const description = this$.Description;
+    const measurementType = this$.MeasurementType;
+    const technologyType = this$.TechnologyType;
+    const technologyPlatform = this$.TechnologyPlatform;
+    return ArcAssay.make(identifier, title, description, measurementType, technologyType, technologyPlatform, nextTables, nextDataMap, nextPerformers, nextComments);
+  }
+  UpdateBy(assay, onlyReplaceExisting, appendSequences) {
+    const this$ = this;
+    const onlyReplaceExisting_1 = defaultArg(onlyReplaceExisting, false);
+    const appendSequences_1 = defaultArg(appendSequences, false);
+    const updateAlways = !onlyReplaceExisting_1;
+    if (assay.Title != null ? true : updateAlways) {
+      this$.Title = assay.Title;
+    }
+    if (assay.Description != null ? true : updateAlways) {
+      this$.Description = assay.Description;
+    }
+    if (assay.MeasurementType != null ? true : updateAlways) {
+      this$.MeasurementType = assay.MeasurementType;
+    }
+    if (assay.TechnologyType != null ? true : updateAlways) {
+      this$.TechnologyType = assay.TechnologyType;
+    }
+    if (assay.TechnologyPlatform != null ? true : updateAlways) {
+      this$.TechnologyPlatform = assay.TechnologyPlatform;
+    }
+    if (assay.Tables.length !== 0 ? true : updateAlways) {
+      let s;
+      const origin = this$.Tables;
+      const next = assay.Tables;
+      if (!appendSequences_1) {
+        s = ResizeArray_map((x) => x, next);
+      } else {
+        const combined = [];
+        let enumerator = getEnumerator(origin);
+        try {
+          while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const e = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (!contains$1(e, combined, {
+              Equals: equals,
+              GetHashCode: safeHash
+            })) {
+              void combined.push(e);
+            }
+          }
+        } finally {
+          disposeSafe(enumerator);
+        }
+        let enumerator_1 = getEnumerator(next);
+        try {
+          while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+            const e_1 = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (!contains$1(e_1, combined, {
+              Equals: equals,
+              GetHashCode: safeHash
+            })) {
+              void combined.push(e_1);
+            }
+          }
+        } finally {
+          disposeSafe(enumerator_1);
+        }
+        s = combined;
+      }
+      this$.Tables = s;
+    }
+    if (assay.Performers.length !== 0 ? true : updateAlways) {
+      let s_1;
+      const origin_1 = this$.Performers;
+      const next_1 = assay.Performers;
+      if (!appendSequences_1) {
+        s_1 = ResizeArray_map((x_3) => x_3, next_1);
+      } else {
+        const combined_1 = [];
+        let enumerator_2 = getEnumerator(origin_1);
+        try {
+          while (enumerator_2["System.Collections.IEnumerator.MoveNext"]()) {
+            const e_2 = enumerator_2["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (!contains$1(e_2, combined_1, {
+              Equals: equals,
+              GetHashCode: safeHash
+            })) {
+              void combined_1.push(e_2);
+            }
+          }
+        } finally {
+          disposeSafe(enumerator_2);
+        }
+        let enumerator_1_1 = getEnumerator(next_1);
+        try {
+          while (enumerator_1_1["System.Collections.IEnumerator.MoveNext"]()) {
+            const e_1_1 = enumerator_1_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (!contains$1(e_1_1, combined_1, {
+              Equals: equals,
+              GetHashCode: safeHash
+            })) {
+              void combined_1.push(e_1_1);
+            }
+          }
+        } finally {
+          disposeSafe(enumerator_1_1);
+        }
+        s_1 = combined_1;
+      }
+      this$.Performers = s_1;
+    }
+    if (assay.Comments.length !== 0 ? true : updateAlways) {
+      let s_2;
+      const origin_2 = this$.Comments;
+      const next_2 = assay.Comments;
+      if (!appendSequences_1) {
+        s_2 = ResizeArray_map((x_6) => x_6, next_2);
+      } else {
+        const combined_2 = [];
+        let enumerator_3 = getEnumerator(origin_2);
+        try {
+          while (enumerator_3["System.Collections.IEnumerator.MoveNext"]()) {
+            const e_3 = enumerator_3["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (!contains$1(e_3, combined_2, {
+              Equals: equals,
+              GetHashCode: safeHash
+            })) {
+              void combined_2.push(e_3);
+            }
+          }
+        } finally {
+          disposeSafe(enumerator_3);
+        }
+        let enumerator_1_2 = getEnumerator(next_2);
+        try {
+          while (enumerator_1_2["System.Collections.IEnumerator.MoveNext"]()) {
+            const e_1_2 = enumerator_1_2["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (!contains$1(e_1_2, combined_2, {
+              Equals: equals,
+              GetHashCode: safeHash
+            })) {
+              void combined_2.push(e_1_2);
+            }
+          }
+        } finally {
+          disposeSafe(enumerator_1_2);
+        }
+        s_2 = combined_2;
+      }
+      this$.Comments = s_2;
+    }
+  }
+  toString() {
+    const this$ = this;
+    const arg = this$.Identifier;
+    const arg_1 = this$.Title;
+    const arg_2 = this$.Description;
+    const arg_3 = this$.MeasurementType;
+    const arg_4 = this$.TechnologyType;
+    const arg_5 = this$.TechnologyPlatform;
+    const arg_6 = this$.Tables;
+    const arg_7 = this$.Performers;
+    const arg_8 = this$.Comments;
+    return toText(printf('ArcAssay({\r\n    Identifier = "%s",\r\n    Title = %A,\r\n    Description = %A,\r\n    MeasurementType = %A,\r\n    TechnologyType = %A,\r\n    TechnologyPlatform = %A,\r\n    Tables = %A,\r\n    Performers = %A,\r\n    Comments = %A\r\n})'))(arg)(arg_1)(arg_2)(arg_3)(arg_4)(arg_5)(arg_6)(arg_7)(arg_8);
+  }
+  AddToInvestigation(investigation) {
+    const this$ = this;
+    this$.Investigation = investigation;
+  }
+  RemoveFromInvestigation() {
+    const this$ = this;
+    this$.Investigation = void 0;
+  }
+  UpdateReferenceByAssayFile(assay, onlyReplaceExisting) {
+    const this$ = this;
+    const updateAlways = !defaultArg(onlyReplaceExisting, false);
+    if (assay.Title != null ? true : updateAlways) {
+      this$.Title = assay.Title;
+    }
+    if (assay.Description != null ? true : updateAlways) {
+      this$.Description = assay.Description;
+    }
+    if (assay.MeasurementType != null ? true : updateAlways) {
+      this$.MeasurementType = assay.MeasurementType;
+    }
+    if (assay.TechnologyPlatform != null ? true : updateAlways) {
+      this$.TechnologyPlatform = assay.TechnologyPlatform;
+    }
+    if (assay.TechnologyType != null ? true : updateAlways) {
+      this$.TechnologyType = assay.TechnologyType;
+    }
+    if (assay.Tables.length !== 0 ? true : updateAlways) {
+      this$.Tables = assay.Tables;
+    }
+    if (assay.Comments.length !== 0 ? true : updateAlways) {
+      this$.Comments = assay.Comments;
+    }
+    this$.DataMap = assay.DataMap;
+    if (assay.Performers.length !== 0 ? true : updateAlways) {
+      this$.Performers = assay.Performers;
+    }
+  }
+  StructurallyEquals(other) {
+    let a, b, a_1, b_1, a_2, b_2;
+    const this$ = this;
+    return forAll((x) => x === true, [this$.Identifier === other.Identifier, equals(this$.Title, other.Title), equals(this$.Description, other.Description), equals(this$.MeasurementType, other.MeasurementType), equals(this$.TechnologyType, other.TechnologyType), equals(this$.TechnologyPlatform, other.TechnologyPlatform), equals(this$.DataMap, other.DataMap), (a = this$.Tables, b = other.Tables, length(a) === length(b) && fold((acc, e) => {
+      if (acc) {
+        return e;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_1) => equals(item(i_1, a), item(i_1, b)), rangeDouble(0, 1, length(a) - 1)))))), (a_1 = this$.Performers, b_1 = other.Performers, length(a_1) === length(b_1) && fold((acc_1, e_1) => {
+      if (acc_1) {
+        return e_1;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_2) => equals(item(i_2, a_1), item(i_2, b_1)), rangeDouble(0, 1, length(a_1) - 1)))))), (a_2 = this$.Comments, b_2 = other.Comments, length(a_2) === length(b_2) && fold((acc_2, e_2) => {
+      if (acc_2) {
+        return e_2;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_3) => equals(item(i_3, a_2), item(i_3, b_2)), rangeDouble(0, 1, length(a_2) - 1))))))]);
+  }
+  ReferenceEquals(other) {
+    const this$ = this;
+    return this$ === other;
+  }
+  Equals(other) {
+    let assay;
+    const this$ = this;
+    return other instanceof ArcAssay && (assay = other, this$.StructurallyEquals(assay));
+  }
+  GetLightHashCode() {
+    const this$ = this;
+    return boxHashArray([this$.Identifier, boxHashOption(this$.Title), boxHashOption(this$.Description), boxHashOption(this$.MeasurementType), boxHashOption(this$.TechnologyType), boxHashOption(this$.TechnologyPlatform), boxHashSeq(this$.Tables), boxHashSeq(this$.Performers), boxHashSeq(this$.Comments)]) | 0;
+  }
+  GetHashCode() {
+    const this$ = this;
+    return boxHashArray([this$.Identifier, boxHashOption(this$.Title), boxHashOption(this$.Description), boxHashOption(this$.MeasurementType), boxHashOption(this$.TechnologyType), boxHashOption(this$.TechnologyPlatform), boxHashOption(this$.DataMap), boxHashSeq(this$.Tables), boxHashSeq(this$.Performers), boxHashSeq(this$.Comments)]) | 0;
+  }
+}
+function ArcAssay_$reflection() {
+  return class_type("ARCtrl.ArcAssay", void 0, ArcAssay, ArcTables_$reflection());
+}
+function ArcAssay_$ctor_11E1F34(identifier, title, description, measurementType, technologyType, technologyPlatform, tables, datamap, performers, comments) {
+  return new ArcAssay(identifier, title, description, measurementType, technologyType, technologyPlatform, tables, datamap, performers, comments);
+}
+class ArcStudy extends ArcTables {
+  constructor(identifier, title, description, submissionDate, publicReleaseDate, publications, contacts, studyDesignDescriptors, tables, datamap, registeredAssayIdentifiers, comments) {
+    super(defaultArg(tables, []));
+    let identifier_1;
+    const publications_1 = defaultArg(publications, []);
+    const contacts_1 = defaultArg(contacts, []);
+    const studyDesignDescriptors_1 = defaultArg(studyDesignDescriptors, []);
+    const registeredAssayIdentifiers_1 = defaultArg(registeredAssayIdentifiers, []);
+    const comments_1 = defaultArg(comments, []);
+    this["identifier@579"] = (identifier_1 = identifier.trim(), checkValidCharacters(identifier_1), identifier_1);
+    this.investigation = void 0;
+    this["title@584"] = title;
+    this["description@585"] = description;
+    this["submissionDate@586"] = submissionDate;
+    this["publicReleaseDate@587"] = publicReleaseDate;
+    this["publications@588-1"] = publications_1;
+    this["contacts@589-1"] = contacts_1;
+    this["studyDesignDescriptors@590-1"] = studyDesignDescriptors_1;
+    this["datamap@591"] = datamap;
+    this["registeredAssayIdentifiers@592-1"] = registeredAssayIdentifiers_1;
+    this["comments@593-1"] = comments_1;
+    this.staticHash = 0;
+  }
+  get Identifier() {
+    const this$ = this;
+    return this$["identifier@579"];
+  }
+  set Identifier(i) {
+    const this$ = this;
+    this$["identifier@579"] = i;
+  }
+  get Investigation() {
+    const this$ = this;
+    return unwrap(this$.investigation);
+  }
+  set Investigation(i) {
+    const this$ = this;
+    this$.investigation = i;
+  }
+  get Title() {
+    const this$ = this;
+    return unwrap(this$["title@584"]);
+  }
+  set Title(n) {
+    const this$ = this;
+    this$["title@584"] = n;
+  }
+  get Description() {
+    const this$ = this;
+    return unwrap(this$["description@585"]);
+  }
+  set Description(n) {
+    const this$ = this;
+    this$["description@585"] = n;
+  }
+  get SubmissionDate() {
+    const this$ = this;
+    return unwrap(this$["submissionDate@586"]);
+  }
+  set SubmissionDate(n) {
+    const this$ = this;
+    this$["submissionDate@586"] = n;
+  }
+  get PublicReleaseDate() {
+    const this$ = this;
+    return unwrap(this$["publicReleaseDate@587"]);
+  }
+  set PublicReleaseDate(n) {
+    const this$ = this;
+    this$["publicReleaseDate@587"] = n;
+  }
+  get Publications() {
+    const this$ = this;
+    return this$["publications@588-1"];
+  }
+  set Publications(n) {
+    const this$ = this;
+    this$["publications@588-1"] = n;
+  }
+  get Contacts() {
+    const this$ = this;
+    return this$["contacts@589-1"];
+  }
+  set Contacts(n) {
+    const this$ = this;
+    this$["contacts@589-1"] = n;
+  }
+  get StudyDesignDescriptors() {
+    const this$ = this;
+    return this$["studyDesignDescriptors@590-1"];
+  }
+  set StudyDesignDescriptors(n) {
+    const this$ = this;
+    this$["studyDesignDescriptors@590-1"] = n;
+  }
+  get DataMap() {
+    const this$ = this;
+    return unwrap(this$["datamap@591"]);
+  }
+  set DataMap(n) {
+    const this$ = this;
+    this$["datamap@591"] = n;
+  }
+  get RegisteredAssayIdentifiers() {
+    const this$ = this;
+    return this$["registeredAssayIdentifiers@592-1"];
+  }
+  set RegisteredAssayIdentifiers(n) {
+    const this$ = this;
+    this$["registeredAssayIdentifiers@592-1"] = n;
+  }
+  get Comments() {
+    const this$ = this;
+    return this$["comments@593-1"];
+  }
+  set Comments(n) {
+    const this$ = this;
+    this$["comments@593-1"] = n;
+  }
+  get StaticHash() {
+    const this$ = this;
+    return this$.staticHash | 0;
+  }
+  set StaticHash(h) {
+    const this$ = this;
+    this$.staticHash = h | 0;
+  }
+  static init(identifier) {
+    return new ArcStudy(identifier);
+  }
+  static create(identifier, title, description, submissionDate, publicReleaseDate, publications, contacts, studyDesignDescriptors, tables, datamap, registeredAssayIdentifiers, comments) {
+    return new ArcStudy(identifier, unwrap(title), unwrap(description), unwrap(submissionDate), unwrap(publicReleaseDate), unwrap(publications), unwrap(contacts), unwrap(studyDesignDescriptors), unwrap(tables), unwrap(datamap), unwrap(registeredAssayIdentifiers), unwrap(comments));
+  }
+  static make(identifier, title, description, submissionDate, publicReleaseDate, publications, contacts, studyDesignDescriptors, tables, datamap, registeredAssayIdentifiers, comments) {
+    return new ArcStudy(identifier, unwrap(title), unwrap(description), unwrap(submissionDate), unwrap(publicReleaseDate), publications, contacts, studyDesignDescriptors, tables, unwrap(datamap), registeredAssayIdentifiers, comments);
+  }
+  get isEmpty() {
+    const this$ = this;
+    return equals(this$.Title, void 0) && equals(this$.Description, void 0) && equals(this$.SubmissionDate, void 0) && equals(this$.PublicReleaseDate, void 0) && this$.Publications.length === 0 && this$.Contacts.length === 0 && this$.StudyDesignDescriptors.length === 0 && this$.Tables.length === 0 && this$.RegisteredAssayIdentifiers.length === 0 && this$.Comments.length === 0;
+  }
+  static get FileName() {
+    return "isa.study.xlsx";
+  }
+  get RegisteredAssayIdentifierCount() {
+    const this$ = this;
+    return this$.RegisteredAssayIdentifiers.length | 0;
+  }
+  get RegisteredAssayCount() {
+    const this$ = this;
+    return this$.RegisteredAssays.length | 0;
+  }
+  get RegisteredAssays() {
+    const this$ = this;
+    let inv;
+    const investigation = this$.Investigation;
+    if (investigation != null) {
+      inv = value(investigation);
+    } else {
+      throw new Error("Cannot execute this function. Object is not part of ArcInvestigation.");
+    }
+    const collection = choose((assayIdentifier) => inv.TryGetAssay(assayIdentifier), this$.RegisteredAssayIdentifiers);
+    return Array.from(collection);
+  }
+  get VacantAssayIdentifiers() {
+    const this$ = this;
+    let inv;
+    const investigation = this$.Investigation;
+    if (investigation != null) {
+      inv = value(investigation);
+    } else {
+      throw new Error("Cannot execute this function. Object is not part of ArcInvestigation.");
+    }
+    const collection = filter((arg) => !inv.ContainsAssay(arg), this$.RegisteredAssayIdentifiers);
+    return Array.from(collection);
+  }
+  AddRegisteredAssay(assay) {
+    const this$ = this;
+    let inv;
+    const investigation = this$.Investigation;
+    if (investigation != null) {
+      inv = value(investigation);
+    } else {
+      throw new Error("Cannot execute this function. Object is not part of ArcInvestigation.");
+    }
+    inv.AddAssay(assay);
+    inv.RegisterAssay(this$.Identifier, assay.Identifier);
+  }
+  static addRegisteredAssay(assay) {
+    return (study) => {
+      const newStudy = study.Copy();
+      newStudy.AddRegisteredAssay(assay);
+      return newStudy;
+    };
+  }
+  InitRegisteredAssay(assayIdentifier) {
+    const this$ = this;
+    const assay = new ArcAssay(assayIdentifier);
+    this$.AddRegisteredAssay(assay);
+    return assay;
+  }
+  static initRegisteredAssay(assayIdentifier) {
+    return (study) => {
+      const copy = study.Copy();
+      return [copy, copy.InitRegisteredAssay(assayIdentifier)];
+    };
+  }
+  RegisterAssay(assayIdentifier) {
+    const this$ = this;
+    if (contains(assayIdentifier, this$.RegisteredAssayIdentifiers, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    })) {
+      throw new Error(`Assay \`${assayIdentifier}\` is already registered on the study.`);
+    }
+    void this$.RegisteredAssayIdentifiers.push(assayIdentifier);
+  }
+  static registerAssay(assayIdentifier) {
+    return (study) => {
+      const copy = study.Copy();
+      copy.RegisterAssay(assayIdentifier);
+      return copy;
+    };
+  }
+  DeregisterAssay(assayIdentifier) {
+    const this$ = this;
+    removeInPlace(assayIdentifier, this$.RegisteredAssayIdentifiers, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    });
+  }
+  static deregisterAssay(assayIdentifier) {
+    return (study) => {
+      const copy = study.Copy();
+      copy.DeregisterAssay(assayIdentifier);
+      return copy;
+    };
+  }
+  GetRegisteredAssay(assayIdentifier) {
+    const this$ = this;
+    if (!contains(assayIdentifier, this$.RegisteredAssayIdentifiers, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    })) {
+      throw new Error(`Assay \`${assayIdentifier}\` is not registered on the study.`);
+    }
+    let inv;
+    const investigation = this$.Investigation;
+    if (investigation != null) {
+      inv = value(investigation);
+    } else {
+      throw new Error("Cannot execute this function. Object is not part of ArcInvestigation.");
+    }
+    return inv.GetAssay(assayIdentifier);
+  }
+  static getRegisteredAssay(assayIdentifier) {
+    return (study) => {
+      const copy = study.Copy();
+      return copy.GetRegisteredAssay(assayIdentifier);
+    };
+  }
+  static getRegisteredAssays() {
+    return (study) => {
+      const copy = study.Copy();
+      return copy.RegisteredAssays;
+    };
+  }
+  GetRegisteredAssaysOrIdentifier() {
+    const this$ = this;
+    const matchValue = this$.Investigation;
+    if (matchValue == null) {
+      return ResizeArray_map((identifier_1) => ArcAssay.init(identifier_1), this$.RegisteredAssayIdentifiers);
+    } else {
+      const i = value(matchValue);
+      return ResizeArray_map((identifier) => {
+        const matchValue_1 = i.TryGetAssay(identifier);
+        if (matchValue_1 == null) {
+          return ArcAssay.init(identifier);
+        } else {
+          return value(matchValue_1);
+        }
+      }, this$.RegisteredAssayIdentifiers);
+    }
+  }
+  static getRegisteredAssaysOrIdentifier() {
+    return (study) => {
+      const copy = study.Copy();
+      return copy.GetRegisteredAssaysOrIdentifier();
+    };
+  }
+  static addTable(table, index) {
+    return (study) => {
+      const c = study.Copy();
+      c.AddTable(table, unwrap(index));
+      return c;
+    };
+  }
+  static addTables(tables, index) {
+    return (study) => {
+      const c = study.Copy();
+      c.AddTables(tables, unwrap(index));
+      return c;
+    };
+  }
+  static initTable(tableName, index) {
+    return (study) => {
+      const c = study.Copy();
+      return [c, c.InitTable(tableName, unwrap(index))];
+    };
+  }
+  static initTables(tableNames, index) {
+    return (study) => {
+      const c = study.Copy();
+      c.InitTables(tableNames, unwrap(index));
+      return c;
+    };
+  }
+  static getTableAt(index) {
+    return (study) => {
+      const newAssay = study.Copy();
+      return newAssay.GetTableAt(index);
+    };
+  }
+  static getTable(name) {
+    return (study) => {
+      const newAssay = study.Copy();
+      return newAssay.GetTable(name);
+    };
+  }
+  static updateTableAt(index, table) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.UpdateTableAt(index, table);
+      return newAssay;
+    };
+  }
+  static updateTable(name, table) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.UpdateTable(name, table);
+      return newAssay;
+    };
+  }
+  static setTableAt(index, table) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.SetTableAt(index, table);
+      return newAssay;
+    };
+  }
+  static setTable(name, table) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.SetTable(name, table);
+      return newAssay;
+    };
+  }
+  static removeTableAt(index) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.RemoveTableAt(index);
+      return newAssay;
+    };
+  }
+  static removeTable(name) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.RemoveTable(name);
+      return newAssay;
+    };
+  }
+  static mapTableAt(index, updateFun) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.MapTableAt(index, updateFun);
+      return newAssay;
+    };
+  }
+  static mapTable(name, updateFun) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.MapTable(name, updateFun);
+      return newAssay;
+    };
+  }
+  static renameTableAt(index, newName) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.RenameTableAt(index, newName);
+      return newAssay;
+    };
+  }
+  static renameTable(name, newName) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.RenameTable(name, newName);
+      return newAssay;
+    };
+  }
+  static addColumnAt(tableIndex, header, cells, columnIndex, forceReplace) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.AddColumnAt(tableIndex, header, unwrap(cells), unwrap(columnIndex), unwrap(forceReplace));
+      return newAssay;
+    };
+  }
+  static addColumn(tableName, header, cells, columnIndex, forceReplace) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.AddColumn(tableName, header, unwrap(cells), unwrap(columnIndex), unwrap(forceReplace));
+      return newAssay;
+    };
+  }
+  static removeColumnAt(tableIndex, columnIndex) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.RemoveColumnAt(tableIndex, columnIndex);
+      return newAssay;
+    };
+  }
+  static removeColumn(tableName, columnIndex) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.RemoveColumn(tableName, columnIndex);
+      return newAssay;
+    };
+  }
+  static updateColumnAt(tableIndex, columnIndex, header, cells) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.UpdateColumnAt(tableIndex, columnIndex, header, unwrap(cells));
+      return newAssay;
+    };
+  }
+  static updateColumn(tableName, columnIndex, header, cells) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.UpdateColumn(tableName, columnIndex, header, unwrap(cells));
+      return newAssay;
+    };
+  }
+  static getColumnAt(tableIndex, columnIndex) {
+    return (study) => {
+      const newAssay = study.Copy();
+      return newAssay.GetColumnAt(tableIndex, columnIndex);
+    };
+  }
+  static getColumn(tableName, columnIndex) {
+    return (study) => {
+      const newAssay = study.Copy();
+      return newAssay.GetColumn(tableName, columnIndex);
+    };
+  }
+  static addRowAt(tableIndex, cells, rowIndex) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.AddRowAt(tableIndex, unwrap(cells), unwrap(rowIndex));
+      return newAssay;
+    };
+  }
+  static addRow(tableName, cells, rowIndex) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.AddRow(tableName, unwrap(cells), unwrap(rowIndex));
+      return newAssay;
+    };
+  }
+  static removeRowAt(tableIndex, rowIndex) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.RemoveColumnAt(tableIndex, rowIndex);
+      return newAssay;
+    };
+  }
+  static removeRow(tableName, rowIndex) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.RemoveRow(tableName, rowIndex);
+      return newAssay;
+    };
+  }
+  static updateRowAt(tableIndex, rowIndex, cells) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.UpdateRowAt(tableIndex, rowIndex, cells);
+      return newAssay;
+    };
+  }
+  static updateRow(tableName, rowIndex, cells) {
+    return (study) => {
+      const newAssay = study.Copy();
+      newAssay.UpdateRow(tableName, rowIndex, cells);
+      return newAssay;
+    };
+  }
+  static getRowAt(tableIndex, rowIndex) {
+    return (study) => {
+      const newAssay = study.Copy();
+      return newAssay.GetRowAt(tableIndex, rowIndex);
+    };
+  }
+  static getRow(tableName, rowIndex) {
+    return (study) => {
+      const newAssay = study.Copy();
+      return newAssay.GetRow(tableName, rowIndex);
+    };
+  }
+  AddToInvestigation(investigation) {
+    const this$ = this;
+    this$.Investigation = investigation;
+  }
+  RemoveFromInvestigation() {
+    const this$ = this;
+    this$.Investigation = void 0;
+  }
+  Copy(copyInvestigationRef) {
+    const this$ = this;
+    const copyInvestigationRef_1 = defaultArg(copyInvestigationRef, false);
+    const nextTables = [];
+    const nextAssayIdentifiers = Array.from(this$.RegisteredAssayIdentifiers);
+    let enumerator = getEnumerator(this$.Tables);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const table = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        const copy = table.Copy();
+        void nextTables.push(copy);
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+    const nextComments = ResizeArray_map((c) => c.Copy(), this$.Comments);
+    const nextContacts = ResizeArray_map((c_1) => c_1.Copy(), this$.Contacts);
+    const nextPublications = ResizeArray_map((c_2) => c_2.Copy(), this$.Publications);
+    const nextStudyDesignDescriptors = ResizeArray_map((c_3) => c_3.Copy(), this$.StudyDesignDescriptors);
+    const nextDataMap = map((d) => d.Copy(), this$.DataMap);
+    let study;
+    const identifier = this$.Identifier;
+    const title = this$.Title;
+    const description = this$.Description;
+    const submissionDate = this$.SubmissionDate;
+    const publicReleaseDate = this$.PublicReleaseDate;
+    study = ArcStudy.make(identifier, title, description, submissionDate, publicReleaseDate, nextPublications, nextContacts, nextStudyDesignDescriptors, nextTables, nextDataMap, nextAssayIdentifiers, nextComments);
+    if (copyInvestigationRef_1) {
+      study.Investigation = this$.Investigation;
+    }
+    return study;
+  }
+  UpdateReferenceByStudyFile(study, onlyReplaceExisting, keepUnusedRefTables) {
+    const this$ = this;
+    const updateAlways = !defaultArg(onlyReplaceExisting, false);
+    if (study.Title != null ? true : updateAlways) {
+      this$.Title = study.Title;
+    }
+    if (study.Description != null ? true : updateAlways) {
+      this$.Description = study.Description;
+    }
+    if (study.SubmissionDate != null ? true : updateAlways) {
+      this$.SubmissionDate = study.SubmissionDate;
+    }
+    if (study.PublicReleaseDate != null ? true : updateAlways) {
+      this$.PublicReleaseDate = study.PublicReleaseDate;
+    }
+    if (study.Publications.length !== 0 ? true : updateAlways) {
+      this$.Publications = study.Publications;
+    }
+    if (study.Contacts.length !== 0 ? true : updateAlways) {
+      this$.Contacts = study.Contacts;
+    }
+    if (study.StudyDesignDescriptors.length !== 0 ? true : updateAlways) {
+      this$.StudyDesignDescriptors = study.StudyDesignDescriptors;
+    }
+    if (study.Tables.length !== 0 ? true : updateAlways) {
+      const tables = ArcTables.updateReferenceTablesBySheets(new ArcTables(this$.Tables), new ArcTables(study.Tables), unwrap(keepUnusedRefTables));
+      this$.Tables = tables.Tables;
+    }
+    this$.DataMap = study.DataMap;
+    if (study.RegisteredAssayIdentifiers.length !== 0 ? true : updateAlways) {
+      this$.RegisteredAssayIdentifiers = study.RegisteredAssayIdentifiers;
+    }
+    if (study.Comments.length !== 0 ? true : updateAlways) {
+      this$.Comments = study.Comments;
+    }
+  }
+  StructurallyEquals(other) {
+    let a, b, a_1, b_1, a_2, b_2, a_3, b_3, a_4, b_4, a_5, b_5;
+    const this$ = this;
+    return forAll((x) => x === true, [this$.Identifier === other.Identifier, equals(this$.Title, other.Title), equals(this$.Description, other.Description), equals(this$.SubmissionDate, other.SubmissionDate), equals(this$.PublicReleaseDate, other.PublicReleaseDate), equals(this$.DataMap, other.DataMap), (a = this$.Publications, b = other.Publications, length(a) === length(b) && fold((acc, e) => {
+      if (acc) {
+        return e;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_1) => equals(item(i_1, a), item(i_1, b)), rangeDouble(0, 1, length(a) - 1)))))), (a_1 = this$.Contacts, b_1 = other.Contacts, length(a_1) === length(b_1) && fold((acc_1, e_1) => {
+      if (acc_1) {
+        return e_1;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_2) => equals(item(i_2, a_1), item(i_2, b_1)), rangeDouble(0, 1, length(a_1) - 1)))))), (a_2 = this$.StudyDesignDescriptors, b_2 = other.StudyDesignDescriptors, length(a_2) === length(b_2) && fold((acc_2, e_2) => {
+      if (acc_2) {
+        return e_2;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_3) => equals(item(i_3, a_2), item(i_3, b_2)), rangeDouble(0, 1, length(a_2) - 1)))))), (a_3 = this$.Tables, b_3 = other.Tables, length(a_3) === length(b_3) && fold((acc_3, e_3) => {
+      if (acc_3) {
+        return e_3;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_4) => equals(item(i_4, a_3), item(i_4, b_3)), rangeDouble(0, 1, length(a_3) - 1)))))), (a_4 = this$.RegisteredAssayIdentifiers, b_4 = other.RegisteredAssayIdentifiers, length(a_4) === length(b_4) && fold((acc_4, e_4) => {
+      if (acc_4) {
+        return e_4;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_5) => item(i_5, a_4) === item(i_5, b_4), rangeDouble(0, 1, length(a_4) - 1)))))), (a_5 = this$.Comments, b_5 = other.Comments, length(a_5) === length(b_5) && fold((acc_5, e_5) => {
+      if (acc_5) {
+        return e_5;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_6) => equals(item(i_6, a_5), item(i_6, b_5)), rangeDouble(0, 1, length(a_5) - 1))))))]);
+  }
+  ReferenceEquals(other) {
+    const this$ = this;
+    return this$ === other;
+  }
+  toString() {
+    const this$ = this;
+    const arg = this$.Identifier;
+    const arg_1 = this$.Title;
+    const arg_2 = this$.Description;
+    const arg_3 = this$.SubmissionDate;
+    const arg_4 = this$.PublicReleaseDate;
+    const arg_5 = this$.Publications;
+    const arg_6 = this$.Contacts;
+    const arg_7 = this$.StudyDesignDescriptors;
+    const arg_8 = this$.Tables;
+    const arg_9 = this$.RegisteredAssayIdentifiers;
+    const arg_10 = this$.Comments;
+    return toText(printf("ArcStudy {\r\n    Identifier = %A,\r\n    Title = %A,\r\n    Description = %A,\r\n    SubmissionDate = %A,\r\n    PublicReleaseDate = %A,\r\n    Publications = %A,\r\n    Contacts = %A,\r\n    StudyDesignDescriptors = %A,\r\n    Tables = %A,\r\n    RegisteredAssayIdentifiers = %A,\r\n    Comments = %A,\r\n}"))(arg)(arg_1)(arg_2)(arg_3)(arg_4)(arg_5)(arg_6)(arg_7)(arg_8)(arg_9)(arg_10);
+  }
+  Equals(other) {
+    let s;
+    const this$ = this;
+    return other instanceof ArcStudy && (s = other, this$.StructurallyEquals(s));
+  }
+  GetHashCode() {
+    const this$ = this;
+    return boxHashArray([this$.Identifier, boxHashOption(this$.Title), boxHashOption(this$.Description), boxHashOption(this$.SubmissionDate), boxHashOption(this$.PublicReleaseDate), boxHashOption(this$.DataMap), boxHashSeq(this$.Publications), boxHashSeq(this$.Contacts), boxHashSeq(this$.StudyDesignDescriptors), boxHashSeq(this$.Tables), boxHashSeq(this$.RegisteredAssayIdentifiers), boxHashSeq(this$.Comments)]) | 0;
+  }
+  GetLightHashCode() {
+    const this$ = this;
+    return boxHashArray([this$.Identifier, boxHashOption(this$.Title), boxHashOption(this$.Description), boxHashOption(this$.SubmissionDate), boxHashOption(this$.PublicReleaseDate), boxHashSeq(this$.Publications), boxHashSeq(this$.Contacts), boxHashSeq(this$.StudyDesignDescriptors), boxHashSeq(this$.Tables), boxHashSeq(this$.RegisteredAssayIdentifiers), boxHashSeq(this$.Comments)]) | 0;
+  }
+}
+function ArcStudy_$reflection() {
+  return class_type("ARCtrl.ArcStudy", void 0, ArcStudy, ArcTables_$reflection());
+}
+function ArcStudy_$ctor_64321D5B(identifier, title, description, submissionDate, publicReleaseDate, publications, contacts, studyDesignDescriptors, tables, datamap, registeredAssayIdentifiers, comments) {
+  return new ArcStudy(identifier, title, description, submissionDate, publicReleaseDate, publications, contacts, studyDesignDescriptors, tables, datamap, registeredAssayIdentifiers, comments);
+}
+class ArcWorkflow {
+  constructor(identifier, title, description, workflowType, uri, version, subWorkflowIdentifiers, parameters, components, datamap, contacts, comments) {
+    let identifier_1;
+    this["identifier@1151"] = (identifier_1 = identifier.trim(), checkValidCharacters(identifier_1), identifier_1);
+    this.investigation = void 0;
+    this["title@1156"] = title;
+    this["description@1157"] = description;
+    this["subWorkflowIdentifiers@1158"] = defaultArg(subWorkflowIdentifiers, []);
+    this["workflowType@1159"] = workflowType;
+    this["uri@1160"] = uri;
+    this["version@1161"] = version;
+    this["parameters@1162"] = defaultArg(parameters, []);
+    this["components@1163"] = defaultArg(components, []);
+    this.dataMap = datamap;
+    this["contacts@1165"] = defaultArg(contacts, []);
+    this["comments@1166"] = defaultArg(comments, []);
+    this.staticHash = 0;
+  }
+  get Identifier() {
+    const this$ = this;
+    return this$["identifier@1151"];
+  }
+  set Identifier(i) {
+    const this$ = this;
+    this$["identifier@1151"] = i;
+  }
+  get Investigation() {
+    const this$ = this;
+    return unwrap(this$.investigation);
+  }
+  set Investigation(a) {
+    const this$ = this;
+    this$.investigation = a;
+  }
+  get Title() {
+    const this$ = this;
+    return unwrap(this$["title@1156"]);
+  }
+  set Title(t) {
+    const this$ = this;
+    this$["title@1156"] = t;
+  }
+  get Description() {
+    const this$ = this;
+    return unwrap(this$["description@1157"]);
+  }
+  set Description(d) {
+    const this$ = this;
+    this$["description@1157"] = d;
+  }
+  get SubWorkflowIdentifiers() {
+    const this$ = this;
+    return this$["subWorkflowIdentifiers@1158"];
+  }
+  set SubWorkflowIdentifiers(s) {
+    const this$ = this;
+    this$["subWorkflowIdentifiers@1158"] = s;
+  }
+  get WorkflowType() {
+    const this$ = this;
+    return unwrap(this$["workflowType@1159"]);
+  }
+  set WorkflowType(w) {
+    const this$ = this;
+    this$["workflowType@1159"] = w;
+  }
+  get URI() {
+    const this$ = this;
+    return unwrap(this$["uri@1160"]);
+  }
+  set URI(u) {
+    const this$ = this;
+    this$["uri@1160"] = u;
+  }
+  get Version() {
+    const this$ = this;
+    return unwrap(this$["version@1161"]);
+  }
+  set Version(v) {
+    const this$ = this;
+    this$["version@1161"] = v;
+  }
+  get Parameters() {
+    const this$ = this;
+    return this$["parameters@1162"];
+  }
+  set Parameters(p) {
+    const this$ = this;
+    this$["parameters@1162"] = p;
+  }
+  get Components() {
+    const this$ = this;
+    return this$["components@1163"];
+  }
+  set Components(c) {
+    const this$ = this;
+    this$["components@1163"] = c;
+  }
+  get DataMap() {
+    const this$ = this;
+    return unwrap(this$.dataMap);
+  }
+  set DataMap(dm) {
+    const this$ = this;
+    this$.dataMap = dm;
+  }
+  get Contacts() {
+    const this$ = this;
+    return this$["contacts@1165"];
+  }
+  set Contacts(c) {
+    const this$ = this;
+    this$["contacts@1165"] = c;
+  }
+  get Comments() {
+    const this$ = this;
+    return this$["comments@1166"];
+  }
+  set Comments(c) {
+    const this$ = this;
+    this$["comments@1166"] = c;
+  }
+  get StaticHash() {
+    const this$ = this;
+    return this$.staticHash | 0;
+  }
+  set StaticHash(s) {
+    const this$ = this;
+    this$.staticHash = s | 0;
+  }
+  static init(identifier) {
+    return new ArcWorkflow(identifier);
+  }
+  static create(identifier, title, description, workflowType, uri, version, subWorkflowIdentifiers, parameters, components, datamap, contacts, comments) {
+    return new ArcWorkflow(identifier, unwrap(title), unwrap(description), unwrap(workflowType), unwrap(uri), unwrap(version), unwrap(subWorkflowIdentifiers), unwrap(parameters), unwrap(components), unwrap(datamap), unwrap(contacts), unwrap(comments));
+  }
+  static make(identifier, title, description, workflowType, uri, version, subWorkflowIdentifiers, parameters, components, datamap, contacts, comments) {
+    return new ArcWorkflow(identifier, unwrap(title), unwrap(description), unwrap(workflowType), unwrap(uri), unwrap(version), subWorkflowIdentifiers, parameters, components, unwrap(datamap), contacts, comments);
+  }
+  static get FileName() {
+    return "isa.run.xlsx";
+  }
+  get SubWorkflowIdentifiersCount() {
+    const this$ = this;
+    return this$.SubWorkflowIdentifiers.length | 0;
+  }
+  get SubWorkflowCount() {
+    const this$ = this;
+    return this$.SubWorkflows.length | 0;
+  }
+  get SubWorkflows() {
+    const this$ = this;
+    let inv;
+    const investigation = this$.Investigation;
+    if (investigation != null) {
+      inv = value(investigation);
+    } else {
+      throw new Error("Cannot execute this function. Object is not part of ArcInvestigation.");
+    }
+    const collection = choose((workflowIdentifier) => inv.TryGetWorkflow(workflowIdentifier), this$.SubWorkflowIdentifiers);
+    return Array.from(collection);
+  }
+  get VacantSubWorkflowIdentifiers() {
+    const this$ = this;
+    let inv;
+    const investigation = this$.Investigation;
+    if (investigation != null) {
+      inv = value(investigation);
+    } else {
+      throw new Error("Cannot execute this function. Object is not part of ArcInvestigation.");
+    }
+    const collection = filter((arg) => !inv.ContainsWorkflow(arg), this$.SubWorkflowIdentifiers);
+    return Array.from(collection);
+  }
+  AddSubWorkflow(subWorkflow) {
+    const this$ = this;
+    let inv;
+    const investigation = this$.Investigation;
+    if (investigation != null) {
+      inv = value(investigation);
+    } else {
+      throw new Error("Cannot execute this function. Object is not part of ArcInvestigation.");
+    }
+    inv.AddWorkflow(subWorkflow);
+  }
+  static addSubWorkflow(subWorkflow) {
+    return (workflow) => {
+      const newWorkflow = workflow.Copy();
+      newWorkflow.AddSubWorkflow(subWorkflow);
+      return newWorkflow;
+    };
+  }
+  InitSubWorkflow(subWorkflowIdentifier) {
+    const this$ = this;
+    const subWorkflow = new ArcWorkflow(subWorkflowIdentifier);
+    this$.AddSubWorkflow(subWorkflow);
+    return subWorkflow;
+  }
+  static initSubWorkflow(subWorkflowIdentifier) {
+    return (workflow) => {
+      const copy = workflow.Copy();
+      return [copy, copy.InitSubWorkflow(subWorkflowIdentifier)];
+    };
+  }
+  RegisterSubWorkflow(subWorkflowIdentifier) {
+    const this$ = this;
+    if (contains(subWorkflowIdentifier, this$.SubWorkflowIdentifiers, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    })) {
+      throw new Error(`SubWorkflow \`${subWorkflowIdentifier}\` is already registered on the workflow.`);
+    }
+    void this$.SubWorkflowIdentifiers.push(subWorkflowIdentifier);
+  }
+  static registerSubWorkflow(subWorkflowIdentifier) {
+    return (workflow) => {
+      const copy = workflow.Copy();
+      copy.RegisterSubWorkflow(subWorkflowIdentifier);
+      return copy;
+    };
+  }
+  DeregisterSubWorkflow(subWorkflowIdentifier) {
+    const this$ = this;
+    removeInPlace(subWorkflowIdentifier, this$.SubWorkflowIdentifiers, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    });
+  }
+  static deregisterSubWorkflow(subWorkflowIdentifier) {
+    return (workflow) => {
+      const copy = workflow.Copy();
+      copy.DeregisterSubWorkflow(subWorkflowIdentifier);
+      return copy;
+    };
+  }
+  GetRegisteredSubWorkflow(subWorkflowIdentifier) {
+    const this$ = this;
+    if (!contains(subWorkflowIdentifier, this$.SubWorkflowIdentifiers, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    })) {
+      throw new Error(`SubWorkflow \`${subWorkflowIdentifier}\` is not registered on the workflow.`);
+    }
+    let inv;
+    const investigation = this$.Investigation;
+    if (investigation != null) {
+      inv = value(investigation);
+    } else {
+      throw new Error("Cannot execute this function. Object is not part of ArcInvestigation.");
+    }
+    return inv.GetWorkflow(subWorkflowIdentifier);
+  }
+  static getRegisteredSubWorkflow(subWorkflowIdentifier) {
+    return (workflow) => {
+      const copy = workflow.Copy();
+      return copy.GetRegisteredSubWorkflow(subWorkflowIdentifier);
+    };
+  }
+  static getRegisteredSubWorkflows() {
+    return (workflow) => {
+      const copy = workflow.Copy();
+      return copy.SubWorkflows;
+    };
+  }
+  GetRegisteredSubWorkflowsOrIdentifier() {
+    const this$ = this;
+    const matchValue = this$.Investigation;
+    if (matchValue == null) {
+      return ResizeArray_map((identifier_1) => ArcWorkflow.init(identifier_1), this$.SubWorkflowIdentifiers);
+    } else {
+      const i = value(matchValue);
+      return ResizeArray_map((identifier) => {
+        const matchValue_1 = i.TryGetWorkflow(identifier);
+        if (matchValue_1 == null) {
+          return ArcWorkflow.init(identifier);
+        } else {
+          return value(matchValue_1);
+        }
+      }, this$.SubWorkflowIdentifiers);
+    }
+  }
+  static getRegisteredSubWorkflowsOrIdentifier() {
+    return (workflow) => {
+      const copy = workflow.Copy();
+      return copy.GetRegisteredSubWorkflowsOrIdentifier();
+    };
+  }
+  Copy(copyInvestigationRef) {
+    const this$ = this;
+    const copyInvestigationRef_1 = defaultArg(copyInvestigationRef, false);
+    const nextWorkFlowType = map((w) => w.Copy(), this$.WorkflowType);
+    const nextSubWorkflowIdentifiers = Array.from(this$.SubWorkflowIdentifiers);
+    const nextParameters = ResizeArray_map((x) => x, this$.Parameters);
+    const nextComponents = ResizeArray_map((x_1) => x_1, this$.Components);
+    const nextDataMap = map((d) => d.Copy(), this$.DataMap);
+    const nextContacts = ResizeArray_map((c) => c.Copy(), this$.Contacts);
+    const nextComments = ResizeArray_map((c_1) => c_1.Copy(), this$.Comments);
+    let workflow;
+    const identifier = this$.Identifier;
+    const title = this$.Title;
+    const description = this$.Description;
+    const uri = this$.URI;
+    const version = this$.Version;
+    workflow = ArcWorkflow.make(identifier, title, description, nextWorkFlowType, uri, version, nextSubWorkflowIdentifiers, nextParameters, nextComponents, nextDataMap, nextContacts, nextComments);
+    if (copyInvestigationRef_1) {
+      workflow.Investigation = this$.Investigation;
+    }
+    return workflow;
+  }
+  StructurallyEquals(other) {
+    let a, b, a_1, b_1, a_2, b_2, a_3, b_3, a_4, b_4;
+    const this$ = this;
+    return forAll((x) => x === true, [this$.Identifier === other.Identifier, equals(this$.Title, other.Title), equals(this$.Description, other.Description), equals(this$.WorkflowType, other.WorkflowType), equals(this$.URI, other.URI), equals(this$.Version, other.Version), (a = this$.SubWorkflowIdentifiers, b = other.SubWorkflowIdentifiers, length(a) === length(b) && fold((acc, e) => {
+      if (acc) {
+        return e;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_1) => item(i_1, a) === item(i_1, b), rangeDouble(0, 1, length(a) - 1)))))), (a_1 = this$.Parameters, b_1 = other.Parameters, length(a_1) === length(b_1) && fold((acc_1, e_1) => {
+      if (acc_1) {
+        return e_1;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_2) => equals(item(i_2, a_1), item(i_2, b_1)), rangeDouble(0, 1, length(a_1) - 1)))))), (a_2 = this$.Components, b_2 = other.Components, length(a_2) === length(b_2) && fold((acc_2, e_2) => {
+      if (acc_2) {
+        return e_2;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_3) => equals(item(i_3, a_2), item(i_3, b_2)), rangeDouble(0, 1, length(a_2) - 1)))))), equals(this$.DataMap, other.DataMap), (a_3 = this$.Contacts, b_3 = other.Contacts, length(a_3) === length(b_3) && fold((acc_3, e_3) => {
+      if (acc_3) {
+        return e_3;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_4) => equals(item(i_4, a_3), item(i_4, b_3)), rangeDouble(0, 1, length(a_3) - 1)))))), (a_4 = this$.Comments, b_4 = other.Comments, length(a_4) === length(b_4) && fold((acc_4, e_4) => {
+      if (acc_4) {
+        return e_4;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_5) => equals(item(i_5, a_4), item(i_5, b_4)), rangeDouble(0, 1, length(a_4) - 1))))))]);
+  }
+  ReferenceEquals(other) {
+    const this$ = this;
+    return this$ === other;
+  }
+  toString() {
+    const this$ = this;
+    const arg = this$.Identifier;
+    const arg_1 = this$.Title;
+    const arg_2 = this$.Description;
+    const arg_3 = this$.WorkflowType;
+    const arg_4 = this$.URI;
+    const arg_5 = this$.Version;
+    const arg_6 = this$.SubWorkflowIdentifiers;
+    const arg_7 = this$.Parameters;
+    const arg_8 = this$.Components;
+    const arg_9 = this$.DataMap;
+    const arg_10 = this$.Contacts;
+    const arg_11 = this$.Comments;
+    return toText(printf("ArcWorkflow {\r\n    Identifier = %A,\r\n    Title = %A,\r\n    Description = %A,\r\n    WorkflowType = %A,\r\n    URI = %A,\r\n    Version = %A,\r\n    SubWorkflowIdentifiers = %A,\r\n    Parameters = %A,\r\n    Components = %A,\r\n    DataMap = %A,\r\n    Contacts = %A,\r\n    Comments = %A}"))(arg)(arg_1)(arg_2)(arg_3)(arg_4)(arg_5)(arg_6)(arg_7)(arg_8)(arg_9)(arg_10)(arg_11);
+  }
+  Equals(other) {
+    let s;
+    const this$ = this;
+    return other instanceof ArcWorkflow && (s = other, this$.StructurallyEquals(s));
+  }
+  GetHashCode() {
+    const this$ = this;
+    return boxHashArray([this$.Identifier, boxHashOption(this$.Title), boxHashOption(this$.Description), boxHashOption(this$.WorkflowType), boxHashOption(this$.URI), boxHashOption(this$.Version), boxHashSeq(this$.SubWorkflowIdentifiers), boxHashSeq(this$.Parameters), boxHashSeq(this$.Components), boxHashOption(this$.DataMap), boxHashSeq(this$.Contacts), boxHashSeq(this$.Comments)]) | 0;
+  }
+  GetLightHashCode() {
+    const this$ = this;
+    return boxHashArray([this$.Identifier, boxHashOption(this$.Title), boxHashOption(this$.Description), boxHashOption(this$.WorkflowType), boxHashOption(this$.URI), boxHashOption(this$.Version), boxHashSeq(this$.SubWorkflowIdentifiers), boxHashSeq(this$.Parameters), boxHashSeq(this$.Components), boxHashSeq(this$.Contacts), boxHashSeq(this$.Comments)]) | 0;
+  }
+}
+function ArcWorkflow_$reflection() {
+  return class_type("ARCtrl.ArcWorkflow", void 0, ArcWorkflow);
+}
+function ArcWorkflow_$ctor_Z3BB02240(identifier, title, description, workflowType, uri, version, subWorkflowIdentifiers, parameters, components, datamap, contacts, comments) {
+  return new ArcWorkflow(identifier, title, description, workflowType, uri, version, subWorkflowIdentifiers, parameters, components, datamap, contacts, comments);
+}
+class ArcRun extends ArcTables {
+  constructor(identifier, title, description, measurementType, technologyType, technologyPlatform, workflowIdentifiers, tables, datamap, performers, comments) {
+    super(defaultArg(tables, []));
+    let identifier_1;
+    const performers_1 = defaultArg(performers, []);
+    const comments_1 = defaultArg(comments, []);
+    const workflowIdentifiers_1 = defaultArg(workflowIdentifiers, []);
+    this["identifier@1447"] = (identifier_1 = identifier.trim(), checkValidCharacters(identifier_1), identifier_1);
+    this["title@1451"] = title;
+    this["description@1452"] = description;
+    this.investigation = void 0;
+    this["measurementType@1454"] = measurementType;
+    this["technologyType@1455"] = technologyType;
+    this["technologyPlatform@1456"] = technologyPlatform;
+    this["workflowIdentifiers@1457-1"] = workflowIdentifiers_1;
+    this.dataMap = datamap;
+    this["performers@1459-1"] = performers_1;
+    this["comments@1460-1"] = comments_1;
+    this.staticHash = 0;
+  }
+  get Identifier() {
+    const this$ = this;
+    return this$["identifier@1447"];
+  }
+  set Identifier(i) {
+    const this$ = this;
+    this$["identifier@1447"] = i;
+  }
+  get Investigation() {
+    const this$ = this;
+    return unwrap(this$.investigation);
+  }
+  set Investigation(i) {
+    const this$ = this;
+    this$.investigation = i;
+  }
+  get Title() {
+    const this$ = this;
+    return unwrap(this$["title@1451"]);
+  }
+  set Title(t) {
+    const this$ = this;
+    this$["title@1451"] = t;
+  }
+  get Description() {
+    const this$ = this;
+    return unwrap(this$["description@1452"]);
+  }
+  set Description(d) {
+    const this$ = this;
+    this$["description@1452"] = d;
+  }
+  get MeasurementType() {
+    const this$ = this;
+    return unwrap(this$["measurementType@1454"]);
+  }
+  set MeasurementType(n) {
+    const this$ = this;
+    this$["measurementType@1454"] = n;
+  }
+  get TechnologyType() {
+    const this$ = this;
+    return unwrap(this$["technologyType@1455"]);
+  }
+  set TechnologyType(n) {
+    const this$ = this;
+    this$["technologyType@1455"] = n;
+  }
+  get TechnologyPlatform() {
+    const this$ = this;
+    return unwrap(this$["technologyPlatform@1456"]);
+  }
+  set TechnologyPlatform(n) {
+    const this$ = this;
+    this$["technologyPlatform@1456"] = n;
+  }
+  get WorkflowIdentifiers() {
+    const this$ = this;
+    return this$["workflowIdentifiers@1457-1"];
+  }
+  set WorkflowIdentifiers(w) {
+    const this$ = this;
+    this$["workflowIdentifiers@1457-1"] = w;
+  }
+  get DataMap() {
+    const this$ = this;
+    return unwrap(this$.dataMap);
+  }
+  set DataMap(n) {
+    const this$ = this;
+    this$.dataMap = n;
+  }
+  get Performers() {
+    const this$ = this;
+    return this$["performers@1459-1"];
+  }
+  set Performers(n) {
+    const this$ = this;
+    this$["performers@1459-1"] = n;
+  }
+  get Comments() {
+    const this$ = this;
+    return this$["comments@1460-1"];
+  }
+  set Comments(n) {
+    const this$ = this;
+    this$["comments@1460-1"] = n;
+  }
+  get StaticHash() {
+    const this$ = this;
+    return this$.staticHash | 0;
+  }
+  set StaticHash(h) {
+    const this$ = this;
+    this$.staticHash = h | 0;
+  }
+  static init(identifier) {
+    return new ArcRun(identifier);
+  }
+  static create(identifier, title, description, measurementType, technologyType, technologyPlatform, workflowIdentifiers, tables, datamap, performers, comments) {
+    return new ArcRun(identifier, unwrap(title), unwrap(description), unwrap(measurementType), unwrap(technologyType), unwrap(technologyPlatform), unwrap(workflowIdentifiers), unwrap(tables), unwrap(datamap), unwrap(performers), unwrap(comments));
+  }
+  static make(identifier, title, description, measurementType, technologyType, technologyPlatform, workflowIdentifiers, tables, datamap, performers, comments) {
+    return new ArcRun(identifier, unwrap(title), unwrap(description), unwrap(measurementType), unwrap(technologyType), unwrap(technologyPlatform), workflowIdentifiers, tables, unwrap(datamap), performers, comments);
+  }
+  static get FileName() {
+    return "isa.run.xlsx";
+  }
+  get WorkflowIdentifierCount() {
+    const this$ = this;
+    return this$.WorkflowIdentifiers.length | 0;
+  }
+  get WorkflowCount() {
+    const this$ = this;
+    return this$.Workflows.length | 0;
+  }
+  get Workflows() {
+    const this$ = this;
+    let inv;
+    const investigation = this$.Investigation;
+    if (investigation != null) {
+      inv = value(investigation);
+    } else {
+      throw new Error("Cannot execute this function. Object is not part of ArcInvestigation.");
+    }
+    const collection = choose((workflowIdentifier) => inv.TryGetWorkflow(workflowIdentifier), this$.WorkflowIdentifiers);
+    return Array.from(collection);
+  }
+  get VacantWorkflowIdentifiers() {
+    const this$ = this;
+    let inv;
+    const investigation = this$.Investigation;
+    if (investigation != null) {
+      inv = value(investigation);
+    } else {
+      throw new Error("Cannot execute this function. Object is not part of ArcInvestigation.");
+    }
+    const collection = filter((arg) => !inv.ContainsWorkflow(arg), this$.WorkflowIdentifiers);
+    return Array.from(collection);
+  }
+  static addTable(table, index) {
+    return (run) => {
+      const c = run.Copy();
+      c.AddTable(table, unwrap(index));
+      return c;
+    };
+  }
+  static addTables(tables, index) {
+    return (run) => {
+      const c = run.Copy();
+      c.AddTables(tables, unwrap(index));
+      return c;
+    };
+  }
+  static initTable(tableName, index) {
+    return (run) => {
+      const c = run.Copy();
+      return [c, c.InitTable(tableName, unwrap(index))];
+    };
+  }
+  static initTables(tableNames, index) {
+    return (run) => {
+      const c = run.Copy();
+      c.InitTables(tableNames, unwrap(index));
+      return c;
+    };
+  }
+  static getTableAt(index) {
+    return (run) => {
+      const newRun = run.Copy();
+      return newRun.GetTableAt(index);
+    };
+  }
+  static getTable(name) {
+    return (run) => {
+      const newRun = run.Copy();
+      return newRun.GetTable(name);
+    };
+  }
+  static updateTableAt(index, table) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.UpdateTableAt(index, table);
+      return newRun;
+    };
+  }
+  static updateTable(name, table) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.UpdateTable(name, table);
+      return newRun;
+    };
+  }
+  static setTableAt(index, table) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.SetTableAt(index, table);
+      return newRun;
+    };
+  }
+  static setTable(name, table) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.SetTable(name, table);
+      return newRun;
+    };
+  }
+  static removeTableAt(index) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.RemoveTableAt(index);
+      return newRun;
+    };
+  }
+  static removeTable(name) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.RemoveTable(name);
+      return newRun;
+    };
+  }
+  static mapTableAt(index, updateFun) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.MapTableAt(index, updateFun);
+      return newRun;
+    };
+  }
+  static mapTable(name, updateFun) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.MapTable(name, updateFun);
+      return newRun;
+    };
+  }
+  static renameTableAt(index, newName) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.RenameTableAt(index, newName);
+      return newRun;
+    };
+  }
+  static renameTable(name, newName) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.RenameTable(name, newName);
+      return newRun;
+    };
+  }
+  static addColumnAt(tableIndex, header, cells, columnIndex, forceReplace) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.AddColumnAt(tableIndex, header, unwrap(cells), unwrap(columnIndex), unwrap(forceReplace));
+      return newRun;
+    };
+  }
+  static addColumn(tableName, header, cells, columnIndex, forceReplace) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.AddColumn(tableName, header, unwrap(cells), unwrap(columnIndex), unwrap(forceReplace));
+      return newRun;
+    };
+  }
+  static removeColumnAt(tableIndex, columnIndex) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.RemoveColumnAt(tableIndex, columnIndex);
+      return newRun;
+    };
+  }
+  static removeColumn(tableName, columnIndex) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.RemoveColumn(tableName, columnIndex);
+      return newRun;
+    };
+  }
+  static updateColumnAt(tableIndex, columnIndex, header, cells) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.UpdateColumnAt(tableIndex, columnIndex, header, unwrap(cells));
+      return newRun;
+    };
+  }
+  static updateColumn(tableName, columnIndex, header, cells) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.UpdateColumn(tableName, columnIndex, header, unwrap(cells));
+      return newRun;
+    };
+  }
+  static getColumnAt(tableIndex, columnIndex) {
+    return (run) => {
+      const newRun = run.Copy();
+      return newRun.GetColumnAt(tableIndex, columnIndex);
+    };
+  }
+  static getColumn(tableName, columnIndex) {
+    return (run) => {
+      const newRun = run.Copy();
+      return newRun.GetColumn(tableName, columnIndex);
+    };
+  }
+  static addRowAt(tableIndex, cells, rowIndex) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.AddRowAt(tableIndex, unwrap(cells), unwrap(rowIndex));
+      return newRun;
+    };
+  }
+  static addRow(tableName, cells, rowIndex) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.AddRow(tableName, unwrap(cells), unwrap(rowIndex));
+      return newRun;
+    };
+  }
+  static removeRowAt(tableIndex, rowIndex) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.RemoveColumnAt(tableIndex, rowIndex);
+      return newRun;
+    };
+  }
+  static removeRow(tableName, rowIndex) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.RemoveRow(tableName, rowIndex);
+      return newRun;
+    };
+  }
+  static updateRowAt(tableIndex, rowIndex, cells) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.UpdateRowAt(tableIndex, rowIndex, cells);
+      return newRun;
+    };
+  }
+  static updateRow(tableName, rowIndex, cells) {
+    return (run) => {
+      const newRun = run.Copy();
+      newRun.UpdateRow(tableName, rowIndex, cells);
+      return newRun;
+    };
+  }
+  static getRowAt(tableIndex, rowIndex) {
+    return (run) => {
+      const newRun = run.Copy();
+      return newRun.GetRowAt(tableIndex, rowIndex);
+    };
+  }
+  static getRow(tableName, rowIndex) {
+    return (run) => {
+      const newRun = run.Copy();
+      return newRun.GetRow(tableName, rowIndex);
+    };
+  }
+  static setPerformers(performers, run) {
+    run.Performers = performers;
+    return run;
+  }
+  Copy() {
+    const this$ = this;
+    const nextTables = ResizeArray_map((c) => c.Copy(), this$.Tables);
+    const nextComments = ResizeArray_map((c_1) => c_1.Copy(), this$.Comments);
+    const nextDataMap = map((d) => d.Copy(), this$.DataMap);
+    const nextPerformers = ResizeArray_map((c_2) => c_2.Copy(), this$.Performers);
+    const nextWorkflowIdentifiers = ResizeArray_map((c_3) => c_3, this$.WorkflowIdentifiers);
+    const identifier = this$.Identifier;
+    const title = this$.Title;
+    const description = this$.Description;
+    const measurementType = this$.MeasurementType;
+    const technologyType = this$.TechnologyType;
+    const technologyPlatform = this$.TechnologyPlatform;
+    return ArcRun.make(identifier, title, description, measurementType, technologyType, technologyPlatform, nextWorkflowIdentifiers, nextTables, nextDataMap, nextPerformers, nextComments);
+  }
+  UpdateBy(run, onlyReplaceExisting, appendSequences) {
+    const this$ = this;
+    const onlyReplaceExisting_1 = defaultArg(onlyReplaceExisting, false);
+    const appendSequences_1 = defaultArg(appendSequences, false);
+    const updateAlways = !onlyReplaceExisting_1;
+    if (run.Title != null ? true : updateAlways) {
+      this$.Title = run.Title;
+    }
+    if (run.Description != null ? true : updateAlways) {
+      this$.Description = run.Description;
+    }
+    if (run.MeasurementType != null ? true : updateAlways) {
+      this$.MeasurementType = run.MeasurementType;
+    }
+    if (run.TechnologyType != null ? true : updateAlways) {
+      this$.TechnologyType = run.TechnologyType;
+    }
+    if (run.TechnologyPlatform != null ? true : updateAlways) {
+      this$.TechnologyPlatform = run.TechnologyPlatform;
+    }
+    if (run.WorkflowIdentifiers.length !== 0 ? true : updateAlways) {
+      let s;
+      const origin = this$.WorkflowIdentifiers;
+      const next = run.WorkflowIdentifiers;
+      if (!appendSequences_1) {
+        s = ResizeArray_map((x) => x, next);
+      } else {
+        const combined = [];
+        let enumerator = getEnumerator(origin);
+        try {
+          while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const e = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (!contains$1(e, combined, {
+              Equals: (x_1, y) => x_1 === y,
+              GetHashCode: stringHash
+            })) {
+              void combined.push(e);
+            }
+          }
+        } finally {
+          disposeSafe(enumerator);
+        }
+        let enumerator_1 = getEnumerator(next);
+        try {
+          while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+            const e_1 = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (!contains$1(e_1, combined, {
+              Equals: (x_2, y_1) => x_2 === y_1,
+              GetHashCode: stringHash
+            })) {
+              void combined.push(e_1);
+            }
+          }
+        } finally {
+          disposeSafe(enumerator_1);
+        }
+        s = combined;
+      }
+      this$.WorkflowIdentifiers = s;
+    }
+    if (run.DataMap != null ? true : updateAlways) {
+      this$.DataMap = run.DataMap;
+    }
+    if (run.Tables.length !== 0 ? true : updateAlways) {
+      let s_1;
+      const origin_1 = this$.Tables;
+      const next_1 = run.Tables;
+      if (!appendSequences_1) {
+        s_1 = ResizeArray_map((x_3) => x_3, next_1);
+      } else {
+        const combined_1 = [];
+        let enumerator_2 = getEnumerator(origin_1);
+        try {
+          while (enumerator_2["System.Collections.IEnumerator.MoveNext"]()) {
+            const e_2 = enumerator_2["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (!contains$1(e_2, combined_1, {
+              Equals: equals,
+              GetHashCode: safeHash
+            })) {
+              void combined_1.push(e_2);
+            }
+          }
+        } finally {
+          disposeSafe(enumerator_2);
+        }
+        let enumerator_1_1 = getEnumerator(next_1);
+        try {
+          while (enumerator_1_1["System.Collections.IEnumerator.MoveNext"]()) {
+            const e_1_1 = enumerator_1_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (!contains$1(e_1_1, combined_1, {
+              Equals: equals,
+              GetHashCode: safeHash
+            })) {
+              void combined_1.push(e_1_1);
+            }
+          }
+        } finally {
+          disposeSafe(enumerator_1_1);
+        }
+        s_1 = combined_1;
+      }
+      this$.Tables = s_1;
+    }
+    if (run.Performers.length !== 0 ? true : updateAlways) {
+      let s_2;
+      const origin_2 = this$.Performers;
+      const next_2 = run.Performers;
+      if (!appendSequences_1) {
+        s_2 = ResizeArray_map((x_6) => x_6, next_2);
+      } else {
+        const combined_2 = [];
+        let enumerator_3 = getEnumerator(origin_2);
+        try {
+          while (enumerator_3["System.Collections.IEnumerator.MoveNext"]()) {
+            const e_3 = enumerator_3["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (!contains$1(e_3, combined_2, {
+              Equals: equals,
+              GetHashCode: safeHash
+            })) {
+              void combined_2.push(e_3);
+            }
+          }
+        } finally {
+          disposeSafe(enumerator_3);
+        }
+        let enumerator_1_2 = getEnumerator(next_2);
+        try {
+          while (enumerator_1_2["System.Collections.IEnumerator.MoveNext"]()) {
+            const e_1_2 = enumerator_1_2["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (!contains$1(e_1_2, combined_2, {
+              Equals: equals,
+              GetHashCode: safeHash
+            })) {
+              void combined_2.push(e_1_2);
+            }
+          }
+        } finally {
+          disposeSafe(enumerator_1_2);
+        }
+        s_2 = combined_2;
+      }
+      this$.Performers = s_2;
+    }
+    if (run.Comments.length !== 0 ? true : updateAlways) {
+      let s_3;
+      const origin_3 = this$.Comments;
+      const next_3 = run.Comments;
+      if (!appendSequences_1) {
+        s_3 = ResizeArray_map((x_9) => x_9, next_3);
+      } else {
+        const combined_3 = [];
+        let enumerator_4 = getEnumerator(origin_3);
+        try {
+          while (enumerator_4["System.Collections.IEnumerator.MoveNext"]()) {
+            const e_4 = enumerator_4["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (!contains$1(e_4, combined_3, {
+              Equals: equals,
+              GetHashCode: safeHash
+            })) {
+              void combined_3.push(e_4);
+            }
+          }
+        } finally {
+          disposeSafe(enumerator_4);
+        }
+        let enumerator_1_3 = getEnumerator(next_3);
+        try {
+          while (enumerator_1_3["System.Collections.IEnumerator.MoveNext"]()) {
+            const e_1_3 = enumerator_1_3["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (!contains$1(e_1_3, combined_3, {
+              Equals: equals,
+              GetHashCode: safeHash
+            })) {
+              void combined_3.push(e_1_3);
+            }
+          }
+        } finally {
+          disposeSafe(enumerator_1_3);
+        }
+        s_3 = combined_3;
+      }
+      this$.Comments = s_3;
+    }
+  }
+  toString() {
+    const this$ = this;
+    const arg = this$.Identifier;
+    const arg_1 = this$.Title;
+    const arg_2 = this$.Description;
+    const arg_3 = this$.MeasurementType;
+    const arg_4 = this$.TechnologyType;
+    const arg_5 = this$.TechnologyPlatform;
+    const arg_6 = this$.WorkflowIdentifiers;
+    const arg_7 = this$.DataMap;
+    const arg_8 = this$.Tables;
+    const arg_9 = this$.Performers;
+    const arg_10 = this$.Comments;
+    return toText(printf('ArcRun({\r\n    Identifier = "%s",\r\n    Title = %A,\r\n    Description = %A,\r\n    MeasurementType = %A,\r\n    TechnologyType = %A,\r\n    TechnologyPlatform = %A,\r\n    WorkflowIdentifiers = %A,\r\n    DataMap = %A,\r\n    Tables = %A,\r\n    Performers = %A,\r\n    Comments = %A\r\n})'))(arg)(arg_1)(arg_2)(arg_3)(arg_4)(arg_5)(arg_6)(arg_7)(arg_8)(arg_9)(arg_10);
+  }
+  AddToInvestigation(investigation) {
+    const this$ = this;
+    this$.Investigation = investigation;
+  }
+  RemoveFromInvestigation() {
+    const this$ = this;
+    this$.Investigation = void 0;
+  }
+  StructurallyEquals(other) {
+    let a, b, a_1, b_1, a_2, b_2, a_3, b_3;
+    const this$ = this;
+    return forAll((x) => x === true, [this$.Identifier === other.Identifier, equals(this$.Title, other.Title), equals(this$.Description, other.Description), equals(this$.MeasurementType, other.MeasurementType), equals(this$.TechnologyType, other.TechnologyType), equals(this$.TechnologyPlatform, other.TechnologyPlatform), (a = this$.WorkflowIdentifiers, b = other.WorkflowIdentifiers, length(a) === length(b) && fold((acc, e) => {
+      if (acc) {
+        return e;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_1) => item(i_1, a) === item(i_1, b), rangeDouble(0, 1, length(a) - 1)))))), equals(this$.DataMap, other.DataMap), (a_1 = this$.Tables, b_1 = other.Tables, length(a_1) === length(b_1) && fold((acc_1, e_1) => {
+      if (acc_1) {
+        return e_1;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_2) => equals(item(i_2, a_1), item(i_2, b_1)), rangeDouble(0, 1, length(a_1) - 1)))))), (a_2 = this$.Performers, b_2 = other.Performers, length(a_2) === length(b_2) && fold((acc_2, e_2) => {
+      if (acc_2) {
+        return e_2;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_3) => equals(item(i_3, a_2), item(i_3, b_2)), rangeDouble(0, 1, length(a_2) - 1)))))), (a_3 = this$.Comments, b_3 = other.Comments, length(a_3) === length(b_3) && fold((acc_3, e_3) => {
+      if (acc_3) {
+        return e_3;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_4) => equals(item(i_4, a_3), item(i_4, b_3)), rangeDouble(0, 1, length(a_3) - 1))))))]);
+  }
+  ReferenceEquals(other) {
+    const this$ = this;
+    return this$ === other;
+  }
+  Equals(other) {
+    let run;
+    const this$ = this;
+    return other instanceof ArcRun && (run = other, this$.StructurallyEquals(run));
+  }
+  GetLightHashCode() {
+    const this$ = this;
+    return boxHashArray([this$.Identifier, boxHashOption(this$.Title), boxHashOption(this$.Description), boxHashOption(this$.MeasurementType), boxHashOption(this$.TechnologyType), boxHashOption(this$.TechnologyPlatform), boxHashSeq(this$.WorkflowIdentifiers), boxHashSeq(this$.Tables), boxHashSeq(this$.Performers), boxHashSeq(this$.Comments)]) | 0;
+  }
+  GetHashCode() {
+    const this$ = this;
+    return boxHashArray([this$.Identifier, boxHashOption(this$.Title), boxHashOption(this$.Description), boxHashOption(this$.MeasurementType), boxHashOption(this$.TechnologyType), boxHashOption(this$.TechnologyPlatform), boxHashOption(this$.DataMap), boxHashSeq(this$.WorkflowIdentifiers), boxHashSeq(this$.Tables), boxHashSeq(this$.Performers), boxHashSeq(this$.Comments)]) | 0;
+  }
+}
+function ArcRun_$reflection() {
+  return class_type("ARCtrl.ArcRun", void 0, ArcRun, ArcTables_$reflection());
+}
+function ArcRun_$ctor_Z38E7054B(identifier, title, description, measurementType, technologyType, technologyPlatform, workflowIdentifiers, tables, datamap, performers, comments) {
+  return new ArcRun(identifier, title, description, measurementType, technologyType, technologyPlatform, workflowIdentifiers, tables, datamap, performers, comments);
+}
+class ArcInvestigation {
+  constructor(identifier, title, description, submissionDate, publicReleaseDate, ontologySourceReferences, publications, contacts, assays, studies, workflows, runs, registeredStudyIdentifiers, comments, remarks) {
+    const this$ = new FSharpRef(defaultOf());
+    this$.contents = this;
+    const ontologySourceReferences_1 = defaultArg(ontologySourceReferences, []);
+    const publications_1 = defaultArg(publications, []);
+    const contacts_1 = defaultArg(contacts, []);
+    let assays_1;
+    const ass = defaultArg(assays, []);
+    let enumerator = getEnumerator(ass);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const a = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        a.Investigation = this$.contents;
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+    assays_1 = ass;
+    let studies_1;
+    const sss = defaultArg(studies, []);
+    let enumerator_1 = getEnumerator(sss);
+    try {
+      while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+        const s = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        s.Investigation = this$.contents;
+      }
+    } finally {
+      disposeSafe(enumerator_1);
+    }
+    studies_1 = sss;
+    let workflows_1;
+    const wss = defaultArg(workflows, []);
+    let enumerator_2 = getEnumerator(wss);
+    try {
+      while (enumerator_2["System.Collections.IEnumerator.MoveNext"]()) {
+        const w = enumerator_2["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        w.Investigation = this$.contents;
+      }
+    } finally {
+      disposeSafe(enumerator_2);
+    }
+    workflows_1 = wss;
+    let runs_1;
+    const rss = defaultArg(runs, []);
+    let enumerator_3 = getEnumerator(rss);
+    try {
+      while (enumerator_3["System.Collections.IEnumerator.MoveNext"]()) {
+        const r = enumerator_3["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        r.Investigation = this$.contents;
+      }
+    } finally {
+      disposeSafe(enumerator_3);
+    }
+    runs_1 = rss;
+    const registeredStudyIdentifiers_1 = defaultArg(registeredStudyIdentifiers, []);
+    const comments_1 = defaultArg(comments, []);
+    const remarks_1 = defaultArg(remarks, []);
+    this["identifier@1928"] = identifier;
+    this["title@1929"] = title;
+    this["description@1930"] = description;
+    this["submissionDate@1931"] = submissionDate;
+    this["publicReleaseDate@1932"] = publicReleaseDate;
+    this["ontologySourceReferences@1933-1"] = ontologySourceReferences_1;
+    this["publications@1934-1"] = publications_1;
+    this["contacts@1935-1"] = contacts_1;
+    this["assays@1936-1"] = assays_1;
+    this["studies@1937-1"] = studies_1;
+    this["workflows@1938-1"] = workflows_1;
+    this["runs@1939-1"] = runs_1;
+    this["registeredStudyIdentifiers@1940-1"] = registeredStudyIdentifiers_1;
+    this["comments@1941-1"] = comments_1;
+    this["remarks@1942-1"] = remarks_1;
+    this.staticHash = 0;
+    this["init@1899"] = 1;
+  }
+  get Identifier() {
+    const this$ = this;
+    return this$["identifier@1928"];
+  }
+  set Identifier(i) {
+    const this$ = this;
+    this$["identifier@1928"] = i;
+  }
+  get Title() {
+    const this$ = this;
+    return unwrap(this$["title@1929"]);
+  }
+  set Title(n) {
+    const this$ = this;
+    this$["title@1929"] = n;
+  }
+  get Description() {
+    const this$ = this;
+    return unwrap(this$["description@1930"]);
+  }
+  set Description(n) {
+    const this$ = this;
+    this$["description@1930"] = n;
+  }
+  get SubmissionDate() {
+    const this$ = this;
+    return unwrap(this$["submissionDate@1931"]);
+  }
+  set SubmissionDate(n) {
+    const this$ = this;
+    this$["submissionDate@1931"] = n;
+  }
+  get PublicReleaseDate() {
+    const this$ = this;
+    return unwrap(this$["publicReleaseDate@1932"]);
+  }
+  set PublicReleaseDate(n) {
+    const this$ = this;
+    this$["publicReleaseDate@1932"] = n;
+  }
+  get OntologySourceReferences() {
+    const this$ = this;
+    return this$["ontologySourceReferences@1933-1"];
+  }
+  set OntologySourceReferences(n) {
+    const this$ = this;
+    this$["ontologySourceReferences@1933-1"] = n;
+  }
+  get Publications() {
+    const this$ = this;
+    return this$["publications@1934-1"];
+  }
+  set Publications(n) {
+    const this$ = this;
+    this$["publications@1934-1"] = n;
+  }
+  get Contacts() {
+    const this$ = this;
+    return this$["contacts@1935-1"];
+  }
+  set Contacts(n) {
+    const this$ = this;
+    this$["contacts@1935-1"] = n;
+  }
+  get Assays() {
+    const this$ = this;
+    return this$["assays@1936-1"];
+  }
+  set Assays(n) {
+    const this$ = this;
+    this$["assays@1936-1"] = n;
+  }
+  get Studies() {
+    const this$ = this;
+    return this$["studies@1937-1"];
+  }
+  set Studies(n) {
+    const this$ = this;
+    this$["studies@1937-1"] = n;
+  }
+  get Workflows() {
+    const this$ = this;
+    return this$["workflows@1938-1"];
+  }
+  set Workflows(n) {
+    const this$ = this;
+    this$["workflows@1938-1"] = n;
+  }
+  get Runs() {
+    const this$ = this;
+    return this$["runs@1939-1"];
+  }
+  set Runs(n) {
+    const this$ = this;
+    this$["runs@1939-1"] = n;
+  }
+  get RegisteredStudyIdentifiers() {
+    const this$ = this;
+    return this$["registeredStudyIdentifiers@1940-1"];
+  }
+  set RegisteredStudyIdentifiers(n) {
+    const this$ = this;
+    this$["registeredStudyIdentifiers@1940-1"] = n;
+  }
+  get Comments() {
+    const this$ = this;
+    return this$["comments@1941-1"];
+  }
+  set Comments(n) {
+    const this$ = this;
+    this$["comments@1941-1"] = n;
+  }
+  get Remarks() {
+    const this$ = this;
+    return this$["remarks@1942-1"];
+  }
+  set Remarks(n) {
+    const this$ = this;
+    this$["remarks@1942-1"] = n;
+  }
+  get StaticHash() {
+    const this$ = this;
+    return this$.staticHash | 0;
+  }
+  set StaticHash(h) {
+    const this$ = this;
+    this$.staticHash = h | 0;
+  }
+  static get FileName() {
+    return "isa.investigation.xlsx";
+  }
+  static init(identifier) {
+    return new ArcInvestigation(identifier);
+  }
+  static create(identifier, title, description, submissionDate, publicReleaseDate, ontologySourceReferences, publications, contacts, assays, studies, workflows, runs, registeredStudyIdentifiers, comments, remarks) {
+    return new ArcInvestigation(identifier, unwrap(title), unwrap(description), unwrap(submissionDate), unwrap(publicReleaseDate), unwrap(ontologySourceReferences), unwrap(publications), unwrap(contacts), unwrap(assays), unwrap(studies), unwrap(workflows), unwrap(runs), unwrap(registeredStudyIdentifiers), unwrap(comments), unwrap(remarks));
+  }
+  static make(identifier, title, description, submissionDate, publicReleaseDate, ontologySourceReferences, publications, contacts, assays, studies, workflows, runs, registeredStudyIdentifiers, comments, remarks) {
+    return new ArcInvestigation(identifier, unwrap(title), unwrap(description), unwrap(submissionDate), unwrap(publicReleaseDate), ontologySourceReferences, publications, contacts, assays, studies, workflows, runs, registeredStudyIdentifiers, comments, remarks);
+  }
+  get AssayCount() {
+    const this$ = this;
+    return this$.Assays.length | 0;
+  }
+  get AssayIdentifiers() {
+    const this$ = this;
+    return Array.from(map$1((x) => x.Identifier, this$.Assays));
+  }
+  get UnregisteredAssays() {
+    const this$ = this;
+    return ResizeArray_filter((a) => !exists((s) => exists((i) => i === a.Identifier, s.RegisteredAssayIdentifiers), this$.RegisteredStudies), this$.Assays);
+  }
+  AddAssay(assay, registerIn) {
+    const this$ = this;
+    const assayIdent = assay.Identifier;
+    const matchValue = tryFindIndex((x_1) => x_1 === assayIdent, map$1((x) => x.Identifier, this$.Assays));
+    if (matchValue == null) {
+    } else {
+      throw new Error(`Cannot create assay with name ${assayIdent}, as assay names must be unique and assay at index ${value(matchValue)} has the same name.`);
+    }
+    assay.Investigation = this$;
+    void this$.Assays.push(assay);
+    if (registerIn != null) {
+      let enumerator = getEnumerator(value(registerIn));
+      try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+          const study = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+          study.RegisterAssay(assay.Identifier);
+        }
+      } finally {
+        disposeSafe(enumerator);
+      }
+    }
+  }
+  static addAssay(assay, registerIn) {
+    return (inv) => {
+      const newInvestigation = inv.Copy();
+      newInvestigation.AddAssay(assay, unwrap(registerIn));
+      return newInvestigation;
+    };
+  }
+  InitAssay(assayIdentifier, registerIn) {
+    const this$ = this;
+    const assay = new ArcAssay(assayIdentifier);
+    this$.AddAssay(assay, unwrap(registerIn));
+    return assay;
+  }
+  static initAssay(assayIdentifier, registerIn) {
+    return (inv) => {
+      const newInvestigation = inv.Copy();
+      return newInvestigation.InitAssay(assayIdentifier, unwrap(registerIn));
+    };
+  }
+  DeleteAssayAt(index) {
+    const this$ = this;
+    this$.Assays.splice(index, 1);
+  }
+  static deleteAssayAt(index) {
+    return (inv) => {
+      const newInvestigation = inv.Copy();
+      newInvestigation.DeleteAssayAt(index);
+      return newInvestigation;
+    };
+  }
+  DeleteAssay(assayIdentifier) {
+    const this$ = this;
+    const index = this$.GetAssayIndex(assayIdentifier) | 0;
+    this$.DeleteAssayAt(index);
+  }
+  static deleteAssay(assayIdentifier) {
+    return (inv) => {
+      const newInv = inv.Copy();
+      newInv.DeleteAssay(assayIdentifier);
+      return newInv;
+    };
+  }
+  RemoveAssayAt(index) {
+    const this$ = this;
+    const ident = this$.GetAssayAt(index).Identifier;
+    this$.Assays.splice(index, 1);
+    let enumerator = getEnumerator(this$.Studies);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const study = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        study.DeregisterAssay(ident);
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+  }
+  static removeAssayAt(index) {
+    return (inv) => {
+      const newInvestigation = inv.Copy();
+      newInvestigation.RemoveAssayAt(index);
+      return newInvestigation;
+    };
+  }
+  RemoveAssay(assayIdentifier) {
+    const this$ = this;
+    const index = this$.GetAssayIndex(assayIdentifier) | 0;
+    this$.RemoveAssayAt(index);
+  }
+  static removeAssay(assayIdentifier) {
+    return (inv) => {
+      const newInv = inv.Copy();
+      newInv.RemoveAssay(assayIdentifier);
+      return newInv;
+    };
+  }
+  RenameAssay(oldIdentifier, newIdentifier) {
+    const this$ = this;
+    iterate((a) => {
+      if (a.Identifier === oldIdentifier) {
+        a.Identifier = newIdentifier;
+      }
+    }, this$.Assays);
+    iterate((s) => {
+      const index = tryFindIndex((ai) => ai === oldIdentifier, s.RegisteredAssayIdentifiers);
+      if (index != null) {
+        const index_1 = value(index) | 0;
+        s.RegisteredAssayIdentifiers[index_1] = newIdentifier;
+      }
+    }, this$.Studies);
+  }
+  static renameAssay(oldIdentifier, newIdentifier) {
+    return (inv) => {
+      const newInv = inv.Copy();
+      newInv.RenameAssay(oldIdentifier, newIdentifier);
+      return newInv;
+    };
+  }
+  RenameRun(oldIdentifier, newIdentifier) {
+    const this$ = this;
+    iterate((a) => {
+      if (a.Identifier === oldIdentifier) {
+        a.Identifier = newIdentifier;
+      }
+    }, this$.Runs);
+  }
+  static renameRun(oldIdentifier, newIdentifier) {
+    return (inv) => {
+      const newInv = inv.Copy();
+      newInv.RenameRun(oldIdentifier, newIdentifier);
+      return newInv;
+    };
+  }
+  RenameWorkflow(oldIdentifier, newIdentifier) {
+    const this$ = this;
+    iterate((w) => {
+      if (w.Identifier === oldIdentifier) {
+        w.Identifier = newIdentifier;
+      }
+      const matchValue = tryFindIndex((subId) => subId === oldIdentifier, w.SubWorkflowIdentifiers);
+      if (matchValue != null) {
+        const i = value(matchValue) | 0;
+        w.SubWorkflowIdentifiers[i] = newIdentifier;
+      }
+    }, this$.Workflows);
+    iterate((r) => {
+      const matchValue_1 = tryFindIndex((wId) => wId === oldIdentifier, r.WorkflowIdentifiers);
+      if (matchValue_1 != null) {
+        const i_1 = value(matchValue_1) | 0;
+        r.WorkflowIdentifiers[i_1] = newIdentifier;
+      }
+    }, this$.Runs);
+  }
+  static renameWorkflow(oldIdentifier, newIdentifier) {
+    return (inv) => {
+      const newInv = inv.Copy();
+      newInv.RenameWorkflow(oldIdentifier, newIdentifier);
+      return newInv;
+    };
+  }
+  SetAssayAt(index, assay) {
+    const this$ = this;
+    const assayIdent = assay.Identifier;
+    const matchValue = tryFindIndex((x) => x === assayIdent, map$1((a) => a.Identifier, removeAt(index, this$.Assays)));
+    if (matchValue == null) {
+    } else {
+      throw new Error(`Cannot create assay with name ${assayIdent}, as assay names must be unique and assay at index ${value(matchValue)} has the same name.`);
+    }
+    assay.Investigation = this$;
+    this$.Assays[index] = assay;
+    this$.DeregisterMissingAssays();
+  }
+  static setAssayAt(index, assay) {
+    return (inv) => {
+      const newInvestigation = inv.Copy();
+      newInvestigation.SetAssayAt(index, assay);
+      return newInvestigation;
+    };
+  }
+  SetAssay(assayIdentifier, assay) {
+    const this$ = this;
+    const index = this$.GetAssayIndex(assayIdentifier) | 0;
+    this$.SetAssayAt(index, assay);
+  }
+  static setAssay(assayIdentifier, assay) {
+    return (inv) => {
+      const newInvestigation = inv.Copy();
+      newInvestigation.SetAssay(assayIdentifier, assay);
+      return newInvestigation;
+    };
+  }
+  GetAssayIndex(assayIdentifier) {
+    const this$ = this;
+    const index = this$.Assays.findIndex((a) => a.Identifier === assayIdentifier) | 0;
+    if (index === -1) {
+      throw new Error(`Unable to find assay with specified identifier '${assayIdentifier}'!`);
+    }
+    return index | 0;
+  }
+  static getAssayIndex(assayIdentifier) {
+    return (inv) => inv.GetAssayIndex(assayIdentifier);
+  }
+  GetAssayAt(index) {
+    const this$ = this;
+    return this$.Assays[index];
+  }
+  static getAssayAt(index) {
+    return (inv) => {
+      const newInvestigation = inv.Copy();
+      return newInvestigation.GetAssayAt(index);
+    };
+  }
+  GetAssay(assayIdentifier) {
+    const this$ = this;
+    const matchValue = this$.TryGetAssay(assayIdentifier);
+    if (matchValue == null) {
+      throw new Error(ArcTypesAux_ErrorMsgs_unableToFindAssayIdentifier(assayIdentifier, this$.Identifier));
+    } else {
+      return value(matchValue);
+    }
+  }
+  static getAssay(assayIdentifier) {
+    return (inv) => {
+      const newInvestigation = inv.Copy();
+      return newInvestigation.GetAssay(assayIdentifier);
+    };
+  }
+  TryGetAssay(assayIdentifier) {
+    const this$ = this;
+    return tryFind((a) => a.Identifier === assayIdentifier, this$.Assays);
+  }
+  static tryGetAssay(assayIdentifier) {
+    return (inv) => {
+      const newInvestigation = inv.Copy();
+      return newInvestigation.TryGetAssay(assayIdentifier);
+    };
+  }
+  ContainsAssay(assayIdentifier) {
+    const this$ = this;
+    return exists((a) => a.Identifier === assayIdentifier, this$.Assays);
+  }
+  static containsAssay(assayIdentifier) {
+    return (inv) => inv.ContainsAssay(assayIdentifier);
+  }
+  get RegisteredStudyIdentifierCount() {
+    const this$ = this;
+    return this$.RegisteredStudyIdentifiers.length | 0;
+  }
+  get RegisteredStudies() {
+    const this$ = this;
+    return ResizeArray_choose((identifier) => this$.TryGetStudy(identifier), this$.RegisteredStudyIdentifiers);
+  }
+  get RegisteredStudyCount() {
+    const this$ = this;
+    return this$.RegisteredStudies.length | 0;
+  }
+  get VacantStudyIdentifiers() {
+    const this$ = this;
+    return ResizeArray_filter((arg) => !this$.ContainsStudy(arg), this$.RegisteredStudyIdentifiers);
+  }
+  get StudyCount() {
+    const this$ = this;
+    return this$.Studies.length | 0;
+  }
+  get StudyIdentifiers() {
+    const this$ = this;
+    return toArray(map$1((x) => x.Identifier, this$.Studies));
+  }
+  get UnregisteredStudies() {
+    const this$ = this;
+    return ResizeArray_filter((s) => {
+      let source, x;
+      return !(source = this$.RegisteredStudyIdentifiers, exists((x = s.Identifier, (y) => x === y), source));
+    }, this$.Studies);
+  }
+  AddStudy(study) {
+    const this$ = this;
+    const study_1 = study;
+    const matchValue = tryFindIndex((x) => x.Identifier === study_1.Identifier, this$.Studies);
+    if (matchValue == null) {
+    } else {
+      throw new Error(`Cannot create study with name ${study_1.Identifier}, as study names must be unique and study at index ${value(matchValue)} has the same name.`);
+    }
+    study.Investigation = this$;
+    void this$.Studies.push(study);
+  }
+  static addStudy(study) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.AddStudy(study);
+      return copy;
+    };
+  }
+  InitStudy(studyIdentifier) {
+    const this$ = this;
+    const study = ArcStudy.init(studyIdentifier);
+    this$.AddStudy(study);
+    return study;
+  }
+  static initStudy(studyIdentifier) {
+    return (inv) => {
+      const copy = inv.Copy();
+      return [copy, copy.InitStudy(studyIdentifier)];
+    };
+  }
+  RegisterStudy(studyIdentifier) {
+    const this$ = this;
+    const studyIdent = studyIdentifier;
+    const matchValue = tryFind((x) => x === studyIdent, this$.StudyIdentifiers);
+    if (matchValue != null) {
+    } else {
+      throw new Error(`The given study with identifier '${studyIdent}' must be added to Investigation before it can be registered.`);
+    }
+    const studyIdent_1 = studyIdentifier;
+    if (contains(studyIdent_1, this$.RegisteredStudyIdentifiers, {
+      Equals: (x_1, y) => x_1 === y,
+      GetHashCode: stringHash
+    })) {
+      throw new Error(`Study with identifier '${studyIdent_1}' is already registered!`);
+    }
+    void this$.RegisteredStudyIdentifiers.push(studyIdentifier);
+  }
+  static registerStudy(studyIdentifier) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.RegisterStudy(studyIdentifier);
+      return copy;
+    };
+  }
+  AddRegisteredStudy(study) {
+    const this$ = this;
+    this$.AddStudy(study);
+    this$.RegisterStudy(study.Identifier);
+  }
+  static addRegisteredStudy(study) {
+    return (inv) => {
+      const copy = inv.Copy();
+      const study_1 = study.Copy();
+      copy.AddRegisteredStudy(study_1);
+      return copy;
+    };
+  }
+  DeleteStudyAt(index) {
+    const this$ = this;
+    this$.Studies.splice(index, 1);
+  }
+  static deleteStudyAt(index) {
+    return (i) => {
+      const copy = i.Copy();
+      copy.DeleteStudyAt(index);
+      return copy;
+    };
+  }
+  DeleteStudy(studyIdentifier) {
+    const this$ = this;
+    const index = this$.Studies.findIndex((s) => s.Identifier === studyIdentifier) | 0;
+    this$.DeleteStudyAt(index);
+  }
+  static deleteStudy(studyIdentifier) {
+    return (i) => {
+      const copy = i.Copy();
+      copy.DeleteStudy(studyIdentifier);
+      return copy;
+    };
+  }
+  RemoveStudyAt(index) {
+    const this$ = this;
+    const ident = this$.GetStudyAt(index).Identifier;
+    this$.Studies.splice(index, 1);
+    this$.DeregisterStudy(ident);
+  }
+  static removeStudyAt(index) {
+    return (inv) => {
+      const newInv = inv.Copy();
+      newInv.RemoveStudyAt(index);
+      return newInv;
+    };
+  }
+  RemoveStudy(studyIdentifier) {
+    const this$ = this;
+    const index = this$.GetStudyIndex(studyIdentifier) | 0;
+    this$.RemoveStudyAt(index);
+  }
+  static removeStudy(studyIdentifier) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.RemoveStudy(studyIdentifier);
+      return copy;
+    };
+  }
+  RenameStudy(oldIdentifier, newIdentifier) {
+    const this$ = this;
+    iterate((s) => {
+      if (s.Identifier === oldIdentifier) {
+        s.Identifier = newIdentifier;
+      }
+    }, this$.Studies);
+    const index = tryFindIndex((si) => si === oldIdentifier, this$.RegisteredStudyIdentifiers);
+    if (index != null) {
+      const index_1 = value(index) | 0;
+      this$.RegisteredStudyIdentifiers[index_1] = newIdentifier;
+    }
+  }
+  static renameStudy(oldIdentifier, newIdentifier) {
+    return (inv) => {
+      const newInv = inv.Copy();
+      newInv.RenameStudy(oldIdentifier, newIdentifier);
+      return newInv;
+    };
+  }
+  SetStudyAt(index, study) {
+    const this$ = this;
+    const study_1 = study;
+    const matchValue = tryFindIndex((x) => x.Identifier === study_1.Identifier, removeAt(index, this$.Studies));
+    if (matchValue == null) {
+    } else {
+      throw new Error(`Cannot create study with name ${study_1.Identifier}, as study names must be unique and study at index ${value(matchValue)} has the same name.`);
+    }
+    study.Investigation = this$;
+    this$.Studies[index] = study;
+  }
+  static setStudyAt(index, study) {
+    return (inv) => {
+      const newInv = inv.Copy();
+      newInv.SetStudyAt(index, study);
+      return newInv;
+    };
+  }
+  SetStudy(studyIdentifier, study) {
+    const this$ = this;
+    const index = this$.GetStudyIndex(studyIdentifier) | 0;
+    this$.SetStudyAt(index, study);
+  }
+  static setStudy(studyIdentifier, study) {
+    return (inv) => {
+      const newInv = inv.Copy();
+      newInv.SetStudy(studyIdentifier, study);
+      return newInv;
+    };
+  }
+  GetStudyIndex(studyIdentifier) {
+    const this$ = this;
+    const index = this$.Studies.findIndex((s) => s.Identifier === studyIdentifier) | 0;
+    if (index === -1) {
+      throw new Error(`Unable to find study with specified identifier '${studyIdentifier}'!`);
+    }
+    return index | 0;
+  }
+  static getStudyIndex(studyIdentifier) {
+    return (inv) => inv.GetStudyIndex(studyIdentifier);
+  }
+  GetStudyAt(index) {
+    const this$ = this;
+    return this$.Studies[index];
+  }
+  static getStudyAt(index) {
+    return (inv) => {
+      const newInv = inv.Copy();
+      return newInv.GetStudyAt(index);
+    };
+  }
+  GetStudy(studyIdentifier) {
+    const this$ = this;
+    const matchValue = this$.TryGetStudy(studyIdentifier);
+    if (matchValue == null) {
+      throw new Error(ArcTypesAux_ErrorMsgs_unableToFindStudyIdentifier(studyIdentifier, this$.Identifier));
+    } else {
+      return value(matchValue);
+    }
+  }
+  static getStudy(studyIdentifier) {
+    return (inv) => {
+      const newInv = inv.Copy();
+      return newInv.GetStudy(studyIdentifier);
+    };
+  }
+  TryGetStudy(studyIdentifier) {
+    const this$ = this;
+    return tryFind((s) => s.Identifier === studyIdentifier, this$.Studies);
+  }
+  static tryGetStudy(studyIdentifier) {
+    return (inv) => {
+      const newInv = inv.Copy();
+      return newInv.TryGetStudy(studyIdentifier);
+    };
+  }
+  ContainsStudy(studyIdentifier) {
+    const this$ = this;
+    return exists((s) => s.Identifier === studyIdentifier, this$.Studies);
+  }
+  static containsStudy(studyIdentifier) {
+    return (inv) => inv.ContainsStudy(studyIdentifier);
+  }
+  RegisterAssayAt(studyIndex, assayIdentifier) {
+    const this$ = this;
+    const study = this$.GetStudyAt(studyIndex);
+    const matchValue = tryFind((x) => x === assayIdentifier, map$1((a) => a.Identifier, this$.Assays));
+    if (matchValue != null) {
+    } else {
+      throw new Error("The given assay must be added to Investigation before it can be registered.");
+    }
+    const assayIdent_1 = assayIdentifier;
+    const matchValue_1 = tryFindIndex((x_1) => x_1 === assayIdent_1, study.RegisteredAssayIdentifiers);
+    if (matchValue_1 == null) {
+    } else {
+      throw new Error(`Cannot create assay with name ${assayIdent_1}, as assay names must be unique and assay at index ${value(matchValue_1)} has the same name.`);
+    }
+    study.RegisterAssay(assayIdentifier);
+  }
+  static registerAssayAt(studyIndex, assayIdentifier) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.RegisterAssayAt(studyIndex, assayIdentifier);
+      return copy;
+    };
+  }
+  RegisterAssay(studyIdentifier, assayIdentifier) {
+    const this$ = this;
+    const index = this$.GetStudyIndex(studyIdentifier) | 0;
+    this$.RegisterAssayAt(index, assayIdentifier);
+  }
+  static registerAssay(studyIdentifier, assayIdentifier) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.RegisterAssay(studyIdentifier, assayIdentifier);
+      return copy;
+    };
+  }
+  DeregisterAssayAt(studyIndex, assayIdentifier) {
+    const this$ = this;
+    const study = this$.GetStudyAt(studyIndex);
+    study.DeregisterAssay(assayIdentifier);
+  }
+  static deregisterAssayAt(studyIndex, assayIdentifier) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.DeregisterAssayAt(studyIndex, assayIdentifier);
+      return copy;
+    };
+  }
+  DeregisterAssay(studyIdentifier, assayIdentifier) {
+    const this$ = this;
+    const index = this$.GetStudyIndex(studyIdentifier) | 0;
+    this$.DeregisterAssayAt(index, assayIdentifier);
+  }
+  static deregisterAssay(studyIdentifier, assayIdentifier) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.DeregisterAssay(studyIdentifier, assayIdentifier);
+      return copy;
+    };
+  }
+  DeregisterStudy(studyIdentifier) {
+    const this$ = this;
+    removeInPlace(studyIdentifier, this$.RegisteredStudyIdentifiers, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    });
+  }
+  static deregisterStudy(studyIdentifier) {
+    return (i) => {
+      const copy = i.Copy();
+      copy.DeregisterStudy(studyIdentifier);
+      return copy;
+    };
+  }
+  get WorkflowCount() {
+    const this$ = this;
+    return this$.Workflows.length | 0;
+  }
+  get WorkflowIdentifiers() {
+    const this$ = this;
+    return toArray(map$1((x) => x.Identifier, this$.Workflows));
+  }
+  GetWorkflowIndex(workflowIdentifier) {
+    const this$ = this;
+    const index = this$.Workflows.findIndex((w) => w.Identifier === workflowIdentifier) | 0;
+    if (index === -1) {
+      throw new Error(`Unable to find workflow with specified identifier '${workflowIdentifier}'!`);
+    }
+    return index | 0;
+  }
+  static getWorkflowIndex(workflowIdentifier) {
+    return (inv) => inv.GetWorkflowIndex(workflowIdentifier);
+  }
+  AddWorkflow(workflow) {
+    const this$ = this;
+    const workflow_1 = workflow;
+    const matchValue = tryFindIndex((x) => x.Identifier === workflow_1.Identifier, this$.Workflows);
+    if (matchValue == null) {
+    } else {
+      throw new Error(`Cannot create workflow with name ${workflow_1.Identifier}, as workflow names must be unique and workflow at index ${value(matchValue)} has the same name.`);
+    }
+    workflow.Investigation = this$;
+    void this$.Workflows.push(workflow);
+  }
+  static addWorkflow(workflow) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.AddWorkflow(workflow);
+      return copy;
+    };
+  }
+  InitWorkflow(workflowIdentifier) {
+    const this$ = this;
+    const workflow = ArcWorkflow.init(workflowIdentifier);
+    this$.AddWorkflow(workflow);
+    return workflow;
+  }
+  static initWorkflow(workflowIdentifier) {
+    return (inv) => {
+      const copy = inv.Copy();
+      return copy.InitWorkflow(workflowIdentifier);
+    };
+  }
+  DeleteWorkflowAt(index) {
+    const this$ = this;
+    this$.Workflows.splice(index, 1);
+  }
+  static deleteWorkflowAt(index) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.DeleteWorkflowAt(index);
+      return copy;
+    };
+  }
+  DeleteWorkflow(workflowIdentifier) {
+    const this$ = this;
+    const index = this$.Workflows.findIndex((w) => w.Identifier === workflowIdentifier) | 0;
+    this$.DeleteWorkflowAt(index);
+    iterate((w_1) => {
+      const matchValue = tryFindIndex((swi) => swi === workflowIdentifier, w_1.SubWorkflowIdentifiers);
+      if (matchValue != null) {
+        const swiIndex = value(matchValue) | 0;
+        w_1.SubWorkflowIdentifiers.splice(swiIndex, 1);
+      }
+    }, this$.Workflows);
+    iterate((r) => {
+      const matchValue_1 = tryFindIndex((wi) => wi === workflowIdentifier, r.WorkflowIdentifiers);
+      if (matchValue_1 != null) {
+        const wiIndex = value(matchValue_1) | 0;
+        r.WorkflowIdentifiers.splice(wiIndex, 1);
+      }
+    }, this$.Runs);
+  }
+  static deleteWorkflow(workflowIdentifier) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.DeleteWorkflow(workflowIdentifier);
+      return copy;
+    };
+  }
+  GetWorkflowAt(index) {
+    const this$ = this;
+    return this$.Workflows[index];
+  }
+  static getWorkflowAt(index) {
+    return (inv) => {
+      const copy = inv.Copy();
+      return copy.GetWorkflowAt(index);
+    };
+  }
+  GetWorkflow(workflowIdentifier) {
+    const this$ = this;
+    const matchValue = this$.TryGetWorkflow(workflowIdentifier);
+    if (matchValue == null) {
+      throw new Error(ArcTypesAux_ErrorMsgs_unableToFindWorkflowIdentifier(workflowIdentifier, this$.Identifier));
+    } else {
+      return value(matchValue);
+    }
+  }
+  static getWorkflow(workflowIdentifier) {
+    return (inv) => {
+      const copy = inv.Copy();
+      return copy.GetWorkflow(workflowIdentifier);
+    };
+  }
+  TryGetWorkflow(workflowIdentifier) {
+    const this$ = this;
+    return tryFind((w) => w.Identifier === workflowIdentifier, this$.Workflows);
+  }
+  static tryGetWorkflow(workflowIdentifier) {
+    return (inv) => {
+      const copy = inv.Copy();
+      return copy.TryGetWorkflow(workflowIdentifier);
+    };
+  }
+  ContainsWorkflow(workflowIdentifier) {
+    const this$ = this;
+    return exists((w) => w.Identifier === workflowIdentifier, this$.Workflows);
+  }
+  static containsWorkflow(workflowIdentifier) {
+    return (inv) => inv.ContainsWorkflow(workflowIdentifier);
+  }
+  SetWorkflowAt(index, workflow) {
+    const this$ = this;
+    const workflow_1 = workflow;
+    const matchValue = tryFindIndex((x) => x.Identifier === workflow_1.Identifier, removeAt(index, this$.Workflows));
+    if (matchValue == null) {
+    } else {
+      throw new Error(`Cannot create workflow with name ${workflow_1.Identifier}, as workflow names must be unique and workflow at index ${value(matchValue)} has the same name.`);
+    }
+    workflow.Investigation = this$;
+    this$.Workflows[index] = workflow;
+  }
+  SetWorkflow(workflowIdentifier, workflow) {
+    const this$ = this;
+    const index = this$.GetWorkflowIndex(workflowIdentifier) | 0;
+    this$.SetWorkflowAt(index, workflow);
+  }
+  static setWorkflow(workflowIdentifier, workflow) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.SetWorkflow(workflowIdentifier, workflow);
+      return copy;
+    };
+  }
+  static setWorkflowAt(index, workflow) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.SetWorkflowAt(index, workflow);
+      return copy;
+    };
+  }
+  get RunCount() {
+    const this$ = this;
+    return this$.Runs.length | 0;
+  }
+  get RunIdentifiers() {
+    const this$ = this;
+    return toArray(map$1((x) => x.Identifier, this$.Runs));
+  }
+  GetRunIndex(runIdentifier) {
+    const this$ = this;
+    const index = this$.Runs.findIndex((r) => r.Identifier === runIdentifier) | 0;
+    if (index === -1) {
+      throw new Error(`Unable to find run with specified identifier '${runIdentifier}'!`);
+    }
+    return index | 0;
+  }
+  static getRunIndex(runIdentifier) {
+    return (inv) => inv.GetRunIndex(runIdentifier);
+  }
+  AddRun(run) {
+    const this$ = this;
+    const run_1 = run;
+    const matchValue = tryFindIndex((x) => x.Identifier === run_1.Identifier, this$.Runs);
+    if (matchValue == null) {
+    } else {
+      throw new Error(`Cannot create run with name ${run_1.Identifier}, as run names must be unique and run at index ${value(matchValue)} has the same name.`);
+    }
+    run.Investigation = this$;
+    void this$.Runs.push(run);
+  }
+  static addRun(run) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.AddRun(run);
+      return copy;
+    };
+  }
+  InitRun(runIdentifier) {
+    const this$ = this;
+    const run = ArcRun.init(runIdentifier);
+    this$.AddRun(run);
+    return run;
+  }
+  static initRun(runIdentifier) {
+    return (inv) => {
+      const copy = inv.Copy();
+      return copy.InitRun(runIdentifier);
+    };
+  }
+  DeleteRunAt(index) {
+    const this$ = this;
+    this$.Runs.splice(index, 1);
+  }
+  static deleteRunAt(index) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.DeleteRunAt(index);
+      return copy;
+    };
+  }
+  DeleteRun(runIdentifier) {
+    const this$ = this;
+    const index = this$.Runs.findIndex((w) => w.Identifier === runIdentifier) | 0;
+    this$.DeleteRunAt(index);
+  }
+  static deleteRun(runIdentifier) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.DeleteRun(runIdentifier);
+      return copy;
+    };
+  }
+  GetRunAt(index) {
+    const this$ = this;
+    return this$.Runs[index];
+  }
+  static getRunAt(index) {
+    return (inv) => {
+      const copy = inv.Copy();
+      return copy.GetRunAt(index);
+    };
+  }
+  GetRun(runIdentifier) {
+    const this$ = this;
+    const matchValue = this$.TryGetRun(runIdentifier);
+    if (matchValue == null) {
+      throw new Error(ArcTypesAux_ErrorMsgs_unableToFindRunIdentifier(runIdentifier, this$.Identifier));
+    } else {
+      return value(matchValue);
+    }
+  }
+  static getRun(runIdentifier) {
+    return (inv) => {
+      const copy = inv.Copy();
+      return copy.GetRun(runIdentifier);
+    };
+  }
+  TryGetRun(runIdentifier) {
+    const this$ = this;
+    return tryFind((w) => w.Identifier === runIdentifier, this$.Runs);
+  }
+  static tryGetRun(runIdentifier) {
+    return (inv) => {
+      const copy = inv.Copy();
+      return copy.TryGetRun(runIdentifier);
+    };
+  }
+  ContainsRun(runIdentifier) {
+    const this$ = this;
+    return exists((w) => w.Identifier === runIdentifier, this$.Runs);
+  }
+  static containsRun(runIdentifier) {
+    return (inv) => inv.ContainsRun(runIdentifier);
+  }
+  SetRunAt(index, run) {
+    const this$ = this;
+    const run_1 = run;
+    const matchValue = tryFindIndex((x) => x.Identifier === run_1.Identifier, removeAt(index, this$.Runs));
+    if (matchValue == null) {
+    } else {
+      throw new Error(`Cannot create run with name ${run_1.Identifier}, as run names must be unique and run at index ${value(matchValue)} has the same name.`);
+    }
+    run.Investigation = this$;
+    this$.Runs[index] = run;
+  }
+  SetRun(runIdentifier, run) {
+    const this$ = this;
+    const index = this$.GetRunIndex(runIdentifier) | 0;
+    this$.SetRunAt(index, run);
+  }
+  static setRunAt(index, run) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.SetRunAt(index, run);
+      return copy;
+    };
+  }
+  static setRun(runIdentifier, run) {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.SetRun(runIdentifier, run);
+      return copy;
+    };
+  }
+  GetAllPersons() {
+    const this$ = this;
+    const persons = [];
+    let enumerator = getEnumerator(this$.Assays);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const a = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        addRangeInPlace(a.Performers, persons);
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+    let enumerator_1 = getEnumerator(this$.Studies);
+    try {
+      while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+        const s = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        addRangeInPlace(s.Contacts, persons);
+      }
+    } finally {
+      disposeSafe(enumerator_1);
+    }
+    addRangeInPlace(this$.Contacts, persons);
+    return Array_distinct(Array.from(persons), {
+      Equals: equals,
+      GetHashCode: safeHash
+    });
+  }
+  GetAllPublications() {
+    const this$ = this;
+    const pubs = [];
+    let enumerator = getEnumerator(this$.Studies);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const s = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        addRangeInPlace(s.Publications, pubs);
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+    addRangeInPlace(this$.Publications, pubs);
+    return Array_distinct(Array.from(pubs), {
+      Equals: equals,
+      GetHashCode: safeHash
+    });
+  }
+  DeregisterMissingAssays() {
+    const this$ = this;
+    const inv = this$;
+    const existingAssays = inv.AssayIdentifiers;
+    let enumerator = getEnumerator(inv.Studies);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const study = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        const rai = study.RegisteredAssayIdentifiers;
+        let enumerator_1 = getEnumerator(Array.from(rai));
+        try {
+          while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+            const registeredAssay = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (!contains(registeredAssay, existingAssays, {
+              Equals: (x, y) => x === y,
+              GetHashCode: stringHash
+            })) {
+              const value_1 = study.DeregisterAssay(registeredAssay);
+            }
+          }
+        } finally {
+          disposeSafe(enumerator_1);
+        }
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+  }
+  static deregisterMissingAssays() {
+    return (inv) => {
+      const copy = inv.Copy();
+      copy.DeregisterMissingAssays();
+      return copy;
+    };
+  }
+  UpdateIOTypeByEntityID() {
+    let collection;
+    const this$ = this;
+    const ioMap = ArcTablesAux_getIOMap((collection = toList(delay(() => append(collect((study) => study.Tables, this$.Studies), delay(() => append(collect((assay) => assay.Tables, this$.Assays), delay(() => collect((run) => run.Tables, this$.Runs))))))), Array.from(collection)));
+    let enumerator = getEnumerator(this$.Studies);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const study_1 = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        ArcTablesAux_applyIOMap(ioMap, study_1.Tables);
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+    let enumerator_1 = getEnumerator(this$.Assays);
+    try {
+      while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+        const assay_1 = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        ArcTablesAux_applyIOMap(ioMap, assay_1.Tables);
+      }
+    } finally {
+      disposeSafe(enumerator_1);
+    }
+    let enumerator_2 = getEnumerator(this$.Runs);
+    try {
+      while (enumerator_2["System.Collections.IEnumerator.MoveNext"]()) {
+        const run_1 = enumerator_2["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        ArcTablesAux_applyIOMap(ioMap, run_1.Tables);
+      }
+    } finally {
+      disposeSafe(enumerator_2);
+    }
+  }
+  Copy() {
+    const this$ = this;
+    const nextAssays = [];
+    const nextStudies = [];
+    const nextWorkflows = [];
+    const nextRuns = [];
+    let enumerator = getEnumerator(this$.Assays);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const assay = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        const copy = assay.Copy();
+        void nextAssays.push(copy);
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+    let enumerator_1 = getEnumerator(this$.Studies);
+    try {
+      while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+        const study = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        const copy_1 = study.Copy();
+        void nextStudies.push(copy_1);
+      }
+    } finally {
+      disposeSafe(enumerator_1);
+    }
+    let enumerator_2 = getEnumerator(this$.Workflows);
+    try {
+      while (enumerator_2["System.Collections.IEnumerator.MoveNext"]()) {
+        const workflow = enumerator_2["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        const copy_2 = workflow.Copy();
+        void nextWorkflows.push(copy_2);
+      }
+    } finally {
+      disposeSafe(enumerator_2);
+    }
+    let enumerator_3 = getEnumerator(this$.Runs);
+    try {
+      while (enumerator_3["System.Collections.IEnumerator.MoveNext"]()) {
+        const run = enumerator_3["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        const copy_3 = run.Copy();
+        void nextRuns.push(copy_3);
+      }
+    } finally {
+      disposeSafe(enumerator_3);
+    }
+    const nextComments = ResizeArray_map((c) => c.Copy(), this$.Comments);
+    const nextRemarks = ResizeArray_map((c_1) => c_1.Copy(), this$.Remarks);
+    const nextContacts = ResizeArray_map((c_2) => c_2.Copy(), this$.Contacts);
+    const nextPublications = ResizeArray_map((c_3) => c_3.Copy(), this$.Publications);
+    const nextOntologySourceReferences = ResizeArray_map((c_4) => c_4.Copy(), this$.OntologySourceReferences);
+    const nextStudyIdentifiers = Array.from(this$.RegisteredStudyIdentifiers);
+    return new ArcInvestigation(this$.Identifier, unwrap(this$.Title), unwrap(this$.Description), unwrap(this$.SubmissionDate), unwrap(this$.PublicReleaseDate), nextOntologySourceReferences, nextPublications, nextContacts, nextAssays, nextStudies, nextWorkflows, nextRuns, nextStudyIdentifiers, nextComments, nextRemarks);
+  }
+  StructurallyEquals(other) {
+    let a, b, a_1, b_1, a_2, b_2, a_3, b_3, a_4, b_4, a_5, b_5, a_6, b_6, a_7, b_7, a_8, b_8, a_9, b_9;
+    const this$ = this;
+    return forAll((x) => x === true, [this$.Identifier === other.Identifier, equals(this$.Title, other.Title), equals(this$.Description, other.Description), equals(this$.SubmissionDate, other.SubmissionDate), equals(this$.PublicReleaseDate, other.PublicReleaseDate), (a = this$.Publications, b = other.Publications, length(a) === length(b) && fold((acc, e) => {
+      if (acc) {
+        return e;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_1) => equals(item(i_1, a), item(i_1, b)), rangeDouble(0, 1, length(a) - 1)))))), (a_1 = this$.Contacts, b_1 = other.Contacts, length(a_1) === length(b_1) && fold((acc_1, e_1) => {
+      if (acc_1) {
+        return e_1;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_2) => equals(item(i_2, a_1), item(i_2, b_1)), rangeDouble(0, 1, length(a_1) - 1)))))), (a_2 = this$.OntologySourceReferences, b_2 = other.OntologySourceReferences, length(a_2) === length(b_2) && fold((acc_2, e_2) => {
+      if (acc_2) {
+        return e_2;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_3) => equals(item(i_3, a_2), item(i_3, b_2)), rangeDouble(0, 1, length(a_2) - 1)))))), (a_3 = this$.Assays, b_3 = other.Assays, length(a_3) === length(b_3) && fold((acc_3, e_3) => {
+      if (acc_3) {
+        return e_3;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_4) => equals(item(i_4, a_3), item(i_4, b_3)), rangeDouble(0, 1, length(a_3) - 1)))))), (a_4 = this$.Studies, b_4 = other.Studies, length(a_4) === length(b_4) && fold((acc_4, e_4) => {
+      if (acc_4) {
+        return e_4;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_5) => equals(item(i_5, a_4), item(i_5, b_4)), rangeDouble(0, 1, length(a_4) - 1)))))), (a_5 = this$.Workflows, b_5 = other.Workflows, length(a_5) === length(b_5) && fold((acc_5, e_5) => {
+      if (acc_5) {
+        return e_5;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_6) => equals(item(i_6, a_5), item(i_6, b_5)), rangeDouble(0, 1, length(a_5) - 1)))))), (a_6 = this$.Runs, b_6 = other.Runs, length(a_6) === length(b_6) && fold((acc_6, e_6) => {
+      if (acc_6) {
+        return e_6;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_7) => equals(item(i_7, a_6), item(i_7, b_6)), rangeDouble(0, 1, length(a_6) - 1)))))), (a_7 = this$.RegisteredStudyIdentifiers, b_7 = other.RegisteredStudyIdentifiers, length(a_7) === length(b_7) && fold((acc_7, e_7) => {
+      if (acc_7) {
+        return e_7;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_8) => item(i_8, a_7) === item(i_8, b_7), rangeDouble(0, 1, length(a_7) - 1)))))), (a_8 = this$.Comments, b_8 = other.Comments, length(a_8) === length(b_8) && fold((acc_8, e_8) => {
+      if (acc_8) {
+        return e_8;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_9) => equals(item(i_9, a_8), item(i_9, b_8)), rangeDouble(0, 1, length(a_8) - 1)))))), (a_9 = this$.Remarks, b_9 = other.Remarks, length(a_9) === length(b_9) && fold((acc_9, e_9) => {
+      if (acc_9) {
+        return e_9;
+      } else {
+        return false;
+      }
+    }, true, toList(delay(() => map$1((i_10) => equals(item(i_10, a_9), item(i_10, b_9)), rangeDouble(0, 1, length(a_9) - 1))))))]);
+  }
+  ReferenceEquals(other) {
+    const this$ = this;
+    return this$ === other;
+  }
+  toString() {
+    const this$ = this;
+    const arg = this$.Identifier;
+    const arg_1 = this$.Title;
+    const arg_2 = this$.Description;
+    const arg_3 = this$.SubmissionDate;
+    const arg_4 = this$.PublicReleaseDate;
+    const arg_5 = this$.OntologySourceReferences;
+    const arg_6 = this$.Publications;
+    const arg_7 = this$.Contacts;
+    const arg_8 = this$.Assays;
+    const arg_9 = this$.Studies;
+    const arg_10 = this$.Workflows;
+    const arg_11 = this$.Runs;
+    const arg_12 = this$.RegisteredStudyIdentifiers;
+    const arg_13 = this$.Comments;
+    const arg_14 = this$.Remarks;
+    return toText(printf("ArcInvestigation {\r\n    Identifier = %A,\r\n    Title = %A,\r\n    Description = %A,\r\n    SubmissionDate = %A,\r\n    PublicReleaseDate = %A,\r\n    OntologySourceReferences = %A,\r\n    Publications = %A,\r\n    Contacts = %A,\r\n    Assays = %A,\r\n    Studies = %A,\r\n    Workflows = %A,\r\n    Runs = %A,\r\n    RegisteredStudyIdentifiers = %A,\r\n    Comments = %A,\r\n    Remarks = %A,\r\n}"))(arg)(arg_1)(arg_2)(arg_3)(arg_4)(arg_5)(arg_6)(arg_7)(arg_8)(arg_9)(arg_10)(arg_11)(arg_12)(arg_13)(arg_14);
+  }
+  Equals(other) {
+    let i;
+    const this$ = this;
+    return other instanceof ArcInvestigation && (i = other, this$.StructurallyEquals(i));
+  }
+  GetHashCode() {
+    const this$ = this;
+    return boxHashArray([this$.Identifier, boxHashOption(this$.Title), boxHashOption(this$.Description), boxHashOption(this$.SubmissionDate), boxHashOption(this$.PublicReleaseDate), boxHashSeq(this$.Publications), boxHashSeq(this$.Contacts), boxHashSeq(this$.OntologySourceReferences), boxHashSeq(this$.Assays), boxHashSeq(this$.Studies), boxHashSeq(this$.Workflows), boxHashSeq(this$.Runs), boxHashSeq(this$.RegisteredStudyIdentifiers), boxHashSeq(this$.Comments), boxHashSeq(this$.Remarks)]) | 0;
+  }
+  GetLightHashCode() {
+    const this$ = this;
+    return boxHashArray([this$.Identifier, boxHashOption(this$.Title), boxHashOption(this$.Description), boxHashOption(this$.SubmissionDate), boxHashOption(this$.PublicReleaseDate), boxHashSeq(this$.Publications), boxHashSeq(this$.Contacts), boxHashSeq(this$.OntologySourceReferences), boxHashSeq(this$.RegisteredStudyIdentifiers), boxHashSeq(this$.Comments), boxHashSeq(this$.Remarks)]) | 0;
+  }
+}
+function ArcInvestigation_$reflection() {
+  return class_type("ARCtrl.ArcInvestigation", void 0, ArcInvestigation);
+}
+function ArcInvestigation_$ctor_Z67823F6C(identifier, title, description, submissionDate, publicReleaseDate, ontologySourceReferences, publications, contacts, assays, studies, workflows, runs, registeredStudyIdentifiers, comments, remarks) {
+  return new ArcInvestigation(identifier, title, description, submissionDate, publicReleaseDate, ontologySourceReferences, publications, contacts, assays, studies, workflows, runs, registeredStudyIdentifiers, comments, remarks);
+}
+function ArcTypesAux_ErrorMsgs_unableToFindAssayIdentifier(assayIdentifier, investigationIdentifier) {
+  return `Error. Unable to find assay with identifier '${assayIdentifier}' in investigation ${investigationIdentifier}.`;
+}
+function ArcTypesAux_ErrorMsgs_unableToFindStudyIdentifier(studyIdentifer, investigationIdentifier) {
+  return `Error. Unable to find study with identifier '${studyIdentifer}' in investigation ${investigationIdentifier}.`;
+}
+function ArcTypesAux_ErrorMsgs_unableToFindWorkflowIdentifier(workflowIdentifier, investigationIdentifier) {
+  return `Error. Unable to find workflow with identifier '${workflowIdentifier}' in investigation ${investigationIdentifier}.`;
+}
+function ArcTypesAux_ErrorMsgs_unableToFindRunIdentifier(runIdentifier, investigationIdentifier) {
+  return `Error. Unable to find run with identifier '${runIdentifier}' in investigation ${investigationIdentifier}.`;
+}
+
+export { ArcAssay, ArcAssay_$ctor_11E1F34, ArcAssay_$reflection, ArcInvestigation, ArcInvestigation_$ctor_Z67823F6C, ArcInvestigation_$reflection, ArcRun, ArcRun_$ctor_Z38E7054B, ArcRun_$reflection, ArcStudy, ArcStudy_$ctor_64321D5B, ArcStudy_$reflection, ArcTypesAux_ErrorMsgs_unableToFindAssayIdentifier, ArcTypesAux_ErrorMsgs_unableToFindRunIdentifier, ArcTypesAux_ErrorMsgs_unableToFindStudyIdentifier, ArcTypesAux_ErrorMsgs_unableToFindWorkflowIdentifier, ArcWorkflow, ArcWorkflow_$ctor_Z3BB02240, ArcWorkflow_$reflection };