@nfdi4plants/arctrl 3.0.0-beta.8 → 3.0.0

package/dist/ts/ts/CWL/Decode.js

@@ -0,0 +1,2617 @@
+import { getEnumerator, disposeSafe, Lazy } from '../../node_modules/@fable-org/fable-library-js/Util.js';
+import { replace, trimEnd, join, trimStart, toText, interpolate, printf, substring, trim } from '../../node_modules/@fable-org/fable-library-js/String.js';
+import { item } from '../../node_modules/@fable-org/fable-library-js/Array.js';
+import { choose, isEmpty, head, tail, iterate, map, empty, exists, tryPick, cons, singleton as singleton$1, ofArray, tryHead } from '../../node_modules/@fable-org/fable-library-js/List.js';
+import { YAMLElement_Mapping, YAMLElement_Sequence, YAMLElement_Object, YAMLContent, YAMLElement_Value } from '../fable_modules/YAMLicious.1.0.0-alpha.3/YAMLiciousTypes.fs.js';
+import { value, map as map$1, unwrap, defaultArg, some, bind } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { read, object, string, bool, resizearray, int } from '../fable_modules/YAMLicious.1.0.0-alpha.3/Decode.fs.js';
+import { setProperty, setOptionalProperty } from '../fable_modules/DynamicObj.7.1.0/DynObj.fs.js';
+import { DynamicObj } from '../fable_modules/DynamicObj.7.1.0/DynamicObj.fs.js';
+import { SchemaSaladString_Literal, SchemaSaladString_Import, SchemaSaladString_Include, SchemaSaladStringModule_toDirectiveString, CWLType_Dirent, DirentInstance, DirectoryInstance_$ctor, FileInstance_$ctor, CWLType_Null, CWLType_Stdout, CWLType_Boolean, CWLType_Double, CWLType_Float, CWLType_Long, CWLType_Int, CWLType_String, CWLType_Directory, CWLType_File, CWLType_Array, InputArraySchema, InputRecordField, InputRecordSchema, InputEnumSchema, CWLType_Union, CWLType_Record, CWLType_Enum, SoftwarePackage, SchemaDefRequirementType } from './CWLTypes.js';
+import { OutputBinding, CWLOutput, OutputSource_Multiple, OutputSource_Single } from './Outputs.js';
+import { InitialWorkDirEntry_StringEntry, InitialWorkDirEntry_DirentEntry, InitialWorkDirEntry_DirectoryEntry, InitialWorkDirEntry_FileEntry, DockerRequirement_create_Z14898805, EnvironmentDef, LoadListingRequirementValue, LoadListingEnum_tryParse_Z721C83C5, ResourceRequirementInstance_$ctor_D76FC00, Requirement_WorkReuseExpressionRequirement, Requirement_WorkReuseRequirement, WorkReuseRequirementValue, Requirement_NetworkAccessExpressionRequirement, Requirement_NetworkAccessRequirement, NetworkAccessRequirementValue, InplaceUpdateRequirementValue, ToolTimeLimitValue_ToolTimeLimitExpression, ToolTimeLimitValue_ToolTimeLimitSeconds, InlineJavascriptRequirementValue, Requirement_StepInputExpressionRequirement, Requirement_MultipleInputFeatureRequirement, Requirement_ScatterFeatureRequirement, Requirement_SubworkflowFeatureRequirement, Requirement_ToolTimeLimitRequirement, Requirement_InplaceUpdateRequirement, Requirement_ResourceRequirement, Requirement_ShellCommandRequirement, Requirement_EnvVarRequirement, Requirement_InitialWorkDirRequirement, Requirement_LoadListingRequirement, Requirement_SoftwareRequirement, Requirement_DockerRequirement, Requirement_SchemaDefRequirement, Requirement_InlineJavascriptRequirement, HintEntry_UnknownHint, HintUnknownValue, HintEntry_KnownHint } from './Requirements.js';
+import { toArray, delay, collect, append, empty as empty$1, singleton, head as head$1, map as map$2, length } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { getItemFromDict } from '../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { compare } from '../../node_modules/@fable-org/fable-library-js/BigInt.js';
+import { tryParse } from '../../node_modules/@fable-org/fable-library-js/Long.js';
+import { FSharpRef } from '../../node_modules/@fable-org/fable-library-js/Types.js';
+import { tryParse as tryParse$1 } from '../../node_modules/@fable-org/fable-library-js/Double.js';
+import { InputBinding, CWLInput } from './Inputs.js';
+import { LinkMergeMethod, PickValueMethod, ScatterMethod, StepInput, StepOutput_StepOutputRecord, StepOutputParameter, StepOutput_StepOutputString, WorkflowStepRun_RunString, WorkflowStep } from './WorkflowSteps.js';
+import { WorkflowStepRunOps_fromTool, WorkflowStepRunOps_fromOperation, WorkflowStepRunOps_fromExpressionTool, WorkflowStepRunOps_fromWorkflow, CWLProcessingUnit_Operation, CWLProcessingUnit_ExpressionTool, CWLProcessingUnit_Workflow, CWLProcessingUnit_CommandLineTool } from './CWLProcessingUnit.js';
+import { CWLToolDescription } from './ToolDescription.js';
+import { CWLExpressionToolDescription } from './ExpressionToolDescription.js';
+import { CWLOperationDescription } from './OperationDescription.js';
+import { CWLWorkflowDescription } from './WorkflowDescription.js';
+import { CWLParameterReference } from './ParameterReference.js';
+
+function ResizeArray_map(f, a) {
+  const b = [];
+  let enumerator = getEnumerator(a);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const i = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      void b.push(f(i));
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  return b;
+}
+function Decode_normalizeYamlInput(yaml) {
+  const normalized = yaml == null ? "" : replace(yaml, "\r\n", "\n");
+  const lines = normalized.split("\n");
+  return trimEnd(join("\n", lines.length > 0 && item(0, lines).startsWith("#!") ? lines.slice(1, lines.length) : lines));
+}
+function Decode_removeFullLineComments(yaml) {
+  let array;
+  return join("\n", (array = yaml.split("\n"), array.filter((line) => !trimStart(line).startsWith("#"))));
+}
+function Decode_removeYamlComments(yamlElement) {
+  switch (yamlElement.tag) {
+    case /* Object */
+    3:
+      return YAMLElement_Object(choose((element) => {
+        if (element.tag === /* Comment */
+        4) {
+          return void 0;
+        } else {
+          return Decode_removeYamlComments(element);
+        }
+      }, yamlElement.fields[0]));
+    case /* Sequence */
+    2:
+      return YAMLElement_Sequence(choose((element_1) => {
+        const matchValue = Decode_removeYamlComments(element_1);
+        let matchResult, other_1;
+        switch (matchValue.tag) {
+          case /* Comment */
+          4: {
+            matchResult = 0;
+            break;
+          }
+          case /* Object */
+          3: {
+            if (isEmpty(matchValue.fields[0])) {
+              matchResult = 1;
+            } else {
+              matchResult = 2;
+              other_1 = matchValue;
+            }
+            break;
+          }
+          default: {
+            matchResult = 2;
+            other_1 = matchValue;
+          }
+        }
+        switch (matchResult) {
+          case 0:
+            return void 0;
+          case 1:
+            return void 0;
+          default:
+            return other_1;
+        }
+      }, yamlElement.fields[0]));
+    case /* Mapping */
+    0:
+      return YAMLElement_Mapping(yamlElement.fields[0], Decode_removeYamlComments(yamlElement.fields[1]));
+    default:
+      return yamlElement;
+  }
+}
+function Decode_isRecoverableDecodingError(ex) {
+  let matchResult;
+  if (ex.message.indexOf("Expected") >= 0) {
+    matchResult = 4;
+  } else if (ex.message.indexOf("Required") >= 0) {
+    matchResult = 5;
+  } else {
+    matchResult = 6;
+  }
+  switch (matchResult) {
+    case 0:
+      return true;
+    case 1:
+      return true;
+    case 2:
+      return true;
+    case 3:
+      return true;
+    case 4:
+      return true;
+    case 5:
+      return true;
+    default:
+      return false;
+  }
+}
+function Decode_readSanitizedYaml(yaml) {
+  const normalized = Decode_normalizeYamlInput(yaml);
+  const tryRead = (text) => Decode_removeYamlComments(read(text));
+  try {
+    return tryRead(normalized);
+  } catch (matchValue) {
+    if (Decode_isRecoverableDecodingError(matchValue)) {
+      return tryRead(Decode_removeFullLineComments(normalized));
+    } else {
+      throw matchValue;
+    }
+  }
+}
+function Decode_overflowDecoder(dynObj, dict) {
+  let enumerator = getEnumerator(dict);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const e = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      const matchValue = e[1];
+      let matchResult, v, s;
+      if (matchValue.tag === /* Object */
+      3) {
+        if (!isEmpty(matchValue.fields[0])) {
+          switch (head(matchValue.fields[0]).tag) {
+            case /* Value */
+            1: {
+              if (isEmpty(tail(matchValue.fields[0]))) {
+                matchResult = 0;
+                v = head(matchValue.fields[0]).fields[0];
+              } else {
+                matchResult = 2;
+              }
+              break;
+            }
+            case /* Sequence */
+            2: {
+              if (isEmpty(tail(matchValue.fields[0]))) {
+                matchResult = 1;
+                s = head(matchValue.fields[0]).fields[0];
+              } else {
+                matchResult = 2;
+              }
+              break;
+            }
+            default:
+              matchResult = 2;
+          }
+        } else {
+          matchResult = 2;
+        }
+      } else {
+        matchResult = 2;
+      }
+      switch (matchResult) {
+        case 0: {
+          setProperty(e[0], v.Value, dynObj);
+          break;
+        }
+        case 1: {
+          const newDynObj = new DynamicObj();
+          iterate((x) => {
+            setProperty(e[0], x, dynObj);
+          }, map((arg) => Decode_overflowDecoder(newDynObj, object((get$) => get$.Overflow.FieldList(empty()), arg)), s));
+          break;
+        }
+        case 2: {
+          setProperty(e[0], e[1], dynObj);
+          break;
+        }
+      }
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  return dynObj;
+}
+function Decode_decodeSchemaSaladString(yEle) {
+  let matchResult, v, c, v_1;
+  switch (yEle.tag) {
+    case /* Value */
+    1: {
+      matchResult = 0;
+      v = yEle.fields[0];
+      break;
+    }
+    case /* Object */
+    3: {
+      if (!isEmpty(yEle.fields[0])) {
+        switch (head(yEle.fields[0]).tag) {
+          case /* Value */
+          1: {
+            if (isEmpty(tail(yEle.fields[0]))) {
+              matchResult = 0;
+              v = head(yEle.fields[0]).fields[0];
+            } else {
+              matchResult = 2;
+            }
+            break;
+          }
+          case /* Mapping */
+          0: {
+            switch (head(yEle.fields[0]).fields[1].tag) {
+              case /* Value */
+              1: {
+                if (isEmpty(tail(yEle.fields[0]))) {
+                  matchResult = 1;
+                  c = head(yEle.fields[0]).fields[0];
+                  v_1 = head(yEle.fields[0]).fields[1].fields[0];
+                } else {
+                  matchResult = 2;
+                }
+                break;
+              }
+              case /* Object */
+              3: {
+                if (!isEmpty(head(yEle.fields[0]).fields[1].fields[0])) {
+                  if (head(head(yEle.fields[0]).fields[1].fields[0]).tag === /* Value */
+                  1) {
+                    if (isEmpty(tail(head(yEle.fields[0]).fields[1].fields[0]))) {
+                      if (isEmpty(tail(yEle.fields[0]))) {
+                        matchResult = 1;
+                        c = head(yEle.fields[0]).fields[0];
+                        v_1 = head(head(yEle.fields[0]).fields[1].fields[0]).fields[0];
+                      } else {
+                        matchResult = 2;
+                      }
+                    } else {
+                      matchResult = 2;
+                    }
+                  } else {
+                    matchResult = 2;
+                  }
+                } else {
+                  matchResult = 2;
+                }
+                break;
+              }
+              default:
+                matchResult = 2;
+            }
+            break;
+          }
+          default:
+            matchResult = 2;
+        }
+      } else {
+        matchResult = 2;
+      }
+      break;
+    }
+    default:
+      matchResult = 2;
+  }
+  switch (matchResult) {
+    case 0:
+      return SchemaSaladString_Literal(v.Value);
+    case 1: {
+      const matchValue = c.Value;
+      switch (matchValue) {
+        case "$include":
+          return SchemaSaladString_Include(v_1.Value);
+        case "$import":
+          return SchemaSaladString_Import(v_1.Value);
+        default:
+          return SchemaSaladString_Literal(toText(printf("%s: %s"))(c.Value)(v_1.Value));
+      }
+    }
+    default:
+      throw new Error(toText(interpolate("Unexpected YAMLElement format in decodeSchemaSaladString: %A%P()", [yEle])));
+  }
+}
+function Decode_decodeStringOrExpression(yEle) {
+  return SchemaSaladStringModule_toDirectiveString(Decode_decodeSchemaSaladString(yEle));
+}
+const Decode_outputBindingGlobDecoder = (value_1) => object((get$) => {
+  let objectArg;
+  return new OutputBinding((objectArg = get$.Optional, objectArg.Field("glob", string)));
+}, value_1);
+const Decode_outputBindingDecoder = (value) => object((get$) => {
+  const objectArg = get$.Optional;
+  return objectArg.Field("outputBinding", Decode_outputBindingGlobDecoder);
+}, value);
+function Decode_decodeStringArrayOrScalar(value) {
+  let matchResult, items;
+  switch (value.tag) {
+    case /* Object */
+    3: {
+      if (!isEmpty(value.fields[0])) {
+        if (head(value.fields[0]).tag === /* Sequence */
+        2) {
+          if (isEmpty(tail(value.fields[0]))) {
+            matchResult = 0;
+            items = head(value.fields[0]).fields[0];
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+      break;
+    }
+    case /* Sequence */
+    2: {
+      matchResult = 0;
+      items = value.fields[0];
+      break;
+    }
+    default:
+      matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0: {
+      const collection = map(Decode_decodeStringOrExpression, items);
+      return Array.from(collection);
+    }
+    default:
+      return [Decode_decodeStringOrExpression(value)];
+  }
+}
+const Decode_outputSourceDecoder = (value_1) => object((get$) => {
+  const objectArg = get$.Optional;
+  return objectArg.Field("outputSource", Decode_decodeStringArrayOrScalar);
+}, value_1);
+const Decode_direntDecoder = (value_1) => object((get$) => {
+  let objectArg, objectArg_1, objectArg_2;
+  return CWLType_Dirent(new DirentInstance((objectArg = get$.Required, objectArg.Field("entry", Decode_decodeSchemaSaladString)), (objectArg_1 = get$.Optional, objectArg_1.Field("entryname", Decode_decodeSchemaSaladString)), (objectArg_2 = get$.Optional, objectArg_2.Field("writable", bool))));
+}, value_1);
+function Decode_initialWorkDirEntryDecoder(value$1) {
+  let fileInstance, directoryInstance;
+  switch (value$1.tag) {
+    case /* Object */
+    3: {
+      const mappings = value$1.fields[0];
+      if (exists((_arg) => {
+        let matchResult, k_1;
+        if (_arg.tag === /* Mapping */
+        0) {
+          if (_arg.fields[0].Value === "entry") {
+            matchResult = 0;
+            k_1 = _arg.fields[0];
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+        switch (matchResult) {
+          case 0:
+            return true;
+          default:
+            return false;
+        }
+      }, mappings)) {
+        const matchValue = Decode_direntDecoder(value$1);
+        if (matchValue.tag === /* Dirent */
+        2) {
+          return InitialWorkDirEntry_DirentEntry(matchValue.fields[0]);
+        } else {
+          throw new Error("Unexpected InitialWorkDir Dirent decoding result.");
+        }
+      } else {
+        const classValue = tryPick((_arg_1) => {
+          let v, v_1;
+          let matchResult_1, k_4, v_2, k_5, v_3;
+          if (_arg_1.tag === /* Mapping */
+          0) {
+            switch (_arg_1.fields[1].tag) {
+              case /* Object */
+              3: {
+                if (!isEmpty(_arg_1.fields[1].fields[0])) {
+                  if (head(_arg_1.fields[1].fields[0]).tag === /* Value */
+                  1) {
+                    if (isEmpty(tail(_arg_1.fields[1].fields[0]))) {
+                      if (v = head(_arg_1.fields[1].fields[0]).fields[0], _arg_1.fields[0].Value === "class") {
+                        matchResult_1 = 0;
+                        k_4 = _arg_1.fields[0];
+                        v_2 = head(_arg_1.fields[1].fields[0]).fields[0];
+                      } else {
+                        matchResult_1 = 2;
+                      }
+                    } else {
+                      matchResult_1 = 2;
+                    }
+                  } else {
+                    matchResult_1 = 2;
+                  }
+                } else {
+                  matchResult_1 = 2;
+                }
+                break;
+              }
+              case /* Value */
+              1: {
+                if (v_1 = _arg_1.fields[1].fields[0], _arg_1.fields[0].Value === "class") {
+                  matchResult_1 = 1;
+                  k_5 = _arg_1.fields[0];
+                  v_3 = _arg_1.fields[1].fields[0];
+                } else {
+                  matchResult_1 = 2;
+                }
+                break;
+              }
+              default:
+                matchResult_1 = 2;
+            }
+          } else {
+            matchResult_1 = 2;
+          }
+          switch (matchResult_1) {
+            case 0:
+              return v_2.Value;
+            case 1:
+              return v_3.Value;
+            default:
+              return void 0;
+          }
+        }, mappings);
+        let matchResult_2;
+        if (classValue != null) {
+          switch (value(classValue)) {
+            case "File": {
+              matchResult_2 = 0;
+              break;
+            }
+            case "Directory": {
+              matchResult_2 = 1;
+              break;
+            }
+            default:
+              matchResult_2 = 2;
+          }
+        } else {
+          matchResult_2 = 2;
+        }
+        switch (matchResult_2) {
+          case 0:
+            return InitialWorkDirEntry_FileEntry((fileInstance = FileInstance_$ctor(), void object((get$) => Decode_overflowDecoder(fileInstance, get$.Overflow.FieldList(empty())), value$1), fileInstance));
+          case 1:
+            return InitialWorkDirEntry_DirectoryEntry((directoryInstance = DirectoryInstance_$ctor(), void object((get$_1) => Decode_overflowDecoder(directoryInstance, get$_1.Overflow.FieldList(empty())), value$1), directoryInstance));
+          default:
+            return InitialWorkDirEntry_StringEntry(Decode_decodeSchemaSaladString(value$1));
+        }
+      }
+    }
+    case /* Value */
+    1:
+      return InitialWorkDirEntry_StringEntry(Decode_decodeSchemaSaladString(value$1));
+    default:
+      throw new Error(toText(interpolate("Invalid InitialWorkDir listing entry: %A%P()", [value$1])));
+  }
+}
+function Decode_cwlSimpleTypeFromString(s) {
+  switch (s) {
+    case "File":
+      return CWLType_File(FileInstance_$ctor());
+    case "Directory":
+      return CWLType_Directory(DirectoryInstance_$ctor());
+    case "string":
+      return CWLType_String();
+    case "int":
+      return CWLType_Int();
+    case "long":
+      return CWLType_Long();
+    case "float":
+      return CWLType_Float();
+    case "double":
+      return CWLType_Double();
+    case "boolean":
+      return CWLType_Boolean();
+    case "stdout":
+      return CWLType_Stdout();
+    case "null":
+      return CWLType_Null();
+    default:
+      throw new Error(`Invalid CWL simple type: ${s}`);
+  }
+}
+function Decode_parseArrayShorthand(typeStr) {
+  if (typeStr.endsWith("[]")) {
+    const innerType = substring(typeStr, 0, typeStr.length - 2);
+    const matchValue = Decode_parseArrayShorthand(innerType);
+    if (matchValue == null) {
+      try {
+        return CWLType_Array(new InputArraySchema(Decode_cwlSimpleTypeFromString(innerType), void 0, void 0, void 0));
+      } catch (matchValue_1) {
+        if (Decode_isRecoverableDecodingError(matchValue_1)) {
+          return void 0;
+        } else {
+          throw matchValue_1;
+        }
+      }
+    } else {
+      return CWLType_Array(new InputArraySchema(value(matchValue), void 0, void 0, void 0));
+    }
+  } else {
+    return void 0;
+  }
+}
+function inputArraySchemaDecoder$0040261() {
+  return (value_3) => object((get$) => {
+    let objectArg, objectArg_1, objectArg_2, objectArg_3;
+    return new InputArraySchema(Decode_cwlTypeDecoder$0027((objectArg = get$.Required, objectArg.Field("items", (x) => x))), (objectArg_1 = get$.Optional, objectArg_1.Field("label", string)), (objectArg_2 = get$.Optional, objectArg_2.Field("doc", string)), (objectArg_3 = get$.Optional, objectArg_3.Field("name", string)));
+  }, value_3);
+}
+const inputArraySchemaDecoder$0040261$002D1 = new Lazy(inputArraySchemaDecoder$0040261);
+function inputRecordFieldDecoder$0040275() {
+  return (value_3) => object((get$) => {
+    let objectArg, objectArg_1, objectArg_2, objectArg_3;
+    return new InputRecordField((objectArg = get$.Required, objectArg.Field("name", string)), Decode_cwlTypeDecoder$0027((objectArg_1 = get$.Required, objectArg_1.Field("type", (x) => x))), (objectArg_2 = get$.Optional, objectArg_2.Field("doc", string)), (objectArg_3 = get$.Optional, objectArg_3.Field("label", string)));
+  }, value_3);
+}
+const inputRecordFieldDecoder$0040275$002D1 = new Lazy(inputRecordFieldDecoder$0040275);
+function inputRecordSchemaDecoder$0040314() {
+  return (value_3) => object((get$) => {
+    let fieldsElement, objectArg, element, matchValue, objectArg_1, objectArg_2, objectArg_3;
+    return new InputRecordSchema((fieldsElement = (objectArg = get$.Optional, objectArg.Field("fields", (x) => x)), fieldsElement == null ? void 0 : value(fieldsElement).tag === /* Object */
+    3 ? isEmpty(value(fieldsElement).fields[0]) ? [] : (element = value(fieldsElement), matchValue = Decode_tryDecodeFieldsAsArray(element), matchValue == null ? Decode_tryDecodeFieldsAsMap(element) : value(matchValue)) : (element = value(fieldsElement), matchValue = Decode_tryDecodeFieldsAsArray(element), matchValue == null ? Decode_tryDecodeFieldsAsMap(element) : value(matchValue))), (objectArg_1 = get$.Optional, objectArg_1.Field("label", string)), (objectArg_2 = get$.Optional, objectArg_2.Field("doc", string)), (objectArg_3 = get$.Optional, objectArg_3.Field("name", string)));
+  }, value_3);
+}
+const inputRecordSchemaDecoder$0040314$002D1 = new Lazy(inputRecordSchemaDecoder$0040314);
+function inputEnumSchemaDecoder$0040341() {
+  return (value_5) => object((get$) => {
+    let objectArg, objectArg_1, objectArg_2, objectArg_3;
+    return new InputEnumSchema((objectArg = get$.Required, objectArg.Field("symbols", (value) => resizearray(string, value))), (objectArg_1 = get$.Optional, objectArg_1.Field("label", string)), (objectArg_2 = get$.Optional, objectArg_2.Field("doc", string)), (objectArg_3 = get$.Optional, objectArg_3.Field("name", string)));
+  }, value_5);
+}
+const inputEnumSchemaDecoder$0040341$002D1 = new Lazy(inputEnumSchemaDecoder$0040341);
+const Decode_inputArraySchemaDecoder = inputArraySchemaDecoder$0040261$002D1.Value;
+const Decode_inputRecordFieldDecoder = inputRecordFieldDecoder$0040275$002D1.Value;
+function Decode_tryDecodeFieldsAsArray(element) {
+  try {
+    return resizearray(inputRecordFieldDecoder$0040275$002D1.Value, element);
+  } catch (matchValue) {
+    if (Decode_isRecoverableDecodingError(matchValue)) {
+      return void 0;
+    } else {
+      throw matchValue;
+    }
+  }
+}
+function Decode_tryDecodeFieldsAsMap(element) {
+  try {
+    const fields = [];
+    let enumerator = getEnumerator(object((get2) => get2.Overflow.FieldList(empty()), element));
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const kvp = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        const fieldType = Decode_cwlTypeDecoder$0027(kvp[1]);
+        void fields.push(new InputRecordField(kvp[0], fieldType, void 0, void 0));
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+    return fields;
+  } catch (matchValue) {
+    if (Decode_isRecoverableDecodingError(matchValue)) {
+      return void 0;
+    } else {
+      throw matchValue;
+    }
+  }
+}
+const Decode_inputRecordSchemaDecoder = inputRecordSchemaDecoder$0040314$002D1.Value;
+const Decode_inputEnumSchemaDecoder = inputEnumSchemaDecoder$0040341$002D1.Value;
+function Decode_cwlTypeDecoder$0027(element) {
+  let collection;
+  const parseTypeString = (typeStr) => {
+    const patternInput = typeStr.endsWith("?") ? [replace(typeStr, "?", ""), true] : [typeStr, false];
+    const stripped = patternInput[0];
+    let baseType;
+    const matchValue = Decode_parseArrayShorthand(stripped);
+    baseType = matchValue == null ? Decode_cwlSimpleTypeFromString(stripped) : value(matchValue);
+    if (patternInput[1]) {
+      return CWLType_Union([CWLType_Null(), baseType]);
+    } else {
+      return baseType;
+    }
+  };
+  let matchResult, v, items;
+  switch (element.tag) {
+    case /* Value */
+    1: {
+      matchResult = 0;
+      v = element.fields[0];
+      break;
+    }
+    case /* Object */
+    3: {
+      if (!isEmpty(element.fields[0])) {
+        if (head(element.fields[0]).tag === /* Value */
+        1) {
+          if (isEmpty(tail(element.fields[0]))) {
+            matchResult = 0;
+            v = head(element.fields[0]).fields[0];
+          } else {
+            matchResult = 2;
+          }
+        } else {
+          matchResult = 2;
+        }
+      } else {
+        matchResult = 2;
+      }
+      break;
+    }
+    case /* Sequence */
+    2: {
+      matchResult = 1;
+      items = element.fields[0];
+      break;
+    }
+    default:
+      matchResult = 3;
+  }
+  switch (matchResult) {
+    case 0:
+      return parseTypeString(v.Value);
+    case 1:
+      return CWLType_Union((collection = map(Decode_cwlTypeDecoder$0027, items), Array.from(collection)));
+    case 2:
+      return object((get$) => {
+        let objectArg_1;
+        let typeField;
+        const objectArg = get$.Optional;
+        typeField = objectArg.Field("type", (x) => x);
+        let matchResult_1, v_1;
+        if (typeField != null) {
+          if (value(typeField).tag === /* Object */
+          3) {
+            if (!isEmpty(value(typeField).fields[0])) {
+              if (head(value(typeField).fields[0]).tag === /* Value */
+              1) {
+                if (isEmpty(tail(value(typeField).fields[0]))) {
+                  matchResult_1 = 0;
+                  v_1 = head(value(typeField).fields[0]).fields[0];
+                } else {
+                  matchResult_1 = 1;
+                }
+              } else {
+                matchResult_1 = 1;
+              }
+            } else {
+              matchResult_1 = 1;
+            }
+          } else {
+            matchResult_1 = 2;
+          }
+        } else {
+          matchResult_1 = 2;
+        }
+        switch (matchResult_1) {
+          case 0: {
+            const matchValue_1 = v_1.Value;
+            return matchValue_1 === "record" ? CWLType_Record(inputRecordSchemaDecoder$0040314$002D1.Value(element)) : matchValue_1 === "enum" ? CWLType_Enum(inputEnumSchemaDecoder$0040341$002D1.Value(element)) : matchValue_1 === "array" ? CWLType_Array(inputArraySchemaDecoder$0040261$002D1.Value(element)) : parseTypeString(matchValue_1);
+          }
+          case 1:
+            return Decode_cwlTypeDecoder$0027((objectArg_1 = get$.Required, objectArg_1.Field("type", (x_1) => x_1)));
+          default:
+            throw new Error("Unexpected type format in cwlTypeDecoder'");
+        }
+      }, element);
+    default:
+      throw new Error("Unexpected YAMLElement in cwlTypeDecoder'");
+  }
+}
+function Decode_cwlTypeStringMatcher(t, get$) {
+  const patternInput = t.endsWith("?") ? [true, replace(t, "?", "")] : [false, t];
+  const optional = patternInput[0];
+  const newT = patternInput[1];
+  let cwlType;
+  const matchValue = Decode_parseArrayShorthand(newT);
+  if (matchValue == null) {
+    switch (newT) {
+      case "File": {
+        cwlType = CWLType_File(FileInstance_$ctor());
+        break;
+      }
+      case "Directory": {
+        cwlType = CWLType_Directory(DirectoryInstance_$ctor());
+        break;
+      }
+      case "Dirent": {
+        const objectArg = get$.Required;
+        cwlType = objectArg.Field("listing", Decode_direntDecoder);
+        break;
+      }
+      case "string": {
+        cwlType = CWLType_String();
+        break;
+      }
+      case "int": {
+        cwlType = CWLType_Int();
+        break;
+      }
+      case "long": {
+        cwlType = CWLType_Long();
+        break;
+      }
+      case "float": {
+        cwlType = CWLType_Float();
+        break;
+      }
+      case "double": {
+        cwlType = CWLType_Double();
+        break;
+      }
+      case "boolean": {
+        cwlType = CWLType_Boolean();
+        break;
+      }
+      case "stdout": {
+        cwlType = CWLType_Stdout();
+        break;
+      }
+      case "null": {
+        cwlType = CWLType_Null();
+        break;
+      }
+      default:
+        throw new Error("Invalid CWL type");
+    }
+  } else {
+    cwlType = value(matchValue);
+  }
+  return [optional ? CWLType_Union([CWLType_Null(), cwlType]) : cwlType, optional];
+}
+const Decode_cwlTypeDecoder = (value_1) => object((get$) => {
+  let objectArg_1;
+  let cwlType;
+  const objectArg = get$.Required;
+  cwlType = objectArg.Field("type", (value) => {
+    let matchResult, v, o;
+    switch (value.tag) {
+      case /* Value */
+      1: {
+        matchResult = 0;
+        v = value.fields[0];
+        break;
+      }
+      case /* Object */
+      3: {
+        if (!isEmpty(value.fields[0])) {
+          if (head(value.fields[0]).tag === /* Value */
+          1) {
+            if (isEmpty(tail(value.fields[0]))) {
+              matchResult = 0;
+              v = head(value.fields[0]).fields[0];
+            } else {
+              matchResult = 1;
+              o = value.fields[0];
+            }
+          } else {
+            matchResult = 1;
+            o = value.fields[0];
+          }
+        } else {
+          matchResult = 1;
+          o = value.fields[0];
+        }
+        break;
+      }
+      default:
+        matchResult = 2;
+    }
+    switch (matchResult) {
+      case 0:
+        return v.Value;
+      case 1:
+        return void 0;
+      default:
+        throw new Error("Unexpected YAMLElement in cwlTypeDecoder");
+    }
+  });
+  if (cwlType == null) {
+    return [(objectArg_1 = get$.Required, objectArg_1.Field("type", Decode_cwlTypeDecoder$0027)), false];
+  } else {
+    return Decode_cwlTypeStringMatcher(value(cwlType), get$);
+  }
+}, value_1);
+const Decode_outputArrayDecoder = (value_1) => object((get$) => {
+  const dict = get$.Overflow.FieldList(empty());
+  const collection = toArray(delay(() => collect((key) => {
+    let v;
+    const value$1 = getItemFromDict(dict, key);
+    const outputBinding = Decode_outputBindingDecoder(value$1);
+    const outputSourceValues = Decode_outputSourceDecoder(value$1);
+    const output = new CWLOutput(key, value$1.tag === /* Object */
+    3 ? !isEmpty(value$1.fields[0]) ? head(value$1.fields[0]).tag === /* Value */
+    1 ? isEmpty(tail(value$1.fields[0])) ? (v = head(value$1.fields[0]).fields[0], Decode_cwlTypeStringMatcher(v.Value, get$)[0]) : Decode_cwlTypeDecoder(value$1)[0] : Decode_cwlTypeDecoder(value$1)[0] : Decode_cwlTypeDecoder(value$1)[0] : Decode_cwlTypeDecoder(value$1)[0]);
+    return append(outputBinding != null ? (setOptionalProperty("outputBinding", outputBinding, output), empty$1()) : empty$1(), delay(() => {
+      let matchValue, values, values_2, values_1, values_3;
+      return append((matchValue = outputSourceValues, matchValue != null ? (values = value(matchValue), values.length > 1) ? (values_2 = value(matchValue), output.OutputSource = OutputSource_Multiple(values_2), empty$1()) : (values_1 = value(matchValue), values_1.length === 1) ? (values_3 = value(matchValue), output.OutputSource = OutputSource_Single(values_3[0]), empty$1()) : empty$1() : empty$1()), delay(() => singleton(output)));
+    }));
+  }, dict.keys())));
+  return Array.from(collection);
+}, value_1);
+const Decode_outputsDecoder = (value) => object((get$) => {
+  const objectArg = get$.Required;
+  return objectArg.Field("outputs", Decode_outputArrayDecoder);
+}, value);
+function Decode_dockerRequirementDecoder(get$) {
+  let objectArg, objectArg_1, objectArg_2, objectArg_3, objectArg_4, objectArg_5;
+  const dockerFile = map$1(Decode_decodeSchemaSaladString, (objectArg = get$.Optional, objectArg.Field("dockerFile", (x) => x)));
+  return DockerRequirement_create_Z14898805(unwrap((objectArg_1 = get$.Optional, objectArg_1.Field("dockerPull", string))), void 0, unwrap(dockerFile), unwrap((objectArg_2 = get$.Optional, objectArg_2.Field("dockerImageId", string))), unwrap((objectArg_3 = get$.Optional, objectArg_3.Field("dockerLoad", string))), unwrap((objectArg_4 = get$.Optional, objectArg_4.Field("dockerImport", string))), unwrap((objectArg_5 = get$.Optional, objectArg_5.Field("dockerOutputDirectory", string))));
+}
+function Decode_envVarRequirementDecoder(get$) {
+  let envDefElement;
+  let _arg;
+  const objectArg = get$.Required;
+  _arg = objectArg.Field("envDef", (x) => x);
+  let matchResult, sequence, mappings, other;
+  if (_arg.tag === /* Object */
+  3) {
+    if (!isEmpty(_arg.fields[0])) {
+      switch (head(_arg.fields[0]).tag) {
+        case /* Sequence */
+        2: {
+          if (isEmpty(tail(_arg.fields[0]))) {
+            matchResult = 0;
+            sequence = head(_arg.fields[0]).fields[0];
+          } else {
+            matchResult = 2;
+            other = _arg;
+          }
+          break;
+        }
+        case /* Object */
+        3: {
+          if (isEmpty(tail(_arg.fields[0]))) {
+            matchResult = 1;
+            mappings = head(_arg.fields[0]).fields[0];
+          } else {
+            matchResult = 2;
+            other = _arg;
+          }
+          break;
+        }
+        default: {
+          matchResult = 2;
+          other = _arg;
+        }
+      }
+    } else {
+      matchResult = 2;
+      other = _arg;
+    }
+  } else {
+    matchResult = 2;
+    other = _arg;
+  }
+  switch (matchResult) {
+    case 0: {
+      envDefElement = YAMLElement_Sequence(sequence);
+      break;
+    }
+    case 1: {
+      envDefElement = YAMLElement_Object(mappings);
+      break;
+    }
+    default:
+      envDefElement = other;
+  }
+  switch (envDefElement.tag) {
+    case /* Sequence */
+    2:
+      return resizearray((value_3) => object((get2) => {
+        let objectArg_1, objectArg_2;
+        return new EnvironmentDef((objectArg_1 = get2.Required, objectArg_1.Field("envName", string)), (objectArg_2 = get2.Required, objectArg_2.Field("envValue", string)));
+      }, value_3), envDefElement);
+    case /* Object */
+    3: {
+      const collection = choose((_arg_2) => {
+        let _arg_1, value;
+        if (_arg_2.tag === /* Mapping */
+        0) {
+          return new EnvironmentDef(_arg_2.fields[0].Value, (_arg_1 = _arg_2.fields[1], _arg_1.tag === /* Value */
+          1 ? (value = _arg_1.fields[0], trim(value.Value, '"')) : _arg_1.tag === /* Object */
+          3 ? !isEmpty(_arg_1.fields[0]) ? head(_arg_1.fields[0]).tag === /* Value */
+          1 ? isEmpty(tail(_arg_1.fields[0])) ? (value = head(_arg_1.fields[0]).fields[0], trim(value.Value, '"')) : Decode_decodeStringOrExpression(_arg_1) : Decode_decodeStringOrExpression(_arg_1) : Decode_decodeStringOrExpression(_arg_1) : Decode_decodeStringOrExpression(_arg_1)));
+        } else {
+          return void 0;
+        }
+      }, envDefElement.fields[0]);
+      return Array.from(collection);
+    }
+    default:
+      throw new Error("Invalid envDef format. Expected array or map.");
+  }
+}
+function Decode_softwareRequirementDecoder(get$) {
+  let objectArg;
+  const normalizeCollectionElement = (_arg) => {
+    let matchResult, sequence, mappings, other;
+    if (_arg.tag === /* Object */
+    3) {
+      if (!isEmpty(_arg.fields[0])) {
+        switch (head(_arg.fields[0]).tag) {
+          case /* Sequence */
+          2: {
+            if (isEmpty(tail(_arg.fields[0]))) {
+              matchResult = 0;
+              sequence = head(_arg.fields[0]).fields[0];
+            } else {
+              matchResult = 2;
+              other = _arg;
+            }
+            break;
+          }
+          case /* Object */
+          3: {
+            if (isEmpty(tail(_arg.fields[0]))) {
+              matchResult = 1;
+              mappings = head(_arg.fields[0]).fields[0];
+            } else {
+              matchResult = 2;
+              other = _arg;
+            }
+            break;
+          }
+          default: {
+            matchResult = 2;
+            other = _arg;
+          }
+        }
+      } else {
+        matchResult = 2;
+        other = _arg;
+      }
+    } else {
+      matchResult = 2;
+      other = _arg;
+    }
+    switch (matchResult) {
+      case 0:
+        return YAMLElement_Sequence(sequence);
+      case 1:
+        return YAMLElement_Object(mappings);
+      default:
+        return other;
+    }
+  };
+  const packagesElement = normalizeCollectionElement((objectArg = get$.Required, objectArg.Field("packages", (x) => x)));
+  const decodeSpecsArray = (element) => resizearray(Decode_decodeStringOrExpression, normalizeCollectionElement(element));
+  switch (packagesElement.tag) {
+    case /* Sequence */
+    2:
+      return resizearray((value_5) => object((get2) => {
+        let objectArg_1, objectArg_2, objectArg_3;
+        return new SoftwarePackage((objectArg_1 = get2.Required, objectArg_1.Field("package", string)), (objectArg_2 = get2.Optional, objectArg_2.Field("version", (value_1) => resizearray(string, value_1))), (objectArg_3 = get2.Optional, objectArg_3.Field("specs", (value_3) => resizearray(string, value_3))));
+      }, value_5), packagesElement);
+    case /* Object */
+    3: {
+      const collection = choose((_arg_3) => {
+        let packageName, packageValue, normalizedPackageValue, mappings_1;
+        if (_arg_3.tag === /* Mapping */
+        0) {
+          return packageName = _arg_3.fields[0].Value, packageValue = _arg_3.fields[1], normalizedPackageValue = normalizeCollectionElement(packageValue), normalizedPackageValue.tag === /* Object */
+          3 ? isEmpty(normalizedPackageValue.fields[0]) ? new SoftwarePackage(packageName, void 0, void 0) : (mappings_1 = normalizedPackageValue.fields[0], new SoftwarePackage(packageName, tryPick((_arg_1) => {
+            let v;
+            let matchResult_1, k_1, v_1;
+            if (_arg_1.tag === /* Mapping */
+            0) {
+              if (v = _arg_1.fields[1], _arg_1.fields[0].Value === "version") {
+                matchResult_1 = 0;
+                k_1 = _arg_1.fields[0];
+                v_1 = _arg_1.fields[1];
+              } else {
+                matchResult_1 = 1;
+              }
+            } else {
+              matchResult_1 = 1;
+            }
+            switch (matchResult_1) {
+              case 0:
+                return decodeSpecsArray(v_1);
+              default:
+                return void 0;
+            }
+          }, mappings_1), tryPick((_arg_2) => {
+            let v_2;
+            let matchResult_2, k_3, v_3;
+            if (_arg_2.tag === /* Mapping */
+            0) {
+              if (v_2 = _arg_2.fields[1], _arg_2.fields[0].Value === "specs") {
+                matchResult_2 = 0;
+                k_3 = _arg_2.fields[0];
+                v_3 = _arg_2.fields[1];
+              } else {
+                matchResult_2 = 1;
+              }
+            } else {
+              matchResult_2 = 1;
+            }
+            switch (matchResult_2) {
+              case 0:
+                return decodeSpecsArray(v_3);
+              default:
+                return void 0;
+            }
+          }, mappings_1))) : normalizedPackageValue.tag === /* Sequence */
+          2 ? new SoftwarePackage(packageName, void 0, decodeSpecsArray(normalizedPackageValue)) : new SoftwarePackage(packageName, void 0, [Decode_decodeStringOrExpression(packageValue)]);
+        } else {
+          return void 0;
+        }
+      }, packagesElement.fields[0]);
+      return Array.from(collection);
+    }
+    default:
+      throw new Error("Invalid packages format. Expected array or map.");
+  }
+}
+function Decode_initialWorkDirRequirementDecoder(get$) {
+  let listingElement;
+  const objectArg = get$.Required;
+  listingElement = objectArg.Field("listing", (x) => x);
+  let matchResult;
+  switch (listingElement.tag) {
+    case /* Object */
+    3: {
+      if (!isEmpty(listingElement.fields[0])) {
+        if (head(listingElement.fields[0]).tag === /* Sequence */
+        2) {
+          if (isEmpty(tail(listingElement.fields[0]))) {
+            matchResult = 0;
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+      break;
+    }
+    case /* Sequence */
+    2: {
+      matchResult = 0;
+      break;
+    }
+    default:
+      matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return resizearray(Decode_initialWorkDirEntryDecoder, listingElement);
+    default:
+      return [Decode_initialWorkDirEntryDecoder(listingElement)];
+  }
+}
+function Decode_loadListingRequirementDecoder(get$) {
+  let objectArg, matchValue;
+  const loadListingValue = defaultArg((objectArg = get$.Optional, objectArg.Field("loadListing", string)), "no_listing");
+  return new LoadListingRequirementValue((matchValue = LoadListingEnum_tryParse_Z721C83C5(loadListingValue), matchValue == null ? (() => {
+    throw new Error(`Invalid loadListing value '${loadListingValue}'. Expected one of: no_listing, shallow_listing, deep_listing.`);
+  })() : value(matchValue)));
+}
+function Decode_decodeResourceScalar(element) {
+  let matchValue;
+  const _arg = element;
+  let matchResult, value$1;
+  switch (_arg.tag) {
+    case /* Value */
+    1: {
+      matchResult = 0;
+      value$1 = _arg.fields[0];
+      break;
+    }
+    case /* Object */
+    3: {
+      if (!isEmpty(_arg.fields[0])) {
+        if (head(_arg.fields[0]).tag === /* Value */
+        1) {
+          if (isEmpty(tail(_arg.fields[0]))) {
+            matchResult = 0;
+            value$1 = head(_arg.fields[0]).fields[0];
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+      break;
+    }
+    default:
+      matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0: {
+      matchValue = value$1.Value;
+      break;
+    }
+    default:
+      matchValue = void 0;
+  }
+  if (matchValue == null) {
+    return Decode_decodeStringOrExpression(element);
+  } else {
+    const scalarValue = value(matchValue);
+    let matchValue_1;
+    let outArg = 0n;
+    matchValue_1 = [tryParse(scalarValue, 7, false, 64, new FSharpRef(() => outArg, (v) => {
+      outArg = v;
+    })), outArg];
+    if (matchValue_1[0]) {
+      return matchValue_1[1];
+    } else {
+      let matchValue_2;
+      let outArg_1 = 0;
+      matchValue_2 = [tryParse$1(scalarValue, new FSharpRef(() => outArg_1, (v_1) => {
+        outArg_1 = v_1;
+      })), outArg_1];
+      if (matchValue_2[0]) {
+        return matchValue_2[1];
+      } else {
+        return Decode_decodeStringOrExpression(element);
+      }
+    }
+  }
+}
+function Decode_optionalResourceField(get$, fieldName) {
+  let objectArg;
+  return map$1(Decode_decodeResourceScalar, (objectArg = get$.Optional, objectArg.Field(fieldName, (x) => x)));
+}
+function Decode_resourceRequirementDecoder(get$) {
+  return ResourceRequirementInstance_$ctor_D76FC00(some(Decode_optionalResourceField(get$, "coresMin")), some(Decode_optionalResourceField(get$, "coresMax")), some(Decode_optionalResourceField(get$, "ramMin")), some(Decode_optionalResourceField(get$, "ramMax")), some(Decode_optionalResourceField(get$, "tmpdirMin")), some(Decode_optionalResourceField(get$, "tmpdirMax")), some(Decode_optionalResourceField(get$, "outdirMin")), some(Decode_optionalResourceField(get$, "outdirMax")));
+}
+function Decode_schemaDefRequirementTypeDecoder(value) {
+  const dict = object((get$) => get$.Overflow.FieldList(empty()), value);
+  if (dict.has("name")) {
+    return new SchemaDefRequirementType(Decode_decodeStringOrExpression(getItemFromDict(dict, "name")), Decode_cwlTypeDecoder$0027(value));
+  } else {
+    if (dict.size === 0) {
+      throw new Error("SchemaDefRequirement entry cannot be empty.");
+    }
+    const kv = head$1(dict);
+    return new SchemaDefRequirementType(kv[0], Decode_cwlTypeDecoder$0027(kv[1]));
+  }
+}
+function Decode_schemaDefRequirementDecoder(get$) {
+  const objectArg = get$.Required;
+  return objectArg.Field("types", (value) => resizearray(Decode_schemaDefRequirementTypeDecoder, value));
+}
+function Decode_tryDecodeBoolScalar(element) {
+  let matchResult, value;
+  switch (element.tag) {
+    case /* Value */
+    1: {
+      matchResult = 0;
+      value = element.fields[0];
+      break;
+    }
+    case /* Object */
+    3: {
+      if (!isEmpty(element.fields[0])) {
+        if (head(element.fields[0]).tag === /* Value */
+        1) {
+          if (isEmpty(tail(element.fields[0]))) {
+            matchResult = 0;
+            value = head(element.fields[0]).fields[0];
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+      break;
+    }
+    default:
+      matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0: {
+      const matchValue = value.Value.trim().toLowerCase();
+      switch (matchValue) {
+        case "true":
+          return true;
+        case "false":
+          return false;
+        default:
+          return void 0;
+      }
+    }
+    default:
+      return void 0;
+  }
+}
+function Decode_workReuseRequirementDecoder(get$) {
+  let matchValue;
+  const objectArg = get$.Optional;
+  matchValue = objectArg.Field("enableReuse", (x) => x);
+  if (matchValue != null) {
+    const value$1 = value(matchValue);
+    const matchValue_1 = Decode_tryDecodeBoolScalar(value$1);
+    if (matchValue_1 == null) {
+      return Requirement_WorkReuseExpressionRequirement(Decode_decodeStringOrExpression(value$1));
+    } else {
+      return Requirement_WorkReuseRequirement(new WorkReuseRequirementValue(value(matchValue_1)));
+    }
+  } else {
+    return Requirement_WorkReuseRequirement(new WorkReuseRequirementValue(true));
+  }
+}
+function Decode_networkAccessRequirementDecoder(get$) {
+  let matchValue;
+  const objectArg = get$.Optional;
+  matchValue = objectArg.Field("networkAccess", (x) => x);
+  if (matchValue != null) {
+    const value$1 = value(matchValue);
+    const matchValue_1 = Decode_tryDecodeBoolScalar(value$1);
+    if (matchValue_1 == null) {
+      return Requirement_NetworkAccessExpressionRequirement(Decode_decodeStringOrExpression(value$1));
+    } else {
+      return Requirement_NetworkAccessRequirement(new NetworkAccessRequirementValue(value(matchValue_1)));
+    }
+  } else {
+    return Requirement_NetworkAccessRequirement(new NetworkAccessRequirementValue(true));
+  }
+}
+function Decode_inplaceUpdateRequirementDecoder(get$) {
+  let objectArg;
+  return new InplaceUpdateRequirementValue(defaultArg((objectArg = get$.Optional, objectArg.Field("inplaceUpdate", bool)), true));
+}
+function Decode_toolTimeLimitRequirementDecoder(get$) {
+  let value$1;
+  let timeLimitElement;
+  const objectArg = get$.Required;
+  timeLimitElement = objectArg.Field("timelimit", (x) => x);
+  const tryGetScalarString = timeLimitElement.tag === /* Value */
+  1 ? (value$1 = timeLimitElement.fields[0], value$1.Value) : timeLimitElement.tag === /* Object */
+  3 ? !isEmpty(timeLimitElement.fields[0]) ? head(timeLimitElement.fields[0]).tag === /* Value */
+  1 ? isEmpty(tail(timeLimitElement.fields[0])) ? (value$1 = head(timeLimitElement.fields[0]).fields[0], value$1.Value) : void 0 : void 0 : void 0 : void 0;
+  if (tryGetScalarString == null) {
+    return ToolTimeLimitValue_ToolTimeLimitExpression(Decode_decodeStringOrExpression(timeLimitElement));
+  } else {
+    let matchValue;
+    let outArg = 0n;
+    matchValue = [tryParse(value(tryGetScalarString), 7, false, 64, new FSharpRef(() => outArg, (v) => {
+      outArg = v;
+    })), outArg];
+    if (matchValue[0]) {
+      if (compare(matchValue[1], 0n) >= 0) {
+        return ToolTimeLimitValue_ToolTimeLimitSeconds(matchValue[1]);
+      } else {
+        throw new Error("ToolTimeLimit timelimit must be non-negative.");
+      }
+    } else {
+      return ToolTimeLimitValue_ToolTimeLimitExpression(Decode_decodeStringOrExpression(timeLimitElement));
+    }
+  }
+}
+function Decode_inlineJavascriptRequirementDecoder(get$) {
+  let objectArg;
+  return new InlineJavascriptRequirementValue((objectArg = get$.Optional, objectArg.Field("expressionLib", Decode_decodeStringArrayOrScalar)));
+}
+function Decode_requirementFromTypeName(cls, get$) {
+  switch (cls) {
+    case "InlineJavascriptRequirement":
+      return Requirement_InlineJavascriptRequirement(Decode_inlineJavascriptRequirementDecoder(get$));
+    case "SchemaDefRequirement":
+      return Requirement_SchemaDefRequirement(Decode_schemaDefRequirementDecoder(get$));
+    case "DockerRequirement":
+      return Requirement_DockerRequirement(Decode_dockerRequirementDecoder(get$));
+    case "SoftwareRequirement":
+      return Requirement_SoftwareRequirement(Decode_softwareRequirementDecoder(get$));
+    case "LoadListingRequirement":
+      return Requirement_LoadListingRequirement(Decode_loadListingRequirementDecoder(get$));
+    case "InitialWorkDirRequirement":
+      return Requirement_InitialWorkDirRequirement(Decode_initialWorkDirRequirementDecoder(get$));
+    case "EnvVarRequirement":
+      return Requirement_EnvVarRequirement(Decode_envVarRequirementDecoder(get$));
+    case "ShellCommandRequirement":
+      return Requirement_ShellCommandRequirement();
+    case "ResourceRequirement":
+      return Requirement_ResourceRequirement(Decode_resourceRequirementDecoder(get$));
+    case "WorkReuse":
+    case "WorkReuseRequirement":
+      return Decode_workReuseRequirementDecoder(get$);
+    case "NetworkAccess":
+    case "NetworkAccessRequirement":
+      return Decode_networkAccessRequirementDecoder(get$);
+    case "InplaceUpdateRequirement":
+    case "InplaceUpdate":
+      return Requirement_InplaceUpdateRequirement(Decode_inplaceUpdateRequirementDecoder(get$));
+    case "ToolTimeLimit":
+    case "ToolTimeLimitRequirement":
+      return Requirement_ToolTimeLimitRequirement(Decode_toolTimeLimitRequirementDecoder(get$));
+    case "SubworkflowFeatureRequirement":
+      return Requirement_SubworkflowFeatureRequirement();
+    case "ScatterFeatureRequirement":
+      return Requirement_ScatterFeatureRequirement();
+    case "MultipleInputFeatureRequirement":
+      return Requirement_MultipleInputFeatureRequirement();
+    case "StepInputExpressionRequirement":
+      return Requirement_StepInputExpressionRequirement();
+    default:
+      throw new Error(`Invalid or unsupported requirement class: ${cls}`);
+  }
+}
+function Decode_requirementArrayDecoder(yEle) {
+  let matchResult, items, other;
+  if (yEle.tag === /* Object */
+  3) {
+    if (!isEmpty(yEle.fields[0])) {
+      if (head(yEle.fields[0]).tag === /* Sequence */
+      2) {
+        if (isEmpty(tail(yEle.fields[0]))) {
+          matchResult = 0;
+          items = head(yEle.fields[0]).fields[0];
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 2;
+    other = yEle;
+  }
+  switch (matchResult) {
+    case 0: {
+      const collection = map((ele) => object((get$) => {
+        let objectArg;
+        return Decode_requirementFromTypeName((objectArg = get$.Required, objectArg.Field("class", string)), get$);
+      }, ele), items);
+      return Array.from(collection);
+    }
+    case 1:
+      return object((get$_1) => {
+        const collection_1 = map$2((kv) => object((get$_2) => Decode_requirementFromTypeName(kv[0], get$_2), kv[1]), get$_1.Overflow.FieldList(empty()));
+        return Array.from(collection_1);
+      }, yEle);
+    default:
+      throw new Error(`Invalid CWL requirements syntax: ${other}`);
+  }
+}
+function Decode_tryDecodeKnownRequirementFromElement(element) {
+  try {
+    return object((get$) => {
+      let objectArg;
+      return Decode_requirementFromTypeName((objectArg = get$.Required, objectArg.Field("class", string)), get$);
+    }, element);
+  } catch (ex) {
+    let hintClass;
+    try {
+      hintClass = object((get$_1) => {
+        const objectArg_1 = get$_1.Optional;
+        return objectArg_1.Field("class", string);
+      }, element);
+    } catch (matchValue) {
+      hintClass = void 0;
+    }
+    if (hintClass == null) {
+    } else {
+      const knownClass = value(hintClass);
+    }
+    return void 0;
+  }
+}
+function Decode_decodeHintElement(element) {
+  const matchValue = Decode_tryDecodeKnownRequirementFromElement(element);
+  if (matchValue == null) {
+    return HintEntry_UnknownHint(new HintUnknownValue((() => {
+      try {
+        return object((get$) => {
+          const objectArg = get$.Optional;
+          return objectArg.Field("class", string);
+        }, element);
+      } catch (matchValue_1) {
+        return void 0;
+      }
+    })(), element));
+  } else {
+    return HintEntry_KnownHint(value(matchValue));
+  }
+}
+function Decode_hintArrayDecoder(yEle) {
+  let matchResult, items, other_1;
+  switch (yEle.tag) {
+    case /* Object */
+    3: {
+      if (!isEmpty(yEle.fields[0])) {
+        if (head(yEle.fields[0]).tag === /* Sequence */
+        2) {
+          if (isEmpty(tail(yEle.fields[0]))) {
+            matchResult = 0;
+            items = head(yEle.fields[0]).fields[0];
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+      break;
+    }
+    case /* Sequence */
+    2: {
+      matchResult = 0;
+      items = yEle.fields[0];
+      break;
+    }
+    default: {
+      matchResult = 2;
+      other_1 = yEle;
+    }
+  }
+  switch (matchResult) {
+    case 0: {
+      const collection = map(Decode_decodeHintElement, items);
+      return Array.from(collection);
+    }
+    case 1:
+      return object((get$) => {
+        const collection_1 = map$2((kv) => {
+          let matchValue, mappings;
+          return Decode_decodeHintElement((matchValue = kv[1], matchValue.tag === /* Object */
+          3 ? (mappings = matchValue.fields[0], exists((_arg) => {
+            let matchResult_1, k_1;
+            if (_arg.tag === /* Mapping */
+            0) {
+              if (_arg.fields[0].Value === "class") {
+                matchResult_1 = 0;
+                k_1 = _arg.fields[0];
+              } else {
+                matchResult_1 = 1;
+              }
+            } else {
+              matchResult_1 = 1;
+            }
+            switch (matchResult_1) {
+              case 0:
+                return true;
+              default:
+                return false;
+            }
+          }, mappings) ? kv[1] : YAMLElement_Object(cons(YAMLElement_Mapping(new YAMLContent("class", void 0), YAMLElement_Object(singleton$1(YAMLElement_Value(new YAMLContent(kv[0], void 0))))), mappings))) : YAMLElement_Object(ofArray([YAMLElement_Mapping(new YAMLContent("class", void 0), YAMLElement_Object(singleton$1(YAMLElement_Value(new YAMLContent(kv[0], void 0))))), YAMLElement_Mapping(new YAMLContent("value", void 0), matchValue)]))));
+        }, get$.Overflow.FieldList(empty()));
+        return Array.from(collection_1);
+      }, yEle);
+    default:
+      throw new Error(`Invalid CWL hints syntax: ${other_1}`);
+  }
+}
+const Decode_requirementsDecoder = (value) => object((get$) => {
+  const objectArg = get$.Optional;
+  return objectArg.Field("requirements", Decode_requirementArrayDecoder);
+}, value);
+const Decode_hintsDecoder = (value) => object((get$) => {
+  const objectArg = get$.Optional;
+  return objectArg.Field("hints", Decode_hintArrayDecoder);
+}, value);
+const Decode_inputBindingDecoder = (value_5) => object((get$) => {
+  const objectArg = get$.Optional;
+  return objectArg.Field("inputBinding", (value_4) => object((get$0027) => {
+    let objectArg_1, objectArg_2, objectArg_3, objectArg_4;
+    return new InputBinding((objectArg_1 = get$0027.Optional, objectArg_1.Field("prefix", string)), (objectArg_2 = get$0027.Optional, objectArg_2.Field("position", int)), (objectArg_3 = get$0027.Optional, objectArg_3.Field("itemSeparator", string)), (objectArg_4 = get$0027.Optional, objectArg_4.Field("separate", bool)));
+  }, value_4));
+}, value_5);
+const Decode_inputArrayDecoder = (value_1) => object((get$) => {
+  const dict = get$.Overflow.FieldList(empty());
+  const collection = toArray(delay(() => collect((key) => {
+    const value = getItemFromDict(dict, key);
+    const inputBinding = Decode_inputBindingDecoder(value);
+    let patternInput;
+    let matchResult, v, mappings;
+    if (value.tag === /* Object */
+    3) {
+      if (!isEmpty(value.fields[0])) {
+        if (head(value.fields[0]).tag === /* Value */
+        1) {
+          if (isEmpty(tail(value.fields[0]))) {
+            matchResult = 0;
+            v = head(value.fields[0]).fields[0];
+          } else {
+            matchResult = 1;
+            mappings = value.fields[0];
+          }
+        } else {
+          matchResult = 1;
+          mappings = value.fields[0];
+        }
+      } else {
+        matchResult = 1;
+        mappings = value.fields[0];
+      }
+    } else {
+      matchResult = 2;
+    }
+    switch (matchResult) {
+      case 0: {
+        patternInput = Decode_cwlTypeStringMatcher(v.Value, get$);
+        break;
+      }
+      case 1: {
+        if (exists((m) => {
+          let matchResult_1, k_1;
+          if (m.tag === /* Mapping */
+          0) {
+            if (m.fields[0].Value === "type") {
+              matchResult_1 = 0;
+              k_1 = m.fields[0];
+            } else {
+              matchResult_1 = 1;
+            }
+          } else {
+            matchResult_1 = 1;
+          }
+          switch (matchResult_1) {
+            case 0:
+              return true;
+            default:
+              return false;
+          }
+        }, mappings)) {
+          patternInput = Decode_cwlTypeDecoder(value);
+        } else {
+          let matchResult_2, v_1;
+          if (value.tag === /* Object */
+          3) {
+            if (!isEmpty(value.fields[0])) {
+              if (head(value.fields[0]).tag === /* Value */
+              1) {
+                if (isEmpty(tail(value.fields[0]))) {
+                  matchResult_2 = 0;
+                  v_1 = head(value.fields[0]).fields[0];
+                } else {
+                  matchResult_2 = 1;
+                }
+              } else {
+                matchResult_2 = 1;
+              }
+            } else {
+              matchResult_2 = 1;
+            }
+          } else {
+            matchResult_2 = 1;
+          }
+          switch (matchResult_2) {
+            case 0: {
+              patternInput = Decode_cwlTypeStringMatcher(v_1.Value, get$);
+              break;
+            }
+            default:
+              throw new Error("Unexpected input format without type field");
+          }
+        }
+        break;
+      }
+      default:
+        throw new Error("Unexpected input format in inputArrayDecoder");
+    }
+    const input = new CWLInput(key, patternInput[0]);
+    return append(patternInput[1] ? (setOptionalProperty("optional", true, input), empty$1()) : empty$1(), delay(() => append(inputBinding != null ? (setOptionalProperty("inputBinding", inputBinding, input), empty$1()) : empty$1(), delay(() => singleton(input)))));
+  }, dict.keys())));
+  return Array.from(collection);
+}, value_1);
+const Decode_inputsDecoder = (value) => object((get$) => {
+  const objectArg = get$.Optional;
+  return objectArg.Field("inputs", Decode_inputArrayDecoder);
+}, value);
+const Decode_baseCommandDecoder = (value_2) => object((get$) => {
+  let baseCommandField;
+  const objectArg = get$.Optional;
+  baseCommandField = objectArg.Field("baseCommand", (x) => x);
+  let matchResult, v, v_1, s, s_1;
+  if (baseCommandField == null) {
+    matchResult = 4;
+  } else {
+    switch (value(baseCommandField).tag) {
+      case /* Object */
+      3: {
+        if (!isEmpty(value(baseCommandField).fields[0])) {
+          switch (head(value(baseCommandField).fields[0]).tag) {
+            case /* Value */
+            1: {
+              if (isEmpty(tail(value(baseCommandField).fields[0]))) {
+                matchResult = 0;
+                v = head(value(baseCommandField).fields[0]).fields[0];
+              } else {
+                matchResult = 5;
+              }
+              break;
+            }
+            case /* Sequence */
+            2: {
+              if (isEmpty(tail(value(baseCommandField).fields[0]))) {
+                matchResult = 2;
+                s = head(value(baseCommandField).fields[0]).fields[0];
+              } else {
+                matchResult = 5;
+              }
+              break;
+            }
+            default:
+              matchResult = 5;
+          }
+        } else {
+          matchResult = 5;
+        }
+        break;
+      }
+      case /* Value */
+      1: {
+        matchResult = 1;
+        v_1 = value(baseCommandField).fields[0];
+        break;
+      }
+      case /* Sequence */
+      2: {
+        matchResult = 3;
+        s_1 = value(baseCommandField).fields[0];
+        break;
+      }
+      default:
+        matchResult = 5;
+    }
+  }
+  switch (matchResult) {
+    case 0:
+      return [v.Value];
+    case 1:
+      return [v_1.Value];
+    case 2:
+      return resizearray(string, YAMLElement_Sequence(s));
+    case 3:
+      return resizearray(string, YAMLElement_Sequence(s_1));
+    case 4:
+      return void 0;
+    default:
+      return void 0;
+  }
+}, value_2);
+const Decode_versionDecoder = (value_1) => object((get$) => {
+  const objectArg = get$.Required;
+  return objectArg.Field("cwlVersion", string);
+}, value_1);
+const Decode_classDecoder = (value_1) => object((get$) => {
+  const objectArg = get$.Required;
+  return objectArg.Field("class", string);
+}, value_1);
+function Decode_stringOptionFieldDecoder(field) {
+  return (value_1) => object((get$) => {
+    const objectArg = get$.Optional;
+    return objectArg.Field(field, string);
+  }, value_1);
+}
+function Decode_boolOptionFieldDecoder(field) {
+  return (value_1) => object((get$) => {
+    const objectArg = get$.Optional;
+    return objectArg.Field(field, bool);
+  }, value_1);
+}
+function Decode_yamlElementOptionFieldDecoder(field) {
+  return (value) => object((get$) => {
+    const objectArg = get$.Optional;
+    return objectArg.Field(field, (x) => x);
+  }, value);
+}
+function Decode_stringFieldDecoder(field) {
+  return (value_1) => object((get$) => {
+    const objectArg = get$.Required;
+    return objectArg.Field(field, string);
+  }, value_1);
+}
+function Decode_stringOrStringArrayDecoder(value) {
+  let matchResult, v, s;
+  switch (value.tag) {
+    case /* Object */
+    3: {
+      if (!isEmpty(value.fields[0])) {
+        switch (head(value.fields[0]).tag) {
+          case /* Value */
+          1: {
+            if (isEmpty(tail(value.fields[0]))) {
+              matchResult = 0;
+              v = head(value.fields[0]).fields[0];
+            } else {
+              matchResult = 2;
+            }
+            break;
+          }
+          case /* Sequence */
+          2: {
+            if (isEmpty(tail(value.fields[0]))) {
+              matchResult = 1;
+              s = head(value.fields[0]).fields[0];
+            } else {
+              matchResult = 2;
+            }
+            break;
+          }
+          default:
+            matchResult = 2;
+        }
+      } else {
+        matchResult = 2;
+      }
+      break;
+    }
+    case /* Value */
+    1: {
+      matchResult = 0;
+      v = value.fields[0];
+      break;
+    }
+    case /* Sequence */
+    2: {
+      matchResult = 1;
+      s = value.fields[0];
+      break;
+    }
+    default:
+      matchResult = 2;
+  }
+  switch (matchResult) {
+    case 0:
+      return [v.Value];
+    case 1:
+      return resizearray(string, YAMLElement_Sequence(s));
+    default:
+      return void 0;
+  }
+}
+function Decode_sourceArrayFieldDecoder(field) {
+  return (value_1) => object((get$) => {
+    let objectArg;
+    return bind(Decode_stringOrStringArrayDecoder, (objectArg = get$.Optional, objectArg.Field(field, (x) => x)));
+  }, value_1);
+}
+function Decode_linkMergeFieldDecoder(field) {
+  return (value_1) => object((get$) => {
+    let linkMergeField;
+    const objectArg = get$.Optional;
+    linkMergeField = objectArg.Field(field, string);
+    if (linkMergeField == null) {
+      return void 0;
+    } else {
+      const linkMergeString = value(linkMergeField);
+      const matchValue = LinkMergeMethod.tryParse(linkMergeString);
+      if (matchValue == null) {
+        throw new Error(`Invalid linkMerge value: ${linkMergeString}`);
+      } else {
+        return value(matchValue);
+      }
+    }
+  }, value_1);
+}
+function Decode_pickValueFieldDecoder(field) {
+  return (value_1) => object((get$) => {
+    let pickValueField;
+    const objectArg = get$.Optional;
+    pickValueField = objectArg.Field(field, string);
+    if (pickValueField == null) {
+      return void 0;
+    } else {
+      const pickValueString = value(pickValueField);
+      const matchValue = PickValueMethod.tryParse(pickValueString);
+      if (matchValue == null) {
+        throw new Error(`Invalid pickValue value: ${pickValueString}`);
+      } else {
+        return value(matchValue);
+      }
+    }
+  }, value_1);
+}
+function Decode_scatterFieldDecoder(field) {
+  return (value_1) => object((get$) => {
+    let objectArg;
+    return bind(Decode_stringOrStringArrayDecoder, (objectArg = get$.Optional, objectArg.Field(field, (x) => x)));
+  }, value_1);
+}
+function Decode_scatterMethodFieldDecoder(field) {
+  return (value_1) => object((get$) => {
+    let scatterMethodField;
+    const objectArg = get$.Optional;
+    scatterMethodField = objectArg.Field(field, string);
+    if (scatterMethodField == null) {
+      return void 0;
+    } else {
+      const scatterMethodString = value(scatterMethodField);
+      const matchValue = ScatterMethod.tryParse(scatterMethodString);
+      if (matchValue == null) {
+        throw new Error(`Invalid scatterMethod value: ${scatterMethodString}`);
+      } else {
+        return value(matchValue);
+      }
+    }
+  }, value_1);
+}
+function Decode_expressionStringOptionFieldDecoder(field) {
+  return (value) => object((get$) => {
+    let objectArg;
+    return map$1(Decode_decodeStringOrExpression, (objectArg = get$.Optional, objectArg.Field(field, (x) => x)));
+  }, value);
+}
+function Decode_decodeStepInputFromValue(id, value$1, allowScalarSource) {
+  const scalarSource = allowScalarSource ? Decode_stringOrStringArrayDecoder(value$1) : void 0;
+  const fieldSource = Decode_sourceArrayFieldDecoder("source")(value$1);
+  return new StepInput(id, scalarSource != null ? value(scalarSource) : fieldSource != null ? value(fieldSource) : void 0, Decode_yamlElementOptionFieldDecoder("default")(value$1), Decode_stringOptionFieldDecoder("valueFrom")(value$1), Decode_linkMergeFieldDecoder("linkMerge")(value$1), Decode_pickValueFieldDecoder("pickValue")(value$1), Decode_stringOptionFieldDecoder("doc")(value$1), Decode_boolOptionFieldDecoder("loadContents")(value$1), Decode_stringOptionFieldDecoder("loadListing")(value$1), Decode_stringOptionFieldDecoder("label")(value$1));
+}
+function Decode_decodeStepInputsFromMap(value) {
+  const dict = object((get$) => get$.Overflow.FieldList(empty()), value);
+  const collection = toArray(delay(() => map$2((key) => Decode_decodeStepInputFromValue(key, getItemFromDict(dict, key), true), dict.keys())));
+  return Array.from(collection);
+}
+function Decode_decodeStepInputFromArrayItem(item) {
+  return Decode_decodeStepInputFromValue(Decode_stringFieldDecoder("id")(item), item, false);
+}
+function Decode_decodeStepInputsFromArray(items) {
+  const collection = map(Decode_decodeStepInputFromArrayItem, items);
+  return Array.from(collection);
+}
+function Decode_inputStepDecoder(value) {
+  let matchResult, items;
+  switch (value.tag) {
+    case /* Object */
+    3: {
+      if (!isEmpty(value.fields[0])) {
+        if (head(value.fields[0]).tag === /* Sequence */
+        2) {
+          if (isEmpty(tail(value.fields[0]))) {
+            matchResult = 0;
+            items = head(value.fields[0]).fields[0];
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+      break;
+    }
+    case /* Sequence */
+    2: {
+      matchResult = 0;
+      items = value.fields[0];
+      break;
+    }
+    default:
+      matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return Decode_decodeStepInputsFromArray(items);
+    default:
+      return Decode_decodeStepInputsFromMap(value);
+  }
+}
+function Decode_decodeStepOutputItem(value) {
+  let matchResult, v;
+  switch (value.tag) {
+    case /* Object */
+    3: {
+      if (!isEmpty(value.fields[0])) {
+        if (head(value.fields[0]).tag === /* Value */
+        1) {
+          if (isEmpty(tail(value.fields[0]))) {
+            matchResult = 0;
+            v = head(value.fields[0]).fields[0];
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+      break;
+    }
+    case /* Value */
+    1: {
+      matchResult = 0;
+      v = value.fields[0];
+      break;
+    }
+    default:
+      matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return StepOutput_StepOutputString(v.Value);
+    default:
+      return StepOutput_StepOutputRecord(new StepOutputParameter(Decode_stringFieldDecoder("id")(value)));
+  }
+}
+const Decode_outputStepsDecoder = (value_2) => object((get$) => {
+  let outField;
+  const objectArg = get$.Required;
+  outField = objectArg.Field("out", (x) => x);
+  let matchResult, v_1, outputs, value_1;
+  switch (outField.tag) {
+    case /* Object */
+    3: {
+      if (!isEmpty(outField.fields[0])) {
+        switch (head(outField.fields[0]).tag) {
+          case /* Value */
+          1: {
+            if (isEmpty(tail(outField.fields[0]))) {
+              if (head(outField.fields[0]).fields[0].Value === "[]") {
+                matchResult = 1;
+                v_1 = head(outField.fields[0]).fields[0];
+              } else {
+                matchResult = 4;
+                value_1 = outField;
+              }
+            } else {
+              matchResult = 4;
+              value_1 = outField;
+            }
+            break;
+          }
+          case /* Sequence */
+          2: {
+            if (isEmpty(head(outField.fields[0]).fields[0])) {
+              if (isEmpty(tail(outField.fields[0]))) {
+                matchResult = 2;
+              } else {
+                matchResult = 4;
+                value_1 = outField;
+              }
+            } else if (isEmpty(tail(outField.fields[0]))) {
+              matchResult = 3;
+              outputs = head(outField.fields[0]).fields[0];
+            } else {
+              matchResult = 4;
+              value_1 = outField;
+            }
+            break;
+          }
+          default: {
+            matchResult = 4;
+            value_1 = outField;
+          }
+        }
+      } else {
+        matchResult = 0;
+      }
+      break;
+    }
+    case /* Sequence */
+    2: {
+      if (isEmpty(outField.fields[0])) {
+        matchResult = 2;
+      } else {
+        matchResult = 3;
+        outputs = outField.fields[0];
+      }
+      break;
+    }
+    default: {
+      matchResult = 4;
+      value_1 = outField;
+    }
+  }
+  switch (matchResult) {
+    case 0:
+      return [];
+    case 1:
+      return [];
+    case 2:
+      return [];
+    case 3: {
+      const collection = map(Decode_decodeStepOutputItem, outputs);
+      return Array.from(collection);
+    }
+    default:
+      return [Decode_decodeStepOutputItem(value_1)];
+  }
+}, value_2);
+const Decode_docDecoder = (value_1) => object((get$) => {
+  const objectArg = get$.Optional;
+  return objectArg.Field("doc", string);
+}, value_1);
+const Decode_labelDecoder = (value_1) => object((get$) => {
+  const objectArg = get$.Optional;
+  return objectArg.Field("label", string);
+}, value_1);
+const Decode_intentDecoder = (value_1) => object((get$) => {
+  let objectArg;
+  return bind(Decode_stringOrStringArrayDecoder, (objectArg = get$.Optional, objectArg.Field("intent", (x) => x)));
+}, value_1);
+function Decode_hasField(fieldName, yamlElement) {
+  if (yamlElement.tag === /* Object */
+  3) {
+    return exists((_arg) => {
+      let matchResult, k_1;
+      if (_arg.tag === /* Mapping */
+      0) {
+        if (_arg.fields[0].Value === fieldName) {
+          matchResult = 0;
+          k_1 = _arg.fields[0];
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+      switch (matchResult) {
+        case 0:
+          return true;
+        default:
+          return false;
+      }
+    }, yamlElement.fields[0]);
+  } else {
+    return false;
+  }
+}
+function Decode_withDefaultCwlVersion(defaultCwlVersion, yamlElement) {
+  let fields;
+  if (yamlElement.tag === /* Object */
+  3) {
+    if (fields = yamlElement.fields[0], Decode_hasField("cwlVersion", yamlElement)) {
+      const fields_1 = yamlElement.fields[0];
+      return yamlElement;
+    } else {
+      const fields_2 = yamlElement.fields[0];
+      return YAMLElement_Object(cons(YAMLElement_Mapping(new YAMLContent("cwlVersion", void 0), YAMLElement_Object(singleton$1(YAMLElement_Value(new YAMLContent(defaultCwlVersion, void 0))))), fields_2));
+    }
+  } else {
+    return yamlElement;
+  }
+}
+function Decode_workflowStepRunDecoder(defaultCwlVersion, runValue) {
+  let matchResult, v;
+  switch (runValue.tag) {
+    case /* Object */
+    3: {
+      if (!isEmpty(runValue.fields[0])) {
+        if (head(runValue.fields[0]).tag === /* Value */
+        1) {
+          if (isEmpty(tail(runValue.fields[0]))) {
+            matchResult = 0;
+            v = head(runValue.fields[0]).fields[0];
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+      break;
+    }
+    case /* Value */
+    1: {
+      matchResult = 0;
+      v = runValue.fields[0];
+      break;
+    }
+    default:
+      matchResult = 2;
+  }
+  switch (matchResult) {
+    case 0:
+      return WorkflowStepRun_RunString(v.Value);
+    case 1: {
+      const matchValue = Decode_decodeCWLProcessingUnitElement(Decode_withDefaultCwlVersion(defaultCwlVersion, runValue));
+      switch (matchValue.tag) {
+        case /* Workflow */
+        1:
+          return WorkflowStepRunOps_fromWorkflow(matchValue.fields[0]);
+        case /* ExpressionTool */
+        2:
+          return WorkflowStepRunOps_fromExpressionTool(matchValue.fields[0]);
+        case /* Operation */
+        3:
+          return WorkflowStepRunOps_fromOperation(matchValue.fields[0]);
+        default:
+          return WorkflowStepRunOps_fromTool(matchValue.fields[0]);
+      }
+    }
+    default:
+      throw new Error(toText(interpolate("Unsupported run value for workflow step: %A%P()", [runValue])));
+  }
+}
+function Decode_decodeWorkflowStepFromValueWithId(defaultCwlVersion, stepId, value) {
+  const run = Decode_workflowStepRunDecoder(defaultCwlVersion, object((get$0027) => {
+    const objectArg = get$0027.Required;
+    return objectArg.Field("run", (x) => x);
+  }, value));
+  const inputs = object((get$0027_1) => {
+    const objectArg_1 = get$0027_1.Required;
+    return objectArg_1.Field("in", Decode_inputStepDecoder);
+  }, value);
+  const outputs = Decode_outputStepsDecoder(value);
+  const requirements = Decode_requirementsDecoder(value);
+  const hints = Decode_hintsDecoder(value);
+  const doc = Decode_docDecoder(value);
+  const wfStep = new WorkflowStep(stepId, inputs, outputs, run, unwrap(Decode_labelDecoder(value)), unwrap(doc), unwrap(Decode_scatterFieldDecoder("scatter")(value)), unwrap(Decode_scatterMethodFieldDecoder("scatterMethod")(value)), unwrap(Decode_expressionStringOptionFieldDecoder("when")(value)));
+  if (requirements != null) {
+    wfStep.Requirements = requirements;
+  }
+  if (hints != null) {
+    wfStep.Hints = hints;
+  }
+  return wfStep;
+}
+function Decode_decodeWorkflowStepFromArrayItem(defaultCwlVersion, item) {
+  return Decode_decodeWorkflowStepFromValueWithId(defaultCwlVersion, Decode_stringFieldDecoder("id")(item), item);
+}
+function Decode_stepArrayDecoderWithVersion(defaultCwlVersion, value) {
+  let matchResult, items;
+  switch (value.tag) {
+    case /* Object */
+    3: {
+      if (!isEmpty(value.fields[0])) {
+        if (head(value.fields[0]).tag === /* Sequence */
+        2) {
+          if (isEmpty(tail(value.fields[0]))) {
+            matchResult = 0;
+            items = head(value.fields[0]).fields[0];
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+      break;
+    }
+    case /* Sequence */
+    2: {
+      matchResult = 0;
+      items = value.fields[0];
+      break;
+    }
+    default:
+      matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0: {
+      const collection = map((item) => Decode_decodeWorkflowStepFromArrayItem(defaultCwlVersion, item), items);
+      return Array.from(collection);
+    }
+    default: {
+      const dict = object((get$) => get$.Overflow.FieldList(empty()), value);
+      const collection_1 = toArray(delay(() => map$2((key) => Decode_decodeWorkflowStepFromValueWithId(defaultCwlVersion, key, getItemFromDict(dict, key)), dict.keys())));
+      return Array.from(collection_1);
+    }
+  }
+}
+function Decode_stepsDecoderWithVersion(defaultCwlVersion) {
+  return (value_1) => object((get$) => {
+    const objectArg = get$.Required;
+    return objectArg.Field("steps", (value) => Decode_stepArrayDecoderWithVersion(defaultCwlVersion, value));
+  }, value_1);
+}
+function Decode_commandLineToolDecoder(yamlCWL) {
+  const cwlVersion = Decode_versionDecoder(yamlCWL);
+  const outputs = Decode_outputsDecoder(yamlCWL);
+  const inputs = Decode_inputsDecoder(yamlCWL);
+  const requirements = Decode_requirementsDecoder(yamlCWL);
+  const hints = Decode_hintsDecoder(yamlCWL);
+  const intent = Decode_intentDecoder(yamlCWL);
+  const baseCommand = Decode_baseCommandDecoder(yamlCWL);
+  const doc = Decode_docDecoder(yamlCWL);
+  const label = Decode_labelDecoder(yamlCWL);
+  const description = new CWLToolDescription(outputs, cwlVersion);
+  let metadata;
+  const md = new DynamicObj();
+  object((get$) => Decode_overflowDecoder(md, get$.Overflow.FieldList(ofArray(["inputs", "outputs", "class", "id", "label", "doc", "intent", "requirements", "hints", "cwlVersion", "baseCommand", "arguments", "stdin", "stderr", "stdout", "successCodes", "temporaryFailCodes", "permanentFailCodes"]))), yamlCWL);
+  metadata = md;
+  object((get$_1) => Decode_overflowDecoder(description, get$_1.MultipleOptional.FieldList(ofArray(["id", "arguments", "stdin", "stderr", "stdout", "successCodes", "temporaryFailCodes", "permanentFailCodes"]))), yamlCWL);
+  if (inputs != null) {
+    description.Inputs = inputs;
+  }
+  if (requirements != null) {
+    description.Requirements = requirements;
+  }
+  if (hints != null) {
+    description.Hints = hints;
+  }
+  if (intent != null) {
+    description.Intent = intent;
+  }
+  if (baseCommand != null) {
+    description.BaseCommand = baseCommand;
+  }
+  if (doc != null) {
+    description.Doc = doc;
+  }
+  if (label != null) {
+    description.Label = label;
+  }
+  if (length(metadata.GetProperties(false)) > 0) {
+    description.Metadata = metadata;
+  }
+  return description;
+}
+function Decode_expressionToolDecoder(yamlCWL) {
+  const cwlVersion = Decode_versionDecoder(yamlCWL);
+  const outputs = Decode_outputsDecoder(yamlCWL);
+  const inputs = Decode_inputsDecoder(yamlCWL);
+  const requirements = Decode_requirementsDecoder(yamlCWL);
+  const hints = Decode_hintsDecoder(yamlCWL);
+  const intent = Decode_intentDecoder(yamlCWL);
+  const doc = Decode_docDecoder(yamlCWL);
+  const label = Decode_labelDecoder(yamlCWL);
+  const description = new CWLExpressionToolDescription(outputs, object((get$) => {
+    const objectArg = get$.Required;
+    return objectArg.Field("expression", Decode_decodeStringOrExpression);
+  }, yamlCWL), cwlVersion);
+  let metadata;
+  const md = new DynamicObj();
+  object((get$_1) => Decode_overflowDecoder(md, get$_1.Overflow.FieldList(ofArray(["inputs", "outputs", "class", "id", "label", "doc", "intent", "requirements", "hints", "cwlVersion", "expression"]))), yamlCWL);
+  metadata = md;
+  object((get$_2) => Decode_overflowDecoder(description, get$_2.MultipleOptional.FieldList(singleton$1("id"))), yamlCWL);
+  if (inputs != null) {
+    description.Inputs = inputs;
+  }
+  if (requirements != null) {
+    description.Requirements = requirements;
+  }
+  if (hints != null) {
+    description.Hints = hints;
+  }
+  if (intent != null) {
+    description.Intent = intent;
+  }
+  if (doc != null) {
+    description.Doc = doc;
+  }
+  if (label != null) {
+    description.Label = label;
+  }
+  if (length(metadata.GetProperties(false)) > 0) {
+    description.Metadata = metadata;
+  }
+  return description;
+}
+function Decode_operationDecoder(yamlCWL) {
+  const cwlVersion = Decode_versionDecoder(yamlCWL);
+  const outputs = Decode_outputsDecoder(yamlCWL);
+  let inputs;
+  const matchValue = Decode_inputsDecoder(yamlCWL);
+  if (matchValue == null) {
+    throw new Error("Inputs are required for an operation");
+  } else {
+    inputs = value(matchValue);
+  }
+  const requirements = Decode_requirementsDecoder(yamlCWL);
+  const hints = Decode_hintsDecoder(yamlCWL);
+  const intent = Decode_intentDecoder(yamlCWL);
+  const doc = Decode_docDecoder(yamlCWL);
+  const label = Decode_labelDecoder(yamlCWL);
+  const description = new CWLOperationDescription(inputs, outputs, cwlVersion);
+  let metadata;
+  const md = new DynamicObj();
+  object((get$) => Decode_overflowDecoder(md, get$.Overflow.FieldList(ofArray(["inputs", "outputs", "label", "doc", "intent", "class", "id", "requirements", "hints", "cwlVersion"]))), yamlCWL);
+  metadata = md;
+  object((get$_1) => Decode_overflowDecoder(description, get$_1.MultipleOptional.FieldList(singleton$1("id"))), yamlCWL);
+  if (requirements != null) {
+    description.Requirements = requirements;
+  }
+  if (hints != null) {
+    description.Hints = hints;
+  }
+  if (intent != null) {
+    description.Intent = intent;
+  }
+  if (doc != null) {
+    description.Doc = doc;
+  }
+  if (label != null) {
+    description.Label = label;
+  }
+  if (length(metadata.GetProperties(false)) > 0) {
+    description.Metadata = metadata;
+  }
+  return description;
+}
+function Decode_workflowDecoder(yamlCWL) {
+  const cwlVersion = Decode_versionDecoder(yamlCWL);
+  const outputs = Decode_outputsDecoder(yamlCWL);
+  let inputs;
+  const matchValue = Decode_inputsDecoder(yamlCWL);
+  if (matchValue == null) {
+    throw new Error("Inputs are required for a workflow");
+  } else {
+    inputs = value(matchValue);
+  }
+  const requirements = Decode_requirementsDecoder(yamlCWL);
+  const hints = Decode_hintsDecoder(yamlCWL);
+  const intent = Decode_intentDecoder(yamlCWL);
+  const steps = Decode_stepsDecoderWithVersion(cwlVersion)(yamlCWL);
+  const doc = Decode_docDecoder(yamlCWL);
+  const label = Decode_labelDecoder(yamlCWL);
+  const description = new CWLWorkflowDescription(steps, inputs, outputs, cwlVersion);
+  let metadata;
+  const md = new DynamicObj();
+  object((get$) => Decode_overflowDecoder(md, get$.Overflow.FieldList(ofArray(["inputs", "outputs", "label", "doc", "intent", "class", "steps", "id", "requirements", "hints", "cwlVersion"]))), yamlCWL);
+  metadata = md;
+  object((get$_1) => Decode_overflowDecoder(description, get$_1.MultipleOptional.FieldList(singleton$1("id"))), yamlCWL);
+  if (requirements != null) {
+    description.Requirements = requirements;
+  }
+  if (hints != null) {
+    description.Hints = hints;
+  }
+  if (intent != null) {
+    description.Intent = intent;
+  }
+  if (doc != null) {
+    description.Doc = doc;
+  }
+  if (label != null) {
+    description.Label = label;
+  }
+  if (length(metadata.GetProperties(false)) > 0) {
+    description.Metadata = metadata;
+  }
+  return description;
+}
+function Decode_decodeCWLProcessingUnitElement(yamlCWL) {
+  const cls = Decode_classDecoder(yamlCWL);
+  switch (cls) {
+    case "CommandLineTool":
+      return CWLProcessingUnit_CommandLineTool(Decode_commandLineToolDecoder(yamlCWL));
+    case "Workflow":
+      return CWLProcessingUnit_Workflow(Decode_workflowDecoder(yamlCWL));
+    case "ExpressionTool":
+      return CWLProcessingUnit_ExpressionTool(Decode_expressionToolDecoder(yamlCWL));
+    case "Operation":
+      return CWLProcessingUnit_Operation(Decode_operationDecoder(yamlCWL));
+    default:
+      throw new Error(`Invalid or unsupported CWL class: ${cls}`);
+  }
+}
+const Decode_stepArrayDecoder = (value) => Decode_stepArrayDecoderWithVersion("v1.2", value);
+const Decode_stepsDecoder = Decode_stepsDecoderWithVersion("v1.2");
+function Decode_decodeCommandLineTool(cwl) {
+  return Decode_commandLineToolDecoder(Decode_readSanitizedYaml(cwl));
+}
+function Decode_decodeWorkflow(cwl) {
+  return Decode_workflowDecoder(Decode_readSanitizedYaml(cwl));
+}
+function Decode_decodeExpressionTool(cwl) {
+  return Decode_expressionToolDecoder(Decode_readSanitizedYaml(cwl));
+}
+function Decode_decodeOperation(cwl) {
+  return Decode_operationDecoder(Decode_readSanitizedYaml(cwl));
+}
+function Decode_decodeCWLProcessingUnit(cwl) {
+  return Decode_decodeCWLProcessingUnitElement(Decode_readSanitizedYaml(cwl));
+}
+function DecodeParameters_cwlParameterReferenceDecoder(get$, key, yEle) {
+  let v_1;
+  let matchResult, v, v1, v2, s;
+  if (yEle.tag === /* Object */
+  3) {
+    if (!isEmpty(yEle.fields[0])) {
+      switch (head(yEle.fields[0]).tag) {
+        case /* Value */
+        1: {
+          if (isEmpty(tail(yEle.fields[0]))) {
+            matchResult = 0;
+            v = head(yEle.fields[0]).fields[0];
+          } else {
+            matchResult = 3;
+          }
+          break;
+        }
+        case /* Mapping */
+        0: {
+          if (head(yEle.fields[0]).fields[1].tag === /* Object */
+          3) {
+            if (!isEmpty(head(yEle.fields[0]).fields[1].fields[0])) {
+              if (head(head(yEle.fields[0]).fields[1].fields[0]).tag === /* Value */
+              1) {
+                if (isEmpty(tail(head(yEle.fields[0]).fields[1].fields[0]))) {
+                  if (!isEmpty(tail(yEle.fields[0]))) {
+                    if (head(tail(yEle.fields[0])).tag === /* Mapping */
+                    0) {
+                      if (head(tail(yEle.fields[0])).fields[1].tag === /* Object */
+                      3) {
+                        if (!isEmpty(head(tail(yEle.fields[0])).fields[1].fields[0])) {
+                          if (head(head(tail(yEle.fields[0])).fields[1].fields[0]).tag === /* Value */
+                          1) {
+                            if (isEmpty(tail(head(tail(yEle.fields[0])).fields[1].fields[0]))) {
+                              if (isEmpty(tail(tail(yEle.fields[0])))) {
+                                matchResult = 1;
+                                v1 = head(head(yEle.fields[0]).fields[1].fields[0]).fields[0];
+                                v2 = head(head(tail(yEle.fields[0])).fields[1].fields[0]).fields[0];
+                              } else {
+                                matchResult = 3;
+                              }
+                            } else {
+                              matchResult = 3;
+                            }
+                          } else {
+                            matchResult = 3;
+                          }
+                        } else {
+                          matchResult = 3;
+                        }
+                      } else {
+                        matchResult = 3;
+                      }
+                    } else {
+                      matchResult = 3;
+                    }
+                  } else {
+                    matchResult = 3;
+                  }
+                } else {
+                  matchResult = 3;
+                }
+              } else {
+                matchResult = 3;
+              }
+            } else {
+              matchResult = 3;
+            }
+          } else {
+            matchResult = 3;
+          }
+          break;
+        }
+        case /* Sequence */
+        2: {
+          if (isEmpty(tail(yEle.fields[0]))) {
+            matchResult = 2;
+            s = head(yEle.fields[0]).fields[0];
+          } else {
+            matchResult = 3;
+          }
+          break;
+        }
+        default:
+          matchResult = 3;
+      }
+    } else {
+      matchResult = 3;
+    }
+  } else {
+    matchResult = 3;
+  }
+  switch (matchResult) {
+    case 0:
+      return new CWLParameterReference(key, [v.Value]);
+    case 1:
+      return new CWLParameterReference(key, [v2.Value], Decode_cwlTypeStringMatcher(v1.Value, get$)[0]);
+    case 2: {
+      const matchValue = tryHead(s);
+      let matchResult_1, mappings;
+      if (matchValue != null) {
+        if (value(matchValue).tag === /* Object */
+        3) {
+          matchResult_1 = 0;
+          mappings = value(matchValue).fields[0];
+        } else {
+          matchResult_1 = 1;
+        }
+      } else {
+        matchResult_1 = 1;
+      }
+      switch (matchResult_1) {
+        case 0:
+          if (!exists((_arg) => {
+            if (_arg.tag === /* Mapping */
+            0) {
+              return true;
+            } else {
+              return false;
+            }
+          }, mappings)) {
+            return new CWLParameterReference(key, resizearray(string, YAMLElement_Sequence(s)));
+          } else if (exists((_arg_1) => {
+            let matchResult_2, k_1;
+            if (_arg_1.tag === /* Mapping */
+            0) {
+              if (_arg_1.fields[0].Value === "class") {
+                matchResult_2 = 0;
+                k_1 = _arg_1.fields[0];
+              } else {
+                matchResult_2 = 1;
+              }
+            } else {
+              matchResult_2 = 1;
+            }
+            switch (matchResult_2) {
+              case 0:
+                return true;
+              default:
+                return false;
+            }
+          }, mappings)) {
+            const paths = [];
+            const enumerator = getEnumerator(s);
+            try {
+              while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                const item = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                if (item.tag === /* Object */
+                3) {
+                  const enumerator_1 = getEnumerator(item.fields[0]);
+                  try {
+                    while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+                      const mapping = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                      let matchResult_3, k_3, v_2;
+                      if (mapping.tag === /* Mapping */
+                      0) {
+                        if (mapping.fields[1].tag === /* Object */
+                        3) {
+                          if (!isEmpty(mapping.fields[1].fields[0])) {
+                            if (head(mapping.fields[1].fields[0]).tag === /* Value */
+                            1) {
+                              if (isEmpty(tail(mapping.fields[1].fields[0]))) {
+                                if (v_1 = head(mapping.fields[1].fields[0]).fields[0], mapping.fields[0].Value === "path") {
+                                  matchResult_3 = 0;
+                                  k_3 = mapping.fields[0];
+                                  v_2 = head(mapping.fields[1].fields[0]).fields[0];
+                                } else {
+                                  matchResult_3 = 1;
+                                }
+                              } else {
+                                matchResult_3 = 1;
+                              }
+                            } else {
+                              matchResult_3 = 1;
+                            }
+                          } else {
+                            matchResult_3 = 1;
+                          }
+                        } else {
+                          matchResult_3 = 1;
+                        }
+                      } else {
+                        matchResult_3 = 1;
+                      }
+                      switch (matchResult_3) {
+                        case 0: {
+                          void paths.push(v_2.Value);
+                          break;
+                        }
+                      }
+                    }
+                  } finally {
+                    disposeSafe(enumerator_1);
+                  }
+                }
+              }
+            } finally {
+              disposeSafe(enumerator);
+            }
+            return new CWLParameterReference(key, paths, CWLType_Array(new InputArraySchema(CWLType_File(FileInstance_$ctor()), void 0, void 0, void 0)));
+          } else {
+            return new CWLParameterReference(key, []);
+          }
+        default:
+          return new CWLParameterReference(key, resizearray(string, YAMLElement_Sequence(s)));
+      }
+    }
+    default:
+      throw new Error(toText(interpolate("Unexpected YAMLElement format in cwlParameterReferenceDecoder: %A%P()", [yEle])));
+  }
+}
+const DecodeParameters_cwlparameterReferenceArrayDecoder = (value) => object((get$) => {
+  const dict = get$.Overflow.FieldList(empty());
+  const collection = toArray(delay(() => map$2((ele) => DecodeParameters_cwlParameterReferenceDecoder(get$, ele[0], ele[1]), dict)));
+  return Array.from(collection);
+}, value);
+function DecodeParameters_decodeYAMLParameterFile(yaml) {
+  return DecodeParameters_cwlparameterReferenceArrayDecoder(read(yaml));
+}
+
+export { DecodeParameters_cwlParameterReferenceDecoder, DecodeParameters_cwlparameterReferenceArrayDecoder, DecodeParameters_decodeYAMLParameterFile, Decode_baseCommandDecoder, Decode_boolOptionFieldDecoder, Decode_classDecoder, Decode_commandLineToolDecoder, Decode_cwlSimpleTypeFromString, Decode_cwlTypeDecoder, Decode_cwlTypeDecoder$0027, Decode_cwlTypeStringMatcher, Decode_decodeCWLProcessingUnit, Decode_decodeCWLProcessingUnitElement, Decode_decodeCommandLineTool, Decode_decodeExpressionTool, Decode_decodeHintElement, Decode_decodeOperation, Decode_decodeResourceScalar, Decode_decodeSchemaSaladString, Decode_decodeStepInputFromArrayItem, Decode_decodeStepInputFromValue, Decode_decodeStepInputsFromArray, Decode_decodeStepInputsFromMap, Decode_decodeStepOutputItem, Decode_decodeStringArrayOrScalar, Decode_decodeStringOrExpression, Decode_decodeWorkflow, Decode_decodeWorkflowStepFromArrayItem, Decode_decodeWorkflowStepFromValueWithId, Decode_direntDecoder, Decode_docDecoder, Decode_dockerRequirementDecoder, Decode_envVarRequirementDecoder, Decode_expressionStringOptionFieldDecoder, Decode_expressionToolDecoder, Decode_hasField, Decode_hintArrayDecoder, Decode_hintsDecoder, Decode_initialWorkDirEntryDecoder, Decode_initialWorkDirRequirementDecoder, Decode_inlineJavascriptRequirementDecoder, Decode_inplaceUpdateRequirementDecoder, Decode_inputArrayDecoder, Decode_inputArraySchemaDecoder, Decode_inputBindingDecoder, Decode_inputEnumSchemaDecoder, Decode_inputRecordFieldDecoder, Decode_inputRecordSchemaDecoder, Decode_inputStepDecoder, Decode_inputsDecoder, Decode_intentDecoder, Decode_isRecoverableDecodingError, Decode_labelDecoder, Decode_linkMergeFieldDecoder, Decode_loadListingRequirementDecoder, Decode_networkAccessRequirementDecoder, Decode_normalizeYamlInput, Decode_operationDecoder, Decode_optionalResourceField, Decode_outputArrayDecoder, Decode_outputBindingDecoder, Decode_outputBindingGlobDecoder, Decode_outputSourceDecoder, Decode_outputStepsDecoder, Decode_outputsDecoder, Decode_overflowDecoder, Decode_parseArrayShorthand, Decode_pickValueFieldDecoder, Decode_readSanitizedYaml, Decode_removeFullLineComments, Decode_removeYamlComments, Decode_requirementArrayDecoder, Decode_requirementFromTypeName, Decode_requirementsDecoder, Decode_resourceRequirementDecoder, Decode_scatterFieldDecoder, Decode_scatterMethodFieldDecoder, Decode_schemaDefRequirementDecoder, Decode_schemaDefRequirementTypeDecoder, Decode_softwareRequirementDecoder, Decode_sourceArrayFieldDecoder, Decode_stepArrayDecoder, Decode_stepArrayDecoderWithVersion, Decode_stepsDecoder, Decode_stepsDecoderWithVersion, Decode_stringFieldDecoder, Decode_stringOptionFieldDecoder, Decode_stringOrStringArrayDecoder, Decode_toolTimeLimitRequirementDecoder, Decode_tryDecodeBoolScalar, Decode_tryDecodeFieldsAsArray, Decode_tryDecodeFieldsAsMap, Decode_tryDecodeKnownRequirementFromElement, Decode_versionDecoder, Decode_withDefaultCwlVersion, Decode_workReuseRequirementDecoder, Decode_workflowDecoder, Decode_workflowStepRunDecoder, Decode_yamlElementOptionFieldDecoder, ResizeArray_map, inputArraySchemaDecoder$0040261, inputArraySchemaDecoder$0040261$002D1, inputEnumSchemaDecoder$0040341, inputEnumSchemaDecoder$0040341$002D1, inputRecordFieldDecoder$0040275, inputRecordFieldDecoder$0040275$002D1, inputRecordSchemaDecoder$0040314, inputRecordSchemaDecoder$0040314$002D1 };