@nfdi4plants/arctrl 1.0.0-alpha8 → 1.0.0-beta.1

package/ISA/ISA/ArcTypes/ArcTables.js

@@ -1,16 +1,17 @@
-import { append, toArray, reduce, choose, map, delay, toList, length, tryFindIndex } from "../../../fable_modules/fable-library.4.1.4/Seq.js";
-import { equals, comparePrimitives, stringHash, compare } from "../../../fable_modules/fable-library.4.1.4/Util.js";
+import { append, toArray, reduce, choose, map as map_1, delay, toList, length, findIndex, tryFindIndex } from "../../../fable_modules/fable-library.4.1.4/Seq.js";
+import { Dict_tryFind } from "../Helper.js";
+import { addToSet, addToDict } from "../../../fable_modules/fable-library.4.1.4/MapUtil.js";
+import { toIterator, equals, comparePrimitives, stringHash, compare, disposeSafe, getEnumerator } from "../../../fable_modules/fable-library.4.1.4/Util.js";
+import { bind, map as map_3, unwrap, defaultArg, value as value_2 } from "../../../fable_modules/fable-library.4.1.4/Option.js";
+import { collect as collect_1, map as map_4, insertRangeInPlace, fold } from "../../../fable_modules/fable-library.4.1.4/Array.js";
+import { CompositeHeader } from "./CompositeHeader.js";
 import { Array_groupBy, distinct } from "../../../fable_modules/fable-library.4.1.4/Seq2.js";
 import { FSharpSet__get_IsEmpty, ofSeq, intersect } from "../../../fable_modules/fable-library.4.1.4/Set.js";
-import { class_type } from "../../../fable_modules/fable-library.4.1.4/Reflection.js";
-import { bind, map as map_2, unwrap, defaultArg } from "../../../fable_modules/fable-library.4.1.4/Option.js";
-import { collect as collect_1, map as map_3, insertRangeInPlace } from "../../../fable_modules/fable-library.4.1.4/Array.js";
 import { ArcTable } from "./ArcTable.js";
-import { map as map_1, collect } from "../../../fable_modules/fable-library.4.1.4/List.js";
+import { map as map_2, collect } from "../../../fable_modules/fable-library.4.1.4/List.js";
 import { Unchecked_fillMissingCells, ProcessParsing_groupProcesses, ProcessParsing_processToRows, ProcessParsing_alignByHeaders } from "./ArcTableAux.js";
 import { tryFind, ofSeq as ofSeq_1 } from "../../../fable_modules/fable-library.4.1.4/Map.js";
