@nfdi4plants/arctrl 3.0.0-alpha.4 → 3.0.0-beta.10

package/dist/ts/ts/ARC.js

@@ -0,0 +1,1118 @@
+import { FileSystem } from './FileSystem/FileSystem.js';
+import { unwrap, defaultArg, value, map as map$1, bind, defaultArgWith } from '../node_modules/@fable-org/fable-library-js/Option.js';
+import { License } from './License.js';
+import { ArcInvestigation, ArcInvestigation_$reflection } 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 { toArray, contains, delay, append, singleton, iterate, tryFind, find, empty, collect, toList } from '../node_modules/@fable-org/fable-library-js/Seq.js';
+import { defaultOf, stringHash, comparePrimitives, curry2, safeHash, getEnumerator, disposeSafe, equals } from '../node_modules/@fable-org/fable-library-js/Util.js';
+import { getAssayFolderPath, getRunFolderPath, getWorkflowFolderPath, getStudyFolderPath } from './FileSystem/Path.js';
+import { ARCtrl_ArcAssay__ArcAssay_ToDeleteContract, ARCtrl_ArcAssay__ArcAssay_ToCreateContract_6FCE9E49, ARCtrl_ArcAssay__ArcAssay_ToUpdateContract, ARCtrl_ArcAssay__ArcAssay_tryFromReadContract_Static_7570923F } from './Contract/ArcAssay.js';
+import { ARCtrl_ArcRun__ArcRun_ToDeleteContract, ARCtrl_ArcRun__ArcRun_ToCreateContract_6FCE9E49, ARCtrl_ArcRun__ArcRun_ToUpdateContract, ARCtrl_ArcRun__ArcRun_tryFromReadContract_Static_7570923F } from './Contract/ArcRun.js';
+import { ARCtrl_ArcWorkflow__ArcWorkflow_ToDeleteContract, ARCtrl_ArcWorkflow__ArcWorkflow_ToCreateContract_6FCE9E49, ARCtrl_ArcWorkflow__ArcWorkflow_ToUpdateContract, ARCtrl_ArcWorkflow__ArcWorkflow_tryFromReadContract_Static_7570923F } from './Contract/ArcWorkflow.js';
+import { join, toFail, printf, replace, toText } from '../node_modules/@fable-org/fable-library-js/String.js';
+import { map, choose, fold, concat, contains as contains$2, append as append$1, tryPick, equalsWith, item } from '../node_modules/@fable-org/fable-library-js/Array.js';
+import { ARCtrl_ArcInvestigation__ArcInvestigation_ToUpdateContract, ARCtrl_ArcInvestigation__ArcInvestigation_tryFromReadContract_Static_7570923F } from './Contract/ArcInvestigation.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, contains as contains$1, unionMany, FSharpSet__Contains } from '../node_modules/@fable-org/fable-library-js/Set.js';
+import { ResizeArray_iter, ResizeArray_map } from './Core/Helper/Collections.js';
+import { FileSystemTree_Folder, FileSystemTree, FileSystemTree_File } 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_ArcStudy__ArcStudy_ToCreateContract_6FCE9E49, ARCtrl_ArcStudy__ArcStudy_ToUpdateContract, ARCtrl_ArcStudy__ArcStudy_tryFromReadContract_Static_7570923F } from './Contract/ArcStudy.js';
+import { 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, ARCtrl_DataMap__DataMap_tryFromReadContractForAssay_Static, ARCtrl_DataMap__DataMap_tryFromReadContractForStudy_Static, ARCtrl_DataMap__DataMap_tryFromReadContractForWorkflow_Static, ARCtrl_DataMap__DataMap_tryFromReadContractForRun_Static } from './Contract/Datamap.js';
+import { Init_createInitContract_6DFDD678, gitignoreContract, gitattributesContract, Init_createAddRemoteContract_Z721C83C5, Clone_createCloneContract_5000466F } 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_1E8A3F74 } 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';
+import { class_type } from '../node_modules/@fable-org/fable-library-js/Reflection.js';
+
+class ARC extends ArcInvestigation {
+  constructor(identifier, title, description, submissionDate, publicReleaseDate, ontologySourceReferences, publications, contacts, assays, studies, workflows, runs, registeredStudyIdentifiers, comments, remarks, fs, license) {
+    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._license = license;
+    this._fs = (fs_1 = defaultArg(fs, FileSystem.create({
+      tree: FileSystemTree_Folder("", [])
+    })), ARCAux_updateFSByARC(this$.contents, license, fs_1));
+    this["init@96"] = 1;
+  }
+  get FileSystem() {
+    const this$ = this;
+    return this$._fs;
+  }
+  set FileSystem(fs) {
+    const this$ = this;
+    this$._fs = fs;
+  }
+  get License() {
+    const this$ = this;
+    return unwrap(this$._license);
+  }
+  set License(license) {
+    const this$ = this;
+    this$._license = license;
+  }
+  static fromArcInvestigation(isa, fs, license) {
+    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, unwrap(fs), unwrap(license));
+  }
+  TryWriteAsync(arcPath) {
+    const this$ = this;
+    return fullFillContractBatchAsync(arcPath, this$.GetWriteContracts());
+  }
+  TryUpdateAsync(arcPath) {
+    const this$ = this;
+    return fullFillContractBatchAsync(arcPath, this$.GetUpdateContracts());
+  }
+  SetLicenseFulltext(fulltext, path) {
+    const this$ = this;
+    const matchValue = this$.License;
+    if (matchValue == null) {
+      const license_1 = new License("fulltext", fulltext);
+      this$.License = license_1;
+      if (path != null) {
+        license_1.Path = value(path);
+      }
+    } else {
+      const license = value(matchValue);
+      license.Type = "fulltext";
+      license.Content = fulltext;
+      if (path != null) {
+        license.Path = value(path);
+      }
+    }
+  }
+  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(singleton(ARCtrl_ArcAssay__ArcAssay_ToDeleteContract(assay)), delay(() => this$.GetUpdateContracts()))));
+  }
+  GetRunRemoveContracts(runIdentifier) {
+    const this$ = this;
+    if (!contains(runIdentifier, this$.RunIdentifiers, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    })) {
+      throw new Error("ARC does not contain run with given name");
+    }
+    const run = this$.GetRun(runIdentifier);
+    this$.DeleteRun(runIdentifier);
+    const paths = this$.FileSystem.Tree.ToFilePaths();
+    const runFolderPath = getRunFolderPath(runIdentifier);
+    const filteredPaths = paths.filter((p) => !p.startsWith(runFolderPath));
+    this$.SetFilePaths(filteredPaths);
+    return toArray(delay(() => append(singleton(ARCtrl_ArcRun__ArcRun_ToDeleteContract(run)), delay(() => this$.GetUpdateContracts()))));
+  }
+  GetWorkflowRemoveContracts(workflowIdentifier) {
+    const this$ = this;
+    if (!contains(workflowIdentifier, this$.WorkflowIdentifiers, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    })) {
+      throw new Error("ARC does not contain workflow with given name");
+    }
+    const workflow = this$.GetWorkflow(workflowIdentifier);
+    this$.DeleteWorkflow(workflowIdentifier);
+    const paths = this$.FileSystem.Tree.ToFilePaths();
+    const workflowFolderPath = getWorkflowFolderPath(workflowIdentifier);
+    const filteredPaths = paths.filter((p) => !p.startsWith(workflowFolderPath));
+    this$.SetFilePaths(filteredPaths);
+    return toArray(delay(() => append(singleton(ARCtrl_ArcWorkflow__ArcWorkflow_ToDeleteContract(workflow)), delay(() => this$.GetUpdateContracts()))));
+  }
+  TryRemoveAssayAsync(arcPath, assayIdentifier) {
+    const this$ = this;
+    return fullFillContractBatchAsync(arcPath, this$.GetAssayRemoveContracts(assayIdentifier));
+  }
+  TryRemoveRunAsync(arcPath, runIdentifier) {
+    const this$ = this;
+    return fullFillContractBatchAsync(arcPath, this$.GetRunRemoveContracts(runIdentifier));
+  }
+  TryRemoveWorkflowAsync(arcPath, workflowIdentifier) {
+    const this$ = this;
+    return fullFillContractBatchAsync(arcPath, this$.GetWorkflowRemoveContracts(workflowIdentifier));
+  }
+  RemoveRunAsync(arcPath, runIdentifier) {
+    const this$ = this;
+    return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => this$.TryRemoveRunAsync(arcPath, runIdentifier).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 run, failed with the following errors %s"))(appended);
+        return Promise.resolve();
+      } else {
+        return Promise.resolve();
+      }
+    })));
+  }
+  RemoveWorkflowAsync(arcPath, workflowIdentifier) {
+    const this$ = this;
+    return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => this$.TryRemoveWorkflowAsync(arcPath, workflowIdentifier).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 workflow, failed with the following errors %s"))(appended);
+        return Promise.resolve();
+      } else {
+        return Promise.resolve();
+      }
+    })));
+  }
+  TryRenameRunAsync(arcPath, oldRunIdentifier, newRunIdentifier) {
+    const this$ = this;
+    return fullFillContractBatchAsync(arcPath, this$.GetRunRenameContracts(oldRunIdentifier, newRunIdentifier));
+  }
+  TryRenameWorkflowAsync(arcPath, oldWorkflowIdentifier, newWorkflowIdentifier) {
+    const this$ = this;
+    return fullFillContractBatchAsync(arcPath, this$.GetWorkflowRenameContracts(oldWorkflowIdentifier, newWorkflowIdentifier));
+  }
+  RenameRunAsync(arcPath, oldRunIdentifier, newRunIdentifier) {
+    const this$ = this;
+    return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => this$.TryRenameRunAsync(arcPath, oldRunIdentifier, newRunIdentifier).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 run, failed with the following errors %s"))(appended);
+        return Promise.resolve();
+      } else {
+        return Promise.resolve();
+      }
+    })));
+  }
+  RenameWorkflowAsync(arcPath, oldWorkflowIdentifier, newWorkflowIdentifier) {
+    const this$ = this;
+    return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => this$.TryRenameWorkflowAsync(arcPath, oldWorkflowIdentifier, newWorkflowIdentifier).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 workflow, failed with the following errors %s"))(appended);
+        return Promise.resolve();
+      } else {
+        return Promise.resolve();
+      }
+    })));
+  }
+  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(singleton(Contract.createRename(oldAssayFolderPath, newAssayFolderPath)), delay(() => this$.GetUpdateContracts()))));
+  }
+  GetRunRenameContracts(oldRunIdentifier, newRunIdentifier) {
+    const this$ = this;
+    if (!contains(oldRunIdentifier, this$.RunIdentifiers, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    })) {
+      throw new Error("ARC does not contain run with given name");
+    }
+    super.RenameRun(oldRunIdentifier, newRunIdentifier);
+    const paths = this$.FileSystem.Tree.ToFilePaths();
+    const oldPath = getRunFolderPath(oldRunIdentifier);
+    const newPath = getRunFolderPath(newRunIdentifier);
+    const renamedPaths = map((p) => replace(p, oldPath, newPath), paths);
+    this$.SetFilePaths(renamedPaths);
+    return toArray(delay(() => append(singleton(Contract.createRename(oldPath, newPath)), delay(() => this$.GetUpdateContracts()))));
+  }
+  GetWorkflowRenameContracts(oldWorkflowIdentifier, newWorkflowIdentifier) {
+    const this$ = this;
+    if (!contains(oldWorkflowIdentifier, this$.WorkflowIdentifiers, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    })) {
+      throw new Error("ARC does not contain workflow with given name");
+    }
+    super.RenameWorkflow(oldWorkflowIdentifier, newWorkflowIdentifier);
+    const paths = this$.FileSystem.Tree.ToFilePaths();
+    const oldPath = getWorkflowFolderPath(oldWorkflowIdentifier);
+    const newPath = getWorkflowFolderPath(newWorkflowIdentifier);
+    const renamedPaths = map((p) => replace(p, oldPath, newPath), paths);
+    this$.SetFilePaths(renamedPaths);
+    return toArray(delay(() => append(singleton(Contract.createRename(oldPath, newPath)), 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(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$1(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;
+        }
+        case 1: {
+          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;
+        }
+      }, dm.DataContexts);
+    };
+    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, 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 license = ARCAux_getLicenseFromContracts(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(workflow.Identifier, contracts);
+      if (workflow.DataMap == null) {
+        workflow.DataMap = datamap_2;
+      }
+      this$.AddWorkflow(workflow);
+      workflow.StaticHash = workflow.GetLightHashCode() | 0;
+    });
+    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$.License = license;
+    this$.StaticHash = this$.GetLightHashCode() | 0;
+  }
+  UpdateFileSystem() {
+    const this$ = this;
+    const newFS = ARCAux_updateFSByARC(this$, this$._license, this$._fs);
+    this$._fs = newFS;
+  }
+  GetWriteContracts(skipUpdateFS) {
+    const this$ = this;
+    if (!defaultArg(skipUpdateFS, false)) {
+      this$.UpdateFileSystem();
+    }
+    const filemap = /* @__PURE__ */ new Map([]);
+    addToDict(filemap, "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(filemap, Study_fileNameFromIdentifier(s.Identifier), ["ISA_Study", ARCtrl_ArcStudy__ArcStudy_toFsWorkbook_Static_Z4CEFA522(s)]);
+      if (s.DataMap != null) {
+        const dm = value(s.DataMap);
+        dm.StaticHash = safeHash(dm) | 0;
+        addToDict(filemap, Study_datamapFileNameFromIdentifier(s.Identifier), ["ISA_Datamap", toFsWorkbook(dm)]);
+      }
+    }, this$.Studies);
+    iterate((a) => {
+      a.StaticHash = a.GetLightHashCode() | 0;
+      addToDict(filemap, Assay_fileNameFromIdentifier(a.Identifier), ["ISA_Assay", ARCtrl_ArcAssay__ArcAssay_toFsWorkbook_Static_Z2508BE4F(a)]);
+      if (a.DataMap != null) {
+        const dm_1 = value(a.DataMap);
+        dm_1.StaticHash = safeHash(dm_1) | 0;
+        addToDict(filemap, Assay_datamapFileNameFromIdentifier(a.Identifier), ["ISA_Datamap", toFsWorkbook(dm_1)]);
+      }
+    }, this$.Assays);
+    iterate((w) => {
+      w.StaticHash = w.GetLightHashCode() | 0;
+      addToDict(filemap, Workflow_fileNameFromIdentifier(w.Identifier), ["ISA_Workflow", ARCtrl_ArcWorkflow__ArcWorkflow_toFsWorkbook_Static_Z1C75CB0E(w)]);
+      if (w.DataMap != null) {
+        const dm_2 = value(w.DataMap);
+        dm_2.StaticHash = safeHash(dm_2) | 0;
+        addToDict(filemap, Workflow_datamapFileNameFromIdentifier(w.Identifier), ["ISA_Datamap", toFsWorkbook(dm_2)]);
+      }
+    }, this$.Workflows);
+    iterate((r) => {
+      r.StaticHash = r.GetLightHashCode() | 0;
+      addToDict(filemap, Run_fileNameFromIdentifier(r.Identifier), ["ISA_Run", ARCtrl_ArcRun__ArcRun_toFsWorkbook_Static_Z3EFAF6F8(r)]);
+      if (r.DataMap != null) {
+        const dm_3 = value(r.DataMap);
+        dm_3.StaticHash = safeHash(dm_3) | 0;
+        addToDict(filemap, Run_datamapFileNameFromIdentifier(r.Identifier), ["ISA_Datamap", toFsWorkbook(dm_3)]);
+      }
+    }, this$.Runs);
+    const matchValue = this$.License;
+    if (matchValue == null) {
+    } else {
+      const l = value(matchValue);
+      const matchValue_1 = l.Type;
+      l.StaticHash = safeHash(l) | 0;
+      addToDict(filemap, l.Path, ["PlainText", l.Content]);
+    }
+    return map((fp) => {
+      const matchValue_2 = Dictionary_tryGet(fp, filemap);
+      if (matchValue_2 == null) {
+        return Contract.createCreate(fp, "PlainText");
+      } else {
+        const wb = value(matchValue_2)[1];
+        const dto = value(matchValue_2)[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(this$.StaticHash !== hash ? singleton(ARCtrl_ArcInvestigation__ArcInvestigation_ToUpdateContract(this$)) : empty(), delay(() => {
+          this$.StaticHash = hash | 0;
+          return append(collect((s) => {
+            const hash_1 = s.GetLightHashCode() | 0;
+            return append(s.StaticHash === 0 ? ARCtrl_ArcStudy__ArcStudy_ToCreateContract_6FCE9E49(s, true) : s.StaticHash !== hash_1 ? singleton(ARCtrl_ArcStudy__ArcStudy_ToUpdateContract(s)) : empty(), delay(() => {
+              let dm, dm_1;
+              s.StaticHash = hash_1 | 0;
+              const matchValue = s.DataMap;
+              let matchResult, dm_2, dm_3;
+              if (matchValue != null) {
+                if (dm = value(matchValue), dm.StaticHash === 0) {
+                  matchResult = 0;
+                  dm_2 = value(matchValue);
+                } else if (dm_1 = value(matchValue), dm_1.StaticHash !== safeHash(dm_1)) {
+                  matchResult = 1;
+                  dm_3 = value(matchValue);
+                } else {
+                  matchResult = 2;
+                }
+              } else {
+                matchResult = 2;
+              }
+              switch (matchResult) {
+                case 0:
+                  return append(singleton(ARCtrl_DataMap__DataMap_ToCreateContractForStudy_Z721C83C5(dm_2, s.Identifier)), delay(() => {
+                    dm_2.StaticHash = safeHash(dm_2) | 0;
+                    return empty();
+                  }));
+                case 1:
+                  return append(singleton(ARCtrl_DataMap__DataMap_ToUpdateContractForStudy_Z721C83C5(dm_3, s.Identifier)), delay(() => {
+                    dm_3.StaticHash = safeHash(dm_3) | 0;
+                    return empty();
+                  }));
+                default: {
+                  return empty();
+                }
+              }
+            }));
+          }, this$.Studies), delay(() => append(collect((a) => {
+            const hash_2 = a.GetLightHashCode() | 0;
+            return append(a.StaticHash === 0 ? ARCtrl_ArcAssay__ArcAssay_ToCreateContract_6FCE9E49(a, true) : a.StaticHash !== hash_2 ? singleton(ARCtrl_ArcAssay__ArcAssay_ToUpdateContract(a)) : empty(), delay(() => {
+              let dm_4, dm_5;
+              a.StaticHash = hash_2 | 0;
+              const matchValue_1 = a.DataMap;
+              let matchResult_1, dm_6, dm_7;
+              if (matchValue_1 != null) {
+                if (dm_4 = value(matchValue_1), dm_4.StaticHash === 0) {
+                  matchResult_1 = 0;
+                  dm_6 = value(matchValue_1);
+                } else if (dm_5 = value(matchValue_1), dm_5.StaticHash !== 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(singleton(ARCtrl_DataMap__DataMap_ToCreateContractForAssay_Z721C83C5(dm_6, a.Identifier)), delay(() => {
+                    dm_6.StaticHash = safeHash(dm_6) | 0;
+                    return empty();
+                  }));
+                case 1:
+                  return append(singleton(ARCtrl_DataMap__DataMap_ToUpdateContractForAssay_Z721C83C5(dm_7, a.Identifier)), delay(() => {
+                    dm_7.StaticHash = safeHash(dm_7) | 0;
+                    return empty();
+                  }));
+                default: {
+                  return empty();
+                }
+              }
+            }));
+          }, this$.Assays), delay(() => append(collect((w) => {
+            const hash_3 = w.GetLightHashCode() | 0;
+            return append(w.StaticHash === 0 ? ARCtrl_ArcWorkflow__ArcWorkflow_ToCreateContract_6FCE9E49(w, true) : w.StaticHash !== hash_3 ? singleton(ARCtrl_ArcWorkflow__ArcWorkflow_ToUpdateContract(w)) : empty(), delay(() => {
+              let dm_8, dm_9;
+              w.StaticHash = hash_3 | 0;
+              const matchValue_2 = w.DataMap;
+              let matchResult_2, dm_10, dm_11;
+              if (matchValue_2 != null) {
+                if (dm_8 = value(matchValue_2), dm_8.StaticHash === 0) {
+                  matchResult_2 = 0;
+                  dm_10 = value(matchValue_2);
+                } else if (dm_9 = value(matchValue_2), dm_9.StaticHash !== 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(singleton(ARCtrl_DataMap__DataMap_ToCreateContractForWorkflow_Z721C83C5(dm_10, w.Identifier)), delay(() => {
+                    dm_10.StaticHash = safeHash(dm_10) | 0;
+                    return empty();
+                  }));
+                case 1:
+                  return append(singleton(ARCtrl_DataMap__DataMap_ToUpdateContractForWorkflow_Z721C83C5(dm_11, w.Identifier)), delay(() => {
+                    dm_11.StaticHash = safeHash(dm_11) | 0;
+                    return empty();
+                  }));
+                default: {
+                  return empty();
+                }
+              }
+            }));
+          }, this$.Workflows), delay(() => append(collect((r) => {
+            const hash_4 = r.GetLightHashCode() | 0;
+            return append(r.StaticHash === 0 ? ARCtrl_ArcRun__ArcRun_ToCreateContract_6FCE9E49(r, true) : r.StaticHash !== hash_4 ? singleton(ARCtrl_ArcRun__ArcRun_ToUpdateContract(r)) : empty(), delay(() => {
+              let dm_12, dm_13;
+              r.StaticHash = hash_4 | 0;
+              const matchValue_3 = r.DataMap;
+              let matchResult_3, dm_14, dm_15;
+              if (matchValue_3 != null) {
+                if (dm_12 = value(matchValue_3), dm_12.StaticHash === 0) {
+                  matchResult_3 = 0;
+                  dm_14 = value(matchValue_3);
+                } else if (dm_13 = value(matchValue_3), dm_13.StaticHash !== 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(singleton(ARCtrl_DataMap__DataMap_ToCreateContractForRun_Z721C83C5(dm_14, r.Identifier)), delay(() => {
+                    dm_14.StaticHash = safeHash(dm_14) | 0;
+                    return empty();
+                  }));
+                case 1:
+                  return append(singleton(ARCtrl_DataMap__DataMap_ToUpdateContractForRun_Z721C83C5(dm_15, r.Identifier)), delay(() => {
+                    dm_15.StaticHash = safeHash(dm_15) | 0;
+                    return empty();
+                  }));
+                default: {
+                  return empty();
+                }
+              }
+            }));
+          }, this$.Runs), delay(() => {
+            const matchValue_4 = this$.License;
+            if (matchValue_4 == null) {
+              return empty();
+            } else {
+              const l = value(matchValue_4);
+              const hash_5 = safeHash(l) | 0;
+              return append(l.StaticHash === 0 ? singleton(l.ToCreateContract()) : l.StaticHash !== hash_5 ? singleton(l.ToUpdateContract()) : empty(), delay(() => {
+                l.StaticHash = hash_5 | 0;
+                return empty();
+              }));
+            }
+          }))))))));
+        }));
+      }));
+    }
+  }
+  GetGitInitContracts(branch, repositoryAddress, defaultGitignore, defaultGitattributes) {
+    const defaultGitignore_1 = defaultArg(defaultGitignore, false);
+    const defaultGitattributes_1 = defaultArg(defaultGitattributes, false);
+    return toArray(delay(() => append(singleton(Init_createInitContract_6DFDD678(unwrap(branch))), delay(() => append(defaultGitignore_1 ? singleton(gitignoreContract) : empty(), delay(() => append(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"]();
+        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);
+    const nextLicense = map$1((_arg) => _arg.Copy(), this$.License);
+    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, fsCopy, unwrap(nextLicense));
+  }
+  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(toList(delay(() => append(singleton("isa.investigation.xlsx"), delay(() => append(singleton("README.md"), delay(() => this$.License != null ? singleton(value(this$.License).Path) : empty())))))), {
+      Compare: comparePrimitives
+    }), unionMany(map((s_1) => {
+      const studyFoldername = `${"studies"}/${s_1.Identifier}`;
+      return ofSeq(toList(delay(() => append(singleton(`${studyFoldername}/${"isa.study.xlsx"}`), delay(() => append(singleton(`${studyFoldername}/${"README.md"}`), delay(() => collect((table) => collect((kv) => {
+        const textValue = kv[1].ToFreeTextCell().AsFreeText;
+        return append(singleton(textValue), delay(() => append(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(singleton(`${assayFoldername}/${"isa.assay.xlsx"}`), delay(() => append(singleton(`${assayFoldername}/${"README.md"}`), delay(() => collect((table_1) => collect((kv_1) => {
+        const textValue_1 = kv_1[1].ToFreeTextCell().AsFreeText;
+        return append(singleton(textValue_1), delay(() => append(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], fileSystem, unwrap(patternInput[2]));
+    } 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_1E8A3F74(this$, unwrap(this$._license), this$._fs);
+    return toString(defaultSpaces(spaces), value);
+  }
+  static toROCrateJsonString(spaces) {
+    return (obj) => obj.ToROCrateJsonString(unwrap(spaces));
+  }
+  GetLicenseWriteContract() {
+    const this$ = this;
+    const _arg = defaultArgWith(this$.License, () => License.GetDefaultLicense());
+    return _arg.ToCreateContract();
+  }
+  GetValidationPackagesConfigWriteContract(vpc) {
+    const this$ = this;
+    const paths = this$.FileSystem.Tree.ToFilePaths();
+    if (!contains$2(ValidationPackagesConfigHelper_ConfigFilePath, paths, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    })) {
+      const filePaths = append$1([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$2(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(vpc);
+  }
+  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 ARC_$reflection() {
+  return class_type("ARCtrl.ARC", void 0, ARC, ArcInvestigation_$reflection());
+}
+function ARC_$ctor_Z443FB9BF(identifier, title, description, submissionDate, publicReleaseDate, ontologySourceReferences, publications, contacts, assays, studies, workflows, runs, registeredStudyIdentifiers, comments, remarks, fs, license) {
+  return new ARC(identifier, title, description, submissionDate, publicReleaseDate, ontologySourceReferences, publications, contacts, assays, studies, workflows, runs, registeredStudyIdentifiers, comments, remarks, fs, license);
+}
+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_getLicenseFromContracts(contracts) {
+  return tryPick((c) => License.tryFromReadContract(c), contracts);
+}
+function ARCAux_updateFSByARC(isa, license, 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(w.Identifier, w.DataMap != 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(toArray(delay(() => append(singleton(investigation), delay(() => append(singleton(assaysFolder), delay(() => append(singleton(studiesFolder), delay(() => append(singleton(workflowsFolder), delay(() => append(singleton(runsFolder), delay(() => license != null ? singleton(FileSystemTree_File(value(license).Path)) : empty())))))))))))));
+  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_getLicenseFromContracts, ARCAux_getRunDataMapFromContracts, ARCAux_getStudyDataMapFromContracts, ARCAux_getWorkflowDataMapFromContracts, ARCAux_updateFSByARC, ARC_$ctor_Z443FB9BF, ARC_$reflection };