@nfdi4plants/arctrl 3.0.0-beta.2 → 3.0.0-beta.4

package/dist/ts/ts/ARC.js

@@ -0,0 +1,914 @@
+import { FileSystem } from './FileSystem/FileSystem.js';
+import { unwrap, defaultArg, value, bind } from '../node_modules/@fable-org/fable-library-js/Option.js';
+import { ArcInvestigation, ArcWorkflow__get_Identifier, ArcWorkflow__get_DataMap, ArcWorkflow__set_DataMap_51F1E59E, ArcWorkflow__set_StaticHash_Z524259A4, ArcWorkflow__GetLightHashCode, ArcWorkflow__Copy_6FCE9E49, ArcWorkflow__get_StaticHash } from './Core/ArcTypes.js';
+import { fullFillContractBatchAsync } from './ContractIO/ContractIO.js';
+import { FSharpResult$2_Error, FSharpResult$2_Ok } from '../node_modules/@fable-org/fable-library-js/Result.js';
+import { Contract } from './Contract/Contract.js';
+import { PromiseBuilder__Run_212F1D4B, PromiseBuilder__Delay_62FBFDE1 } from './fable_modules/Fable.Promise.3.2.0/Promise.fs.js';
+import { promise } from './fable_modules/Fable.Promise.3.2.0/PromiseImpl.fs.js';
+import { getAllFilePathsAsync } from './ContractIO/FileSystemHelper.js';
+import { contains, toArray, delay, iterate, tryFind, find, toList, append as append$1, singleton, empty, map as map$1, collect } from '../node_modules/@fable-org/fable-library-js/Seq.js';
+import { stringHash, curry2, safeHash, getEnumerator, disposeSafe, comparePrimitives, defaultOf, equals } from '../node_modules/@fable-org/fable-library-js/Util.js';
+import { getAssayFolderPath, getStudyFolderPath } from './FileSystem/Path.js';
+import { ARCtrl_ArcAssay__ArcAssay_tryFromReadContract_Static_7570923F, ARCtrl_ArcAssay__ArcAssay_ToDeleteContract, ARCtrl_ArcAssay__ArcAssay_ToCreateContract_6FCE9E49, ARCtrl_ArcAssay__ArcAssay_ToUpdateContract } from './Contract/ArcAssay.js';
+import { ARCtrl_ArcInvestigation__ArcInvestigation_ToUpdateContract, ARCtrl_ArcInvestigation__ArcInvestigation_tryFromReadContract_Static_7570923F } from './Contract/ArcInvestigation.js';
+import { ARCtrl_ArcStudy__ArcStudy_tryFromReadContract_Static_7570923F, ARCtrl_ArcStudy__ArcStudy_ToUpdateContract, ARCtrl_ArcStudy__ArcStudy_ToCreateContract_6FCE9E49 } from './Contract/ArcStudy.js';
+import { map, choose, fold, concat, contains as contains$1, append, equalsWith, item, tryPick } from '../node_modules/@fable-org/fable-library-js/Array.js';
+import { replace, toText, printf, toFail, join } from '../node_modules/@fable-org/fable-library-js/String.js';
+import { createMissingIdentifier, Study_fileNameFromIdentifier, Study_datamapFileNameFromIdentifier, Assay_fileNameFromIdentifier, Assay_datamapFileNameFromIdentifier, Workflow_fileNameFromIdentifier, Workflow_datamapFileNameFromIdentifier, Run_fileNameFromIdentifier, Run_datamapFileNameFromIdentifier } from './Core/Helper/Identifier.js';
+import { ofSeq, unionMany, FSharpSet__Contains, contains as contains$2 } from '../node_modules/@fable-org/fable-library-js/Set.js';
+import { ResizeArray_map, ResizeArray_iter } from './Core/Helper/Collections.js';
+import { DataMap__set_StaticHash_Z524259A4, DataMap__get_DataContexts, DataMap__get_StaticHash } from './Core/DataMap.js';
+import { FileSystemTree_Folder, FileSystemTree } from './FileSystem/FileSystemTree.js';
+import { tryISAReadContractFromPath } from './Contract/ARC.js';
+import { setInvestigationIdentifier } from './Core/IdentifierSetters.js';
+import { ArcTables } from './Core/Table/ArcTables.js';
+import { addToDict } from '../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { ARCtrl_ArcInvestigation__ArcInvestigation_toFsWorkbook_Static_Z720BD3FF } from './Spreadsheet/ArcInvestigation.js';
+import { ARCtrl_ArcStudy__ArcStudy_toFsWorkbook_Static_Z4CEFA522 } from './Spreadsheet/ArcStudy.js';
+import { toFsWorkbook } from './Spreadsheet/DataMap.js';
+import { ARCtrl_ArcAssay__ArcAssay_toFsWorkbook_Static_Z2508BE4F } from './Spreadsheet/ArcAssay.js';
+import { ARCtrl_ArcWorkflow__ArcWorkflow_toFsWorkbook_Static_Z1C75CB0E } from './Spreadsheet/ArcWorkflow.js';
+import { ARCtrl_ArcRun__ArcRun_toFsWorkbook_Static_Z3EFAF6F8 } from './Spreadsheet/ArcRun.js';
+import { Dictionary_tryGet } from './fable_modules/FsSpreadsheet.7.0.0-alpha.1/Cells/FsCellsCollection.fs.js';
+import { ARCtrl_DataMap__DataMap_tryFromReadContractForAssay_Static, ARCtrl_DataMap__DataMap_tryFromReadContractForStudy_Static, ARCtrl_DataMap__DataMap_tryFromReadContractForWorkflow_Static, ARCtrl_DataMap__DataMap_tryFromReadContractForRun_Static, ARCtrl_DataMap__DataMap_ToUpdateContractForStudy_Z721C83C5, ARCtrl_DataMap__DataMap_ToCreateContractForStudy_Z721C83C5, ARCtrl_DataMap__DataMap_ToUpdateContractForAssay_Z721C83C5, ARCtrl_DataMap__DataMap_ToCreateContractForAssay_Z721C83C5, ARCtrl_DataMap__DataMap_ToUpdateContractForWorkflow_Z721C83C5, ARCtrl_DataMap__DataMap_ToCreateContractForWorkflow_Z721C83C5, ARCtrl_DataMap__DataMap_ToUpdateContractForRun_Z721C83C5, ARCtrl_DataMap__DataMap_ToCreateContractForRun_Z721C83C5 } from './Contract/Datamap.js';
+import { ARCtrl_ArcWorkflow__ArcWorkflow_tryFromReadContract_Static_7570923F, ARCtrl_ArcWorkflow__ArcWorkflow_ToCreateContract_6FCE9E49, ARCtrl_ArcWorkflow__ArcWorkflow_ToUpdateContract } from './Contract/ArcWorkflow.js';
+import { ARCtrl_ArcRun__ArcRun_tryFromReadContract_Static_7570923F, ARCtrl_ArcRun__ArcRun_ToCreateContract_6FCE9E49, ARCtrl_ArcRun__ArcRun_ToUpdateContract } from './Contract/ArcRun.js';
+import { Clone_createCloneContract_5000466F, gitignoreContract, gitattributesContract, Init_createInitContract_6DFDD678, Init_createAddRemoteContract_Z721C83C5 } from './Contract/Git.js';
+import { ofSeq as ofSeq$1 } from '../node_modules/@fable-org/fable-library-js/Map.js';
+import { fromString } from './fable_modules/Thoth.Json.JavaScript.0.4.1/Decode.fs.js';
+import { ROCrate_get_decoderDeprecated, ROCrate_get_decoder, ROCrate_encoder_B568605 } from './ROCrateIO.js';
+import { toString } from './fable_modules/Thoth.Json.JavaScript.0.4.1/Encode.fs.js';
+import { defaultSpaces } from './Json/Encode.js';
+import { ValidationPackagesConfigHelper_ConfigFilePath, ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toCreateContract_Static_724DAE55, ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toDeleteContract_Static_724DAE55, ValidationPackagesConfigHelper_ReadContract, ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_tryFromReadContract_Static_7570923F } from './Contract/ValidationPackagesConfig.js';
+import { FSharpRef } from '../node_modules/@fable-org/fable-library-js/Types.js';
+
+class ARC extends ArcInvestigation {
+  constructor(identifier, title, description, submissionDate, publicReleaseDate, ontologySourceReferences, publications, contacts, assays, studies, workflows, runs, registeredStudyIdentifiers, comments, remarks, cwl, fs) {
+    super(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));
+    let fs_1;
+    const this$ = new FSharpRef(defaultOf());
+    this$.contents = this;
+    this._cwl = cwl;
+    this._fs = (fs_1 = defaultArg(fs, FileSystem.create({
+      tree: FileSystemTree_Folder("", [])
+    })), ARCAux_updateFSByISA(this$.contents, fs_1));
+    this["init@90"] = 1;
+  }
+  get FileSystem() {
+    const this$ = this;
+    return this$._fs;
+  }
+  set FileSystem(fs) {
+    const this$ = this;
+    this$._fs = fs;
+  }
+  static fromArcInvestigation(isa, cwl, fs) {
+    return new ARC(isa.Identifier, unwrap(isa.Title), unwrap(isa.Description), unwrap(isa.SubmissionDate), unwrap(isa.PublicReleaseDate), isa.OntologySourceReferences, isa.Publications, isa.Contacts, isa.Assays, isa.Studies, isa.Workflows, isa.Runs, isa.RegisteredStudyIdentifiers, isa.Comments, isa.Remarks, cwl, unwrap(fs));
+  }
+  TryWriteAsync(arcPath) {
+    const this$ = this;
+    return fullFillContractBatchAsync(arcPath, this$.GetWriteContracts());
+  }
+  TryUpdateAsync(arcPath) {
+    const this$ = this;
+    return fullFillContractBatchAsync(arcPath, this$.GetUpdateContracts());
+  }
+  static tryLoadAsync(arcPath) {
+    return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => getAllFilePathsAsync(arcPath).then((_arg) => {
+      const arc = ARC.fromFilePaths(toArray(_arg));
+      const contracts = arc.GetReadContracts();
+      return fullFillContractBatchAsync(arcPath, contracts).then((_arg_1) => {
+        const fulFilledContracts = _arg_1;
+        if (fulFilledContracts.tag === /* Error */
+        1) {
+          const e = fulFilledContracts.fields[0];
+          return Promise.resolve(FSharpResult$2_Error(e));
+        } else {
+          const c = fulFilledContracts.fields[0];
+          arc.SetISAFromContracts(c);
+          return Promise.resolve(FSharpResult$2_Ok(arc));
+        }
+      });
+    })));
+  }
+  GetAssayRemoveContracts(assayIdentifier) {
+    const this$ = this;
+    if (!contains(assayIdentifier, this$.AssayIdentifiers, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    })) {
+      throw new Error("ARC does not contain assay with given name");
+    }
+    const assay = this$.GetAssay(assayIdentifier);
+    const studies = assay.StudiesRegisteredIn;
+    super.RemoveAssay(assayIdentifier);
+    const paths = this$.FileSystem.Tree.ToFilePaths();
+    const assayFolderPath = getAssayFolderPath(assayIdentifier);
+    const filteredPaths = paths.filter((p) => !p.startsWith(assayFolderPath));
+    this$.SetFilePaths(filteredPaths);
+    return toArray(delay(() => append$1(singleton(ARCtrl_ArcAssay__ArcAssay_ToDeleteContract(assay)), delay(() => append$1(singleton(ARCtrl_ArcInvestigation__ArcInvestigation_ToUpdateContract(this$)), delay(() => map$1(ARCtrl_ArcStudy__ArcStudy_ToUpdateContract, studies)))))));
+  }
+  TryRemoveAssayAsync(arcPath, assayIdentifier) {
+    const this$ = this;
+    return fullFillContractBatchAsync(arcPath, this$.GetAssayRemoveContracts(assayIdentifier));
+  }
+  GetAssayRenameContracts(oldAssayIdentifier, newAssayIdentifier) {
+    const this$ = this;
+    if (!contains(oldAssayIdentifier, this$.AssayIdentifiers, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    })) {
+      throw new Error("ARC does not contain assay with given name");
+    }
+    super.RenameAssay(oldAssayIdentifier, newAssayIdentifier);
+    const paths = this$.FileSystem.Tree.ToFilePaths();
+    const oldAssayFolderPath = getAssayFolderPath(oldAssayIdentifier);
+    const newAssayFolderPath = getAssayFolderPath(newAssayIdentifier);
+    const renamedPaths = map((p) => replace(p, oldAssayFolderPath, newAssayFolderPath), paths);
+    this$.SetFilePaths(renamedPaths);
+    return toArray(delay(() => append$1(singleton(Contract.createRename(oldAssayFolderPath, newAssayFolderPath)), delay(() => this$.GetUpdateContracts()))));
+  }
+  TryRenameAssayAsync(arcPath, oldAssayIdentifier, newAssayIdentifier) {
+    const this$ = this;
+    return fullFillContractBatchAsync(arcPath, this$.GetAssayRenameContracts(oldAssayIdentifier, newAssayIdentifier));
+  }
+  GetStudyRemoveContracts(studyIdentifier) {
+    const this$ = this;
+    super.RemoveStudy(studyIdentifier);
+    const paths = this$.FileSystem.Tree.ToFilePaths();
+    const studyFolderPath = getStudyFolderPath(studyIdentifier);
+    const filteredPaths = paths.filter((p) => !p.startsWith(studyFolderPath));
+    this$.SetFilePaths(filteredPaths);
+    return [Contract.createDelete(studyFolderPath), ARCtrl_ArcInvestigation__ArcInvestigation_ToUpdateContract(this$)];
+  }
+  TryRemoveStudyAsync(arcPath, studyIdentifier) {
+    const this$ = this;
+    return fullFillContractBatchAsync(arcPath, this$.GetStudyRemoveContracts(studyIdentifier));
+  }
+  GetStudyRenameContracts(oldStudyIdentifier, newStudyIdentifier) {
+    const this$ = this;
+    if (!contains(oldStudyIdentifier, this$.StudyIdentifiers, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    })) {
+      throw new Error("ARC does not contain study with given name");
+    }
+    super.RenameStudy(oldStudyIdentifier, newStudyIdentifier);
+    const paths = this$.FileSystem.Tree.ToFilePaths();
+    const oldStudyFolderPath = getStudyFolderPath(oldStudyIdentifier);
+    const newStudyFolderPath = getStudyFolderPath(newStudyIdentifier);
+    const renamedPaths = map((p) => replace(p, oldStudyFolderPath, newStudyFolderPath), paths);
+    this$.SetFilePaths(renamedPaths);
+    return toArray(delay(() => append$1(singleton(Contract.createRename(oldStudyFolderPath, newStudyFolderPath)), delay(() => this$.GetUpdateContracts()))));
+  }
+  TryRenameStudyAsync(arcPath, oldStudyIdentifier, newStudyIdentifier) {
+    const this$ = this;
+    return fullFillContractBatchAsync(arcPath, this$.GetStudyRenameContracts(oldStudyIdentifier, newStudyIdentifier));
+  }
+  WriteAsync(arcPath) {
+    const this$ = this;
+    return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => this$.TryWriteAsync(arcPath).then((_arg) => {
+      const result = _arg;
+      if (result.tag === /* Error */
+      1) {
+        const appended = join("\n", map((e) => e, result.fields[0]));
+        toFail(printf("Could not write ARC, failed with the following errors %s"))(appended);
+        return Promise.resolve();
+      } else {
+        return Promise.resolve();
+      }
+    })));
+  }
+  UpdateAsync(arcPath) {
+    const this$ = this;
+    return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => this$.TryUpdateAsync(arcPath).then((_arg) => {
+      const result = _arg;
+      if (result.tag === /* Error */
+      1) {
+        const appended = join("\n", map((e) => e, result.fields[0]));
+        toFail(printf("Could not update ARC, failed with the following errors %s"))(appended);
+        return Promise.resolve();
+      } else {
+        return Promise.resolve();
+      }
+    })));
+  }
+  RemoveAssayAsync(arcPath, assayIdentifier) {
+    const this$ = this;
+    return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => this$.TryRemoveAssayAsync(arcPath, assayIdentifier).then((_arg) => {
+      const result = _arg;
+      if (result.tag === /* Error */
+      1) {
+        const appended = join("\n", map((e) => e, result.fields[0]));
+        toFail(printf("Could not remove assay, failed with the following errors %s"))(appended);
+        return Promise.resolve();
+      } else {
+        return Promise.resolve();
+      }
+    })));
+  }
+  RenameAssayAsync(arcPath, oldAssayIdentifier, newAssayIdentifier) {
+    const this$ = this;
+    return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => this$.TryRenameAssayAsync(arcPath, oldAssayIdentifier, newAssayIdentifier).then((_arg) => {
+      const result = _arg;
+      if (result.tag === /* Error */
+      1) {
+        const appended = join("\n", map((e) => e, result.fields[0]));
+        toFail(printf("Could not rename assay, failed with the following errors %s"))(appended);
+        return Promise.resolve();
+      } else {
+        return Promise.resolve();
+      }
+    })));
+  }
+  RemoveStudyAsync(arcPath, studyIdentifier) {
+    const this$ = this;
+    return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => this$.TryRemoveStudyAsync(arcPath, studyIdentifier).then((_arg) => {
+      const result = _arg;
+      if (result.tag === /* Error */
+      1) {
+        const appended = join("\n", map((e) => e, result.fields[0]));
+        toFail(printf("Could not remove study, failed with the following errors %s"))(appended);
+        return Promise.resolve();
+      } else {
+        return Promise.resolve();
+      }
+    })));
+  }
+  RenameStudyAsync(arcPath, oldStudyIdentifier, newStudyIdentifier) {
+    const this$ = this;
+    return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => this$.TryRenameStudyAsync(arcPath, oldStudyIdentifier, newStudyIdentifier).then((_arg) => {
+      const result = _arg;
+      if (result.tag === /* Error */
+      1) {
+        const appended = join("\n", map((e) => e, result.fields[0]));
+        toFail(printf("Could not rename study, failed with the following errors %s"))(appended);
+        return Promise.resolve();
+      } else {
+        return Promise.resolve();
+      }
+    })));
+  }
+  static loadAsync(arcPath) {
+    return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => ARC.tryLoadAsync(arcPath).then((_arg) => {
+      const result = _arg;
+      if (result.tag === /* Error */
+      1) {
+        const appended = join("\n", map((e) => e, result.fields[0]));
+        toFail(printf("Could not load ARC, failed with the following errors %s"))(appended);
+        return Promise.resolve(new ARC(createMissingIdentifier()));
+      } else {
+        const arc = result.fields[0];
+        return Promise.resolve(arc);
+      }
+    })));
+  }
+  MakeDataFilesAbsolute() {
+    const this$ = this;
+    const filesPaths = ofSeq(this$.FileSystem.Tree.ToFilePaths(), {
+      Compare: comparePrimitives
+    });
+    const checkExistenceFromRoot = (p) => contains$2(p, filesPaths);
+    const updateColumnOption = (dataNameFunction, col) => {
+      let col_1;
+      let matchResult, col_2;
+      if (col != null) {
+        if (col_1 = value(col), col_1.Header.IsDataColumn) {
+          matchResult = 0;
+          col_2 = value(col);
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+      switch (matchResult) {
+        case 0: {
+          ResizeArray_iter((c) => {
+            if (c.AsData.FilePath != null) {
+              const newFilePath = dataNameFunction(c.AsData);
+              c.AsData.FilePath = newFilePath;
+            }
+          }, col_2.Cells);
+          break;
+        }
+      }
+    };
+    const updateTable = (dataNameFunction_1, t) => {
+      updateColumnOption(dataNameFunction_1, t.TryGetInputColumn());
+      updateColumnOption(dataNameFunction_1, t.TryGetOutputColumn());
+    };
+    const updateDataMap = (dataNameFunction_2, dm) => {
+      iterate((c_1) => {
+        if (c_1.FilePath != null) {
+          const newFilePath_1 = dataNameFunction_2(c_1);
+          c_1.FilePath = newFilePath_1;
+        }
+      }, DataMap__get_DataContexts(dm));
+    };
+    iterate((s) => {
+      const f_1 = (d) => d.GetAbsolutePathForStudy(s.Identifier, checkExistenceFromRoot);
+      const source_1 = s.Tables;
+      iterate(curry2(updateTable)(f_1), source_1);
+      if (s.DataMap != null) {
+        updateDataMap(f_1, value(s.DataMap));
+      }
+    }, this$.Studies);
+    iterate((a_1) => {
+      const f_2 = (d_1) => d_1.GetAbsolutePathForAssay(a_1.Identifier, checkExistenceFromRoot);
+      const source_3 = a_1.Tables;
+      iterate(curry2(updateTable)(f_2), source_3);
+      if (a_1.DataMap != null) {
+        updateDataMap(f_2, value(a_1.DataMap));
+      }
+    }, this$.Assays);
+  }
+  static fromFilePaths(filePaths) {
+    const fs = FileSystem.fromFilePaths(filePaths);
+    return new ARC(createMissingIdentifier(), void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, fs);
+  }
+  SetFilePaths(filePaths) {
+    const this$ = this;
+    const tree = FileSystemTree.fromFilePaths(filePaths);
+    this$._fs = new FileSystem(tree, this$._fs.History);
+  }
+  GetReadContracts() {
+    const this$ = this;
+    return choose(tryISAReadContractFromPath, this$._fs.Tree.ToFilePaths());
+  }
+  SetISAFromContracts(contracts) {
+    const this$ = this;
+    const investigation = ARCAux_getArcInvestigationFromContracts(contracts);
+    setInvestigationIdentifier(investigation.Identifier, this$);
+    this$.Title = investigation.Title;
+    this$.Description = investigation.Description;
+    this$.SubmissionDate = investigation.SubmissionDate;
+    this$.PublicReleaseDate = investigation.PublicReleaseDate;
+    this$.OntologySourceReferences = investigation.OntologySourceReferences;
+    this$.Publications = investigation.Publications;
+    this$.Contacts = investigation.Contacts;
+    this$.Comments = investigation.Comments;
+    this$.Remarks = investigation.Remarks;
+    this$.RegisteredStudyIdentifiers = investigation.RegisteredStudyIdentifiers;
+    const studies = map((tuple) => tuple[0], ARCAux_getArcStudiesFromContracts(contracts));
+    const assays = ARCAux_getArcAssaysFromContracts(contracts);
+    const workflows = ARCAux_getArcWorkflowsFromContracts(contracts);
+    const runs = ARCAux_getArcRunsFromContracts(contracts);
+    const array_2 = this$.AssayIdentifiers;
+    array_2.forEach((ai) => {
+      if (!assays.some((a) => a.Identifier === ai)) {
+        this$.DeleteAssay(ai);
+      }
+    });
+    const array_4 = this$.StudyIdentifiers;
+    array_4.forEach((si) => {
+      if (!studies.some((s) => s.Identifier === si)) {
+        this$.DeleteStudy(si);
+      }
+    });
+    studies.forEach((study) => {
+      const registeredStudyOpt = tryFind((s_1) => s_1.Identifier === study.Identifier, this$.Studies);
+      if (registeredStudyOpt == null) {
+        this$.AddStudy(study);
+      } else {
+        const registeredStudy = value(registeredStudyOpt);
+        registeredStudy.UpdateReferenceByStudyFile(study, true);
+      }
+      const datamap = ARCAux_getStudyDataMapFromContracts(study.Identifier, contracts);
+      if (study.DataMap == null) {
+        study.DataMap = datamap;
+      }
+      study.StaticHash = study.GetLightHashCode() | 0;
+    });
+    assays.forEach((assay) => {
+      const registeredAssayOpt = tryFind((a_1) => a_1.Identifier === assay.Identifier, this$.Assays);
+      if (registeredAssayOpt == null) {
+        this$.AddAssay(assay);
+      } else {
+        const registeredAssay = value(registeredAssayOpt);
+        registeredAssay.UpdateReferenceByAssayFile(assay, true);
+      }
+      const assay_1 = find((a_2) => a_2.Identifier === assay.Identifier, this$.Assays);
+      let updatedTables;
+      const array_6 = assay_1.StudiesRegisteredIn;
+      updatedTables = fold((tables, study_1) => ArcTables.updateReferenceTablesBySheets(new ArcTables(study_1.Tables), tables, false), new ArcTables(assay_1.Tables), array_6);
+      const datamap_1 = ARCAux_getAssayDataMapFromContracts(assay_1.Identifier, contracts);
+      if (assay_1.DataMap == null) {
+        assay_1.DataMap = datamap_1;
+      }
+      assay_1.Tables = updatedTables.Tables;
+    });
+    workflows.forEach((workflow) => {
+      const datamap_2 = ARCAux_getWorkflowDataMapFromContracts(ArcWorkflow__get_Identifier(workflow), contracts);
+      if (ArcWorkflow__get_DataMap(workflow) == null) {
+        ArcWorkflow__set_DataMap_51F1E59E(workflow, datamap_2);
+      }
+      this$.AddWorkflow(workflow);
+      ArcWorkflow__set_StaticHash_Z524259A4(workflow, ArcWorkflow__GetLightHashCode(workflow));
+    });
+    runs.forEach((run) => {
+      const datamap_3 = ARCAux_getRunDataMapFromContracts(run.Identifier, contracts);
+      if (run.DataMap == null) {
+        run.DataMap = datamap_3;
+      }
+      this$.AddRun(run);
+      run.StaticHash = run.GetLightHashCode() | 0;
+    });
+    iterate((a_3) => {
+      a_3.StaticHash = a_3.GetLightHashCode() | 0;
+    }, this$.Assays);
+    iterate((s_2) => {
+      s_2.StaticHash = s_2.GetLightHashCode() | 0;
+    }, this$.Studies);
+    this$.StaticHash = this$.GetLightHashCode() | 0;
+  }
+  UpdateFileSystem() {
+    const this$ = this;
+    const newFS = ARCAux_updateFSByISA(this$, this$._fs);
+    this$._fs = newFS;
+  }
+  GetWriteContracts(skipUpdateFS) {
+    const this$ = this;
+    if (!defaultArg(skipUpdateFS, false)) {
+      this$.UpdateFileSystem();
+    }
+    const workbooks = /* @__PURE__ */ new Map([]);
+    addToDict(workbooks, "isa.investigation.xlsx", ["ISA_Investigation", ARCtrl_ArcInvestigation__ArcInvestigation_toFsWorkbook_Static_Z720BD3FF(this$)]);
+    this$.StaticHash = this$.GetLightHashCode() | 0;
+    iterate((s) => {
+      s.StaticHash = s.GetLightHashCode() | 0;
+      addToDict(workbooks, Study_fileNameFromIdentifier(s.Identifier), ["ISA_Study", ARCtrl_ArcStudy__ArcStudy_toFsWorkbook_Static_Z4CEFA522(s)]);
+      if (s.DataMap != null) {
+        const dm = value(s.DataMap);
+        DataMap__set_StaticHash_Z524259A4(dm, safeHash(dm));
+        addToDict(workbooks, Study_datamapFileNameFromIdentifier(s.Identifier), ["ISA_Datamap", toFsWorkbook(dm)]);
+      }
+    }, this$.Studies);
+    iterate((a) => {
+      a.StaticHash = a.GetLightHashCode() | 0;
+      addToDict(workbooks, Assay_fileNameFromIdentifier(a.Identifier), ["ISA_Assay", ARCtrl_ArcAssay__ArcAssay_toFsWorkbook_Static_Z2508BE4F(a)]);
+      if (a.DataMap != null) {
+        const dm_1 = value(a.DataMap);
+        DataMap__set_StaticHash_Z524259A4(dm_1, safeHash(dm_1));
+        addToDict(workbooks, Assay_datamapFileNameFromIdentifier(a.Identifier), ["ISA_Datamap", toFsWorkbook(dm_1)]);
+      }
+    }, this$.Assays);
+    iterate((w) => {
+      ArcWorkflow__set_StaticHash_Z524259A4(w, ArcWorkflow__GetLightHashCode(w));
+      addToDict(workbooks, Workflow_fileNameFromIdentifier(ArcWorkflow__get_Identifier(w)), ["ISA_Workflow", ARCtrl_ArcWorkflow__ArcWorkflow_toFsWorkbook_Static_Z1C75CB0E(w)]);
+      if (ArcWorkflow__get_DataMap(w) != null) {
+        const dm_2 = value(ArcWorkflow__get_DataMap(w));
+        DataMap__set_StaticHash_Z524259A4(dm_2, safeHash(dm_2));
+        addToDict(workbooks, Workflow_datamapFileNameFromIdentifier(ArcWorkflow__get_Identifier(w)), ["ISA_Datamap", toFsWorkbook(dm_2)]);
+      }
+    }, this$.Workflows);
+    iterate((r) => {
+      r.StaticHash = r.GetLightHashCode() | 0;
+      addToDict(workbooks, Run_fileNameFromIdentifier(r.Identifier), ["ISA_Run", ARCtrl_ArcRun__ArcRun_toFsWorkbook_Static_Z3EFAF6F8(r)]);
+      if (r.DataMap != null) {
+        const dm_3 = value(r.DataMap);
+        DataMap__set_StaticHash_Z524259A4(dm_3, safeHash(dm_3));
+        addToDict(workbooks, Run_datamapFileNameFromIdentifier(r.Identifier), ["ISA_Datamap", toFsWorkbook(dm_3)]);
+      }
+    }, this$.Runs);
+    return map((fp) => {
+      const matchValue = Dictionary_tryGet(fp, workbooks);
+      if (matchValue == null) {
+        return Contract.createCreate(fp, "PlainText");
+      } else {
+        const wb = value(matchValue)[1];
+        const dto = value(matchValue)[0];
+        return Contract.createCreate(fp, dto, wb);
+      }
+    }, this$._fs.Tree.ToFilePaths(true));
+  }
+  GetUpdateContracts(skipUpdateFS) {
+    const this$ = this;
+    if (this$.StaticHash === 0) {
+      this$.StaticHash = this$.GetLightHashCode() | 0;
+      return this$.GetWriteContracts(unwrap(skipUpdateFS));
+    } else {
+      return toArray(delay(() => {
+        const hash = this$.GetLightHashCode() | 0;
+        return append$1(this$.StaticHash !== hash ? singleton(ARCtrl_ArcInvestigation__ArcInvestigation_ToUpdateContract(this$)) : empty(), delay(() => {
+          this$.StaticHash = hash | 0;
+          return append$1(collect((s) => {
+            const hash_1 = s.GetLightHashCode() | 0;
+            return append$1(s.StaticHash === 0 ? ARCtrl_ArcStudy__ArcStudy_ToCreateContract_6FCE9E49(s, true) : s.StaticHash !== hash_1 ? singleton(ARCtrl_ArcStudy__ArcStudy_ToUpdateContract(s)) : empty(), delay(() => {
+              let dm_1;
+              s.StaticHash = hash_1 | 0;
+              const matchValue = s.DataMap;
+              let matchResult, dm_2, dm_3;
+              if (matchValue != null) {
+                if (DataMap__get_StaticHash(value(matchValue)) === 0) {
+                  matchResult = 0;
+                  dm_2 = value(matchValue);
+                } else if (dm_1 = value(matchValue), DataMap__get_StaticHash(dm_1) !== safeHash(dm_1)) {
+                  matchResult = 1;
+                  dm_3 = value(matchValue);
+                } else {
+                  matchResult = 2;
+                }
+              } else {
+                matchResult = 2;
+              }
+              switch (matchResult) {
+                case 0:
+                  return append$1(singleton(ARCtrl_DataMap__DataMap_ToCreateContractForStudy_Z721C83C5(dm_2, s.Identifier)), delay(() => {
+                    DataMap__set_StaticHash_Z524259A4(dm_2, safeHash(dm_2));
+                    return empty();
+                  }));
+                case 1:
+                  return append$1(singleton(ARCtrl_DataMap__DataMap_ToUpdateContractForStudy_Z721C83C5(dm_3, s.Identifier)), delay(() => {
+                    DataMap__set_StaticHash_Z524259A4(dm_3, safeHash(dm_3));
+                    return empty();
+                  }));
+                default: {
+                  return empty();
+                }
+              }
+            }));
+          }, this$.Studies), delay(() => append$1(collect((a) => {
+            const hash_2 = a.GetLightHashCode() | 0;
+            return append$1(a.StaticHash === 0 ? ARCtrl_ArcAssay__ArcAssay_ToCreateContract_6FCE9E49(a, true) : a.StaticHash !== hash_2 ? singleton(ARCtrl_ArcAssay__ArcAssay_ToUpdateContract(a)) : empty(), delay(() => {
+              let dm_5;
+              a.StaticHash = hash_2 | 0;
+              const matchValue_1 = a.DataMap;
+              let matchResult_1, dm_6, dm_7;
+              if (matchValue_1 != null) {
+                if (DataMap__get_StaticHash(value(matchValue_1)) === 0) {
+                  matchResult_1 = 0;
+                  dm_6 = value(matchValue_1);
+                } else if (dm_5 = value(matchValue_1), DataMap__get_StaticHash(dm_5) !== safeHash(dm_5)) {
+                  matchResult_1 = 1;
+                  dm_7 = value(matchValue_1);
+                } else {
+                  matchResult_1 = 2;
+                }
+              } else {
+                matchResult_1 = 2;
+              }
+              switch (matchResult_1) {
+                case 0:
+                  return append$1(singleton(ARCtrl_DataMap__DataMap_ToCreateContractForAssay_Z721C83C5(dm_6, a.Identifier)), delay(() => {
+                    DataMap__set_StaticHash_Z524259A4(dm_6, safeHash(dm_6));
+                    return empty();
+                  }));
+                case 1:
+                  return append$1(singleton(ARCtrl_DataMap__DataMap_ToUpdateContractForAssay_Z721C83C5(dm_7, a.Identifier)), delay(() => {
+                    DataMap__set_StaticHash_Z524259A4(dm_7, safeHash(dm_7));
+                    return empty();
+                  }));
+                default: {
+                  return empty();
+                }
+              }
+            }));
+          }, this$.Assays), delay(() => append$1(collect((w) => {
+            const hash_3 = ArcWorkflow__GetLightHashCode(w) | 0;
+            return append$1(ArcWorkflow__get_StaticHash(w) === 0 ? ARCtrl_ArcWorkflow__ArcWorkflow_ToCreateContract_6FCE9E49(w, true) : ArcWorkflow__get_StaticHash(w) !== hash_3 ? singleton(ARCtrl_ArcWorkflow__ArcWorkflow_ToUpdateContract(w)) : empty(), delay(() => {
+              let dm_9;
+              ArcWorkflow__set_StaticHash_Z524259A4(w, hash_3);
+              const matchValue_2 = ArcWorkflow__get_DataMap(w);
+              let matchResult_2, dm_10, dm_11;
+              if (matchValue_2 != null) {
+                if (DataMap__get_StaticHash(value(matchValue_2)) === 0) {
+                  matchResult_2 = 0;
+                  dm_10 = value(matchValue_2);
+                } else if (dm_9 = value(matchValue_2), DataMap__get_StaticHash(dm_9) !== safeHash(dm_9)) {
+                  matchResult_2 = 1;
+                  dm_11 = value(matchValue_2);
+                } else {
+                  matchResult_2 = 2;
+                }
+              } else {
+                matchResult_2 = 2;
+              }
+              switch (matchResult_2) {
+                case 0:
+                  return append$1(singleton(ARCtrl_DataMap__DataMap_ToCreateContractForWorkflow_Z721C83C5(dm_10, ArcWorkflow__get_Identifier(w))), delay(() => {
+                    DataMap__set_StaticHash_Z524259A4(dm_10, safeHash(dm_10));
+                    return empty();
+                  }));
+                case 1:
+                  return append$1(singleton(ARCtrl_DataMap__DataMap_ToUpdateContractForWorkflow_Z721C83C5(dm_11, ArcWorkflow__get_Identifier(w))), delay(() => {
+                    DataMap__set_StaticHash_Z524259A4(dm_11, safeHash(dm_11));
+                    return empty();
+                  }));
+                default: {
+                  return empty();
+                }
+              }
+            }));
+          }, this$.Workflows), delay(() => collect((r) => {
+            const hash_4 = r.GetLightHashCode() | 0;
+            return append$1(r.StaticHash === 0 ? ARCtrl_ArcRun__ArcRun_ToCreateContract_6FCE9E49(r, true) : r.StaticHash !== hash_4 ? singleton(ARCtrl_ArcRun__ArcRun_ToUpdateContract(r)) : empty(), delay(() => {
+              let dm_13;
+              r.StaticHash = hash_4 | 0;
+              const matchValue_3 = r.DataMap;
+              let matchResult_3, dm_14, dm_15;
+              if (matchValue_3 != null) {
+                if (DataMap__get_StaticHash(value(matchValue_3)) === 0) {
+                  matchResult_3 = 0;
+                  dm_14 = value(matchValue_3);
+                } else if (dm_13 = value(matchValue_3), DataMap__get_StaticHash(dm_13) !== safeHash(dm_13)) {
+                  matchResult_3 = 1;
+                  dm_15 = value(matchValue_3);
+                } else {
+                  matchResult_3 = 2;
+                }
+              } else {
+                matchResult_3 = 2;
+              }
+              switch (matchResult_3) {
+                case 0:
+                  return append$1(singleton(ARCtrl_DataMap__DataMap_ToCreateContractForRun_Z721C83C5(dm_14, r.Identifier)), delay(() => {
+                    DataMap__set_StaticHash_Z524259A4(dm_14, safeHash(dm_14));
+                    return empty();
+                  }));
+                case 1:
+                  return append$1(singleton(ARCtrl_DataMap__DataMap_ToUpdateContractForRun_Z721C83C5(dm_15, r.Identifier)), delay(() => {
+                    DataMap__set_StaticHash_Z524259A4(dm_15, safeHash(dm_15));
+                    return empty();
+                  }));
+                default: {
+                  return empty();
+                }
+              }
+            }));
+          }, this$.Runs)))))));
+        }));
+      }));
+    }
+  }
+  GetGitInitContracts(branch, repositoryAddress, defaultGitignore, defaultGitattributes) {
+    const defaultGitignore_1 = defaultArg(defaultGitignore, false);
+    const defaultGitattributes_1 = defaultArg(defaultGitattributes, false);
+    return toArray(delay(() => append$1(singleton(Init_createInitContract_6DFDD678(unwrap(branch))), delay(() => append$1(defaultGitignore_1 ? singleton(gitignoreContract) : empty(), delay(() => append$1(defaultGitattributes_1 ? singleton(gitattributesContract) : empty(), delay(() => repositoryAddress != null ? singleton(Init_createAddRemoteContract_Z721C83C5(value(repositoryAddress))) : empty()))))))));
+  }
+  static getCloneContract(remoteUrl, merge, branch, token, nolfs) {
+    return Clone_createCloneContract_5000466F(remoteUrl, unwrap(merge), unwrap(branch), unwrap(token), unwrap(nolfs));
+  }
+  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"]();
+        void nextWorkflows.push(ArcWorkflow__Copy_6FCE9E49(workflow));
+      }
+    } 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);
+    const fsCopy = this$._fs.Copy();
+    return new ARC(this$.Identifier, unwrap(this$.Title), unwrap(this$.Description), unwrap(this$.SubmissionDate), unwrap(this$.PublicReleaseDate), nextOntologySourceReferences, nextPublications, nextContacts, nextAssays, nextStudies, nextWorkflows, nextRuns, nextStudyIdentifiers, nextComments, nextRemarks, this$._cwl, fsCopy);
+  }
+  GetRegisteredPayload(IgnoreHidden) {
+    let tree, paths, array_3;
+    const this$ = this;
+    const copy = this$.Copy();
+    const registeredStudies = copy.Studies.slice();
+    const registeredAssays = concat(map((s) => s.RegisteredAssays.slice(), registeredStudies));
+    const includeFiles = unionMany([ofSeq(["isa.investigation.xlsx", "README.md"], {
+      Compare: comparePrimitives
+    }), unionMany(map((s_1) => {
+      const studyFoldername = `${"studies"}/${s_1.Identifier}`;
+      return ofSeq(toList(delay(() => append$1(singleton(`${studyFoldername}/${"isa.study.xlsx"}`), delay(() => append$1(singleton(`${studyFoldername}/${"README.md"}`), delay(() => collect((table) => collect((kv) => {
+        const textValue = kv[1].ToFreeTextCell().AsFreeText;
+        return append$1(singleton(textValue), delay(() => append$1(singleton(`${studyFoldername}/${"resources"}/${textValue}`), delay(() => singleton(`${studyFoldername}/${"protocols"}/${textValue}`)))));
+      }, table.Values), s_1.Tables))))))), {
+        Compare: comparePrimitives
+      });
+    }, registeredStudies), {
+      Compare: comparePrimitives
+    }), unionMany(map((a) => {
+      const assayFoldername = `${"assays"}/${a.Identifier}`;
+      return ofSeq(toList(delay(() => append$1(singleton(`${assayFoldername}/${"isa.assay.xlsx"}`), delay(() => append$1(singleton(`${assayFoldername}/${"README.md"}`), delay(() => collect((table_1) => collect((kv_1) => {
+        const textValue_1 = kv_1[1].ToFreeTextCell().AsFreeText;
+        return append$1(singleton(textValue_1), delay(() => append$1(singleton(`${assayFoldername}/${"dataset"}/${textValue_1}`), delay(() => singleton(`${assayFoldername}/${"protocols"}/${textValue_1}`)))));
+      }, table_1.Values), a.Tables))))))), {
+        Compare: comparePrimitives
+      });
+    }, registeredAssays), {
+      Compare: comparePrimitives
+    })], {
+      Compare: comparePrimitives
+    });
+    const ignoreHidden = defaultArg(IgnoreHidden, true);
+    const fsCopy = this$._fs.Copy();
+    return defaultArg(bind((tree_1) => {
+      if (ignoreHidden) {
+        return FileSystemTree.filterFolders((n_1) => !n_1.startsWith("."))(tree_1);
+      } else {
+        return tree_1;
+      }
+    }, (tree = (paths = (array_3 = FileSystemTree.toFilePaths()(fsCopy.Tree), array_3.filter((p) => {
+      if (p.startsWith("workflows") ? true : p.startsWith("runs")) {
+        return true;
+      } else {
+        return FSharpSet__Contains(includeFiles, p);
+      }
+    })), FileSystemTree.fromFilePaths(paths)), ignoreHidden ? FileSystemTree.filterFiles((n) => !n.startsWith("."))(tree) : tree)), FileSystemTree.fromFilePaths([]));
+  }
+  GetAdditionalPayload(IgnoreHidden) {
+    let tree, paths, array;
+    const this$ = this;
+    const ignoreHidden = defaultArg(IgnoreHidden, true);
+    const registeredPayload = ofSeq(FileSystemTree.toFilePaths()(this$.GetRegisteredPayload()), {
+      Compare: comparePrimitives
+    });
+    return defaultArg(bind((tree_1) => {
+      if (ignoreHidden) {
+        return FileSystemTree.filterFolders((n_1) => !n_1.startsWith("."))(tree_1);
+      } else {
+        return tree_1;
+      }
+    }, (tree = (paths = (array = FileSystemTree.toFilePaths()(this$._fs.Copy().Tree), array.filter((p) => !FSharpSet__Contains(registeredPayload, p))), FileSystemTree.fromFilePaths(paths)), ignoreHidden ? FileSystemTree.filterFiles((n) => !n.startsWith("."))(tree) : tree)), FileSystemTree.fromFilePaths([]));
+  }
+  static get DefaultContracts() {
+    return ofSeq$1([[".gitignore", gitignoreContract], [".gitattributes", gitattributesContract]], {
+      Compare: comparePrimitives
+    });
+  }
+  static fromDeprecatedROCrateJsonString(s) {
+    let arg;
+    try {
+      const s_1 = replace(s, "bio:additionalProperty", "sdo:additionalProperty");
+      let isa;
+      const matchValue = fromString(ROCrate_get_decoderDeprecated(), s_1);
+      if (matchValue.tag === /* Error */
+      1) {
+        throw new Error((arg = matchValue.fields[0], toText(printf("Error decoding string: %O"))(arg)));
+      } else {
+        isa = matchValue.fields[0];
+      }
+      return ARC.fromArcInvestigation(isa);
+    } catch (ex) {
+      const arg_1 = ex.message;
+      return toFail(printf("Could not parse deprecated ARC-RO-Crate metadata: \n%s"))(arg_1);
+    }
+  }
+  static fromROCrateJsonString(s) {
+    let arg;
+    try {
+      let patternInput;
+      const matchValue = fromString(ROCrate_get_decoder(), s);
+      if (matchValue.tag === /* Error */
+      1) {
+        throw new Error((arg = matchValue.fields[0], toText(printf("Error decoding string: %O"))(arg)));
+      } else {
+        patternInput = matchValue.fields[0];
+      }
+      let fileSystem;
+      const paths = Array.from(patternInput[1]);
+      fileSystem = FileSystem.fromFilePaths(paths);
+      return ARC.fromArcInvestigation(patternInput[0], void 0, fileSystem);
+    } catch (ex) {
+      const arg_1 = ex.message;
+      return toFail(printf("Could not parse ARC-RO-Crate metadata: \n%s"))(arg_1);
+    }
+  }
+  ToROCrateJsonString(spaces) {
+    const this$ = this;
+    this$.MakeDataFilesAbsolute();
+    const value = ROCrate_encoder_B568605(this$, void 0, this$._fs);
+    return toString(defaultSpaces(spaces), value);
+  }
+  static toROCrateJsonString(spaces) {
+    return (obj) => obj.ToROCrateJsonString(unwrap(spaces));
+  }
+  GetValidationPackagesConfigWriteContract(vpc) {
+    const this$ = this;
+    const paths = this$.FileSystem.Tree.ToFilePaths();
+    if (!contains$1(ValidationPackagesConfigHelper_ConfigFilePath, paths, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    })) {
+      const filePaths = append([ValidationPackagesConfigHelper_ConfigFilePath], paths);
+      this$.SetFilePaths(filePaths);
+    }
+    return ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toCreateContract_Static_724DAE55(vpc);
+  }
+  GetValidationPackagesConfigDeleteContract(vpc) {
+    const this$ = this;
+    const paths = this$.FileSystem.Tree.ToFilePaths();
+    if (contains$1(ValidationPackagesConfigHelper_ConfigFilePath, paths, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    })) {
+      const filePaths = paths.filter((p) => !(p === ValidationPackagesConfigHelper_ConfigFilePath));
+      this$.SetFilePaths(filePaths);
+    }
+    return ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toDeleteContract_Static_724DAE55();
+  }
+  GetValidationPackagesConfigReadContract() {
+    return ValidationPackagesConfigHelper_ReadContract;
+  }
+  GetValidationPackagesConfigFromReadContract(contract) {
+    return ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_tryFromReadContract_Static_7570923F(contract);
+  }
+  ToFilePaths(removeRoot, skipUpdateFS) {
+    const this$ = this;
+    if (!defaultArg(skipUpdateFS, false)) {
+      this$.UpdateFileSystem();
+    }
+    return this$.FileSystem.Tree.ToFilePaths(unwrap(removeRoot));
+  }
+}
+function ARCAux_getArcAssaysFromContracts(contracts) {
+  return choose(ARCtrl_ArcAssay__ArcAssay_tryFromReadContract_Static_7570923F, contracts);
+}
+function ARCAux_getArcStudiesFromContracts(contracts) {
+  return choose(ARCtrl_ArcStudy__ArcStudy_tryFromReadContract_Static_7570923F, contracts);
+}
+function ARCAux_getArcWorkflowsFromContracts(contracts) {
+  return choose(ARCtrl_ArcWorkflow__ArcWorkflow_tryFromReadContract_Static_7570923F, contracts);
+}
+function ARCAux_getArcRunsFromContracts(contracts) {
+  return choose(ARCtrl_ArcRun__ArcRun_tryFromReadContract_Static_7570923F, contracts);
+}
+function ARCAux_getAssayDataMapFromContracts(assayIdentifier, contracts) {
+  return tryPick((c) => ARCtrl_DataMap__DataMap_tryFromReadContractForAssay_Static(assayIdentifier, c), contracts);
+}
+function ARCAux_getStudyDataMapFromContracts(studyIdentifier, contracts) {
+  return tryPick((c) => ARCtrl_DataMap__DataMap_tryFromReadContractForStudy_Static(studyIdentifier, c), contracts);
+}
+function ARCAux_getWorkflowDataMapFromContracts(workflowIdentifier, contracts) {
+  return tryPick((c) => ARCtrl_DataMap__DataMap_tryFromReadContractForWorkflow_Static(workflowIdentifier, c), contracts);
+}
+function ARCAux_getRunDataMapFromContracts(runIdentifier, contracts) {
+  return tryPick((c) => ARCtrl_DataMap__DataMap_tryFromReadContractForRun_Static(runIdentifier, c), contracts);
+}
+function ARCAux_getArcInvestigationFromContracts(contracts) {
+  const matchValue = choose(ARCtrl_ArcInvestigation__ArcInvestigation_tryFromReadContract_Static_7570923F, contracts);
+  if (!equalsWith(equals, matchValue, defaultOf()) && matchValue.length === 1) {
+    return item(0, matchValue);
+  } else {
+    const arg = matchValue.length | 0;
+    return toFail(printf("Could not find investigation in contracts. Expected exactly one investigation, but found %d."))(arg);
+  }
+}
+function ARCAux_updateFSByISA(isa, fs) {
+  let assaysFolder;
+  const assays = map((a) => FileSystemTree.createAssayFolder(a.Identifier, a.DataMap != null), toArray(isa.Assays));
+  assaysFolder = FileSystemTree.createAssaysFolder(assays);
+  let studiesFolder;
+  const studies = map((s) => FileSystemTree.createStudyFolder(s.Identifier, s.DataMap != null), toArray(isa.Studies));
+  studiesFolder = FileSystemTree.createStudiesFolder(studies);
+  let workflowsFolder;
+  const workflows = map((w) => FileSystemTree.createWorkflowFolder(ArcWorkflow__get_Identifier(w), ArcWorkflow__get_DataMap(w) != null), toArray(isa.Workflows));
+  workflowsFolder = FileSystemTree.createWorkflowsFolder(workflows);
+  let runsFolder;
+  const runs = map((r) => FileSystemTree.createRunFolder(r.Identifier, r.DataMap != null), toArray(isa.Runs));
+  runsFolder = FileSystemTree.createRunsFolder(runs);
+  const investigation = FileSystemTree.createInvestigationFile();
+  let tree_1;
+  const tree = FileSystemTree.createRootFolder([investigation, assaysFolder, studiesFolder, workflowsFolder, runsFolder]);
+  tree_1 = FileSystem.create({
+    tree
+  });
+  return fs.Union(tree_1);
+}
+
+export { ARC, ARCAux_getArcAssaysFromContracts, ARCAux_getArcInvestigationFromContracts, ARCAux_getArcRunsFromContracts, ARCAux_getArcStudiesFromContracts, ARCAux_getArcWorkflowsFromContracts, ARCAux_getAssayDataMapFromContracts, ARCAux_getRunDataMapFromContracts, ARCAux_getStudyDataMapFromContracts, ARCAux_getWorkflowDataMapFromContracts, ARCAux_updateFSByISA };