-import { CompositeHeader } from "./CompositeHeader.js";
-import { addToSet } from "../../../fable_modules/fable-library.4.1.4/MapUtil.js";
+import { class_type } from "../../../fable_modules/fable-library.4.1.4/Reflection.js";
 
 /**
  * If a table with the given name exists in the TableList, returns it, else returns None.
@@ -32,6 +33,104 @@ export function ArcTablesAux_findIndexByTableName(name, tables) {
     }
 }
 
+/**
+ * Collects the IOType of each distinct entity in the tables. Then merges the IOType of each entity according to the IOType.Merge function.
+ */
+export function ArcTablesAux_getIOMap(tables) {
+    const mappings = new Map([]);
+    const includeInMap = (name, ioType) => {
+        if (name !== "") {
+            const matchValue = Dict_tryFind(name, mappings);
+            if (matchValue == null) {
+                addToDict(mappings, name, ioType);
+            }
+            else {
+                const oldIOType = matchValue;
+                const newIOType = oldIOType.Merge(ioType);
+                mappings.set(name, newIOType);
+            }
+        }
+    };
+    let enumerator = getEnumerator(tables);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const table = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            const matchValue_1 = table.TryGetInputColumn();
+            if (matchValue_1 == null) {
+            }
+            else {
+                const ic = matchValue_1;
+                const ioType_1 = value_2(ic.Header.tryInput());
+                ic.Cells.forEach((c) => {
+                    includeInMap(c.ToFreeTextCell().AsFreeText, ioType_1);
+                });
+            }
+            const matchValue_2 = table.TryGetOutputColumn();
+            if (matchValue_2 == null) {
+            }
+            else {
+                const oc = matchValue_2;
+                const ioType_2 = value_2(oc.Header.tryOutput());
+                oc.Cells.forEach((c_1) => {
+                    includeInMap(c_1.ToFreeTextCell().AsFreeText, ioType_2);
+                });
+            }
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    return mappings;
+}
+
+export function ArcTablesAux_applyIOMap(map, tables) {
+    let enumerator = getEnumerator(tables);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const table = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            const matchValue = table.TryGetInputColumn();
+            if (matchValue == null) {
+            }
+            else {
+                const ic = matchValue;
+                const index = findIndex((x) => x.isInput, table.Headers) | 0;
+                const newIOType = fold((io, c) => {
+                    const matchValue_1 = Dict_tryFind(c.ToFreeTextCell().AsFreeText, map);
+                    if (matchValue_1 == null) {
+                        return io;
+                    }
+                    else {
+                        const newIO = matchValue_1;
+                        return io.Merge(newIO);
+                    }
+                }, value_2(ic.Header.tryInput()), ic.Cells);
+                table.UpdateHeader(index, new CompositeHeader(11, [newIOType]));
+            }
+            const matchValue_2 = table.TryGetOutputColumn();
+            if (matchValue_2 == null) {
+            }
+            else {
+                const oc = matchValue_2;
+                const index_1 = findIndex((x_1) => x_1.isOutput, table.Headers) | 0;
+                const newIOType_1 = fold((io_1, c_1) => {
+                    const matchValue_3 = Dict_tryFind(c_1.ToFreeTextCell().AsFreeText, map);
+                    if (matchValue_3 == null) {
+                        return io_1;
+                    }
+                    else {
+                        const newIO_1 = matchValue_3;
+                        return io_1.Merge(newIO_1);
+                    }
+                }, value_2(oc.Header.tryOutput()), oc.Cells);
+                table.UpdateHeader(index_1, new CompositeHeader(12, [newIOType_1]));
+            }
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+}
+
 /**
  * Fails, if the index is out of range of the Tables collection. When allowAppend is set to true, it may be out of range by at most 1.
  */
