@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

package/dist/ts/esm/ts/ARC.js

@@ -0,0 +1,948 @@
+import { FileSystem } from "./FileSystem/FileSystem.js";
+import { bind, defaultArg, value as value_3, unwrap } from "@fable-org/fable-library-js/Option.js";
+import { ArcInvestigation_$reflection, ArcWorkflow__Copy_6FCE9E49, ArcWorkflow__get_StaticHash, ArcWorkflow__GetLightHashCode, ArcWorkflow__set_StaticHash_Z524259A4, ArcWorkflow__set_DataMap_51F1E59E, ArcWorkflow__get_DataMap, ArcWorkflow__get_Identifier, ArcInvestigation } from "./Core/ArcTypes.js";
+import { fullFillContractBatchAsync } from "./ContractIO/ContractIO.js";
+import { FSharpResult$2_Ok, FSharpResult$2_Error } from "@fable-org/fable-library-js/Result.js";
+import { Contract } from "./Contract/Contract.js";
+import { PromiseBuilder__Delay_62FBFDE1, PromiseBuilder__Run_212F1D4B } 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 { toList, collect, empty, find, tryFind, iterate, map, singleton, append, delay, contains, toArray } from "@fable-org/fable-library-js/Seq.js";
+import { defaultOf, disposeSafe, getEnumerator, safeHash, curry2, comparePrimitives, stringHash } from "@fable-org/fable-library-js/Util.js";
+import { getStudyFolderPath, getAssayFolderPath } from "./FileSystem/Path.js";
+import { ARCtrl_ArcAssay__ArcAssay_tryFromReadContract_Static_7570923F, ARCtrl_ArcAssay__ArcAssay_ToUpdateContract, ARCtrl_ArcAssay__ArcAssay_ToCreateContract_6FCE9E49, ARCtrl_ArcAssay__ArcAssay_ToDeleteContract } from "./Contract/ArcAssay.js";
+import { ARCtrl_ArcInvestigation__ArcInvestigation_tryFromReadContract_Static_7570923F, ARCtrl_ArcInvestigation__ArcInvestigation_ToUpdateContract } from "./Contract/ArcInvestigation.js";
+import { ARCtrl_ArcStudy__ArcStudy_tryFromReadContract_Static_7570923F, ARCtrl_ArcStudy__ArcStudy_ToCreateContract_6FCE9E49, ARCtrl_ArcStudy__ArcStudy_ToUpdateContract } from "./Contract/ArcStudy.js";
+import { exactlyOne, tryPick, append as append_1, contains as contains_2, concat, fold, choose, map as map_1 } from "@fable-org/fable-library-js/Array.js";
+import { toText, printf, toFail, join, replace } from "@fable-org/fable-library-js/String.js";
+import { Run_datamapFileNameFromIdentifier, Run_fileNameFromIdentifier, Workflow_datamapFileNameFromIdentifier, Workflow_fileNameFromIdentifier, Assay_datamapFileNameFromIdentifier, Assay_fileNameFromIdentifier, Study_datamapFileNameFromIdentifier, Study_fileNameFromIdentifier, createMissingIdentifier } from "./Core/Helper/Identifier.js";
+import { FSharpSet__Contains, unionMany, contains as contains_1, ofSeq } from "@fable-org/fable-library-js/Set.js";
+import { DataMap__get_StaticHash, DataMap__set_StaticHash_Z524259A4, DataMap__get_DataContexts } 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 "@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.6.3.1/Cells/FsCellsCollection.fs.js";
+import { ARCtrl_DataMap__DataMap_tryFromReadContractForRun_Static, ARCtrl_DataMap__DataMap_tryFromReadContractForWorkflow_Static, ARCtrl_DataMap__DataMap_tryFromReadContractForStudy_Static, ARCtrl_DataMap__DataMap_tryFromReadContractForAssay_Static, ARCtrl_DataMap__DataMap_ToUpdateContractForRun_Z721C83C5, ARCtrl_DataMap__DataMap_ToCreateContractForRun_Z721C83C5, ARCtrl_DataMap__DataMap_ToUpdateContractForWorkflow_Z721C83C5, ARCtrl_DataMap__DataMap_ToCreateContractForWorkflow_Z721C83C5, ARCtrl_DataMap__DataMap_ToUpdateContractForAssay_Z721C83C5, ARCtrl_DataMap__DataMap_ToCreateContractForAssay_Z721C83C5, ARCtrl_DataMap__DataMap_ToUpdateContractForStudy_Z721C83C5, ARCtrl_DataMap__DataMap_ToCreateContractForStudy_Z721C83C5 } from "./Contract/Datamap.js";
+import { ARCtrl_ArcWorkflow__ArcWorkflow_tryFromReadContract_Static_7570923F, ARCtrl_ArcWorkflow__ArcWorkflow_ToUpdateContract, ARCtrl_ArcWorkflow__ArcWorkflow_ToCreateContract_6FCE9E49 } from "./Contract/ArcWorkflow.js";
+import { ARCtrl_ArcRun__ArcRun_tryFromReadContract_Static_7570923F, ARCtrl_ArcRun__ArcRun_ToUpdateContract, ARCtrl_ArcRun__ArcRun_ToCreateContract_6FCE9E49 } from "./Contract/ArcRun.js";
+import { Clone_createCloneContract_5000466F, Init_createAddRemoteContract_Z721C83C5, gitignoreContract, gitattributesContract, Init_createInitContract_6DFDD678 } from "./Contract/Git.js";
+import { ResizeArray_map } from "./Core/Helper/Collections.js";
+import { ofSeq as ofSeq_1 } from "@fable-org/fable-library-js/Map.js";
+import { fromString } from "./fable_modules/Thoth.Json.JavaScript.0.3.0/Decode.fs.js";
+import { ROCrate_encoder_8A8D439, ROCrate_get_decoder, ROCrate_get_decoderDeprecated } from "./ROCrateIO.js";
+import { toString } from "./fable_modules/Thoth.Json.JavaScript.0.3.0/Encode.fs.js";
+import { defaultSpaces } from "./Json/Encode.js";
+import { ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_tryFromReadContract_Static_7570923F, ValidationPackagesConfigHelper_ReadContract, ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toDeleteContract_Static_724DAE55, ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toCreateContract_Static_724DAE55, ValidationPackagesConfigHelper_ConfigFilePath } from "./Contract/ValidationPackagesConfig.js";
+import { FSharpRef } from "@fable-org/fable-library-js/Types.js";
+import { class_type } from "@fable-org/fable-library-js/Reflection.js";
+export 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@89"] = 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(singleton(ARCtrl_ArcAssay__ArcAssay_ToDeleteContract(assay)), delay(() => append(singleton(ARCtrl_ArcInvestigation__ArcInvestigation_ToUpdateContract(this$)), delay(() => map(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_1((p) => replace(p, oldAssayFolderPath, newAssayFolderPath), paths);
+        this$.SetFilePaths(renamedPaths);
+        return toArray(delay(() => append(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_1((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_1((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_1((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_1((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_1((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_1((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_1((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_1((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_3(col), col_1.Header.IsDataColumn)) {
+                    matchResult = 0;
+                    col_2 = value_3(col);
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0: {
+                    col_2.Cells.forEach((c) => {
+                        if (c.AsData.FilePath != null) {
+                            const newFilePath = dataNameFunction(c.AsData);
+                            c.AsData.FilePath = newFilePath;
+                        }
+                    });
+                    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;
+                }
+            }, DataMap__get_DataContexts(dm));
+        };
+        iterate((s) => {
+            const f = (d) => d.GetAbsolutePathForStudy(s.Identifier, checkExistenceFromRoot);
+            const source_1 = s.Tables;
+            iterate(curry2(updateTable)(f), source_1);
+            if (s.DataMap != null) {
+                updateDataMap(f, value_3(s.DataMap));
+            }
+        }, this$.Studies);
+        iterate((a) => {
+            const f_1 = (d_1) => d_1.GetAbsolutePathForAssay(a.Identifier, checkExistenceFromRoot);
+            const source_3 = a.Tables;
+            iterate(curry2(updateTable)(f_1), source_3);
+            if (a.DataMap != null) {
+                updateDataMap(f_1, value_3(a.DataMap));
+            }
+        }, this$.Assays);
+    }
+    static fromFilePaths(filePaths) {
+        const fs = FileSystem.fromFilePaths(filePaths);
+        return new ARC(createMissingIdentifier(), undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, 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_1((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_3(registeredStudyOpt);
+                registeredStudy.UpdateReferenceByStudyFile(study, true);
+            }
+            const datamap = ARCAux_getAssayDataMapFromContracts(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_3(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 = 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_3(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_3(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_3(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_3(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_1((fp) => {
+            const matchValue = Dictionary_tryGet(fp, workbooks);
+            if (matchValue == null) {
+                return Contract.createCreate(fp, "PlainText");
+            }
+            else {
+                const wb = value_3(matchValue)[1];
+                const dto = value_3(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((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_1;
+                            s.StaticHash = (hash_1 | 0);
+                            const matchValue = s.DataMap;
+                            let matchResult, dm_2, dm_3;
+                            if (matchValue != null) {
+                                if (DataMap__get_StaticHash(value_3(matchValue)) === 0) {
+                                    matchResult = 0;
+                                    dm_2 = value_3(matchValue);
+                                }
+                                else if ((dm_1 = value_3(matchValue), DataMap__get_StaticHash(dm_1) !== safeHash(dm_1))) {
+                                    matchResult = 1;
+                                    dm_3 = value_3(matchValue);
+                                }
+                                else {
+                                    matchResult = 2;
+                                }
+                            }
+                            else {
+                                matchResult = 2;
+                            }
+                            switch (matchResult) {
+                                case 0:
+                                    return append(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(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(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_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_3(matchValue_1)) === 0) {
+                                    matchResult_1 = 0;
+                                    dm_6 = value_3(matchValue_1);
+                                }
+                                else if ((dm_5 = value_3(matchValue_1), DataMap__get_StaticHash(dm_5) !== safeHash(dm_5))) {
+                                    matchResult_1 = 1;
+                                    dm_7 = value_3(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(() => {
+                                        DataMap__set_StaticHash_Z524259A4(dm_6, safeHash(dm_6));
+                                        return empty();
+                                    }));
+                                case 1:
+                                    return append(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(collect((w) => {
+                        const hash_3 = ArcWorkflow__GetLightHashCode(w) | 0;
+                        return append((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_3(matchValue_2)) === 0) {
+                                    matchResult_2 = 0;
+                                    dm_10 = value_3(matchValue_2);
+                                }
+                                else if ((dm_9 = value_3(matchValue_2), DataMap__get_StaticHash(dm_9) !== safeHash(dm_9))) {
+                                    matchResult_2 = 1;
+                                    dm_11 = value_3(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, ArcWorkflow__get_Identifier(w))), delay(() => {
+                                        DataMap__set_StaticHash_Z524259A4(dm_10, safeHash(dm_10));
+                                        return empty();
+                                    }));
+                                case 1:
+                                    return append(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((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_3(matchValue_3)) === 0) {
+                                    matchResult_3 = 0;
+                                    dm_14 = value_3(matchValue_3);
+                                }
+                                else if ((dm_13 = value_3(matchValue_3), DataMap__get_StaticHash(dm_13) !== safeHash(dm_13))) {
+                                    matchResult_3 = 1;
+                                    dm_15 = value_3(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(() => {
+                                        DataMap__set_StaticHash_Z524259A4(dm_14, safeHash(dm_14));
+                                        return empty();
+                                    }));
+                                case 1:
+                                    return append(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) {
+        const defaultGitignore_1 = defaultArg(defaultGitignore, false);
+        return toArray(delay(() => append(singleton(Init_createInitContract_6DFDD678(unwrap(branch))), delay(() => append(singleton(gitattributesContract), delay(() => append(defaultGitignore_1 ? singleton(gitignoreContract) : empty(), delay(() => ((repositoryAddress != null) ? singleton(Init_createAddRemoteContract_Z721C83C5(value_3(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_1((s) => s.RegisteredAssays.slice(), registeredStudies));
+        const includeFiles = unionMany([ofSeq(["isa.investigation.xlsx", "README.md"], {
+                Compare: comparePrimitives,
+            }), unionMany(map_1((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_1((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 isa;
+            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 {
+                isa = matchValue.fields[0];
+            }
+            return ARC.fromArcInvestigation(isa);
+        }
+        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_8A8D439(this$);
+        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_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));
+    }
+}
+export function ARC_$reflection() {
+    return class_type("ARCtrl.ARC", undefined, ARC, ArcInvestigation_$reflection());
+}
+export function ARC_$ctor_5BB4A6F7(identifier, title, description, submissionDate, publicReleaseDate, ontologySourceReferences, publications, contacts, assays, studies, workflows, runs, registeredStudyIdentifiers, comments, remarks, cwl, fs) {
+    return new ARC(identifier, title, description, submissionDate, publicReleaseDate, ontologySourceReferences, publications, contacts, assays, studies, workflows, runs, registeredStudyIdentifiers, comments, remarks, cwl, fs);
+}
+export function ARCAux_getArcAssaysFromContracts(contracts) {
+    return choose(ARCtrl_ArcAssay__ArcAssay_tryFromReadContract_Static_7570923F, contracts);
+}
+export function ARCAux_getArcStudiesFromContracts(contracts) {
+    return choose(ARCtrl_ArcStudy__ArcStudy_tryFromReadContract_Static_7570923F, contracts);
+}
+export function ARCAux_getArcWorkflowsFromContracts(contracts) {
+    return choose(ARCtrl_ArcWorkflow__ArcWorkflow_tryFromReadContract_Static_7570923F, contracts);
+}
+export function ARCAux_getArcRunsFromContracts(contracts) {
+    return choose(ARCtrl_ArcRun__ArcRun_tryFromReadContract_Static_7570923F, contracts);
+}
+export function ARCAux_getAssayDataMapFromContracts(assayIdentifier, contracts) {
+    return tryPick((c) => ARCtrl_DataMap__DataMap_tryFromReadContractForAssay_Static(assayIdentifier, c), contracts);
+}
+export function ARCAux_getStudyDataMapFromContracts(studyIdentifier, contracts) {
+    return tryPick((c) => ARCtrl_DataMap__DataMap_tryFromReadContractForStudy_Static(studyIdentifier, c), contracts);
+}
+export function ARCAux_getWorkflowDataMapFromContracts(workflowIdentifier, contracts) {
+    return tryPick((c) => ARCtrl_DataMap__DataMap_tryFromReadContractForWorkflow_Static(workflowIdentifier, c), contracts);
+}
+export function ARCAux_getRunDataMapFromContracts(runIdentifier, contracts) {
+    return tryPick((c) => ARCtrl_DataMap__DataMap_tryFromReadContractForRun_Static(runIdentifier, c), contracts);
+}
+export function ARCAux_getArcInvestigationFromContracts(contracts) {
+    return exactlyOne(choose(ARCtrl_ArcInvestigation__ArcInvestigation_tryFromReadContract_Static_7570923F, contracts));
+}
+export function ARCAux_updateFSByISA(isa, fs) {
+    let assaysFolder;
+    const assays = map_1((a) => FileSystemTree.createAssayFolder(a.Identifier, a.DataMap != null), toArray(isa.Assays));
+    assaysFolder = FileSystemTree.createAssaysFolder(assays);
+    let studiesFolder;
+    const studies = map_1((s) => FileSystemTree.createStudyFolder(s.Identifier, s.DataMap != null), toArray(isa.Studies));
+    studiesFolder = FileSystemTree.createStudiesFolder(studies);
+    let workflowsFolder;
+    const workflows = map_1((w) => FileSystemTree.createWorkflowFolder(ArcWorkflow__get_Identifier(w), ArcWorkflow__get_DataMap(w) != null), toArray(isa.Workflows));
+    workflowsFolder = FileSystemTree.createWorkflowsFolder(workflows);
+    let runsFolder;
+    const runs = map_1((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: tree,
+    });
+    return fs.Union(tree_1);
+}
+export function ARCAux_updateFSByCWL(cwl, fs) {
+    const workflows = FileSystemTree.createWorkflowsFolder([]);
+    const runs = FileSystemTree.createRunsFolder([]);
+    let tree_1;
+    const tree = FileSystemTree.createRootFolder([workflows, runs]);
+    tree_1 = FileSystem.create({
+        tree: tree,
+    });
+    return fs.Union(tree_1);
+}