@nfdi4plants/arctrl 1.0.0-alpha10

package/ISA/ISA/JsonTypes/Process.js

@@ -0,0 +1,401 @@
+import { Record, toString } from "../../../fable_modules/fable-library.4.1.4/Types.js";
+import { zip, tryPick, map as map_1, tryFind, append, collect, choose, empty, length } from "../../../fable_modules/fable-library.4.1.4/List.js";
+import { map, value as value_4, bind, defaultArg } from "../../../fable_modules/fable-library.4.1.4/Option.js";
+import { printf, toText } from "../../../fable_modules/fable-library.4.1.4/String.js";
+import { getRecordFields, makeRecord, record_type, list_type, option_type, string_type } from "../../../fable_modules/fable-library.4.1.4/Reflection.js";
+import { Protocol_$reflection } from "./Protocol.js";
+import { ProcessParameterValue_$reflection } from "./ProcessParameterValue.js";
+import { ProcessInput_tryMaterial_102B6859, ProcessInput_trySample_102B6859, ProcessInput_tryData_102B6859, ProcessInput_trySource_102B6859, ProcessInput_tryGetCharacteristicValues_102B6859, ProcessInput_$reflection } from "./ProcessInput.js";
+import { ProcessOutput_tryGetFactorValues_11830B70, ProcessOutput_tryGetCharacteristicValues_11830B70, ProcessOutput_$reflection } from "./ProcessOutput.js";
+import { Comment$_$reflection } from "./Comment.js";
+import { create, match } from "../../../fable_modules/fable-library.4.1.4/RegExp.js";
+import { parse } from "../../../fable_modules/fable-library.4.1.4/Int32.js";
+import { List_distinct } from "../../../fable_modules/fable-library.4.1.4/Seq2.js";
+import { safeHash, equals } from "../../../fable_modules/fable-library.4.1.4/Util.js";
+import { ProtocolParameter_get_empty } from "./ProtocolParameter.js";
+import { Update_UpdateOptions, Option_fromValueWithDefault } from "../Helper.js";
+import { map2 } from "../../../fable_modules/fable-library.4.1.4/Array.js";
+import { Update_updateOnlyByExistingAppend, Update_updateOnlyByExisting, Update_updateAppend } from "../Helper.js";
+
+export class Process extends Record {
+    constructor(ID, Name, ExecutesProtocol, ParameterValues, Performer, Date$, PreviousProcess, NextProcess, Inputs, Outputs, Comments) {
+        super();
+        this.ID = ID;
+        this.Name = Name;
+        this.ExecutesProtocol = ExecutesProtocol;
+        this.ParameterValues = ParameterValues;
+        this.Performer = Performer;
+        this.Date = Date$;
+        this.PreviousProcess = PreviousProcess;
+        this.NextProcess = NextProcess;
+        this.Inputs = Inputs;
+        this.Outputs = Outputs;
+        this.Comments = Comments;
+    }
+    Print() {
+        const this$ = this;
+        return toString(this$);
+    }
+    PrintCompact() {
+        const this$ = this;
+        const inputCount = length(defaultArg(this$.Inputs, empty())) | 0;
+        const outputCount = length(defaultArg(this$.Outputs, empty())) | 0;
+        const paramCount = length(defaultArg(this$.ParameterValues, empty())) | 0;
+        const name = defaultArg(this$.Name, "Unnamed Process");
+        return toText(printf("%s [%i Inputs -> %i Params -> %i Outputs]"))(name)(inputCount)(paramCount)(outputCount);
+    }
+}
+
+export function Process_$reflection() {
+    return record_type("ARCtrl.ISA.Process", [], Process, () => [["ID", option_type(string_type)], ["Name", option_type(string_type)], ["ExecutesProtocol", option_type(Protocol_$reflection())], ["ParameterValues", option_type(list_type(ProcessParameterValue_$reflection()))], ["Performer", option_type(string_type)], ["Date", option_type(string_type)], ["PreviousProcess", option_type(Process_$reflection())], ["NextProcess", option_type(Process_$reflection())], ["Inputs", option_type(list_type(ProcessInput_$reflection()))], ["Outputs", option_type(list_type(ProcessOutput_$reflection()))], ["Comments", option_type(list_type(Comment$_$reflection()))]]);
+}
+
+export function Process_make(id, name, executesProtocol, parameterValues, performer, date, previousProcess, nextProcess, inputs, outputs, comments) {
+    return new Process(id, name, executesProtocol, parameterValues, performer, date, previousProcess, nextProcess, inputs, outputs, comments);
+}
+
+export function Process_create_Z42860F3E(Id, Name, ExecutesProtocol, ParameterValues, Performer, Date$, PreviousProcess, NextProcess, Inputs, Outputs, Comments) {
+    return Process_make(Id, Name, ExecutesProtocol, ParameterValues, Performer, Date$, PreviousProcess, NextProcess, Inputs, Outputs, Comments);
+}
+
+export function Process_get_empty() {
+    return Process_create_Z42860F3E();
+}
+
+export function Process_composeName(processNameRoot, i) {
+    return `${processNameRoot}_${i}`;
+}
+
+export function Process_decomposeName_Z721C83C5(name) {
+    const r = match(create("(?<name>.+)_(?<num>\\d+)"), name);
+    if (r != null) {
+        return [(r.groups && r.groups.name) || "", parse((r.groups && r.groups.num) || "", 511, false, 32)];
+    }
+    else {
+        return [name, void 0];
+    }
+}
+
+/**
+ * Returns the name of the protocol the given process executes
+ */
+export function Process_tryGetProtocolName_716E708F(p) {
+    return bind((p_1) => p_1.Name, p.ExecutesProtocol);
+}
+
+/**
+ * Returns the name of the protocol the given process executes
+ */
+export function Process_getProtocolName_716E708F(p) {
+    return value_4(bind((p_1) => p_1.Name, p.ExecutesProtocol));
+}
+
+/**
+ * Returns the parameter values describing the process
+ */
+export function Process_getParameterValues_716E708F(p) {
+    return defaultArg(p.ParameterValues, empty());
+}
+
+/**
+ * Returns the parameters describing the process
+ */
+export function Process_getParameters_716E708F(p) {
+    return choose((pv) => pv.Category, Process_getParameterValues_716E708F(p));
+}
+
+/**
+ * Returns the characteristics describing the inputs of the process
+ */
+export function Process_getInputCharacteristicValues_716E708F(p) {
+    const matchValue = p.Inputs;
+    if (matchValue == null) {
+        return empty();
+    }
+    else {
+        return List_distinct(collect((inp) => defaultArg(ProcessInput_tryGetCharacteristicValues_102B6859(inp), empty()), matchValue), {
+            Equals: equals,
+            GetHashCode: safeHash,
+        });
+    }
+}
+
+/**
+ * Returns the characteristics describing the outputs of the process
+ */
+export function Process_getOutputCharacteristicValues_716E708F(p) {
+    const matchValue = p.Outputs;
+    if (matchValue == null) {
+        return empty();
+    }
+    else {
+        return List_distinct(collect((out) => defaultArg(ProcessOutput_tryGetCharacteristicValues_11830B70(out), empty()), matchValue), {
+            Equals: equals,
+            GetHashCode: safeHash,
+        });
+    }
+}
+
+/**
+ * Returns the characteristic values describing the inputs and outputs of the process
+ */
+export function Process_getCharacteristicValues_716E708F(p) {
+    return List_distinct(append(Process_getInputCharacteristicValues_716E708F(p), Process_getOutputCharacteristicValues_716E708F(p)), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+/**
+ * Returns the characteristics describing the inputs and outputs of the process
+ */
+export function Process_getCharacteristics_716E708F(p) {
+    return List_distinct(choose((cv) => cv.Category, Process_getCharacteristicValues_716E708F(p)), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+/**
+ * Returns the factor values of the samples of the process
+ */
+export function Process_getFactorValues_716E708F(p) {
+    return List_distinct(collect((arg_1) => defaultArg(ProcessOutput_tryGetFactorValues_11830B70(arg_1), empty()), defaultArg(p.Outputs, empty())), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+/**
+ * Returns the factors of the samples of the process
+ */
+export function Process_getFactors_716E708F(p) {
+    return List_distinct(choose((fv) => fv.Category, Process_getFactorValues_716E708F(p)), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+/**
+ * Returns the units of the process
+ */
+export function Process_getUnits_716E708F(p) {
+    return append(choose((cv) => cv.Unit, Process_getCharacteristicValues_716E708F(p)), append(choose((pv) => pv.Unit, Process_getParameterValues_716E708F(p)), choose((fv) => fv.Unit, Process_getFactorValues_716E708F(p))));
+}
+
+/**
+ * If the process implements the given parameter, return the list of input files together with their according parameter values of this parameter
+ */
+export function Process_tryGetInputsWithParameterBy(predicate, p) {
+    const matchValue = p.ParameterValues;
+    if (matchValue == null) {
+        return void 0;
+    }
+    else {
+        const matchValue_1 = tryFind((pv) => predicate(defaultArg(pv.Category, ProtocolParameter_get_empty())), matchValue);
+        if (matchValue_1 == null) {
+            return void 0;
+        }
+        else {
+            const paramValue = matchValue_1;
+            return map((list_1) => map_1((i) => [i, paramValue], list_1), p.Inputs);
+        }
+    }
+}
+
+/**
+ * If the process implements the given parameter, return the list of output files together with their according parameter values of this parameter
+ */
+export function Process_tryGetOutputsWithParameterBy(predicate, p) {
+    const matchValue = p.ParameterValues;
+    if (matchValue == null) {
+        return void 0;
+    }
+    else {
+        const matchValue_1 = tryFind((pv) => predicate(defaultArg(pv.Category, ProtocolParameter_get_empty())), matchValue);
+        if (matchValue_1 == null) {
+            return void 0;
+        }
+        else {
+            const paramValue = matchValue_1;
+            return map((list_1) => map_1((i) => [i, paramValue], list_1), p.Outputs);
+        }
+    }
+}
+
+/**
+ * If the process implements the given characteristic, return the list of input files together with their according characteristic values of this characteristic
+ */
+export function Process_tryGetInputsWithCharacteristicBy(predicate, p) {
+    const matchValue = p.Inputs;
+    if (matchValue == null) {
+        return void 0;
+    }
+    else {
+        return Option_fromValueWithDefault(empty(), choose((i) => tryPick((mv) => {
+            const matchValue_1 = mv.Category;
+            let matchResult, m_1;
+            if (matchValue_1 != null) {
+                if (predicate(matchValue_1)) {
+                    matchResult = 0;
+                    m_1 = matchValue_1;
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0:
+                    return [i, mv];
+                default:
+                    return void 0;
+            }
+        }, defaultArg(ProcessInput_tryGetCharacteristicValues_102B6859(i), empty())), matchValue));
+    }
+}
+
+/**
+ * If the process implements the given characteristic, return the list of output files together with their according characteristic values of this characteristic
+ */
+export function Process_tryGetOutputsWithCharacteristicBy(predicate, p) {
+    const matchValue = p.Inputs;
+    const matchValue_1 = p.Outputs;
+    let matchResult, is, os;
+    if (matchValue != null) {
+        if (matchValue_1 != null) {
+            matchResult = 0;
+            is = matchValue;
+            os = matchValue_1;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return Option_fromValueWithDefault(empty(), choose((tupledArg) => tryPick((mv) => {
+                const matchValue_3 = mv.Category;
+                let matchResult_1, m_1;
+                if (matchValue_3 != null) {
+                    if (predicate(matchValue_3)) {
+                        matchResult_1 = 0;
+                        m_1 = matchValue_3;
+                    }
+                    else {
+                        matchResult_1 = 1;
+                    }
+                }
+                else {
+                    matchResult_1 = 1;
+                }
+                switch (matchResult_1) {
+                    case 0:
+                        return [tupledArg[1], mv];
+                    default:
+                        return void 0;
+                }
+            }, defaultArg(ProcessInput_tryGetCharacteristicValues_102B6859(tupledArg[0]), empty())), zip(is, os)));
+        default:
+            return void 0;
+    }
+}
+
+/**
+ * If the process implements the given factor, return the list of output files together with their according factor values of this factor
+ */
+export function Process_tryGetOutputsWithFactorBy(predicate, p) {
+    const matchValue = p.Outputs;
+    if (matchValue == null) {
+        return void 0;
+    }
+    else {
+        return Option_fromValueWithDefault(empty(), choose((o) => tryPick((mv) => {
+            const matchValue_1 = mv.Category;
+            let matchResult, m_1;
+            if (matchValue_1 != null) {
+                if (predicate(matchValue_1)) {
+                    matchResult = 0;
+                    m_1 = matchValue_1;
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0:
+                    return [o, mv];
+                default:
+                    return void 0;
+            }
+        }, defaultArg(ProcessOutput_tryGetFactorValues_11830B70(o), empty())), matchValue));
+    }
+}
+
+export function Process_getSources_716E708F(p) {
+    return List_distinct(choose(ProcessInput_trySource_102B6859, defaultArg(p.Inputs, empty())), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+export function Process_getData_716E708F(p) {
+    return List_distinct(append(choose(ProcessInput_tryData_102B6859, defaultArg(p.Inputs, empty())), choose(ProcessInput_tryData_102B6859, defaultArg(p.Inputs, empty()))), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+export function Process_getSamples_716E708F(p) {
+    return List_distinct(append(choose(ProcessInput_trySample_102B6859, defaultArg(p.Inputs, empty())), choose(ProcessInput_trySample_102B6859, defaultArg(p.Inputs, empty()))), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+export function Process_getMaterials_716E708F(p) {
+    return List_distinct(append(choose(ProcessInput_tryMaterial_102B6859, defaultArg(p.Inputs, empty())), choose(ProcessInput_tryMaterial_102B6859, defaultArg(p.Inputs, empty()))), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+export function Process_updateProtocol(referenceProtocols, p) {
+    let this$, recordType_1, recordType_2;
+    const matchValue = p.ExecutesProtocol;
+    let matchResult, protocol_1;
+    if (matchValue != null) {
+        if (matchValue.Name != null) {
+            matchResult = 0;
+            protocol_1 = matchValue;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            const matchValue_1 = tryFind((prot) => (value_4(prot.Name) === defaultArg(protocol_1.Name, "")), referenceProtocols);
+            if (matchValue_1 != null) {
+                return new Process(p.ID, p.Name, (this$ = (new Update_UpdateOptions(3, [])), (recordType_1 = protocol_1, (recordType_2 = matchValue_1, (this$.tag === 2) ? makeRecord(Protocol_$reflection(), map2(Update_updateAppend, getRecordFields(recordType_1), getRecordFields(recordType_2))) : ((this$.tag === 1) ? makeRecord(Protocol_$reflection(), map2(Update_updateOnlyByExisting, getRecordFields(recordType_1), getRecordFields(recordType_2))) : ((this$.tag === 3) ? makeRecord(Protocol_$reflection(), map2(Update_updateOnlyByExistingAppend, getRecordFields(recordType_1), getRecordFields(recordType_2))) : recordType_2))))), p.ParameterValues, p.Performer, p.Date, p.PreviousProcess, p.NextProcess, p.Inputs, p.Outputs, p.Comments);
+            }
+            else {
+                return p;
+            }
+        }
+        default:
+            return p;
+    }
+}
+

package/ISA/ISA/JsonTypes/ProcessInput.js

@@ -0,0 +1,297 @@
+import { Union, toString } from "../../../fable_modules/fable-library.4.1.4/Types.js";
+import { printf, toText } from "../../../fable_modules/fable-library.4.1.4/String.js";
+import { Source_create_7A281ED9, Source_getUnits_Z28BE5327, Source_setCharacteristicValues, Source_get_empty, Source_$reflection } from "./Source.js";
+import { Sample_create_E50ED22, Sample_getUnits_Z29207F1E, Sample_setCharacteristicValues, Sample_$reflection } from "./Sample.js";
+import { Data_create_Z326CF519, Data_$reflection } from "./Data.js";
+import { Material_create_Z31BE6CDD, Material_getUnits_Z42815C11, Material_setCharacteristicValues, Material_$reflection } from "./Material.js";
+import { union_type } from "../../../fable_modules/fable-library.4.1.4/Reflection.js";
+import { unwrap, map, defaultArg } from "../../../fable_modules/fable-library.4.1.4/Option.js";
+import { empty, choose } from "../../../fable_modules/fable-library.4.1.4/List.js";
+import { DataFile } from "./DataFile.js";
+
+export class ProcessInput extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Source", "Sample", "Data", "Material"];
+    }
+    Print() {
+        const this$ = this;
+        return toString(this$);
+    }
+    PrintCompact() {
+        const this$ = this;
+        switch (this$.tag) {
+            case 0: {
+                const arg_1 = this$.fields[0].PrintCompact();
+                return toText(printf("Source {%s}"))(arg_1);
+            }
+            case 3: {
+                const arg_2 = this$.fields[0].PrintCompact();
+                return toText(printf("Material {%s}"))(arg_2);
+            }
+            case 2: {
+                const arg_3 = this$.fields[0].PrintCompact();
+                return toText(printf("Data {%s}"))(arg_3);
+            }
+            default: {
+                const arg = this$.fields[0].PrintCompact();
+                return toText(printf("Sample {%s}"))(arg);
+            }
+        }
+    }
+}
+
+export function ProcessInput_$reflection() {
+    return union_type("ARCtrl.ISA.ProcessInput", [], ProcessInput, () => [[["Item", Source_$reflection()]], [["Item", Sample_$reflection()]], [["Item", Data_$reflection()]], [["Item", Material_$reflection()]]]);
+}
+
+export function ProcessInput__get_TryName(this$) {
+    switch (this$.tag) {
+        case 0:
+            return this$.fields[0].Name;
+        case 3:
+            return this$.fields[0].Name;
+        case 2:
+            return this$.fields[0].Name;
+        default:
+            return this$.fields[0].Name;
+    }
+}
+
+export function ProcessInput__get_Name(this$) {
+    return defaultArg(ProcessInput__get_TryName(this$), "");
+}
+
+export function ProcessInput_get_Default() {
+    return new ProcessInput(0, [Source_get_empty()]);
+}
+
+/**
+ * Returns name of processInput
+ */
+export function ProcessInput_tryGetName_102B6859(pi) {
+    return ProcessInput__get_TryName(pi);
+}
+
+/**
+ * Returns name of processInput
+ */
+export function ProcessInput_getName_102B6859(pi) {
+    return ProcessInput__get_Name(pi);
+}
+
+/**
+ * Returns true, if given name equals name of processInput
+ */
+export function ProcessInput_nameEquals(name, pi) {
+    return ProcessInput__get_Name(pi) === name;
+}
+
+/**
+ * Returns true, if Process Input is Sample
+ */
+export function ProcessInput_isSample_102B6859(pi) {
+    if (pi.tag === 1) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
+/**
+ * Returns true, if Process Input is Source
+ */
+export function ProcessInput_isSource_102B6859(pi) {
+    if (pi.tag === 0) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
+/**
+ * Returns true, if Process Input is Data
+ */
+export function ProcessInput_isData_102B6859(pi) {
+    if (pi.tag === 2) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
+/**
+ * Returns true, if Process Input is Material
+ */
+export function ProcessInput_isMaterial_102B6859(pi) {
+    if (pi.tag === 3) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
+/**
+ * Returns true, if Process Input is Source
+ */
+export function ProcessInput__isSource(this$) {
+    return ProcessInput_isSource_102B6859(this$);
+}
+
+/**
+ * Returns true, if Process Input is Sample
+ */
+export function ProcessInput__isSample(this$) {
+    return ProcessInput_isSample_102B6859(this$);
+}
+
+/**
+ * Returns true, if Process Input is Data
+ */
+export function ProcessInput__isData(this$) {
+    return ProcessInput_isData_102B6859(this$);
+}
+
+/**
+ * Returns true, if Process Input is Material
+ */
+export function ProcessInput__isMaterial(this$) {
+    return ProcessInput_isMaterial_102B6859(this$);
+}
+
+/**
+ * If given process input is a sample, returns it, else returns None
+ */
+export function ProcessInput_trySample_102B6859(pi) {
+    if (pi.tag === 1) {
+        return pi.fields[0];
+    }
+    else {
+        return void 0;
+    }
+}
+
+/**
+ * If given process input is a source, returns it, else returns None
+ */
+export function ProcessInput_trySource_102B6859(pi) {
+    if (pi.tag === 0) {
+        return pi.fields[0];
+    }
+    else {
+        return void 0;
+    }
+}
+
+/**
+ * If given process input is a data, returns it, else returns None
+ */
+export function ProcessInput_tryData_102B6859(pi) {
+    if (pi.tag === 2) {
+        return pi.fields[0];
+    }
+    else {
+        return void 0;
+    }
+}
+
+/**
+ * If given process input is a material, returns it, else returns None
+ */
+export function ProcessInput_tryMaterial_102B6859(pi) {
+    if (pi.tag === 3) {
+        return pi.fields[0];
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function ProcessInput_setCharacteristicValues(characteristics, pi) {
+    switch (pi.tag) {
+        case 0:
+            return new ProcessInput(0, [Source_setCharacteristicValues(characteristics, pi.fields[0])]);
+        case 3:
+            return new ProcessInput(3, [Material_setCharacteristicValues(characteristics, pi.fields[0])]);
+        case 2:
+            return pi;
+        default:
+            return new ProcessInput(1, [Sample_setCharacteristicValues(characteristics, pi.fields[0])]);
+    }
+}
+
+/**
+ * If given process input contains characteristics, returns them
+ */
+export function ProcessInput_tryGetCharacteristicValues_102B6859(pi) {
+    switch (pi.tag) {
+        case 0:
+            return pi.fields[0].Characteristics;
+        case 3:
+            return pi.fields[0].Characteristics;
+        case 2:
+            return void 0;
+        default:
+            return pi.fields[0].Characteristics;
+    }
+}
+
+/**
+ * If given process input contains characteristics, returns them
+ */
+export function ProcessInput_tryGetCharacteristics_102B6859(pi) {
+    return map((list) => choose((c) => c.Category, list), ProcessInput_tryGetCharacteristicValues_102B6859(pi));
+}
+
+export function ProcessInput_getCharacteristicValues_102B6859(pi) {
+    return defaultArg(ProcessInput_tryGetCharacteristicValues_102B6859(pi), empty());
+}
+
+/**
+ * If given process output contains units, returns them
+ */
+export function ProcessInput_getUnits_102B6859(pi) {
+    switch (pi.tag) {
+        case 1:
+            return Sample_getUnits_Z29207F1E(pi.fields[0]);
+        case 3:
+            return Material_getUnits_Z42815C11(pi.fields[0]);
+        case 2:
+            return empty();
+        default:
+            return Source_getUnits_Z28BE5327(pi.fields[0]);
+    }
+}
+
+export function ProcessInput_createSource_7888CE42(name, characteristics) {
+    return new ProcessInput(0, [Source_create_7A281ED9(void 0, name, unwrap(characteristics))]);
+}
+
+export function ProcessInput_createSample_Z6DF16D07(name, characteristics, factors, derivesFrom) {
+    return new ProcessInput(1, [Sample_create_E50ED22(void 0, name, unwrap(characteristics), unwrap(factors), unwrap(derivesFrom))]);
+}
+
+export function ProcessInput_createMaterial_2363974C(name, characteristics, derivesFrom) {
+    return new ProcessInput(3, [Material_create_Z31BE6CDD(void 0, name, void 0, unwrap(characteristics), unwrap(derivesFrom))]);
+}
+
+export function ProcessInput_createImageFile_Z721C83C5(name) {
+    return new ProcessInput(2, [Data_create_Z326CF519(void 0, name, new DataFile(2, []))]);
+}
+
+export function ProcessInput_createRawData_Z721C83C5(name) {
+    return new ProcessInput(2, [Data_create_Z326CF519(void 0, name, new DataFile(0, []))]);
+}
+
+export function ProcessInput_createDerivedData_Z721C83C5(name) {
+    return new ProcessInput(2, [Data_create_Z326CF519(void 0, name, new DataFile(1, []))]);
+}
+