@nfdi4plants/arctrl 3.0.0-beta.8 → 3.0.0

package/dist/ts/ts/CWL/Encode.js

@@ -0,0 +1,1509 @@
+import { FSharpChoice$2_Choice1Of2, FSharpChoice$2_Choice2Of2 } from '../../node_modules/@fable-org/fable-library-js/Choice.js';
+import { map, value, bind, filter } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { toList, map as map$2, choose as choose$1, fold, delay, append as append$1, singleton as singleton$1, empty as empty$1 } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { isEmpty, head, tail, map as map$1, singleton, ofArray, empty, append, ofSeq, choose, exists, cons, filter as filter$1, contains, tryFind, reverse, length } from '../../node_modules/@fable-org/fable-library-js/List.js';
+import { YAMLElement_Value, YAMLContent, YAMLElement_Object, YAMLElement_Mapping, YAMLElement_Sequence, YAMLElement, Config } from '../fable_modules/YAMLicious.1.0.0-alpha.3/YAMLiciousTypes.fs.js';
+import { trimEnd, replace, toText, interpolate, trimStart, join, split } from '../../node_modules/@fable-org/fable-library-js/String.js';
+import { string, int, float } from '../fable_modules/YAMLicious.1.0.0-alpha.3/Encode.fs.js';
+import { LoadListingEnum_get_toCwlString } from './Requirements.js';
+import { int64ToString, stringHash, comparePrimitives } from '../../node_modules/@fable-org/fable-library-js/Util.js';
+import { WorkflowStepRunOps_tryGetOperation, WorkflowStepRunOps_tryGetExpressionTool, WorkflowStepRunOps_tryGetWorkflow, WorkflowStepRunOps_tryGetTool } from './CWLProcessingUnit.js';
+import { toString } from '../../node_modules/@fable-org/fable-library-js/Types.js';
+import { write } from '../fable_modules/YAMLicious.1.0.0-alpha.3/Writer.fs.js';
+import { ofList, FSharpSet__Contains } from '../../node_modules/@fable-org/fable-library-js/Set.js';
+
+function $007CPrimitiveType$007CComplexType$007C(t) {
+  switch (t.tag) {
+    case /* Directory */
+    1:
+      return FSharpChoice$2_Choice1Of2("Directory");
+    case /* Dirent */
+    2:
+      return FSharpChoice$2_Choice1Of2("Dirent");
+    case /* String */
+    3:
+      return FSharpChoice$2_Choice1Of2("string");
+    case /* Int */
+    4:
+      return FSharpChoice$2_Choice1Of2("int");
+    case /* Long */
+    5:
+      return FSharpChoice$2_Choice1Of2("long");
+    case /* Float */
+    6:
+      return FSharpChoice$2_Choice1Of2("float");
+    case /* Double */
+    7:
+      return FSharpChoice$2_Choice1Of2("double");
+    case /* Boolean */
+    8:
+      return FSharpChoice$2_Choice1Of2("boolean");
+    case /* Null */
+    10:
+      return FSharpChoice$2_Choice1Of2("null");
+    case /* Stdout */
+    9:
+      return FSharpChoice$2_Choice1Of2("stdout");
+    case /* Record */
+    12:
+    case /* Enum */
+    13:
+    case /* Union */
+    14:
+      return FSharpChoice$2_Choice2Of2(void 0);
+    case /* Array */
+    11: {
+      const arraySchema = t.fields[0];
+      if ($007CPrimitiveType$007CComplexType$007C(arraySchema.Items).tag === /* Choice2Of2 */
+      1) {
+        return FSharpChoice$2_Choice2Of2(void 0);
+      } else {
+        return FSharpChoice$2_Choice1Of2("array");
+      }
+    }
+    default:
+      return FSharpChoice$2_Choice1Of2("File");
+  }
+}
+function tryGetArrayShorthand(cwlType) {
+  let matchResult, name_1, arraySchema;
+  const activePatternResult = $007CPrimitiveType$007CComplexType$007C(cwlType);
+  if (activePatternResult.tag === /* Choice1Of2 */
+  0) {
+    if (activePatternResult.fields[0] !== "array") {
+      matchResult = 0;
+      name_1 = activePatternResult.fields[0];
+    } else if (cwlType.tag === /* Array */
+    11) {
+      matchResult = 1;
+      arraySchema = cwlType.fields[0];
+    } else {
+      matchResult = 2;
+    }
+  } else if (cwlType.tag === /* Array */
+  11) {
+    matchResult = 1;
+    arraySchema = cwlType.fields[0];
+  } else {
+    matchResult = 2;
+  }
+  switch (matchResult) {
+    case 0:
+      return name_1;
+    case 1:
+      return map((s) => s + "[]", tryGetArrayShorthand(arraySchema.Items));
+    default:
+      return void 0;
+  }
+}
+function isComplexType(t_mut) {
+  isComplexType:
+    while (true) {
+      const t = t_mut;
+      switch (t.tag) {
+        case /* Record */
+        12:
+        case /* Enum */
+        13:
+          return true;
+        case /* Array */
+        11:
+          return tryGetArrayShorthand(t.fields[0].Items) == null;
+        case /* Union */
+        14: {
+          const typesList = toList(t.fields[0]);
+          let matchResult, otherType;
+          if (!isEmpty(typesList)) {
+            if (head(typesList).tag === /* Null */
+            10) {
+              if (!isEmpty(tail(typesList))) {
+                if (isEmpty(tail(tail(typesList)))) {
+                  matchResult = 0;
+                  otherType = head(tail(typesList));
+                } else {
+                  matchResult = 1;
+                }
+              } else {
+                matchResult = 1;
+              }
+            } else if (!isEmpty(tail(typesList))) {
+              if (head(tail(typesList)).tag === /* Null */
+              10) {
+                if (isEmpty(tail(tail(typesList)))) {
+                  matchResult = 0;
+                  otherType = head(typesList);
+                } else {
+                  matchResult = 1;
+                }
+              } else {
+                matchResult = 1;
+              }
+            } else {
+              matchResult = 1;
+            }
+          } else {
+            matchResult = 1;
+          }
+          switch (matchResult) {
+            case 0: {
+              t_mut = otherType;
+              continue isComplexType;
+            }
+            default:
+              return true;
+          }
+        }
+        default:
+          return false;
+      }
+      break;
+    }
+}
+function yBool(b) {
+  return YAMLElement_Value(new YAMLContent(b ? "true" : "false", void 0));
+}
+function yMap(pairs) {
+  return YAMLElement_Object(map$1((tupledArg) => {
+    let _arg, single;
+    return YAMLElement_Mapping(new YAMLContent(tupledArg[0], void 0), (_arg = tupledArg[1], _arg.tag === /* Object */
+    3 ? !isEmpty(_arg.fields[0]) ? isEmpty(tail(_arg.fields[0])) ? (single = head(_arg.fields[0]), single) : _arg : YAMLElement_Value(new YAMLContent("{}", void 0)) : _arg));
+  }, pairs));
+}
+function normalizeDocString(doc) {
+  return trimEnd(trimEnd(replace(doc, "\r\n", "\n"), "\n"), "\r");
+}
+function encodeSchemaSaladString(value) {
+  switch (value.tag) {
+    case /* Include */
+    1:
+      return yMap(singleton(["$include", string(value.fields[0])]));
+    case /* Import */
+    2:
+      return yMap(singleton(["$import", string(value.fields[0])]));
+    default:
+      return string(value.fields[0]);
+  }
+}
+function normalizeEnvValueForEncode(envValue) {
+  if (envValue === "true" ? true : envValue === "false") {
+    return '"' + envValue + '"';
+  } else {
+    return envValue;
+  }
+}
+function encodeEnvVarRequirementCompactMap(envs) {
+  const envDefMap = yMap(toList(map$2((env) => [env.EnvName, string(normalizeEnvValueForEncode(env.EnvValue))], envs)));
+  return yMap(ofArray([["class", string("EnvVarRequirement")], ["envDef", envDefMap]]));
+}
+function encodeSoftwareRequirementCompactMap(packages) {
+  const packagesMap = yMap(toList(map$2((package$_1) => {
+    let package$, matchValue_1, value_6, acc_3, value_3, acc_1;
+    return [package$_1.Package, (package$ = package$_1, matchValue_1 = package$.Specs, package$.Version == null ? matchValue_1 != null ? YAMLElement_Sequence(toList(map$2(string, value(matchValue_1)))) : yMap(empty()) : yMap((value_6 = package$.Specs, acc_3 = (value_3 = package$.Version, acc_1 = empty(), value_3 == null ? acc_1 : append(acc_1, singleton(["version", YAMLElement_Sequence(toList(map$2(string, value(value_3))))]))), value_6 == null ? acc_3 : append(acc_3, singleton(["specs", YAMLElement_Sequence(toList(map$2(string, value(value_6))))])))))];
+  }, packages)));
+  return yMap(ofArray([["class", string("SoftwareRequirement")], ["packages", packagesMap]]));
+}
+function encodeLabel(label) {
+  return ["label", string(label)];
+}
+function encodeDoc(doc) {
+  return ["doc", string(normalizeDocString(doc))];
+}
+function encodeIntent(intent) {
+  return ["intent", YAMLElement_Sequence(ofSeq(map$2(string, intent)))];
+}
+function encodeCWLType(t) {
+  let value_4, acc_3, value_2, acc_1;
+  switch (t.tag) {
+    case /* Directory */
+    1:
+      return string("Directory");
+    case /* Dirent */
+    2: {
+      const d = t.fields[0];
+      return yMap((value_4 = d.Writable, acc_3 = (value_2 = d.Entryname, acc_1 = singleton(["entry", encodeSchemaSaladString(d.Entry)]), value_2 == null ? acc_1 : append(acc_1, singleton(["entryname", encodeSchemaSaladString(value(value_2))]))), value_4 == null ? acc_3 : append(acc_3, singleton(["writable", yBool(value(value_4))]))));
+    }
+    case /* String */
+    3:
+      return string("string");
+    case /* Int */
+    4:
+      return string("int");
+    case /* Long */
+    5:
+      return string("long");
+    case /* Float */
+    6:
+      return string("float");
+    case /* Double */
+    7:
+      return string("double");
+    case /* Boolean */
+    8:
+      return string("boolean");
+    case /* Stdout */
+    9:
+      return string("stdout");
+    case /* Null */
+    10:
+      return string("null");
+    case /* Union */
+    14: {
+      const typesList = toList(t.fields[0]);
+      let matchResult, otherType;
+      if (!isEmpty(typesList)) {
+        if (head(typesList).tag === /* Null */
+        10) {
+          if (!isEmpty(tail(typesList))) {
+            if (isEmpty(tail(tail(typesList)))) {
+              matchResult = 0;
+              otherType = head(tail(typesList));
+            } else {
+              matchResult = 1;
+            }
+          } else {
+            matchResult = 1;
+          }
+        } else if (!isEmpty(tail(typesList))) {
+          if (head(tail(typesList)).tag === /* Null */
+          10) {
+            if (isEmpty(tail(tail(typesList)))) {
+              matchResult = 0;
+              otherType = head(typesList);
+            } else {
+              matchResult = 1;
+            }
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+      switch (matchResult) {
+        case 0:
+          switch (otherType.tag) {
+            case /* File */
+            0:
+              return string("File?");
+            case /* Directory */
+            1:
+              return string("Directory?");
+            case /* String */
+            3:
+              return string("string?");
+            case /* Int */
+            4:
+              return string("int?");
+            case /* Long */
+            5:
+              return string("long?");
+            case /* Float */
+            6:
+              return string("float?");
+            case /* Double */
+            7:
+              return string("double?");
+            case /* Boolean */
+            8:
+              return string("boolean?");
+            case /* Array */
+            11: {
+              const arraySchema = otherType.fields[0];
+              const matchValue = tryGetArrayShorthand(arraySchema.Items);
+              if (matchValue == null) {
+                return YAMLElement_Sequence(ofArray([string("null"), encodeInputArraySchema(arraySchema)]));
+              } else {
+                return string(value(matchValue) + "[]?");
+              }
+            }
+            default:
+              return YAMLElement_Sequence(map$1(encodeCWLType, typesList));
+          }
+        default:
+          return YAMLElement_Sequence(map$1(encodeCWLType, typesList));
+      }
+    }
+    case /* Array */
+    11: {
+      const arraySchema_1 = t.fields[0];
+      const matchValue_1 = tryGetArrayShorthand(arraySchema_1.Items);
+      if (matchValue_1 == null) {
+        return encodeInputArraySchema(arraySchema_1);
+      } else {
+        return string(value(matchValue_1) + "[]");
+      }
+    }
+    case /* Record */
+    12:
+      return encodeInputRecordSchema(t.fields[0]);
+    case /* Enum */
+    13:
+      return encodeInputEnumSchema(t.fields[0]);
+    default:
+      return string("File");
+  }
+}
+function encodeInputRecordField(field) {
+  return [field.Name, yMap(singleton(["type", encodeCWLType(field.Type)]))];
+}
+function encodeInputRecordSchema(schema) {
+  let fieldsElement;
+  const matchValue = schema.Fields;
+  fieldsElement = matchValue == null ? yMap(empty()) : yMap(toList(map$2(encodeInputRecordField, value(matchValue))));
+  return yMap(ofArray([["type", string("record")], ["fields", fieldsElement]]));
+}
+function encodeInputEnumSchema(schema) {
+  return yMap(append(singleton(["type", string("enum")]), singleton(["symbols", YAMLElement_Sequence(ofSeq(map$2(string, schema.Symbols)))])));
+}
+function encodeInputArraySchema(schema) {
+  return yMap(ofArray([["type", string("array")], ["items", encodeCWLType(schema.Items)]]));
+}
+function encodeOutputBinding(ob) {
+  return yMap(choose((x) => x, singleton(map((g) => ["glob", string(g)], ob.Glob))));
+}
+function encodeStringArrayOrScalar(values) {
+  if (values.length === 1) {
+    return string(values[0]);
+  } else {
+    return YAMLElement_Sequence(ofSeq(map$2(string, values)));
+  }
+}
+function encodeCWLOutput(o) {
+  let values;
+  const typeElement = map((t) => {
+    switch (t.tag) {
+      case /* Union */
+      14: {
+        const typesList = toList(t.fields[0]);
+        let matchResult, otherType;
+        if (!isEmpty(typesList)) {
+          if (head(typesList).tag === /* Null */
+          10) {
+            if (!isEmpty(tail(typesList))) {
+              if (isEmpty(tail(tail(typesList)))) {
+                matchResult = 0;
+                otherType = head(tail(typesList));
+              } else {
+                matchResult = 1;
+              }
+            } else {
+              matchResult = 1;
+            }
+          } else if (!isEmpty(tail(typesList))) {
+            if (head(tail(typesList)).tag === /* Null */
+            10) {
+              if (isEmpty(tail(tail(typesList)))) {
+                matchResult = 0;
+                otherType = head(typesList);
+              } else {
+                matchResult = 1;
+              }
+            } else {
+              matchResult = 1;
+            }
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+        switch (matchResult) {
+          case 0:
+            switch (otherType.tag) {
+              case /* File */
+              0:
+              case /* Directory */
+              1:
+              case /* String */
+              3:
+              case /* Int */
+              4:
+              case /* Long */
+              5:
+              case /* Float */
+              6:
+              case /* Double */
+              7:
+              case /* Boolean */
+              8:
+                return encodeCWLType(t);
+              case /* Array */
+              11: {
+                const matchValue = otherType.fields[0].Items;
+                switch (matchValue.tag) {
+                  case /* File */
+                  0:
+                  case /* Directory */
+                  1:
+                  case /* String */
+                  3:
+                  case /* Int */
+                  4:
+                  case /* Long */
+                  5:
+                  case /* Float */
+                  6:
+                  case /* Double */
+                  7:
+                  case /* Boolean */
+                  8:
+                    return encodeCWLType(t);
+                  default:
+                    return encodeCWLType(t);
+                }
+              }
+              default:
+                return encodeCWLType(t);
+            }
+          default:
+            return encodeCWLType(t);
+        }
+      }
+      case /* Array */
+      11: {
+        const arraySchema_1 = t.fields[0];
+        const matchValue_1 = arraySchema_1.Items;
+        switch (matchValue_1.tag) {
+          case /* File */
+          0:
+          case /* Directory */
+          1:
+          case /* Dirent */
+          2:
+          case /* String */
+          3:
+          case /* Int */
+          4:
+          case /* Long */
+          5:
+          case /* Float */
+          6:
+          case /* Double */
+          7:
+          case /* Boolean */
+          8:
+            return encodeCWLType(t);
+          default:
+            return yMap(singleton(["type", encodeInputArraySchema(arraySchema_1)]));
+        }
+      }
+      case /* Record */
+      12:
+        return yMap(singleton(["type", encodeInputRecordSchema(t.fields[0])]));
+      case /* Enum */
+      13:
+        return yMap(singleton(["type", encodeInputEnumSchema(t.fields[0])]));
+      default:
+        return encodeCWLType(t);
+    }
+  }, o.Type_);
+  let pairs;
+  let value_4;
+  const matchValue_2 = o.OutputSource;
+  let matchResult_1, value$1, values_1;
+  if (matchValue_2 != null) {
+    if (value(matchValue_2).tag === /* Multiple */
+    1) {
+      if (values = value(matchValue_2).fields[0], values.length > 0) {
+        matchResult_1 = 1;
+        values_1 = value(matchValue_2).fields[0];
+      } else {
+        matchResult_1 = 2;
+      }
+    } else {
+      matchResult_1 = 0;
+      value$1 = value(matchValue_2).fields[0];
+    }
+  } else {
+    matchResult_1 = 2;
+  }
+  switch (matchResult_1) {
+    case 0: {
+      value_4 = string(value$1);
+      break;
+    }
+    case 1: {
+      value_4 = encodeStringArrayOrScalar(values_1);
+      break;
+    }
+    default:
+      value_4 = void 0;
+  }
+  let acc_5;
+  let acc_2;
+  const value_1 = typeElement;
+  const acc_1 = empty();
+  acc_2 = value_1 == null ? acc_1 : append(acc_1, singleton(["type", value(value_1)]));
+  const value_3 = o.OutputBinding;
+  const acc_3 = acc_2;
+  acc_5 = value_3 == null ? acc_3 : append(acc_3, singleton(["outputBinding", encodeOutputBinding(value(value_3))]));
+  pairs = value_4 == null ? acc_5 : append(acc_5, singleton(["outputSource", value(value_4)]));
+  let matchResult_2, t_1;
+  if (!isEmpty(pairs)) {
+    if (head(pairs)[0] === "type") {
+      if (isEmpty(tail(pairs))) {
+        matchResult_2 = 0;
+        t_1 = head(pairs)[1];
+      } else {
+        matchResult_2 = 1;
+      }
+    } else {
+      matchResult_2 = 1;
+    }
+  } else {
+    matchResult_2 = 1;
+  }
+  switch (matchResult_2) {
+    case 0:
+      return [o.Name, t_1];
+    default:
+      return [o.Name, yMap(pairs)];
+  }
+}
+function encodeInputBinding(ib) {
+  let value_9, acc_7, value_7, acc_5, value_4, acc_3, value_2, acc_1;
+  return yMap((value_9 = ib.Separate, acc_7 = (value_7 = ib.ItemSeparator, acc_5 = (value_4 = ib.Position, acc_3 = (value_2 = ib.Prefix, acc_1 = empty(), value_2 == null ? acc_1 : append(acc_1, singleton(["prefix", string(value(value_2))]))), value_4 == null ? acc_3 : append(acc_3, singleton(["position", int(value(value_4))]))), value_7 == null ? acc_5 : append(acc_5, singleton(["itemSeparator", string(value(value_7))]))), value_9 == null ? acc_7 : append(acc_7, singleton(["separate", yBool(value(value_9))]))));
+}
+function encodeCWLInput(i) {
+  let pairs;
+  let acc_4;
+  let acc_2;
+  const value$1 = map((t) => {
+    switch (t.tag) {
+      case /* Union */
+      14: {
+        const typesList = toList(t.fields[0]);
+        let matchResult, otherType;
+        if (!isEmpty(typesList)) {
+          if (head(typesList).tag === /* Null */
+          10) {
+            if (!isEmpty(tail(typesList))) {
+              if (isEmpty(tail(tail(typesList)))) {
+                matchResult = 0;
+                otherType = head(tail(typesList));
+              } else {
+                matchResult = 1;
+              }
+            } else {
+              matchResult = 1;
+            }
+          } else if (!isEmpty(tail(typesList))) {
+            if (head(tail(typesList)).tag === /* Null */
+            10) {
+              if (isEmpty(tail(tail(typesList)))) {
+                matchResult = 0;
+                otherType = head(typesList);
+              } else {
+                matchResult = 1;
+              }
+            } else {
+              matchResult = 1;
+            }
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+        switch (matchResult) {
+          case 0:
+            switch (otherType.tag) {
+              case /* File */
+              0:
+              case /* Directory */
+              1:
+              case /* String */
+              3:
+              case /* Int */
+              4:
+              case /* Long */
+              5:
+              case /* Float */
+              6:
+              case /* Double */
+              7:
+              case /* Boolean */
+              8:
+                return encodeCWLType(t);
+              case /* Array */
+              11: {
+                const matchValue = otherType.fields[0].Items;
+                switch (matchValue.tag) {
+                  case /* File */
+                  0:
+                  case /* Directory */
+                  1:
+                  case /* String */
+                  3:
+                  case /* Int */
+                  4:
+                  case /* Long */
+                  5:
+                  case /* Float */
+                  6:
+                  case /* Double */
+                  7:
+                  case /* Boolean */
+                  8:
+                    return encodeCWLType(t);
+                  default:
+                    return encodeCWLType(t);
+                }
+              }
+              default:
+                return encodeCWLType(t);
+            }
+          default:
+            return encodeCWLType(t);
+        }
+      }
+      case /* Array */
+      11: {
+        const arraySchema_1 = t.fields[0];
+        const matchValue_1 = arraySchema_1.Items;
+        switch (matchValue_1.tag) {
+          case /* File */
+          0:
+          case /* Directory */
+          1:
+          case /* Dirent */
+          2:
+          case /* String */
+          3:
+          case /* Int */
+          4:
+          case /* Long */
+          5:
+          case /* Float */
+          6:
+          case /* Double */
+          7:
+          case /* Boolean */
+          8:
+            return encodeCWLType(t);
+          default:
+            return yMap(singleton(["type", encodeInputArraySchema(arraySchema_1)]));
+        }
+      }
+      case /* Record */
+      12:
+        return yMap(singleton(["type", encodeInputRecordSchema(t.fields[0])]));
+      case /* Enum */
+      13:
+        return yMap(singleton(["type", encodeInputEnumSchema(t.fields[0])]));
+      default:
+        return encodeCWLType(t);
+    }
+  }, i.Type_);
+  const acc_1 = empty();
+  acc_2 = value$1 == null ? acc_1 : append(acc_1, singleton(["type", value(value$1)]));
+  const value_2 = i.InputBinding;
+  const acc_3 = acc_2;
+  acc_4 = value_2 == null ? acc_3 : append(acc_3, singleton(["inputBinding", encodeInputBinding(value(value_2))]));
+  const value_4 = i.Optional;
+  const acc_5 = acc_4;
+  pairs = value_4 == null ? acc_5 : append(acc_5, singleton(["optional", yBool(value(value_4))]));
+  let matchResult_1, t_1;
+  if (!isEmpty(pairs)) {
+    if (head(pairs)[0] === "type") {
+      if (isEmpty(tail(pairs))) {
+        matchResult_1 = 0;
+        t_1 = head(pairs)[1];
+      } else {
+        matchResult_1 = 1;
+      }
+    } else {
+      matchResult_1 = 1;
+    }
+  } else {
+    matchResult_1 = 1;
+  }
+  switch (matchResult_1) {
+    case 0:
+      return [i.Name, t_1];
+    default:
+      return [i.Name, yMap(pairs)];
+  }
+}
+function encodeSchemaDefRequirementType(s) {
+  return yMap(ofArray([["name", string(s.Name)], ["type", encodeCWLType(s.Type_)]]));
+}
+function encodeRequirement(r) {
+  let value_20, acc_13, value_17, acc_11, value_14, acc_9, value_11, acc_7, value_8, acc_5, value_5, acc_3, value_2, acc_1;
+  switch (r.tag) {
+    case /* SchemaDefRequirement */
+    1: {
+      const types = r.fields[0];
+      return yMap(ofArray([["class", string("SchemaDefRequirement")], ["types", YAMLElement_Sequence(ofSeq(map$2(encodeSchemaDefRequirementType, types)))]]));
+    }
+    case /* DockerRequirement */
+    2: {
+      const dr = r.fields[0];
+      return yMap((value_20 = dr.DockerOutputDirectory, acc_13 = (value_17 = dr.DockerImport, acc_11 = (value_14 = dr.DockerLoad, acc_9 = (value_11 = dr.DockerImageId, acc_7 = (value_8 = dr.DockerFile, acc_5 = (value_5 = dr.DockerPull, acc_3 = singleton(["class", string("DockerRequirement")]), value_5 == null ? acc_3 : append(acc_3, singleton(["dockerPull", string(value(value_5))]))), value_8 == null ? acc_5 : append(acc_5, singleton(["dockerFile", encodeSchemaSaladString(value(value_8))]))), value_11 == null ? acc_7 : append(acc_7, singleton(["dockerImageId", string(value(value_11))]))), value_14 == null ? acc_9 : append(acc_9, singleton(["dockerLoad", string(value(value_14))]))), value_17 == null ? acc_11 : append(acc_11, singleton(["dockerImport", string(value(value_17))]))), value_20 == null ? acc_13 : append(acc_13, singleton(["dockerOutputDirectory", string(value(value_20))]))));
+    }
+    case /* SoftwareRequirement */
+    3: {
+      const pkgs = r.fields[0];
+      return yMap(ofArray([["class", string("SoftwareRequirement")], ["packages", YAMLElement_Sequence(ofSeq(map$2((p) => {
+        let value_26, acc_18, value_23, acc_16;
+        return yMap((value_26 = p.Specs, acc_18 = (value_23 = p.Version, acc_16 = append(empty(), singleton(["package", string(p.Package)])), value_23 == null ? acc_16 : append(acc_16, singleton(["version", YAMLElement_Sequence(ofSeq(map$2(string, value(value_23))))]))), value_26 == null ? acc_18 : append(acc_18, singleton(["specs", YAMLElement_Sequence(ofSeq(map$2(string, value(value_26))))]))));
+      }, pkgs)))]]));
+    }
+    case /* LoadListingRequirement */
+    4: {
+      const loadListing = r.fields[0];
+      return yMap(ofArray([["class", string("LoadListingRequirement")], ["loadListing", string(LoadListingEnum_get_toCwlString()(loadListing.LoadListing))]]));
+    }
+    case /* InitialWorkDirRequirement */
+    5: {
+      const listing = r.fields[0];
+      const encodeDynamicObjWithClass = (className, dynObj) => {
+        const dynamicPairs = toList(choose$1((kvp) => {
+          const matchValue = kvp[1];
+          if (typeof matchValue === "string") {
+            return [kvp[0], string(matchValue)];
+          } else if (typeof matchValue === "boolean") {
+            return [kvp[0], yBool(matchValue)];
+          } else if (typeof matchValue === "number") {
+            return [kvp[0], int(matchValue)];
+          } else if (typeof matchValue === "bigint") {
+            return [kvp[0], string(int64ToString(matchValue))];
+          } else if (typeof matchValue === "number") {
+            return [kvp[0], float(matchValue)];
+          } else if (matchValue instanceof YAMLElement) {
+            return [kvp[0], matchValue];
+          } else {
+            return void 0;
+          }
+        }, dynObj.GetProperties(false)));
+        if (exists((tupledArg) => tupledArg[0] === "class", dynamicPairs)) {
+          return yMap(dynamicPairs);
+        } else {
+          return yMap(cons(["class", string(className)], dynamicPairs));
+        }
+      };
+      return yMap(ofArray([["class", string("InitialWorkDirRequirement")], ["listing", YAMLElement_Sequence(ofSeq(map$2((_arg_1) => {
+        let value_31, acc_23, value_29, acc_20;
+        switch (_arg_1.tag) {
+          case /* StringEntry */
+          1:
+            return encodeSchemaSaladString(_arg_1.fields[0]);
+          case /* FileEntry */
+          2: {
+            const arg_1 = _arg_1.fields[0];
+            return encodeDynamicObjWithClass("File", arg_1);
+          }
+          case /* DirectoryEntry */
+          3: {
+            const arg_3 = _arg_1.fields[0];
+            return encodeDynamicObjWithClass("Directory", arg_3);
+          }
+          default: {
+            const d = _arg_1.fields[0];
+            return yMap((value_31 = d.Writable, acc_23 = append((value_29 = d.Entryname, acc_20 = empty(), value_29 == null ? acc_20 : append(acc_20, singleton(["entryname", encodeSchemaSaladString(value(value_29))]))), singleton(["entry", encodeSchemaSaladString(d.Entry)])), value_31 == null ? acc_23 : append(acc_23, singleton(["writable", yBool(value(value_31))]))));
+          }
+        }
+      }, listing)))]]));
+    }
+    case /* EnvVarRequirement */
+    6: {
+      const envs = r.fields[0];
+      return yMap(ofArray([["class", string("EnvVarRequirement")], ["envDef", YAMLElement_Sequence(ofSeq(map$2((e) => {
+        const v_11 = normalizeEnvValueForEncode(e.EnvValue);
+        return yMap(ofArray([["envName", string(e.EnvName)], ["envValue", string(v_11)]]));
+      }, envs)))]]));
+    }
+    case /* ShellCommandRequirement */
+    7:
+      return yMap(singleton(["class", string("ShellCommandRequirement")]));
+    case /* ResourceRequirement */
+    8: {
+      const rr = r.fields[0];
+      const tryEncodeScalar = (key, value_32) => {
+        if (typeof value_32 === "number") {
+          return [key, int(value_32)];
+        } else if (typeof value_32 === "bigint") {
+          return [key, YAMLElement_Value(new YAMLContent(int64ToString(value_32), void 0))];
+        } else if (typeof value_32 === "number") {
+          return [key, float(value_32)];
+        } else if (typeof value_32 === "string") {
+          return [key, string(value_32)];
+        } else if (typeof value_32 === "boolean") {
+          return [key, yBool(value_32)];
+        } else {
+          return void 0;
+        }
+      };
+      const dynamicPairs_1 = toList(choose$1((kvp_1) => {
+        const matchValue_1 = kvp_1[1];
+        return tryEncodeScalar(kvp_1[0], matchValue_1);
+      }, rr.GetProperties(false)));
+      return yMap(append(singleton(["class", string("ResourceRequirement")]), dynamicPairs_1));
+    }
+    case /* WorkReuseRequirement */
+    9: {
+      const workReuse = r.fields[0];
+      return yMap(ofArray([["class", string("WorkReuse")], ["enableReuse", yBool(workReuse.EnableReuse)]]));
+    }
+    case /* WorkReuseExpressionRequirement */
+    10: {
+      const expression = r.fields[0];
+      return yMap(ofArray([["class", string("WorkReuse")], ["enableReuse", string(expression)]]));
+    }
+    case /* NetworkAccessRequirement */
+    11: {
+      const networkAccess = r.fields[0];
+      return yMap(ofArray([["class", string("NetworkAccess")], ["networkAccess", yBool(networkAccess.NetworkAccess)]]));
+    }
+    case /* NetworkAccessExpressionRequirement */
+    12: {
+      const expression_1 = r.fields[0];
+      return yMap(ofArray([["class", string("NetworkAccess")], ["networkAccess", string(expression_1)]]));
+    }
+    case /* InplaceUpdateRequirement */
+    13: {
+      const inplaceUpdate = r.fields[0];
+      return yMap(ofArray([["class", string("InplaceUpdateRequirement")], ["inplaceUpdate", yBool(inplaceUpdate.InplaceUpdate)]]));
+    }
+    case /* ToolTimeLimitRequirement */
+    14: {
+      const tl = r.fields[0];
+      const timelimit = tl.tag === /* ToolTimeLimitExpression */
+      1 ? string(tl.fields[0]) : YAMLElement_Value(new YAMLContent(int64ToString(tl.fields[0]), void 0));
+      return yMap(ofArray([["class", string("ToolTimeLimit")], ["timelimit", timelimit]]));
+    }
+    case /* SubworkflowFeatureRequirement */
+    15:
+      return yMap(singleton(["class", string("SubworkflowFeatureRequirement")]));
+    case /* ScatterFeatureRequirement */
+    16:
+      return yMap(singleton(["class", string("ScatterFeatureRequirement")]));
+    case /* MultipleInputFeatureRequirement */
+    17:
+      return yMap(singleton(["class", string("MultipleInputFeatureRequirement")]));
+    case /* StepInputExpressionRequirement */
+    18:
+      return yMap(singleton(["class", string("StepInputExpressionRequirement")]));
+    default:
+      return yMap((value_2 = bind((entries) => {
+        if (entries.length > 0) {
+          return entries;
+        } else {
+          return void 0;
+        }
+      }, r.fields[0].ExpressionLib), acc_1 = singleton(["class", string("InlineJavascriptRequirement")]), value_2 == null ? acc_1 : append(acc_1, singleton(["expressionLib", YAMLElement_Sequence(ofSeq(map$2(string, value(value_2))))]))));
+  }
+}
+function encodeHintEntry(hint) {
+  if (hint.tag === /* UnknownHint */
+  1) {
+    return hint.fields[0].Raw;
+  } else {
+    return encodeRequirement(hint.fields[0]);
+  }
+}
+function encodeSourceArray(sources) {
+  if (sources.length === 1) {
+    return string(sources[0]);
+  } else {
+    return YAMLElement_Sequence(ofSeq(map$2((s) => YAMLElement_Object(singleton(YAMLElement_Value(new YAMLContent(s, void 0)))), sources)));
+  }
+}
+function encodeLinkMergeMethod(linkMerge) {
+  return string(linkMerge.AsCwlString);
+}
+function encodePickValueMethod(pickValue) {
+  return string(pickValue.AsCwlString);
+}
+function encodeScatterMethod(scatterMethod) {
+  return string(scatterMethod.AsCwlString);
+}
+function encodeStepInput(si) {
+  let pairs;
+  const value_21 = si.Label;
+  let acc_17;
+  const value_18 = si.LoadListing;
+  let acc_15;
+  const value_15 = si.LoadContents;
+  let acc_13;
+  const value_13 = si.Doc;
+  let acc_11;
+  const value_10 = si.PickValue;
+  let acc_9;
+  const value_8 = si.LinkMerge;
+  let acc_7;
+  const value_6 = si.ValueFrom;
+  let acc_5;
+  const value_3 = si.DefaultValue;
+  let acc_3;
+  const value_1 = si.Source;
+  const acc_1 = empty();
+  acc_3 = value_1 == null ? acc_1 : append(acc_1, singleton(["source", encodeSourceArray(value(value_1))]));
+  acc_5 = value_3 == null ? acc_3 : append(acc_3, singleton(["default", value(value_3)]));
+  acc_7 = value_6 == null ? acc_5 : append(acc_5, singleton(["valueFrom", string(value(value_6))]));
+  acc_9 = value_8 == null ? acc_7 : append(acc_7, singleton(["linkMerge", encodeLinkMergeMethod(value(value_8))]));
+  acc_11 = value_10 == null ? acc_9 : append(acc_9, singleton(["pickValue", encodePickValueMethod(value(value_10))]));
+  acc_13 = value_13 == null ? acc_11 : append(acc_11, singleton(["doc", string(value(value_13))]));
+  acc_15 = value_15 == null ? acc_13 : append(acc_13, singleton(["loadContents", yBool(value(value_15))]));
+  acc_17 = value_18 == null ? acc_15 : append(acc_15, singleton(["loadListing", string(value(value_18))]));
+  pairs = value_21 == null ? acc_17 : append(acc_17, singleton(["label", string(value(value_21))]));
+  let matchResult, s_1;
+  if (!isEmpty(pairs)) {
+    if (head(pairs)[0] === "source") {
+      if (isEmpty(tail(pairs))) {
+        if (si.DefaultValue == null && si.ValueFrom == null && si.LinkMerge == null && si.PickValue == null && si.Doc == null && si.LoadContents == null && si.LoadListing == null && si.Label == null) {
+          matchResult = 0;
+          s_1 = head(pairs)[1];
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return [si.Id, s_1];
+    default:
+      return [si.Id, yMap(pairs)];
+  }
+}
+function encodeStepInputs(inputs) {
+  return yMap(toList(map$2(encodeStepInput, inputs)));
+}
+function encodeStepOutputParameter(so) {
+  return yMap(singleton(["id", string(so.Id)]));
+}
+function encodeStepOutputs(outputs) {
+  return YAMLElement_Sequence(ofSeq(map$2((output) => {
+    if (output.tag === /* StepOutputRecord */
+    1) {
+      return encodeStepOutputParameter(output.fields[0]);
+    } else {
+      return string(output.fields[0]);
+    }
+  }, outputs)));
+}
+function encodeScatter(scatter) {
+  if (scatter.length === 1) {
+    return string(scatter[0]);
+  } else {
+    return YAMLElement_Sequence(ofSeq(map$2(string, scatter)));
+  }
+}
+function encodeWorkflowStepRun(run) {
+  switch (run.tag) {
+    case /* RunCommandLineTool */
+    1: {
+      const toolObj = run.fields[0];
+      const matchValue = WorkflowStepRunOps_tryGetTool(run);
+      if (matchValue == null) {
+        throw new Error(toText(interpolate("RunCommandLineTool must contain CWLToolDescription but got %A%P()", [toolObj])));
+      } else {
+        return encodeToolDescriptionElement(value(matchValue));
+      }
+    }
+    case /* RunWorkflow */
+    2: {
+      const workflowObj = run.fields[0];
+      const matchValue_1 = WorkflowStepRunOps_tryGetWorkflow(run);
+      if (matchValue_1 == null) {
+        throw new Error(toText(interpolate("RunWorkflow must contain CWLWorkflowDescription but got %A%P()", [workflowObj])));
+      } else {
+        return encodeWorkflowDescriptionElement(value(matchValue_1));
+      }
+    }
+    case /* RunExpressionTool */
+    3: {
+      const expressionToolObj = run.fields[0];
+      const matchValue_2 = WorkflowStepRunOps_tryGetExpressionTool(run);
+      if (matchValue_2 == null) {
+        throw new Error(toText(interpolate("RunExpressionTool must contain CWLExpressionToolDescription but got %A%P()", [expressionToolObj])));
+      } else {
+        return encodeExpressionToolDescriptionElement(value(matchValue_2));
+      }
+    }
+    case /* RunOperation */
+    4: {
+      const operationObj = run.fields[0];
+      const matchValue_3 = WorkflowStepRunOps_tryGetOperation(run);
+      if (matchValue_3 == null) {
+        throw new Error(toText(interpolate("RunOperation must contain CWLOperationDescription but got %A%P()", [operationObj])));
+      } else {
+        return encodeOperationDescriptionElement(value(matchValue_3));
+      }
+    }
+    default:
+      return string(run.fields[0]);
+  }
+}
+function encodeToolDescriptionElement(td) {
+  let h, r, bc, matchValue_3, i, i_1, matchValue_4, md;
+  let basePairs;
+  let acc_4;
+  let acc_2;
+  const acc = ofArray([["cwlVersion", string(td.CWLVersion)], ["class", string("CommandLineTool")]]);
+  const pairOpt_1 = map(encodeLabel, td.Label);
+  const acc_1 = acc;
+  acc_2 = pairOpt_1 == null ? acc_1 : append(acc_1, singleton(value(pairOpt_1)));
+  const pairOpt_3 = map(encodeDoc, td.Doc);
+  const acc_3 = acc_2;
+  acc_4 = pairOpt_3 == null ? acc_3 : append(acc_3, singleton(value(pairOpt_3)));
+  const pairOpt_5 = map(encodeIntent, filter((intent) => intent.length > 0, td.Intent));
+  const acc_5 = acc_4;
+  basePairs = pairOpt_5 == null ? acc_5 : append(acc_5, singleton(value(pairOpt_5)));
+  let withHints;
+  const matchValue = td.Hints;
+  let matchResult, h_1;
+  if (matchValue != null) {
+    if (h = value(matchValue), h.length > 0) {
+      matchResult = 0;
+      h_1 = value(matchValue);
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0: {
+      withHints = append(basePairs, singleton(["hints", YAMLElement_Sequence(ofSeq(map$2(encodeHintEntry, h_1)))]));
+      break;
+    }
+    default:
+      withHints = basePairs;
+  }
+  let withRequirements;
+  const matchValue_1 = td.Requirements;
+  let matchResult_1, r_1;
+  if (matchValue_1 != null) {
+    if (r = value(matchValue_1), r.length > 0) {
+      matchResult_1 = 0;
+      r_1 = value(matchValue_1);
+    } else {
+      matchResult_1 = 1;
+    }
+  } else {
+    matchResult_1 = 1;
+  }
+  switch (matchResult_1) {
+    case 0: {
+      withRequirements = append(withHints, singleton(["requirements", YAMLElement_Sequence(ofSeq(map$2(encodeRequirement, r_1)))]));
+      break;
+    }
+    default:
+      withRequirements = withHints;
+  }
+  let withBaseCommand;
+  const matchValue_2 = td.BaseCommand;
+  let matchResult_2, bc_1;
+  if (matchValue_2 != null) {
+    if (bc = value(matchValue_2), bc.length > 0) {
+      matchResult_2 = 0;
+      bc_1 = value(matchValue_2);
+    } else {
+      matchResult_2 = 1;
+    }
+  } else {
+    matchResult_2 = 1;
+  }
+  switch (matchResult_2) {
+    case 0: {
+      withBaseCommand = append(withRequirements, singleton(["baseCommand", YAMLElement_Sequence(ofSeq(map$2(string, bc_1)))]));
+      break;
+    }
+    default:
+      withBaseCommand = withRequirements;
+  }
+  const withOutputs = append((matchValue_3 = td.Inputs, matchValue_3 != null ? (i = value(matchValue_3), i.length > 0) ? (i_1 = value(matchValue_3), append(withBaseCommand, singleton(["inputs", yMap(toList(map$2(encodeCWLInput, i_1)))]))) : withBaseCommand : withBaseCommand), singleton(["outputs", yMap(toList(map$2(encodeCWLOutput, td.Outputs)))]));
+  return yMap((matchValue_4 = td.Metadata, matchValue_4 == null ? withOutputs : (md = value(matchValue_4), fold((acc_6, kvp) => {
+    let matchValue_5;
+    return append(acc_6, singleton([kvp[0], (matchValue_5 = kvp[1], typeof matchValue_5 === "string" ? string(matchValue_5) : typeof matchValue_5 === "boolean" ? yBool(matchValue_5) : typeof matchValue_5 === "number" ? int(matchValue_5) : typeof matchValue_5 === "number" ? float(matchValue_5) : matchValue_5 instanceof YAMLElement ? matchValue_5 : string(toString(kvp[1])))]));
+  }, withOutputs, md.GetProperties(false)))));
+}
+function encodeExpressionToolDescriptionElement(et) {
+  let h, r, matchValue_2, i, i_1, matchValue_3, md;
+  let basePairs;
+  let acc_4;
+  let acc_2;
+  const acc = ofArray([["cwlVersion", string(et.CWLVersion)], ["class", string("ExpressionTool")]]);
+  const pairOpt_1 = map(encodeLabel, et.Label);
+  const acc_1 = acc;
+  acc_2 = pairOpt_1 == null ? acc_1 : append(acc_1, singleton(value(pairOpt_1)));
+  const pairOpt_3 = map(encodeDoc, et.Doc);
+  const acc_3 = acc_2;
+  acc_4 = pairOpt_3 == null ? acc_3 : append(acc_3, singleton(value(pairOpt_3)));
+  const pairOpt_5 = map(encodeIntent, filter((intent) => intent.length > 0, et.Intent));
+  const acc_5 = acc_4;
+  basePairs = pairOpt_5 == null ? acc_5 : append(acc_5, singleton(value(pairOpt_5)));
+  let withHints;
+  const matchValue = et.Hints;
+  let matchResult, h_1;
+  if (matchValue != null) {
+    if (h = value(matchValue), h.length > 0) {
+      matchResult = 0;
+      h_1 = value(matchValue);
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0: {
+      withHints = append(basePairs, singleton(["hints", YAMLElement_Sequence(ofSeq(map$2(encodeHintEntry, h_1)))]));
+      break;
+    }
+    default:
+      withHints = basePairs;
+  }
+  let withRequirements;
+  const matchValue_1 = et.Requirements;
+  let matchResult_1, r_1;
+  if (matchValue_1 != null) {
+    if (r = value(matchValue_1), r.length > 0) {
+      matchResult_1 = 0;
+      r_1 = value(matchValue_1);
+    } else {
+      matchResult_1 = 1;
+    }
+  } else {
+    matchResult_1 = 1;
+  }
+  switch (matchResult_1) {
+    case 0: {
+      withRequirements = append(withHints, singleton(["requirements", YAMLElement_Sequence(ofSeq(map$2(encodeRequirement, r_1)))]));
+      break;
+    }
+    default:
+      withRequirements = withHints;
+  }
+  const withExpression = append(append((matchValue_2 = et.Inputs, matchValue_2 != null ? (i = value(matchValue_2), i.length > 0) ? (i_1 = value(matchValue_2), append(withRequirements, singleton(["inputs", yMap(toList(map$2(encodeCWLInput, i_1)))]))) : withRequirements : withRequirements), singleton(["outputs", yMap(toList(map$2(encodeCWLOutput, et.Outputs)))])), singleton(["expression", string(et.Expression)]));
+  return yMap((matchValue_3 = et.Metadata, matchValue_3 == null ? withExpression : (md = value(matchValue_3), fold((acc_6, kvp) => {
+    let matchValue_4;
+    return append(acc_6, singleton([kvp[0], (matchValue_4 = kvp[1], typeof matchValue_4 === "string" ? string(matchValue_4) : typeof matchValue_4 === "boolean" ? yBool(matchValue_4) : typeof matchValue_4 === "number" ? int(matchValue_4) : typeof matchValue_4 === "number" ? float(matchValue_4) : matchValue_4 instanceof YAMLElement ? matchValue_4 : string(toString(kvp[1])))]));
+  }, withExpression, md.GetProperties(false)))));
+}
+function encodeOperationDescriptionElement(op) {
+  let h, matchValue_1, r, r_1, matchValue_2, md;
+  let basePairs;
+  let acc_4;
+  let acc_2;
+  const acc = ofArray([["cwlVersion", string(op.CWLVersion)], ["class", string("Operation")]]);
+  const pairOpt_1 = map(encodeLabel, op.Label);
+  const acc_1 = acc;
+  acc_2 = pairOpt_1 == null ? acc_1 : append(acc_1, singleton(value(pairOpt_1)));
+  const pairOpt_3 = map(encodeDoc, op.Doc);
+  const acc_3 = acc_2;
+  acc_4 = pairOpt_3 == null ? acc_3 : append(acc_3, singleton(value(pairOpt_3)));
+  const pairOpt_5 = map(encodeIntent, filter((intent) => intent.length > 0, op.Intent));
+  const acc_5 = acc_4;
+  basePairs = pairOpt_5 == null ? acc_5 : append(acc_5, singleton(value(pairOpt_5)));
+  let withHints;
+  const matchValue = op.Hints;
+  let matchResult, h_1;
+  if (matchValue != null) {
+    if (h = value(matchValue), h.length > 0) {
+      matchResult = 0;
+      h_1 = value(matchValue);
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0: {
+      withHints = append(basePairs, singleton(["hints", YAMLElement_Sequence(ofSeq(map$2(encodeHintEntry, h_1)))]));
+      break;
+    }
+    default:
+      withHints = basePairs;
+  }
+  const withOutputs = append(append((matchValue_1 = op.Requirements, matchValue_1 != null ? (r = value(matchValue_1), r.length > 0) ? (r_1 = value(matchValue_1), append(withHints, singleton(["requirements", YAMLElement_Sequence(ofSeq(map$2(encodeRequirement, r_1)))]))) : withHints : withHints), singleton(["inputs", yMap(toList(map$2(encodeCWLInput, op.Inputs)))])), singleton(["outputs", yMap(toList(map$2(encodeCWLOutput, op.Outputs)))]));
+  return yMap((matchValue_2 = op.Metadata, matchValue_2 == null ? withOutputs : (md = value(matchValue_2), fold((acc_6, kvp) => {
+    let matchValue_3;
+    return append(acc_6, singleton([kvp[0], (matchValue_3 = kvp[1], typeof matchValue_3 === "string" ? string(matchValue_3) : typeof matchValue_3 === "boolean" ? yBool(matchValue_3) : typeof matchValue_3 === "number" ? int(matchValue_3) : typeof matchValue_3 === "number" ? float(matchValue_3) : matchValue_3 instanceof YAMLElement ? matchValue_3 : string(toString(kvp[1])))]));
+  }, withOutputs, md.GetProperties(false)))));
+}
+function encodeWorkflowDescriptionElement(wd) {
+  let h, matchValue_1, r, r_1, matchValue_2, md;
+  let basePairs;
+  let acc_4;
+  let acc_2;
+  const acc = ofArray([["cwlVersion", string(wd.CWLVersion)], ["class", string("Workflow")]]);
+  const pairOpt_1 = map(encodeLabel, wd.Label);
+  const acc_1 = acc;
+  acc_2 = pairOpt_1 == null ? acc_1 : append(acc_1, singleton(value(pairOpt_1)));
+  const pairOpt_3 = map(encodeDoc, wd.Doc);
+  const acc_3 = acc_2;
+  acc_4 = pairOpt_3 == null ? acc_3 : append(acc_3, singleton(value(pairOpt_3)));
+  const pairOpt_5 = map(encodeIntent, filter((intent) => intent.length > 0, wd.Intent));
+  const acc_5 = acc_4;
+  basePairs = pairOpt_5 == null ? acc_5 : append(acc_5, singleton(value(pairOpt_5)));
+  let withHints;
+  const matchValue = wd.Hints;
+  let matchResult, h_1;
+  if (matchValue != null) {
+    if (h = value(matchValue), h.length > 0) {
+      matchResult = 0;
+      h_1 = value(matchValue);
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0: {
+      withHints = append(basePairs, singleton(["hints", YAMLElement_Sequence(ofSeq(map$2(encodeHintEntry, h_1)))]));
+      break;
+    }
+    default:
+      withHints = basePairs;
+  }
+  const withOutputs = append(append(append((matchValue_1 = wd.Requirements, matchValue_1 != null ? (r = value(matchValue_1), r.length > 0) ? (r_1 = value(matchValue_1), append(withHints, singleton(["requirements", YAMLElement_Sequence(ofSeq(map$2(encodeRequirement, r_1)))]))) : withHints : withHints), singleton(["inputs", yMap(toList(map$2(encodeCWLInput, wd.Inputs)))])), singleton(["steps", yMap(toList(map$2(encodeWorkflowStep, wd.Steps)))])), singleton(["outputs", yMap(toList(map$2(encodeCWLOutput, wd.Outputs)))]));
+  return yMap((matchValue_2 = wd.Metadata, matchValue_2 == null ? withOutputs : (md = value(matchValue_2), fold((acc_6, kvp) => {
+    let matchValue_3;
+    return append(acc_6, singleton([kvp[0], (matchValue_3 = kvp[1], typeof matchValue_3 === "string" ? string(matchValue_3) : typeof matchValue_3 === "boolean" ? yBool(matchValue_3) : typeof matchValue_3 === "number" ? int(matchValue_3) : typeof matchValue_3 === "number" ? float(matchValue_3) : matchValue_3 instanceof YAMLElement ? matchValue_3 : string(toString(kvp[1])))]));
+  }, withOutputs, md.GetProperties(false)))));
+}
+function encodeWorkflowStep(ws) {
+  let h, r;
+  let basePairs;
+  let acc_8;
+  let acc_6;
+  let acc_4;
+  let acc_2;
+  const acc = ofArray([["run", encodeWorkflowStepRun(ws.Run)], ["in", encodeStepInputs(ws.In)], ["out", encodeStepOutputs(ws.Out)]]);
+  const value_2 = ws.Label;
+  const acc_1 = acc;
+  acc_2 = value_2 == null ? acc_1 : append(acc_1, singleton(["label", string(value(value_2))]));
+  const value_5 = ws.Doc;
+  const acc_3 = acc_2;
+  acc_4 = value_5 == null ? acc_3 : append(acc_3, singleton(["doc", string(value(value_5))]));
+  const value_7 = ws.Scatter;
+  const acc_5 = acc_4;
+  acc_6 = value_7 == null ? acc_5 : append(acc_5, singleton(["scatter", encodeScatter(value(value_7))]));
+  const value_9 = ws.ScatterMethod;
+  const acc_7 = acc_6;
+  acc_8 = value_9 == null ? acc_7 : append(acc_7, singleton(["scatterMethod", encodeScatterMethod(value(value_9))]));
+  const value_12 = ws.When_;
+  const acc_9 = acc_8;
+  basePairs = value_12 == null ? acc_9 : append(acc_9, singleton(["when", string(value(value_12))]));
+  let withHints;
+  const matchValue = ws.Hints;
+  let matchResult, h_1;
+  if (matchValue != null) {
+    if (h = value(matchValue), h.length > 0) {
+      matchResult = 0;
+      h_1 = value(matchValue);
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0: {
+      withHints = append(basePairs, singleton(["hints", YAMLElement_Sequence(ofSeq(map$2(encodeHintEntry, h_1)))]));
+      break;
+    }
+    default:
+      withHints = basePairs;
+  }
+  let withReq;
+  const matchValue_1 = ws.Requirements;
+  let matchResult_1, r_1;
+  if (matchValue_1 != null) {
+    if (r = value(matchValue_1), r.length > 0) {
+      matchResult_1 = 0;
+      r_1 = value(matchValue_1);
+    } else {
+      matchResult_1 = 1;
+    }
+  } else {
+    matchResult_1 = 1;
+  }
+  switch (matchResult_1) {
+    case 0: {
+      withReq = append(withHints, singleton(["requirements", YAMLElement_Sequence(ofSeq(map$2(encodeRequirement, r_1)))]));
+      break;
+    }
+    default:
+      withReq = withHints;
+  }
+  return [ws.Id, yMap(withReq)];
+}
+function writeYaml(element) {
+  return write(element, (c) => new Config(2, c.Level));
+}
+function getObjectPairs(element) {
+  if (element.tag === /* Object */
+  3) {
+    return choose((_arg) => {
+      if (_arg.tag === /* Mapping */
+      0) {
+        return [_arg.fields[0].Value, _arg.fields[1]];
+      } else {
+        return void 0;
+      }
+    }, element.fields[0]);
+  } else {
+    return empty();
+  }
+}
+function renderTopLevelElement(baseKeys, orderedSectionKeys, element) {
+  const section = (pairs) => trimEnd(replace(writeYaml(yMap(pairs)), "\r\n", "\n"), "\n");
+  const pairs_2 = getObjectPairs(element);
+  const basePairs = filter$1((tupledArg) => contains(tupledArg[0], baseKeys, {
+    Equals: (x, y) => x === y,
+    GetHashCode: stringHash
+  }), pairs_2);
+  const knownSections = choose((sectionKey) => map(singleton, tryFind((tupledArg_1) => tupledArg_1[0] === sectionKey, pairs_2)), orderedSectionKeys);
+  const reservedKeys = ofList(append(baseKeys, orderedSectionKeys), {
+    Compare: comparePrimitives
+  });
+  const metadataPairs = filter$1((tupledArg_2) => !FSharpSet__Contains(reservedKeys, tupledArg_2[0]), pairs_2);
+  const merge = (acc_mut, remaining_mut) => {
+    merge:
+      while (true) {
+        const acc = acc_mut, remaining = remaining_mut;
+        let matchResult, a_1, b_1, rest_1, l, rest_2;
+        if (isEmpty(remaining)) {
+          matchResult = 2;
+        } else if (!isEmpty(tail(remaining))) {
+          if (head(remaining).trim() === "-" && trimStart(head(tail(remaining))).indexOf(":") >= 0) {
+            matchResult = 0;
+            a_1 = head(remaining);
+            b_1 = head(tail(remaining));
+            rest_1 = tail(tail(remaining));
+          } else {
+            matchResult = 1;
+            l = head(remaining);
+            rest_2 = tail(remaining);
+          }
+        } else {
+          matchResult = 1;
+          l = head(remaining);
+          rest_2 = tail(remaining);
+        }
+        switch (matchResult) {
+          case 0: {
+            acc_mut = cons(a_1 + " " + b_1.trim(), acc);
+            remaining_mut = rest_1;
+            continue merge;
+          }
+          case 1: {
+            acc_mut = cons(l, acc);
+            remaining_mut = rest_2;
+            continue merge;
+          }
+          default:
+            return reverse(acc);
+        }
+        break;
+      }
+  };
+  return join("\r\n", merge(empty(), ofArray(split(join("\r\n\r\n", toList(delay(() => append$1(length(basePairs) > 0 ? singleton$1(section(basePairs)) : empty$1(), delay(() => append$1(map$1(section, knownSections), delay(() => length(metadataPairs) > 0 ? singleton$1(section(metadataPairs)) : empty$1()))))))), ["\r\n"], void 0, 0))));
+}
+function encodeToolDescription(td) {
+  return renderTopLevelElement(ofArray(["cwlVersion", "class", "label", "doc", "intent"]), ofArray(["hints", "requirements", "baseCommand", "inputs", "outputs"]), encodeToolDescriptionElement(td));
+}
+function encodeWorkflowDescription(wd) {
+  return renderTopLevelElement(ofArray(["cwlVersion", "class", "label", "doc", "intent"]), ofArray(["hints", "requirements", "inputs", "steps", "outputs"]), encodeWorkflowDescriptionElement(wd));
+}
+function encodeExpressionToolDescription(et) {
+  return renderTopLevelElement(ofArray(["cwlVersion", "class", "label", "doc", "intent"]), ofArray(["hints", "requirements", "inputs", "outputs", "expression"]), encodeExpressionToolDescriptionElement(et));
+}
+function encodeOperationDescription(op) {
+  return renderTopLevelElement(ofArray(["cwlVersion", "class", "label", "doc", "intent"]), ofArray(["hints", "requirements", "inputs", "outputs"]), encodeOperationDescriptionElement(op));
+}
+function encodeProcessingUnit(pu) {
+  switch (pu.tag) {
+    case /* Workflow */
+    1:
+      return encodeWorkflowDescription(pu.fields[0]);
+    case /* ExpressionTool */
+    2:
+      return encodeExpressionToolDescription(pu.fields[0]);
+    case /* Operation */
+    3:
+      return encodeOperationDescription(pu.fields[0]);
+    default:
+      return encodeToolDescription(pu.fields[0]);
+  }
+}
+function encodeCWLTypeYaml(t) {
+  switch (t.tag) {
+    case /* Union */
+    14:
+      return "[" + join(", ", map$2(encodeCWLTypeYaml, t.fields[0])) + "]";
+    case /* Array */
+    11:
+      return encodeInputArraySchemaYaml(t.fields[0]);
+    case /* Record */
+    12:
+      return encodeInputRecordSchemaYaml(t.fields[0]);
+    case /* Enum */
+    13:
+      return encodeInputEnumSchemaYaml(t.fields[0]);
+    case /* Null */
+    10:
+      return '"null"';
+    default: {
+      const yamlForm = writeYaml(encodeCWLType(t));
+      return yamlForm.trim();
+    }
+  }
+}
+function encodeInputRecordFieldYaml(field) {
+  return `{name: ${field.Name}, type: ${encodeCWLTypeYaml(field.Type)}}`;
+}
+function encodeInputRecordSchemaYaml(schema) {
+  let fs;
+  let fieldsYaml;
+  const matchValue = schema.Fields;
+  let matchResult, fs_1;
+  if (matchValue != null) {
+    if (fs = value(matchValue), fs.length > 0) {
+      matchResult = 0;
+      fs_1 = value(matchValue);
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0: {
+      fieldsYaml = join(", ", map$2(encodeInputRecordFieldYaml, fs_1));
+      break;
+    }
+    default:
+      fieldsYaml = "";
+  }
+  if (fieldsYaml === "") {
+    return "{type: record, fields: []}";
+  } else {
+    return `{type: record, fields: [${fieldsYaml}]}`;
+  }
+}
+function encodeInputEnumSchemaYaml(schema) {
+  return `{type: enum, symbols: [${join(", ", schema.Symbols)}]}`;
+}
+function encodeInputArraySchemaYaml(schema) {
+  return `{type: array, items: ${encodeCWLTypeYaml(schema.Items)}}`;
+}
+function cwlTypeToYamlString(t) {
+  return encodeCWLTypeYaml(t);
+}
+
+export { $007CPrimitiveType$007CComplexType$007C, cwlTypeToYamlString, encodeCWLInput, encodeCWLOutput, encodeCWLType, encodeCWLTypeYaml, encodeDoc, encodeEnvVarRequirementCompactMap, encodeExpressionToolDescription, encodeExpressionToolDescriptionElement, encodeHintEntry, encodeInputArraySchema, encodeInputArraySchemaYaml, encodeInputBinding, encodeInputEnumSchema, encodeInputEnumSchemaYaml, encodeInputRecordField, encodeInputRecordFieldYaml, encodeInputRecordSchema, encodeInputRecordSchemaYaml, encodeIntent, encodeLabel, encodeLinkMergeMethod, encodeOperationDescription, encodeOperationDescriptionElement, encodeOutputBinding, encodePickValueMethod, encodeProcessingUnit, encodeRequirement, encodeScatter, encodeScatterMethod, encodeSchemaDefRequirementType, encodeSchemaSaladString, encodeSoftwareRequirementCompactMap, encodeSourceArray, encodeStepInput, encodeStepInputs, encodeStepOutputParameter, encodeStepOutputs, encodeStringArrayOrScalar, encodeToolDescription, encodeToolDescriptionElement, encodeWorkflowDescription, encodeWorkflowDescriptionElement, encodeWorkflowStep, encodeWorkflowStepRun, getObjectPairs, isComplexType, normalizeDocString, normalizeEnvValueForEncode, renderTopLevelElement, tryGetArrayShorthand, writeYaml, yBool, yMap };