@@ -100,281 +199,285 @@ export function ArcTablesAux_SanityChecks_validateNewNamesUnique(newNames, exist
 }
 
 export class ArcTables {
-    constructor(thisTables) {
-        this.thisTables = thisTables;
+    constructor(initTables) {
+        this["Tables@"] = initTables;
     }
-}
-
-export function ArcTables_$reflection() {
-    return class_type("ARCtrl.ISA.ArcTables", void 0, ArcTables);
-}
-
-export function ArcTables_$ctor_Z18C2F36D(thisTables) {
-    return new ArcTables(thisTables);
-}
-
-export function ArcTables__get_Count(this$) {
-    return this$.thisTables.length;
-}
-
-export function ArcTables__get_TableNames(this$) {
-    return toList(delay(() => map((s) => s.Name, this$.thisTables)));
-}
-
-export function ArcTables__get_Tables(this$) {
-    return this$.thisTables;
-}
-
-export function ArcTables__get_Item_Z524259A4(this$, index) {
-    return this$.thisTables[index];
-}
-
-export function ArcTables__AddTable_EC12B15(this$, table, index) {
-    const index_1 = defaultArg(index, ArcTables__get_Count(this$)) | 0;
-    ArcTablesAux_SanityChecks_validateSheetIndex(index_1, true, this$.thisTables);
-    ArcTablesAux_SanityChecks_validateNewNameUnique(table.Name, ArcTables__get_TableNames(this$));
-    this$.thisTables.splice(index_1, 0, table);
-}
-
-export function ArcTables__AddTables_Z2D453886(this$, tables, index) {
-    const index_1 = defaultArg(index, ArcTables__get_Count(this$)) | 0;
-    ArcTablesAux_SanityChecks_validateSheetIndex(index_1, true, this$.thisTables);
-    ArcTablesAux_SanityChecks_validateNewNamesUnique(map((x) => x.Name, tables), ArcTables__get_TableNames(this$));
-    insertRangeInPlace(index_1, tables, this$.thisTables);
-}
-
-export function ArcTables__InitTable_3B406CA4(this$, tableName, index) {
-    const index_1 = defaultArg(index, ArcTables__get_Count(this$)) | 0;
-    const table = ArcTable.init(tableName);
-    ArcTablesAux_SanityChecks_validateSheetIndex(index_1, true, this$.thisTables);
-    ArcTablesAux_SanityChecks_validateNewNameUnique(table.Name, ArcTables__get_TableNames(this$));
-    this$.thisTables.splice(index_1, 0, table);
-    return table;
-}
-
-export function ArcTables__InitTables_7B28792B(this$, tableNames, index) {
-    const index_1 = defaultArg(index, ArcTables__get_Count(this$)) | 0;
-    const tables = map((x) => ArcTable.init(x), tableNames);
-    ArcTablesAux_SanityChecks_validateSheetIndex(index_1, true, this$.thisTables);
-    ArcTablesAux_SanityChecks_validateNewNamesUnique(map((x_1) => x_1.Name, tables), ArcTables__get_TableNames(this$));
-    insertRangeInPlace(index_1, tables, this$.thisTables);
-}
-
-export function ArcTables__GetTableAt_Z524259A4(this$, index) {
-    ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.thisTables);
-    return this$.thisTables[index];
-}
-
-export function ArcTables__GetTable_Z721C83C5(this$, name) {
-    return ArcTables__GetTableAt_Z524259A4(this$, ArcTablesAux_findIndexByTableName(name, this$.thisTables));
-}
-
-export function ArcTables__UpdateTableAt_7E571736(this$, index, table) {
-    ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.thisTables);
-    ArcTablesAux_SanityChecks_validateNewNameAtUnique(index, table.Name, ArcTables__get_TableNames(this$));
-    this$.thisTables[index] = table;
-}
-
-export function ArcTables__UpdateTable_51766571(this$, name, table) {
-    const tupledArg = [ArcTablesAux_findIndexByTableName(name, this$.thisTables), table];
-    ArcTables__UpdateTableAt_7E571736(this$, tupledArg[0], tupledArg[1]);
-}
-
-export function ArcTables__SetTableAt_7E571736(this$, index, table) {
-    ArcTablesAux_SanityChecks_validateSheetIndex(index, true, this$.thisTables);
-    ArcTablesAux_SanityChecks_validateNewNameAtUnique(index, table.Name, ArcTables__get_TableNames(this$));
-    this$.thisTables[index] = table;
-}
-
-export function ArcTables__SetTable_51766571(this$, name, table) {
-    const matchValue = ArcTablesAux_tryFindIndexByTableName(name, this$.thisTables);
-    if (matchValue == null) {
-        ArcTables__AddTable_EC12B15(this$, table);
+    get Tables() {
+        const __ = this;
+        return __["Tables@"];
     }
-    else {
-        ArcTables__SetTableAt_7E571736(this$, matchValue, table);
+    set Tables(v) {
+        const __ = this;
+        __["Tables@"] = v;
     }
-}
-
-export function ArcTables__RemoveTableAt_Z524259A4(this$, index) {
-    ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.thisTables);
-    this$.thisTables.splice(index, 1);
-}
-
-export function ArcTables__RemoveTable_Z721C83C5(this$, name) {
-    ArcTables__RemoveTableAt_Z524259A4(this$, ArcTablesAux_findIndexByTableName(name, this$.thisTables));
-}
-
-export function ArcTables__MapTableAt_8FC095C(this$, index, updateFun) {
-    ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.thisTables);
-    updateFun(this$.thisTables[index]);
-}
-
-export function ArcTables__MapTable_27DD7B1B(this$, name, updateFun) {
-    const tupledArg = [ArcTablesAux_findIndexByTableName(name, this$.thisTables), updateFun];
-    ArcTables__MapTableAt_8FC095C(this$, tupledArg[0], tupledArg[1]);
-}
-
-export function ArcTables__RenameTableAt_Z176EF219(this$, index, newName) {
-    ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.thisTables);
-    ArcTablesAux_SanityChecks_validateNewNameUnique(newName, ArcTables__get_TableNames(this$));
-    const table = ArcTables__GetTableAt_Z524259A4(this$, index);
-    table.Name = newName;
-}
-
-export function ArcTables__RenameTable_Z384F8060(this$, name, newName) {
-    const tupledArg = [ArcTablesAux_findIndexByTableName(name, this$.thisTables), newName];
-    ArcTables__RenameTableAt_Z176EF219(this$, tupledArg[0], tupledArg[1]);
-}
-
-export function ArcTables__AddColumnAt_6A9784DB(this$, tableIndex, header, cells, columnIndex, forceReplace) {
-    ArcTables__MapTableAt_8FC095C(this$, tableIndex, (table) => {
-        table.AddColumn(header, unwrap(cells), unwrap(columnIndex), unwrap(forceReplace));
-    });
-}
-
-export function ArcTables__AddColumn_1FF50D3C(this$, tableName, header, cells, columnIndex, forceReplace) {
-    ArcTables__AddColumnAt_6A9784DB(this$, ArcTablesAux_findIndexByTableName(tableName, this$.thisTables), header, unwrap(cells), unwrap(columnIndex), unwrap(forceReplace));
-}
-
-export function ArcTables__RemoveColumnAt_Z37302880(this$, tableIndex, columnIndex) {
-    ArcTables__MapTableAt_8FC095C(this$, tableIndex, (table) => {
-        table.RemoveColumn(columnIndex);
-    });
-}
-
-export function ArcTables__RemoveColumn_Z18115A39(this$, tableName, columnIndex) {
-    const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.thisTables), columnIndex];
-    ArcTables__RemoveColumnAt_Z37302880(this$, tupledArg[0], tupledArg[1]);
-}
-
-export function ArcTables__UpdateColumnAt_21300791(this$, tableIndex, columnIndex, header, cells) {
-    ArcTables__MapTableAt_8FC095C(this$, tableIndex, (table) => {
-        table.UpdateColumn(columnIndex, header, unwrap(cells));
-    });
-}
-
-export function ArcTables__UpdateColumn_Z6083042A(this$, tableName, columnIndex, header, cells) {
-    ArcTables__UpdateColumnAt_21300791(this$, ArcTablesAux_findIndexByTableName(tableName, this$.thisTables), columnIndex, header, unwrap(cells));
-}
-
-export function ArcTables__GetColumnAt_Z37302880(this$, tableIndex, columnIndex) {
-    const table = ArcTables__GetTableAt_Z524259A4(this$, tableIndex);
-    return table.GetColumn(columnIndex);
-}
-
-export function ArcTables__GetColumn_Z18115A39(this$, tableName, columnIndex) {
-    const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.thisTables), columnIndex];
-    return ArcTables__GetColumnAt_Z37302880(this$, tupledArg[0], tupledArg[1]);
-}
-
-export function ArcTables__AddRowAt_Z12CDB784(this$, tableIndex, cells, rowIndex) {
-    ArcTables__MapTableAt_8FC095C(this$, tableIndex, (table) => {
-        table.AddRow(unwrap(cells), unwrap(rowIndex));
-    });
-}
-
-export function ArcTables__AddRow_Z16315DE5(this$, tableName, cells, rowIndex) {
-    ArcTables__AddRowAt_Z12CDB784(this$, ArcTablesAux_findIndexByTableName(tableName, this$.thisTables), unwrap(cells), unwrap(rowIndex));
-}
-
-export function ArcTables__RemoveRowAt_Z37302880(this$, tableIndex, rowIndex) {
-    ArcTables__MapTableAt_8FC095C(this$, tableIndex, (table) => {
-        table.RemoveRow(rowIndex);
-    });
-}
-
-export function ArcTables__RemoveRow_Z18115A39(this$, tableName, rowIndex) {
-    const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.thisTables), rowIndex];
-    ArcTables__RemoveRowAt_Z37302880(this$, tupledArg[0], tupledArg[1]);
-}
-
-export function ArcTables__UpdateRowAt_1CF7B5DC(this$, tableIndex, rowIndex, cells) {
-    ArcTables__MapTableAt_8FC095C(this$, tableIndex, (table) => {
-        table.UpdateRow(rowIndex, cells);
-    });
-}
-
-export function ArcTables__UpdateRow_1BFE2CFB(this$, tableName, rowIndex, cells) {
-    const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.thisTables), rowIndex, cells];
-    ArcTables__UpdateRowAt_1CF7B5DC(this$, tupledArg[0], tupledArg[1], tupledArg[2]);
-}
-
-export function ArcTables__GetRowAt_Z37302880(this$, tableIndex, rowIndex) {
-    const table = ArcTables__GetTableAt_Z524259A4(this$, tableIndex);
-    return table.GetRow(rowIndex);
-}
-
-export function ArcTables__GetRow_Z18115A39(this$, tableName, rowIndex) {
-    const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.thisTables), rowIndex];
-    return ArcTables__GetRowAt_Z37302880(this$, tupledArg[0], tupledArg[1]);
-}
-
-/**
- * Return a list of all the processes in all the tables.
- */
-export function ArcTables__GetProcesses(this$) {
-    return collect((t) => t.GetProcesses(), toList(ArcTables__get_Tables(this$)));
-}
-
-export function ArcTables_ofSeq_3B4333A5(tables) {
-    return ArcTables_$ctor_Z18C2F36D(Array.from(tables));
-}
-
-/**
- * Create a collection of tables from a list of processes.
- * 
- * For this, the processes are grouped by nameroot ("nameroot_1", "nameroot_2" ...) or exectued protocol if no name exists
- * 
- * Then each group is converted to a table with this nameroot as sheetname
- */
-export function ArcTables_fromProcesses_134EBDED(ps) {
-    let arg;
-    return ArcTables_$ctor_Z18C2F36D((arg = map_1((tupledArg) => {
-        const tupledArg_1 = ProcessParsing_alignByHeaders(true, collect(ProcessParsing_processToRows, tupledArg[1]));
-        return ArcTable.create(tupledArg[0], tupledArg_1[0], tupledArg_1[1]);
-    }, ProcessParsing_groupProcesses(ps)), Array.from(arg)));
-}
-
-export function ArcTables_updateReferenceTablesBySheets_Z2EE88E97(referenceTables, sheetTables, keepUnusedRefTables) {
-    let arg_4, s, array;
-    const keepUnusedRefTables_1 = defaultArg(keepUnusedRefTables, false);
-    const usedTables = new Set([]);
-    const referenceTableMap = ofSeq_1(choose((t) => map_2((c) => [c.Cells[0].AsFreeText, t], t.TryGetProtocolNameColumn()), ArcTables__get_Tables(referenceTables)), {
-        Compare: comparePrimitives,
-    });
-    return ArcTables_$ctor_Z18C2F36D((arg_4 = ((s = map_3((t_3) => {
-        Unchecked_fillMissingCells(t_3.Headers, t_3.Values);
-        return t_3;
-    }, map_3((tupledArg) => reduce((arg_2, arg_3) => ArcTable.append(arg_2, arg_3), tupledArg[1]), Array_groupBy((t_2) => t_2.Name, map_3((t_1) => {
-        const k = defaultArg(bind((c_1) => {
-            if (c_1.AsFreeText === "") {
-                return void 0;
-            }
-            else {
-                return c_1.AsFreeText;
-            }
-        }, bind((i) => t_1.TryGetCellAt(i, 0), tryFindIndex((x_1) => equals(x_1, new CompositeHeader(8, [])), t_1.Headers))), t_1.Name);
-        const matchValue = tryFind(k, referenceTableMap);
+    get TableNames() {
+        const this$ = this;
+        return toList(delay(() => map_1((s) => s.Name, this$.Tables)));
+    }
+    get TableCount() {
+        const this$ = this;
+        return this$.Tables.length | 0;
+    }
+    AddTable(table, index) {
+        const this$ = this;
+        const index_1 = defaultArg(index, this$.TableCount) | 0;
+        ArcTablesAux_SanityChecks_validateSheetIndex(index_1, true, this$.Tables);
+        ArcTablesAux_SanityChecks_validateNewNameUnique(table.Name, this$.TableNames);
+        this$.Tables.splice(index_1, 0, table);
+    }
+    AddTables(tables, index) {
+        const this$ = this;
+        const index_1 = defaultArg(index, this$.TableCount) | 0;
+        ArcTablesAux_SanityChecks_validateSheetIndex(index_1, true, this$.Tables);
+        ArcTablesAux_SanityChecks_validateNewNamesUnique(map_1((x) => x.Name, tables), this$.TableNames);
+        insertRangeInPlace(index_1, tables, this$.Tables);
+    }
+    InitTable(tableName, index) {
+        const this$ = this;
+        const index_1 = defaultArg(index, this$.TableCount) | 0;
+        const table = ArcTable.init(tableName);
+        ArcTablesAux_SanityChecks_validateSheetIndex(index_1, true, this$.Tables);
+        ArcTablesAux_SanityChecks_validateNewNameUnique(table.Name, this$.TableNames);
+        this$.Tables.splice(index_1, 0, table);
+        return table;
+    }
+    InitTables(tableNames, index) {
+        const this$ = this;
+        const index_1 = defaultArg(index, this$.TableCount) | 0;
+        const tables = map_1((x) => ArcTable.init(x), tableNames);
+        ArcTablesAux_SanityChecks_validateSheetIndex(index_1, true, this$.Tables);
+        ArcTablesAux_SanityChecks_validateNewNamesUnique(map_1((x_1) => x_1.Name, tables), this$.TableNames);
+        insertRangeInPlace(index_1, tables, this$.Tables);
+    }
+    GetTableAt(index) {
+        const this$ = this;
+        ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.Tables);
+        return this$.Tables[index];
+    }
+    GetTable(name) {
+        const this$ = this;
+        const arg = ArcTablesAux_findIndexByTableName(name, this$.Tables) | 0;
+        return this$.GetTableAt(arg);
+    }
+    UpdateTableAt(index, table) {
+        const this$ = this;
+        ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.Tables);
+        ArcTablesAux_SanityChecks_validateNewNameAtUnique(index, table.Name, this$.TableNames);
+        this$.Tables[index] = table;
+    }
+    UpdateTable(name, table) {
+        const this$ = this;
+        const tupledArg = [ArcTablesAux_findIndexByTableName(name, this$.Tables), table];
+        this$.UpdateTableAt(tupledArg[0], tupledArg[1]);
+    }
+    SetTableAt(index, table) {
+        const this$ = this;
+        ArcTablesAux_SanityChecks_validateSheetIndex(index, true, this$.Tables);
+        ArcTablesAux_SanityChecks_validateNewNameAtUnique(index, table.Name, this$.TableNames);
+        this$.Tables[index] = table;
+    }
+    SetTable(name, table) {
+        const this$ = this;
+        const matchValue = ArcTablesAux_tryFindIndexByTableName(name, this$.Tables);
         if (matchValue == null) {
-            return t_1;
+            this$.AddTable(table);
         }
         else {
-            const rt = matchValue;
-            addToSet(k, usedTables);
-            const updatedTable = ArcTable.updateReferenceByAnnotationTable(rt, t_1);
-            return ArcTable.create(t_1.Name, updatedTable.Headers, updatedTable.Values);
+            const index = matchValue | 0;
+            this$.SetTableAt(index, table);
         }
-    }, (array = toArray(ArcTables__get_Tables(sheetTables)), collect_1(ArcTable.SplitByProtocolREF, array))), {
-        Equals: (x_2, y_1) => (x_2 === y_1),
-        GetHashCode: stringHash,
-    }))), keepUnusedRefTables_1 ? append(choose((kv) => {
-        if (usedTables.has(kv[0])) {
-            return void 0;
-        }
-        else {
-            return kv[1];
-        }
-    }, referenceTableMap), s) : s)), Array.from(arg_4)));
+    }
+    RemoveTableAt(index) {
+        const this$ = this;
+        ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.Tables);
+        this$.Tables.splice(index, 1);
+    }
+    RemoveTable(name) {
+        const this$ = this;
+        const arg = ArcTablesAux_findIndexByTableName(name, this$.Tables) | 0;
+        this$.RemoveTableAt(arg);
+    }
+    MapTableAt(index, updateFun) {
+        const this$ = this;
+        ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.Tables);
+        updateFun(this$.Tables[index]);
+    }
+    MapTable(name, updateFun) {
+        const this$ = this;
+        const tupledArg = [ArcTablesAux_findIndexByTableName(name, this$.Tables), updateFun];
+        this$.MapTableAt(tupledArg[0], tupledArg[1]);
+    }
+    RenameTableAt(index, newName) {
+        const this$ = this;
+        ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.Tables);
+        ArcTablesAux_SanityChecks_validateNewNameUnique(newName, this$.TableNames);
+        const table = this$.GetTableAt(index);
+        table.Name = newName;
+    }
+    RenameTable(name, newName) {
+        const this$ = this;
+        const tupledArg = [ArcTablesAux_findIndexByTableName(name, this$.Tables), newName];
+        this$.RenameTableAt(tupledArg[0], tupledArg[1]);
+    }
+    AddColumnAt(tableIndex, header, cells, columnIndex, forceReplace) {
+        const this$ = this;
+        this$.MapTableAt(tableIndex, (table) => {
+            table.AddColumn(header, unwrap(cells), unwrap(columnIndex), unwrap(forceReplace));
+        });
+    }
+    AddColumn(tableName, header, cells, columnIndex, forceReplace) {
+        const this$ = this;
+        const i = ArcTablesAux_findIndexByTableName(tableName, this$.Tables) | 0;
+        this$.AddColumnAt(i, header, unwrap(cells), unwrap(columnIndex), unwrap(forceReplace));
+    }
+    RemoveColumnAt(tableIndex, columnIndex) {
+        const this$ = this;
+        this$.MapTableAt(tableIndex, (table) => {
+            table.RemoveColumn(columnIndex);
+        });
+    }
+    RemoveColumn(tableName, columnIndex) {
+        const this$ = this;
+        const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.Tables), columnIndex];
+        this$.RemoveColumnAt(tupledArg[0], tupledArg[1]);
+    }
+    UpdateColumnAt(tableIndex, columnIndex, header, cells) {
+        const this$ = this;
+        this$.MapTableAt(tableIndex, (table) => {
+            table.UpdateColumn(columnIndex, header, unwrap(cells));
+        });
+    }
+    UpdateColumn(tableName, columnIndex, header, cells) {
+        const this$ = this;
+        const tableIndex = ArcTablesAux_findIndexByTableName(tableName, this$.Tables) | 0;
+        this$.UpdateColumnAt(tableIndex, columnIndex, header, unwrap(cells));
+    }
+    GetColumnAt(tableIndex, columnIndex) {
+        const this$ = this;
+        const table = this$.GetTableAt(tableIndex);
+        return table.GetColumn(columnIndex);
+    }
+    GetColumn(tableName, columnIndex) {
+        const this$ = this;
+        const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.Tables), columnIndex];
+        return this$.GetColumnAt(tupledArg[0], tupledArg[1]);
+    }
+    AddRowAt(tableIndex, cells, rowIndex) {
+        const this$ = this;
+        this$.MapTableAt(tableIndex, (table) => {
+            table.AddRow(unwrap(cells), unwrap(rowIndex));
+        });
+    }
+    AddRow(tableName, cells, rowIndex) {
+        const this$ = this;
+        const i = ArcTablesAux_findIndexByTableName(tableName, this$.Tables) | 0;
+        this$.AddRowAt(i, unwrap(cells), unwrap(rowIndex));
+    }
+    RemoveRowAt(tableIndex, rowIndex) {
+        const this$ = this;
+        this$.MapTableAt(tableIndex, (table) => {
+            table.RemoveRow(rowIndex);
+        });
+    }
+    RemoveRow(tableName, rowIndex) {
+        const this$ = this;
+        const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.Tables), rowIndex];
+        this$.RemoveRowAt(tupledArg[0], tupledArg[1]);
+    }
+    UpdateRowAt(tableIndex, rowIndex, cells) {
+        const this$ = this;
+        this$.MapTableAt(tableIndex, (table) => {
+            table.UpdateRow(rowIndex, cells);
+        });
+    }
+    UpdateRow(tableName, rowIndex, cells) {
+        const this$ = this;
+        const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.Tables), rowIndex, cells];
+        this$.UpdateRowAt(tupledArg[0], tupledArg[1], tupledArg[2]);
+    }
+    GetRowAt(tableIndex, rowIndex) {
+        const this$ = this;
+        const table = this$.GetTableAt(tableIndex);
+        return table.GetRow(rowIndex);
+    }
+    GetRow(tableName, rowIndex) {
+        const this$ = this;
+        const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.Tables), rowIndex];
+        return this$.GetRowAt(tupledArg[0], tupledArg[1]);
+    }
+    GetProcesses() {
+        const this$ = this;
+        return collect((t) => t.GetProcesses(), toList(this$.Tables));
+    }
+    static ofSeq(tables) {
+        return new ArcTables(Array.from(tables));
+    }
+    static fromProcesses(ps) {
+        let arg;
+        return new ArcTables((arg = map_2((tupledArg) => {
+            const tupledArg_1 = ProcessParsing_alignByHeaders(true, collect(ProcessParsing_processToRows, tupledArg[1]));
+            return ArcTable.create(tupledArg[0], tupledArg_1[0], tupledArg_1[1]);
+        }, ProcessParsing_groupProcesses(ps)), Array.from(arg)));
+    }
+    static updateReferenceTablesBySheets(referenceTables, sheetTables, keepUnusedRefTables) {
+        let arg_4, s, array;
+        const keepUnusedRefTables_1 = defaultArg(keepUnusedRefTables, false);
+        const usedTables = new Set([]);
+        const referenceTableMap = ofSeq_1(choose((t) => map_3((c) => [c.Cells[0].AsFreeText, t], t.TryGetProtocolNameColumn()), referenceTables.Tables), {
+            Compare: comparePrimitives,
+        });
+        return new ArcTables((arg_4 = ((s = map_4((t_3) => {
+            Unchecked_fillMissingCells(t_3.Headers, t_3.Values);
+            return t_3;
+        }, map_4((tupledArg) => reduce((arg_2, arg_3) => ArcTable.append(arg_2, arg_3), tupledArg[1]), Array_groupBy((t_2) => t_2.Name, map_4((t_1) => {
+            const k = defaultArg(bind((c_1) => {
+                if (c_1.AsFreeText === "") {
+                    return void 0;
+                }
+                else {
+                    return c_1.AsFreeText;
+                }
+            }, bind((i) => t_1.TryGetCellAt(i, 0), tryFindIndex((x_1) => equals(x_1, new CompositeHeader(8, [])), t_1.Headers))), t_1.Name);
+            const matchValue = tryFind(k, referenceTableMap);
+            if (matchValue == null) {
+                return t_1;
+            }
+            else {
+                const rt = matchValue;
+                addToSet(k, usedTables);
+                const updatedTable = ArcTable.updateReferenceByAnnotationTable(rt, t_1);
+                return ArcTable.create(t_1.Name, updatedTable.Headers, updatedTable.Values);
+            }
+        }, (array = toArray(sheetTables.Tables), collect_1(ArcTable.SplitByProtocolREF, array))), {
+            Equals: (x_2, y_1) => (x_2 === y_1),
+            GetHashCode: stringHash,
+        }))), keepUnusedRefTables_1 ? append(choose((kv) => {
+            if (usedTables.has(kv[0])) {
+                return void 0;
+            }
+            else {
+                return kv[1];
+            }
+        }, referenceTableMap), s) : s)), Array.from(arg_4)));
+    }
+    GetEnumerator() {
+        const this$ = this;
+        return getEnumerator(this$.Tables);
+    }
+    [Symbol.iterator]() {
+        return toIterator(getEnumerator(this));
+    }
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const this$ = this;
+        return getEnumerator(this$.Tables);
+    }
+}
+
+export function ArcTables_$reflection() {
+    return class_type("ARCtrl.ISA.ArcTables", void 0, ArcTables);
+}
+
+export function ArcTables_$ctor_Z18C2F36D(initTables) {
+    return new ArcTables(initTables);
 }