@nfdi4plants/arctrl 3.2.3 → 3.3.1

package/dist/ts/ts/CWL/Decode.d.ts

@@ -1,19 +1,20 @@
-import { IMap, Exception, IComparable, IEquatable } from '@fable-org/fable-library-ts/Util.ts';
-import { Record } from '@fable-org/fable-library-ts/Types.ts';
+import { IComparable, IEquatable } from '@fable-org/fable-library-ts/Util.ts';
+import { Union, Record } from '@fable-org/fable-library-ts/Types.ts';
 import { Option } from '@fable-org/fable-library-ts/Option.ts';
 import { TypeInfo } from '@fable-org/fable-library-ts/Reflection.ts';
-import { YAMLElement_$union } from '../fable_modules/YAMLicious.1.0.0/YAMLiciousTypes.fs.js';
-import { int32 } from '@fable-org/fable-library-ts/Int32.ts';
+import { MappingEntry, YamlNode } from '../fable_modules/YAMLicious.2.0.0/Model.fs.js';
+import { Decode_IGetters } from '../fable_modules/YAMLicious.2.0.0/Decode.fs.js';
 import { FSharpList } from '@fable-org/fable-library-ts/List.ts';
-import { IGetters } from '../fable_modules/YAMLicious.1.0.0/Decode.fs.js';
+import { float64, int32 } from '@fable-org/fable-library-ts/Int32.ts';
+import { FSharpChoice$6_$union } from '@fable-org/fable-library-ts/Choice.ts';
 import { int64 } from '@fable-org/fable-library-ts/BigInt.ts';
 import { DynamicObj } from '../fable_modules/DynamicObj.8.0.0/DynamicObj.fs.js';
-import { HintEntry_$union, InlineJavascriptRequirementValue, ToolTimeLimitValue_$union, InplaceUpdateRequirementValue, Requirement_$union, ResourceRequirementInstance, LoadListingRequirementValue, EnvironmentDef, DockerRequirement, InitialWorkDirEntry_$union, LoadListingEnum_$union } from './Requirements.ts';
-import { SchemaDefRequirementType, SoftwarePackage, InputEnumSchema, InputRecordSchema, InputRecordField, InputArraySchema, CWLType_$union, SchemaSaladString_$union, DirectoryInstance, FileInstance } from './CWLTypes.ts';
-import { CWLOutput, OutputBinding } from './Outputs.ts';
-import { CWLInput, InputBinding } from './Inputs.ts';
-import { WorkflowStep, WorkflowStepRun_$union, StepOutput_$union, StepInput, ScatterMethod_$union, PickValueMethod_$union, LinkMergeMethod_$union } from './WorkflowSteps.ts';
+import { SchemaDefinition_$union, SoftwarePackage, InputEnumSchema, InputRecordSchema, InputRecordField, InputArraySchema, CWLType_$union, DirentInstance, SourceNodes, DocText_$union, ListEntry$1_$union, DirectoryInstance, FileInstance, FileSize_$union, SchemaSaladBool_$union, SchemaSaladString_$union, RawYaml } from './CWLTypes.ts';
+import { HintEntry_$union, InlineJavascriptRequirementValue, ToolTimeLimitValue_$union, InplaceUpdateRequirementValue, SchemaDefEntry_$union, ResourceRequirementInstance, LoadListingRequirementValue, Requirement_$union, EnvironmentDef, DockerRequirement, InitialWorkDirEntry_$union, LoadListingEnum_$union } from './Requirements.ts';
+import { CWLOutput, OutputSource_$union, OutputBinding, OutputGlob_$union } from './Outputs.ts';
 import { CWLProcessingUnit_$union } from './CWLProcessingUnit.ts';
+import { CWLInput, InputFormat_$union, InputBinding, BindingPosition_$union } from './Inputs.ts';
+import { WorkflowStep, WorkflowStepRun_$union, StepOutput_$union, StepInput, ScatterMethod_$union, PickValueMethod_$union, LinkMergeMethod_$union } from './WorkflowSteps.ts';
 import { CWLWorkflowDescription } from './WorkflowDescription.ts';
 import { CWLExpressionToolDescription } from './ExpressionToolDescription.ts';
 import { CWLOperationDescription } from './OperationDescription.ts';
@@ -37,378 +38,638 @@ export declare function Decode_DecodeResult$1_$reflection(gen0: TypeInfo): TypeI
 /**
  * Add a recoverable decode warning only when the caller requested warning collection.
  */
-export declare function Decode_addWarning(warnings: Option<Decode_DecodeWarning[]>, path: string, message: string, raw: Option<YAMLElement_$union>): void;
+export declare function Decode_addWarning(warnings: Option<Decode_DecodeWarning[]>, path: string, message: string, raw: Option<YamlNode>): void;
+export declare function Decode_failAlias<T>(name: string, node: YamlNode): T;
 /**
- * Strip parser-level comment nodes and sequence placeholders before CWL semantic decoding.
+ * The type that the YAML 1.2 core schema gives a scalar node. This is the rule behind the quoting of
+ * Encode.string, so a decoder has to read the plain spellings the same way. Quoted and block scalars
+ * are text, and an explicit tag fixes the type. A node that is no scalar counts as text. The core schema sets no
+ * size limit for an int, so an int beyond 64 bits is a case of its own that holds the text of the scalar, and the
+ * field that takes it converts it (CoreSchema.integerToFloat).
  */
-export declare function Decode_removeYamlComments(yamlElement: YAMLElement_$union): YAMLElement_$union;
+export declare function Decode_$007CCoreNull$007CCoreBool$007CCoreInt$007CCoreBigInt$007CCoreFloat$007CCoreText$007C(node: YamlNode): FSharpChoice$6_$union<void, boolean, int64, string, float64, void>;
 /**
- * Determines if an exception represents a recoverable decoding error.
- * Returns true for schema mismatches; false for system errors that should propagate.
+ * Fail with the first anchor, alias, explicit tag, repeated scalar key and $namespaces field that holds no mapping in the
+ * tree. Schema Salad v1.2 prohibits the first three (see prohibitedMessage). Every anchor counts, also one that no alias
+ * names, and so does every explicit tag, also the non-specific tag !. Raw values keep their entries as they were written,
+ * so a repeated key would be written back twice, and YAML 1.2 asks for unique keys. Two keys repeat each other when the
+ * loader of cwltool takes them for one key (see keyIdentity). cwltool refuses a $namespaces that is
+ * no mapping in any object of a document, and in a job file too. A mapping with a $mixin and everything below it is exempt
+ * from the $namespaces check. Schema Salad merges the fields beside a $mixin into the data of the file only when that
+ * data is a mapping, so the fields drop out when the file holds a scalar or a list, and the verdict depends on the file.
+ * The other checks apply there. The walk keeps its own stack, so a raw value of any depth is safe. It checks the keys and
+ * the values of a mapping and the items of a sequence.
  */
-export declare function Decode_isRecoverableDecodingError(ex: Exception): boolean;
+export declare function Decode_rejectWhatTheSpecProhibits(root: YamlNode): void;
 /**
- * Read YAML and normalize comment nodes that CWL decoders intentionally ignore.
+ * Read the root node of a CWL document. The text must hold one document that follows the restrictions of Schema Salad: no
+ * %YAML or %TAG directive, no explicit tag, no anchor, no alias and no repeated key (see rejectWhatTheSpecProhibits). A
+ * merge key is no YAML 1.2 feature, so << is an ordinary key. Every text entry point reads through this function, also the
+ * one of the job files and of the additional type of an RO-Crate. A decoder that takes a tree has its own entry point, which
+ * applies rejectWhatTheSpecProhibits to the tree. An alias without an anchor fails in the reader before a tree exists, so
+ * its error stands at the root of the document.
  */
-export declare function Decode_readSanitizedYaml(yaml: string): YAMLElement_$union;
+export declare function Decode_readYaml(yaml: string): YamlNode;
 /**
  * Box int64 values in a way that preserves 64-bit numeric intent across Fable targets.
  */
 export declare function Decode_boxOverflowInt64(value: int64): any;
+/**
+ * The entries of a mapping in source order, with keys of any type. Decode.object takes strings as keys only. A caller
+ * reads a key with idMapKey, which names the type of a key that is no string in the CWL message, or with entryName,
+ * which takes the text of any scalar. Decode.entries returns every entry as written, and a public decoder may get a
+ * tree that did not pass rejectWhatTheSpecProhibits, so the function checks the keys of this mapping with the same
+ * rule and fails with the same error. A caller that loops over the entries inside an array comprehension binds the
+ * result first. When the source of a comprehension fails, Python raises a TypeError of its runtime that hides
+ * the decode error.
+ */
+export declare function Decode_mappingEntries(node: YamlNode): FSharpList<MappingEntry>;
+/**
+ * The text of the key of an entry as it is written, also for a key that the core schema reads as a number, a bool or
+ * null.
+ */
+export declare function Decode_entryName(entry: MappingEntry): string;
+/**
+ * Run a decoder for the value of a map entry and put the name of the entry in the path of its error.
+ */
+export declare function Decode_atField<T>(name: string, decode: (() => T)): T;
+/**
+ * The text of a CWL string field. CWL types these fields as strings, so a plain scalar that the core schema reads
+ * as null, a bool, an int or a float is a decode error at the field, as cwltool reports it. Every other scalar is
+ * a string, for example a quoted one or one tagged !!str. A collection and an alias are errors too. Decode.string
+ * accepts the same nodes and fails at the same place, and this decoder gives the CWL message with the advice to
+ * quote the value.
+ */
+export declare function Decode_stringDecoder(node: YamlNode): string;
+/**
+ * The text of a type. CWL types a type name as a string, so a plain null (null, Null, NULL or ~), like a plain bool or
+ * number, is a decode error at the node, and the null type is the quoted text "null". A missing value fails with the
+ * message for a missing value.
+ */
+export declare function Decode_typeText(node: YamlNode): string;
+/**
+ * The id that the key of an entry gives its value in an id map, such as inputs, outputs, steps and requirements in map
+ * form. CWL types the id as a string, so a plain key that the core schema reads as null, a bool, an int or a float
+ * is a decode error at the key.
+ */
+export declare function Decode_idMapKey(entry: MappingEntry): string;
 /**
  * Decode key value pairs into a dynamic object, while preserving their tree structure.
  */
-export declare function Decode_overflowDecoder(dynObj: DynamicObj, dict: IMap<string, YAMLElement_$union>): DynamicObj;
+export declare function Decode_overflowDecoder(dynObj: DynamicObj, entries: FSharpList<MappingEntry>): DynamicObj;
+/**
+ * Decode an optional field of a node that may be a scalar shorthand. A node that is no mapping has no
+ * fields, and a field with a null value counts as missing.
+ */
+export declare function Decode_tryGetPresentField<T>(fieldName: string, decoder: ((arg0: YamlNode) => T), node: YamlNode): Option<T>;
+export declare function Decode_tryGetStringField(fieldName: string, value: YamlNode): Option<string>;
+export declare function Decode_tryGetYamlField(fieldName: string, value: YamlNode): Option<RawYaml>;
+/**
+ * Preserve unknown object fields on DynamicObj-backed CWL objects.
+ */
+export declare function Decode_overflowIntoDynamicObj(dynObj: DynamicObj, knownFields: FSharpList<string>, value: YamlNode): DynamicObj;
+/**
+ * Read a directive at a place that takes a string. The directive stays a case of SchemaSaladString, so the encoder
+ * writes the mapping again. A $mixin beside other fields stays as it was written, because the file decides whether
+ * the fields count. A mapping with a directive key that is no directive is an error, and a node without a
+ * directive key is none.
+ */
+export declare function Decode_tryDirective(node: YamlNode): Option<SchemaSaladString_$union>;
 /**
- * Treat comment artifacts and empty placeholder objects as non-semantic collection items.
+ * Read a directive at a place that takes the whole of a list. Only $import can stand there, because an $include
+ * yields the text of a file and a $mixin completes an object with the fields beside it. The result is the path of
+ * the imported file, and none for a node without a directive key. The text names what the place takes, as in the
+ * types field.
  */
-export declare function Decode_isIgnorableYamlNoise(value: YAMLElement_$union): boolean;
+export declare function Decode_importOnly(what: string, node: YamlNode): Option<string>;
+export type Decode_ValueDirective_$union = Decode_ValueDirective<0> | Decode_ValueDirective<1>;
+export type Decode_ValueDirective_$cases = {
+    0: ["ImportedFile", [string]];
+    1: ["MixedMapping", [RawYaml]];
+};
+export declare function Decode_ValueDirective_ImportedFile(Item: string): Decode_ValueDirective<0>;
+export declare function Decode_ValueDirective_MixedMapping(Item: RawYaml): Decode_ValueDirective<1>;
 /**
- * Decode an optional field only if the field is physically present, avoiding fallback
- * behavior that can blur absent fields with malformed field values.
+ * What a mapping with a directive stands for at a place that takes an object or a scalar that is no string.
  */
-export declare function Decode_tryGetPresentField<T>(fieldName: string, decoder: ((arg0: YAMLElement_$union) => T), value: YAMLElement_$union): Option<T>;
-export declare function Decode_tryGetStringField(fieldName: string, value: YAMLElement_$union): Option<string>;
-export declare function Decode_tryGetBoolField(fieldName: string, value: YAMLElement_$union): Option<boolean>;
-export declare function Decode_tryGetYamlField(fieldName: string, value: YAMLElement_$union): Option<YAMLElement_$union>;
-export declare function Decode_tryGetIntArrayField(fieldName: string, value: YAMLElement_$union): Option<int32[]>;
+export declare class Decode_ValueDirective<Tag extends keyof Decode_ValueDirective_$cases> extends Union<Tag, Decode_ValueDirective_$cases[Tag][0]> {
+    constructor(tag: Tag, fields: Decode_ValueDirective_$cases[Tag][1]);
+    readonly tag: Tag;
+    readonly fields: Decode_ValueDirective_$cases[Tag][1];
+    cases(): string[];
+}
+export declare function Decode_ValueDirective_$reflection(): TypeInfo;
+/**
+ * Read a directive at a place that takes an object, as in an entry of the types field.
+ */
+export declare function Decode_objectDirective(what: string, node: YamlNode): Option<Decode_ValueDirective_$union>;
 /**
- * Decode int64 fields explicitly so resource and File sizes do not narrow to int.
+ * Decode a boolean field. A directive stands for the boolean of a file. The text names what the place is, as in the
+ * loadContents field.
  */
-export declare function Decode_tryGetInt64Field(fieldName: string, value: YAMLElement_$union): Option<int64>;
+export declare function Decode_schemaSaladBoolDecoder(what: string, node: YamlNode): SchemaSaladBool_$union;
+/**
+ * Decode the boolean field of a node that may be a scalar shorthand. A node that is no mapping has no fields, and a
+ * field with a null value counts as missing.
+ */
+export declare function Decode_tryGetBoolField(fieldName: string, value: YamlNode): Option<SchemaSaladBool_$union>;
+/**
+ * Decode the size of a File through the core schema, so that the size does not narrow to int and a quoted size
+ * fails like the other typed fields. A directive stands for the size of a file.
+ */
+export declare function Decode_fileSizeDecoder(node: YamlNode): FileSize_$union;
+export declare const Decode_loadListingDecoder: (node_1: YamlNode) => LoadListingEnum_$union;
 /**
  * Decode and validate CWL loadListing enum fields from their YAML string form.
  */
-export declare function Decode_tryGetLoadListingField(fieldName: string, value: YAMLElement_$union): Option<LoadListingEnum_$union>;
+export declare function Decode_tryGetLoadListingField(fieldName: string, value: YamlNode): Option<LoadListingEnum_$union>;
 /**
- * Preserve unknown object fields on DynamicObj-backed CWL objects.
+ * Decode a string field that may hold a Schema Salad directive. A scalar is the literal text. A mapping with a
+ * directive as its only field names the file whose text or data takes the place of the mapping.
  */
-export declare function Decode_overflowIntoDynamicObj(dynObj: DynamicObj, knownFields: FSharpList<string>, value: YAMLElement_$union): DynamicObj;
+export declare function Decode_decodeSchemaSaladString(node: YamlNode): SchemaSaladString_$union;
 /**
  * Decode File object fields while preserving unrecognized extension metadata.
  */
-export declare function Decode_decodeFileInstanceFields(element: YAMLElement_$union): FileInstance;
+export declare function Decode_decodeFileInstanceFields(element: YamlNode): FileInstance;
 /**
  * Decode Directory object fields while preserving unrecognized extension metadata.
  */
-export declare function Decode_decodeDirectoryInstanceFields(element: YAMLElement_$union): DirectoryInstance;
+export declare function Decode_decodeDirectoryInstanceFields(element: YamlNode): DirectoryInstance;
+/**
+ * Decode a list of schema-salad strings.
+ */
+export declare function Decode_decodeSchemaSaladStringArray(value: YamlNode): SchemaSaladString_$union[];
+/**
+ * Decode a field that holds a list of strings and nothing else. A directive on its own stands for the whole list when
+ * it is an $import or a $mixin, and it is the one entry of the result.
+ */
+export declare function Decode_decodeSchemaSaladStringList(what: string, node: YamlNode): SchemaSaladString_$union[];
+/**
+ * Decode a field that holds a list of numbers. A directive on its own stands for the whole list when it is an $import
+ * or a $mixin, and it is the one entry of the result.
+ */
+export declare function Decode_intListDecoder(what: string, node: YamlNode): ListEntry$1_$union<int32>[];
+export declare function Decode_tryGetIntListField(fieldName: string, value: YamlNode): Option<ListEntry$1_$union<int32>[]>;
+/**
+ * Decode a field that holds a string or a list of strings, such as the scatter. A string is one entry. A directive on
+ * its own stands for the string or the list of strings of a file, so it is one entry whichever directive it is.
+ */
+export declare function Decode_stringsOrOneDecoder(node: YamlNode): SchemaSaladString_$union[];
+/**
+ * Decode the doc and the label of a mapping, each with the node that it was read from. The values go to the Doc and
+ * Label properties of an object, and the nodes go to its SourceNodes, so that the encoder can write the layout of
+ * the author again. A field with a null value counts as missing, as it does for the other fields. A doc and a label
+ * are strings in CWL, so a plain scalar that the core schema reads as a number or a bool is a decode error at the
+ * field. Every other scalar is a string, for example a quoted one or one tagged !!str, and a directive names a file
+ * with the text. A doc may also be a list of strings, which Schema Salad concatenates without a separator. A list of
+ * plain strings is one text, and a list with a directive keeps its parts, because the model does not hold the text
+ * of the file. The node of a doc may be the sequence.
+ */
+export declare function Decode_docAndLabelDecoder(value: YamlNode): [Option<DocText_$union>, Option<SchemaSaladString_$union>, SourceNodes];
+/**
+ * Decode the glob of an output binding: one pattern or a list of patterns, kept as it was written.
+ */
+export declare function Decode_outputGlobDecoder(node: YamlNode): OutputGlob_$union;
+/**
+ * Decode a YamlNode into the fields of an output binding. The argument decodes the outputEval.
+ */
+export declare function Decode_outputBindingGlobDecoder(outputEvalDecoder: ((arg0: YamlNode) => SchemaSaladString_$union), value: YamlNode): OutputBinding;
+/**
+ * Decode a YamlNode into an OutputBinding, or the directive that stands for it. A port in scalar shorthand has none.
+ */
+export declare function Decode_outputBindingDecoder(outputEvalDecoder: ((arg0: YamlNode) => SchemaSaladString_$union)): ((arg0: YamlNode) => Option<ListEntry$1_$union<OutputBinding>>);
 /**
- * Decode scalar schema-salad string fields.
- * Recognized directive wrappers are `$include` and `$import`.
- * Unknown single-key mappings are intentionally coerced to a legacy literal `key: value` string.
+ * Decode a list of strings. A single string stands for a list of one.
  */
-export declare function Decode_decodeSchemaSaladString(yEle: YAMLElement_$union): SchemaSaladString_$union;
+export declare function Decode_decodeStringArrayOrScalar(value: YamlNode): string[];
 /**
- * Decode a YAMLElement which is either a string or expression into a string.
- * Directive objects such as {$include: path} are represented using legacy string form.
+ * Decode a source or an outputSource. A string is a single source and a list is a list of sources, also a list of
+ * one, because cwltool keeps the two apart when a linkMerge applies. A directive on its own is a single source.
  */
-export declare function Decode_decodeStringOrExpression(yEle: YAMLElement_$union): string;
+export declare function Decode_sourceDecoder(node: YamlNode): OutputSource_$union;
+export declare const Decode_outputSourceDecoder: (node: YamlNode) => Option<OutputSource_$union>;
 /**
- * Decode a YAMLElement into a glob search pattern for output binding
+ * Decode a YamlNode into a Dirent
  */
-export declare function Decode_outputBindingGlobDecoder(value: YAMLElement_$union): OutputBinding;
-export declare const Decode_outputBindingDecoder: (value_1: YAMLElement_$union) => Option<OutputBinding>;
+export declare function Decode_direntDecoder(value: YamlNode): DirentInstance;
 /**
- * Decode schema-salad string-or-array fields into a uniform ResizeArray.
+ * Decode a listing entry of InitialWorkDirRequirement. CWL admits null, a Dirent, an expression, a File, a
+ * Directory and an array of Files and Directories. A text is an expression, so it holds $( or ${.
  */
-export declare function Decode_decodeStringArrayOrScalar(value: YAMLElement_$union): string[];
-export declare const Decode_outputSourceDecoder: (value_1: YAMLElement_$union) => Option<string[]>;
+export declare function Decode_initialWorkDirEntryDecoder(value: YamlNode): InitialWorkDirEntry_$union;
+export type Decode_StreamTypes_$union = Decode_StreamTypes<0> | Decode_StreamTypes<1> | Decode_StreamTypes<2> | Decode_StreamTypes<3>;
+export type Decode_StreamTypes_$cases = {
+    0: ["NoStreams", []];
+    1: ["OutputStreams", []];
+    2: ["InputStreams", []];
+    3: ["AnyStreams", []];
+};
+export declare function Decode_StreamTypes_NoStreams(): any;
+export declare function Decode_StreamTypes_OutputStreams(): any;
+export declare function Decode_StreamTypes_InputStreams(): any;
+export declare function Decode_StreamTypes_AnyStreams(): any;
 /**
- * Decode a YAMLElement into a Dirent
+ * Where a type may be one of the stream types stdout, stderr and stdin.
  */
-export declare function Decode_direntDecoder(value: YAMLElement_$union): CWLType_$union;
+export declare class Decode_StreamTypes<Tag extends keyof Decode_StreamTypes_$cases> extends Union<Tag, Decode_StreamTypes_$cases[Tag][0]> {
+    constructor(tag: Tag, fields: Decode_StreamTypes_$cases[Tag][1]);
+    readonly tag: Tag;
+    readonly fields: Decode_StreamTypes_$cases[Tag][1];
+    cases(): string[];
+    static readonly NoStreams: any;
+    static readonly OutputStreams: any;
+    static readonly InputStreams: any;
+    static readonly AnyStreams: any;
+}
+export declare function Decode_StreamTypes_$reflection(): TypeInfo;
+export type Decode_ProcessClass_$union = Decode_ProcessClass<0> | Decode_ProcessClass<1> | Decode_ProcessClass<2> | Decode_ProcessClass<3>;
+export type Decode_ProcessClass_$cases = {
+    0: ["CommandLineToolClass", []];
+    1: ["WorkflowClass", []];
+    2: ["ExpressionToolClass", []];
+    3: ["OperationClass", []];
+};
+export declare function Decode_ProcessClass_CommandLineToolClass(): any;
+export declare function Decode_ProcessClass_WorkflowClass(): any;
+export declare function Decode_ProcessClass_ExpressionToolClass(): any;
+export declare function Decode_ProcessClass_OperationClass(): any;
+/**
+ * The class of a process. CWL gives the ports of each class their own fields.
+ */
+export declare class Decode_ProcessClass<Tag extends keyof Decode_ProcessClass_$cases> extends Union<Tag, Decode_ProcessClass_$cases[Tag][0]> {
+    constructor(tag: Tag, fields: Decode_ProcessClass_$cases[Tag][1]);
+    readonly tag: Tag;
+    readonly fields: Decode_ProcessClass_$cases[Tag][1];
+    cases(): string[];
+    static readonly CommandLineToolClass: any;
+    static readonly WorkflowClass: any;
+    static readonly ExpressionToolClass: any;
+    static readonly OperationClass: any;
+}
+export declare function Decode_ProcessClass_$reflection(): TypeInfo;
 /**
- * Decode a listing entry of InitialWorkDirRequirement.
- * Supports both Dirent object form and string/expression form.
+ * What the decoders of types, ports and steps know about the place that they read.
  */
-export declare function Decode_initialWorkDirEntryDecoder(value: YAMLElement_$union): InitialWorkDirEntry_$union;
+export declare class Decode_DecodeScope extends Record implements IEquatable<Decode_DecodeScope>, IComparable<Decode_DecodeScope> {
+    readonly Shorthand: boolean;
+    readonly Process: Option<Decode_ProcessClass_$union>;
+    readonly StreamTypes: Decode_StreamTypes_$union;
+    readonly DocId: string;
+    readonly DefaultCwlVersion: Option<string>;
+    constructor(Shorthand: boolean, Process: Option<Decode_ProcessClass_$union>, StreamTypes: Decode_StreamTypes_$union, DocId: string, DefaultCwlVersion: Option<string>);
+}
+export declare function Decode_DecodeScope_$reflection(): TypeInfo;
+export declare const Decode_rootScope: Decode_DecodeScope;
 /**
- * Decode the contained type of a CWL Array
+ * The scope of a document, with the id of its root process.
  */
-export declare function Decode_cwlSimpleTypeFromString(s: string): CWLType_$union;
+export declare function Decode_documentScope(root: YamlNode): Decode_DecodeScope;
 /**
- * Recursively parse array shorthand notation (File[][], string[][][], etc.)
+ * The type that a type name spells. The node is the scalar that holds the name. A well-formed name that is no
+ * builtin type is a Reference as written. The decoder reads no other file, so it leaves the name to the
+ * SchemaDefRequirements and imports that define it. A name that is not well-formed is a decode error at its place.
+ * The stream types are no name here. A port admits them as its whole type, which
+ * the readers of a port type check before they read a name.
  */
-export declare function Decode_parseArrayShorthand(typeStr: string): Option<CWLType_$union>;
+export declare function Decode_cwlSimpleTypeFromString(scope: Decode_DecodeScope, node: YamlNode, name: string): CWLType_$union;
 /**
- * Decode an InputArraySchema from a YAMLElement
+ * Read a type name with the shorthand of a CWL document. T[] is an array of T and T? is null or T, so T[]? is an
+ * optional array. A document reads one [] only, because CWL reads a nested array as a schema. The scope tells
+ * whether the place of the node reads the shorthand, which a type under items does not.
  */
-export declare function Decode_inputArraySchemaDecoder(value: YAMLElement_$union): InputArraySchema;
+export declare function Decode_cwlTypeFromShorthand(scope: Decode_DecodeScope, node: YamlNode): CWLType_$union;
 /**
- * Decode an InputRecordField from a YAMLElement
+ * Decode an InputArraySchema from a YamlNode
  */
-export declare function Decode_inputRecordFieldDecoder(value: YAMLElement_$union): InputRecordField;
+export declare function Decode_inputArraySchemaDecoder(scope: Decode_DecodeScope, value: YamlNode): InputArraySchema;
 /**
- * Attempt to decode fields as flow-style array: [{name: x, type: y}]
+ * Decode a record field object under its name. The type field is the type of the field. The doc and the label
+ * are typed, and every other property of the field, such as inputBinding or secondaryFiles, stays on the field.
  */
-export declare function Decode_tryDecodeFieldsAsArray(element: YAMLElement_$union): Option<InputRecordField[]>;
+export declare function Decode_inputRecordFieldObject(scope: Decode_DecodeScope, name: string, value: YamlNode): InputRecordField;
 /**
- * Attempt to decode fields as map-style: {fieldName: type}
+ * Decode an InputRecordField from a YamlNode
  */
-export declare function Decode_tryDecodeFieldsAsMap(element: YAMLElement_$union): Option<InputRecordField[]>;
+export declare function Decode_inputRecordFieldDecoder(scope: Decode_DecodeScope, value: YamlNode): InputRecordField;
 /**
- * Decode an InputRecordSchema from a YAMLElement
+ * Decode fields as an array: [{name: x, type: y}]. An $import stands for the fields of a file.
  */
-export declare function Decode_inputRecordSchemaDecoder(value: YAMLElement_$union): InputRecordSchema;
+export declare function Decode_decodeFieldsAsArray(scope: Decode_DecodeScope, element: YamlNode): ListEntry$1_$union<InputRecordField>[];
 /**
- * Decode an InputEnumSchema from a YAMLElement
+ * Decode fields as a map: {fieldName: type} or {fieldName: {type: ..., inputBinding: ...}}
  */
-export declare function Decode_inputEnumSchemaDecoder(value: YAMLElement_$union): InputEnumSchema;
+export declare function Decode_decodeFieldsAsMap(scope: Decode_DecodeScope, element: YamlNode): ListEntry$1_$union<InputRecordField>[];
 /**
- * Decode a CWLType from a YAMLElement (handles all types including complex schemas)
+ * Decode an InputRecordSchema from a YamlNode
  */
-export declare function Decode_cwlTypeDecoder$0027(element: YAMLElement_$union): CWLType_$union;
+export declare function Decode_inputRecordSchemaDecoder(scope: Decode_DecodeScope, value: YamlNode): InputRecordSchema;
 /**
- * Match the input string to the possible CWL types and checks if it is optional
+ * Decode an InputEnumSchema from a YamlNode
  */
-export declare function Decode_cwlTypeStringMatcher(t: string, get$: IGetters): [CWLType_$union, boolean];
-export declare const Decode_cwlTypeDecoder: (value_1: YAMLElement_$union) => [CWLType_$union, boolean];
+export declare function Decode_inputEnumSchemaDecoder(value: YamlNode): InputEnumSchema;
+/**
+ * Decode a CWLType from a YamlNode (handles all types including complex schemas). A document reads the shorthand
+ * File[] and File? as the whole value of a type field and as a member of a type list.
+ */
+export declare function Decode_cwlTypeDecoder$0027(element: YamlNode): CWLType_$union;
+/**
+ * Decode the type under items. It is a name or a schema, and a list of those, with no shorthand.
+ */
+export declare function Decode_itemsTypeDecoder(scope: Decode_DecodeScope, element: YamlNode): CWLType_$union;
+/**
+ * Decode a CWLType from a YamlNode. The scope tells whether the place reads the shorthand of a type name.
+ */
+export declare function Decode_cwlTypeDecoderAt(scope: Decode_DecodeScope, element: YamlNode): CWLType_$union;
+export declare const Decode_typeTextScope: Decode_DecodeScope;
+/**
+ * Decode the type text of a scalar, whether it stands alone or in the type field of a mapping.
+ */
+export declare function Decode_cwlTypeStringDecoder(scope: Decode_DecodeScope, node: YamlNode): CWLType_$union;
+/**
+ * Decode the text of the additional type of an RO-Crate entity. The text is YAML. A scalar is a type name such as
+ * File[][]? and may be quoted, as the null type is written ("null"), or carry a comment. The shorthand nests
+ * arrays there, which a CWL document does not read. Anything else is a schema or a list of types. The text reads
+ * like any type text (typeTextScope). A stream type is the whole text, and a name that is no builtin type is a
+ * Reference when it is well-formed. The text is no CWL document, so the plain text null names the null type there,
+ * where a document needs it in quotes.
+ */
+export declare function Decode_cwlTypeFromAdditionalType(text: string): CWLType_$union;
+/**
+ * Access the type field and decode a YamlNode into a CWLType
+ */
+export declare function Decode_cwlTypeDecoder(scope: Decode_DecodeScope): ((arg0: YamlNode) => CWLType_$union);
+/**
+ * Decode the type of a port. CWL lets a map entry hold just the type, written as a type string
+ * (File?) or as a list of types (a union such as ["null", File]). Any other value is the port object.
+ */
+export declare function Decode_portTypeDecoder(scope: Decode_DecodeScope, value: YamlNode): CWLType_$union;
 /**
  * Decode a named output from either map shorthand or full object form.
  */
-export declare function Decode_decodeNamedOutput(name: string, value: YAMLElement_$union): CWLOutput;
+export declare function Decode_decodeNamedOutput(scope: Decode_DecodeScope, name: string, value: YamlNode): CWLOutput;
 /**
- * Decode one sequence-form output, warning only for malformed unnamed entries.
+ * Decode one sequence-form output, which is a mapping with an id.
  */
-export declare function Decode_decodeOutputSequenceItem(warnings: Option<Decode_DecodeWarning[]>, path: string, index: int32, item: YAMLElement_$union): Option<CWLOutput>;
+export declare function Decode_decodeOutputSequenceItem(scope: Decode_DecodeScope, index: int32, item: YamlNode): CWLOutput;
 /**
- * Decode a YAMLElement into an Output Array
+ * Decode a YamlNode into an Output Array. An $import stands for the outputs of a file, in the list or as the whole
+ * field.
  */
-export declare function Decode_outputArrayDecoderWithWarnings(warnings: Option<Decode_DecodeWarning[]>, path: string, value: YAMLElement_$union): CWLOutput[];
-export declare const Decode_outputArrayDecoder: (value: YAMLElement_$union) => CWLOutput[];
+export declare function Decode_outputArrayDecoderWithWarnings(warnings: Option<Decode_DecodeWarning[]>, scope: Decode_DecodeScope, path: string, value: YamlNode): ListEntry$1_$union<CWLOutput>[];
+export declare const Decode_outputArrayDecoder: (value: YamlNode) => ListEntry$1_$union<CWLOutput>[];
 /**
- * Access the outputs field and decode a YAMLElement into an Output Array
+ * Access the outputs field and decode a YamlNode into an Output Array
  */
-export declare function Decode_outputsDecoderWithWarnings(warnings: Option<Decode_DecodeWarning[]>): ((arg0: YAMLElement_$union) => CWLOutput[]);
-export declare const Decode_outputsDecoder: ((arg0: YAMLElement_$union) => CWLOutput[]);
+export declare function Decode_outputsDecoderWithWarnings(warnings: Option<Decode_DecodeWarning[]>, scope: Decode_DecodeScope): ((arg0: YamlNode) => ListEntry$1_$union<CWLOutput>[]);
+export declare const Decode_outputsDecoder: ((arg0: YamlNode) => ListEntry$1_$union<CWLOutput>[]);
 /**
- * Decode a YAMLElement into a DockerRequirement
+ * Decode a YamlNode into a DockerRequirement
  */
-export declare function Decode_dockerRequirementDecoder(get$: IGetters): DockerRequirement;
+export declare function Decode_dockerRequirementDecoder(get$: Decode_IGetters): DockerRequirement;
 /**
- * Decode a YAMLElement into an EnvVarRequirement array.
- * Supports both array form and map shorthand form (envName -> envValue).
+ * Decode a YamlNode into an EnvVarRequirement array.
+ * Supports both array form and map shorthand form (envName -> envValue). An $import stands for the definitions of
+ * a file, in the list and as the whole field.
  */
-export declare function Decode_envVarRequirementDecoder(get$: IGetters): EnvironmentDef[];
+export declare function Decode_envVarRequirementDecoder(get$: Decode_IGetters): ListEntry$1_$union<EnvironmentDef>[];
 /**
- * Decode a YAMLElement into a SoftwareRequirement array.
+ * Decode a YamlNode into a SoftwareRequirement array.
  * Supports both array form and map shorthand form.
  */
-export declare function Decode_softwareRequirementDecoder(get$: IGetters): SoftwarePackage[];
+export declare function Decode_softwareRequirementDecoder(get$: Decode_IGetters): ListEntry$1_$union<SoftwarePackage>[];
 /**
- * Decode a YAMLElement into an InitialWorkDirRequirement array.
- * Supports both string/expression and Dirent listing items.
+ * Decode a YamlNode into an InitialWorkDirRequirement. The listing is a list of entries or an expression that
+ * evaluates to the list.
  */
-export declare function Decode_initialWorkDirRequirementDecoder(get$: IGetters): InitialWorkDirEntry_$union[];
+export declare function Decode_initialWorkDirRequirementDecoder(get$: Decode_IGetters): Requirement_$union;
 /**
  * Decode LoadListingRequirement, applying CWL's default no_listing behavior.
  */
-export declare function Decode_loadListingRequirementDecoder(get$: IGetters): LoadListingRequirementValue;
+export declare function Decode_loadListingRequirementDecoder(get$: Decode_IGetters): LoadListingRequirementValue;
 /**
  * Decode resource scalar fields as int64, float, or expression string without losing numeric shape.
+ * CWL types these fields as long, float or string, so the core schema decides. A plain number keeps its
+ * numeric shape and a quoted number is a string. Schema Salad accepts an int of any size for a float, and the model holds
+ * an int beyond 64 bits as the nearest float. An int beyond the largest float is a decode error.
  */
-export declare function Decode_decodeResourceScalar(element: YAMLElement_$union): any;
+export declare function Decode_decodeResourceScalar(element: YamlNode): any;
 /**
  * Decode an optional resource field through the resource scalar coercion rules.
  */
-export declare function Decode_optionalResourceField(get$: IGetters, fieldName: string): Option<any>;
+export declare function Decode_optionalResourceField(get$: Decode_IGetters, fieldName: string): Option<any>;
 /**
- * Decode a YAMLElement into a ResourceRequirementInstance
+ * Decode a YamlNode into a ResourceRequirementInstance
  */
-export declare function Decode_resourceRequirementDecoder(get$: IGetters): ResourceRequirementInstance;
+export declare function Decode_resourceRequirementDecoder(get$: Decode_IGetters): ResourceRequirementInstance;
 /**
- * Decode schema definition entries in either named object or map-entry shorthand form.
+ * Decode an entry of the types field that defines a type. CWL defines the entry as the schema itself, with type:
+ * record, enum or array. Process.yml admits no other type there, so any other type is an error at the entry, such
+ * as a builtin type name. The schema keeps its name, which is optional, and its extension fields.
  */
-export declare function Decode_schemaDefRequirementTypeDecoder(value: YAMLElement_$union): SchemaDefRequirementType;
+export declare function Decode_schemaDefinitionDecoder(scope: Decode_DecodeScope, value: YamlNode): SchemaDefinition_$union;
 /**
- * Decode a YAMLElement into a SchemaDefRequirementType array
+ * Decode an entry of the types field: a file to import, as {$import: path}, or a type to define.
  */
-export declare function Decode_schemaDefRequirementDecoder(get$: IGetters): SchemaDefRequirementType[];
+export declare function Decode_schemaDefEntryDecoder(scope: Decode_DecodeScope, value: YamlNode): SchemaDefEntry_$union;
 /**
- * Decode only literal boolean scalars, leaving expressions for requirement-specific handling.
+ * Decode a YamlNode into a SchemaDefEntry array. A types field that is an $import mapping stands for a list with
+ * one import.
  */
-export declare function Decode_tryDecodeBoolScalar(element: YAMLElement_$union): Option<boolean>;
+export declare function Decode_schemaDefRequirementDecoder(scope: Decode_DecodeScope, get$: Decode_IGetters): SchemaDefEntry_$union[];
 /**
- * Decode WorkReuse as either a concrete bool requirement or an expression payload.
+ * Decode only plain boolean scalars, as the core schema reads them, and leave every other node for the
+ * requirement to take as an expression. A quoted "false" is a string.
  */
-export declare function Decode_workReuseRequirementDecoder(get$: IGetters): Requirement_$union;
+export declare function Decode_tryDecodeBoolScalar(element: YamlNode): Option<boolean>;
 /**
- * Decode NetworkAccess as either a concrete bool requirement or an expression payload.
+ * Decode WorkReuse as either a concrete bool requirement or an expression payload. A WorkReuse without
+ * enableReuse enables the reuse.
  */
-export declare function Decode_networkAccessRequirementDecoder(get$: IGetters): Requirement_$union;
+export declare function Decode_workReuseRequirementDecoder(get$: Decode_IGetters): Requirement_$union;
 /**
- * Decode InplaceUpdateRequirement, defaulting missing inplaceUpdate to true.
+ * Decode NetworkAccess as either a concrete bool requirement or an expression payload. CWL requires the
+ * networkAccess field, and a missing one is no permission to use the network.
  */
-export declare function Decode_inplaceUpdateRequirementDecoder(get$: IGetters): InplaceUpdateRequirementValue;
+export declare function Decode_networkAccessRequirementDecoder(get$: Decode_IGetters): Requirement_$union;
 /**
- * Decode a YAMLElement into a ToolTimeLimitRequirement value
+ * Decode InplaceUpdateRequirement. CWL requires the inplaceUpdate field.
  */
-export declare function Decode_toolTimeLimitRequirementDecoder(get$: IGetters): ToolTimeLimitValue_$union;
+export declare function Decode_inplaceUpdateRequirementDecoder(get$: Decode_IGetters): InplaceUpdateRequirementValue;
 /**
- * Decode InlineJavascriptRequirement expressionLib in scalar or array form.
+ * Decode a YamlNode into a ToolTimeLimitRequirement value
  */
-export declare function Decode_inlineJavascriptRequirementDecoder(get$: IGetters): InlineJavascriptRequirementValue;
+export declare function Decode_toolTimeLimitRequirementDecoder(get$: Decode_IGetters): ToolTimeLimitValue_$union;
 /**
- * Dispatch a known CWL requirement class to its typed decoder.
+ * Decode InlineJavascriptRequirement, whose expressionLib is a list of strings.
  */
-export declare function Decode_requirementFromTypeName(cls: string, get$: IGetters): Requirement_$union;
+export declare function Decode_inlineJavascriptRequirementDecoder(get$: Decode_IGetters): InlineJavascriptRequirementValue;
 /**
- * Attach unknown payload fields to DynamicObj-backed requirement values after class dispatch.
+ * The decoder of the payload of a CWL requirement class, and none for a class that the model does not know. The caller
+ * knows the class before it reads the payload, because a hint of an unknown class may hold keys of any type.
  */
-export declare function Decode_addRequirementPayloadOverflow(element: YAMLElement_$union, requirement: Requirement_$union): Requirement_$union;
+export declare function Decode_tryRequirementDecoder(scope: Decode_DecodeScope, cls: string): Option<((arg0: Decode_IGetters) => Requirement_$union)>;
 /**
- * Decode requirements from either sequence syntax or class-name map syntax.
+ * Attach unknown payload fields to DynamicObj-backed requirement values after class dispatch.
  */
-export declare function Decode_requirementArrayDecoder(yEle: YAMLElement_$union): Requirement_$union[];
+export declare function Decode_addRequirementPayloadOverflow(element: YamlNode, requirement: Requirement_$union): Requirement_$union;
 /**
- * Try known requirement decoding for hints, falling back to UnknownHint on decode failure.
+ * Decode requirements from either sequence syntax or class-name map syntax. The field is the name of the field that
+ * holds them in the process, as it stands in the path of a warning. An $import stands for the requirements of a
+ * file, and the field may be that directive as a whole.
  */
-export declare function Decode_tryDecodeKnownRequirementFromElement(element: YAMLElement_$union): Option<Requirement_$union>;
+export declare function Decode_requirementArrayDecoderWithScope(warnings: Option<Decode_DecodeWarning[]>, field: string, scope: Decode_DecodeScope, yEle: YamlNode): Requirement_$union[];
+export declare const Decode_requirementArrayDecoder: (yEle: YamlNode) => Requirement_$union[];
 /**
- * Decode one hint as a known requirement when possible, otherwise preserve the raw hint.
+ * Decode one hint. An $import stands for the hints of a file, and the decoder checks for it before it reads the class,
+ * because the directive has none. A hint of a class that the model knows decodes with the decoder of the requirement of
+ * that class and fails with the same errors. A hint of any other class stays as it was written. cwltool accepts keys of
+ * any type in such a hint, so the decoder reads the class before Decode.object, which takes strings as keys only.
  */
-export declare function Decode_decodeHintElement(element: YAMLElement_$union): HintEntry_$union;
+export declare function Decode_decodeHintElement(scope: Decode_DecodeScope, element: YamlNode): HintEntry_$union;
 /**
  * Decode hints from sequence syntax or class-name map syntax while preserving unknown hints.
  */
-export declare function Decode_hintArrayDecoder(yEle: YAMLElement_$union): HintEntry_$union[];
-export declare const Decode_requirementsDecoder: (value: YAMLElement_$union) => Option<Requirement_$union[]>;
-export declare const Decode_hintsDecoder: (value: YAMLElement_$union) => Option<HintEntry_$union[]>;
-export declare const Decode_inputBindingDecoder: (value_9: YAMLElement_$union) => Option<InputBinding>;
+export declare function Decode_hintArrayDecoderWithScope(warnings: Option<Decode_DecodeWarning[]>, scope: Decode_DecodeScope, yEle: YamlNode): HintEntry_$union[];
+export declare const Decode_hintArrayDecoder: (yEle: YamlNode) => HintEntry_$union[];
 /**
- * Decode a named input from map shorthand or full object form, preserving optionality and extensions.
+ * Access the requirements field and decode the YamlNodes into a Requirement array
  */
-export declare function Decode_decodeNamedInput(name: string, value: YAMLElement_$union): CWLInput;
+export declare function Decode_requirementsDecoderWithScope(warnings: Option<Decode_DecodeWarning[]>, scope: Decode_DecodeScope): ((arg0: YamlNode) => Option<Requirement_$union[]>);
 /**
- * Decode one sequence-form input, warning only for malformed unnamed entries.
+ * Access the hints field and decode the YamlNodes into a HintEntry array
  */
-export declare function Decode_decodeInputSequenceItem(warnings: Option<Decode_DecodeWarning[]>, path: string, index: int32, item: YAMLElement_$union): Option<CWLInput>;
+export declare function Decode_hintsDecoderWithScope(warnings: Option<Decode_DecodeWarning[]>, scope: Decode_DecodeScope): ((arg0: YamlNode) => Option<HintEntry_$union[]>);
 /**
- * Decode a YAMLElement into an Input array
+ * Decode the requirements of a node that stands alone.
  */
-export declare function Decode_inputArrayDecoderWithWarnings(warnings: Option<Decode_DecodeWarning[]>, path: string, value: YAMLElement_$union): CWLInput[];
-export declare const Decode_inputArrayDecoder: (value: YAMLElement_$union) => CWLInput[];
+export declare function Decode_requirementsDecoder(node: YamlNode): Option<Requirement_$union[]>;
 /**
- * Access the inputs field and decode the YAMLElements into an Input array
+ * Decode the hints of a node that stands alone, as requirementsDecoder decodes its requirements.
  */
-export declare function Decode_inputsDecoderWithWarnings(warnings: Option<Decode_DecodeWarning[]>): ((arg0: YAMLElement_$union) => Option<CWLInput[]>);
-export declare const Decode_inputsDecoder: ((arg0: YAMLElement_$union) => Option<CWLInput[]>);
-export declare const Decode_baseCommandDecoder: (value_2: YAMLElement_$union) => Option<string[]>;
-export declare const Decode_versionDecoder: (value_1: YAMLElement_$union) => string;
-export declare const Decode_classDecoder: (value_1: YAMLElement_$union) => string;
-export declare function Decode_stringOptionFieldDecoder(field: string): ((arg0: YAMLElement_$union) => Option<string>);
-export declare function Decode_boolOptionFieldDecoder(field: string): ((arg0: YAMLElement_$union) => Option<boolean>);
-export declare function Decode_yamlElementOptionFieldDecoder(field: string): ((arg0: YAMLElement_$union) => Option<YAMLElement_$union>);
-export declare function Decode_stringFieldDecoder(field: string): ((arg0: YAMLElement_$union) => string);
+export declare function Decode_hintsDecoder(node: YamlNode): Option<HintEntry_$union[]>;
 /**
- * Decode a YAMLElement that may be a single string or an array of strings.
+ * Decode the position of an input binding: an int, or an expression that evaluates to one. A plain scalar that the
+ * core schema reads as an int is the number, and a string with $( or ${ in it is the expression. A directive
+ * stands for the number or the expression of a file.
  */
-export declare function Decode_stringOrStringArrayDecoder(value: YAMLElement_$union): Option<string[]>;
+export declare function Decode_bindingPositionDecoder(node: YamlNode): BindingPosition_$union;
+export declare const Decode_inputBindingDecoder: (node: YamlNode) => Option<ListEntry$1_$union<InputBinding>>;
 /**
- * Decode a YAMLElement into a ResizeArray<string> option for the source field
- * Handles both single string values and arrays of strings
+ * Decode the format of an input: one name or a list of names. The format of an output admits one name only.
  */
-export declare function Decode_sourceArrayFieldDecoder(field: string): ((arg0: YAMLElement_$union) => Option<string[]>);
+export declare function Decode_inputFormatDecoder(node: YamlNode): InputFormat_$union;
 /**
- * Decode and validate linkMerge enum fields.
+ * Decode a named input from map shorthand or full object form, preserving optionality and extensions.
  */
-export declare function Decode_linkMergeFieldDecoder(field: string): ((arg0: YAMLElement_$union) => Option<LinkMergeMethod_$union>);
+export declare function Decode_decodeNamedInput(scope: Decode_DecodeScope, name: string, value: YamlNode): CWLInput;
 /**
- * Decode and validate pickValue enum fields.
+ * Decode one sequence-form input, which is a mapping with an id.
  */
-export declare function Decode_pickValueFieldDecoder(field: string): ((arg0: YAMLElement_$union) => Option<PickValueMethod_$union>);
-export declare function Decode_scatterFieldDecoder(field: string): ((arg0: YAMLElement_$union) => Option<string[]>);
+export declare function Decode_decodeInputSequenceItem(scope: Decode_DecodeScope, index: int32, item: YamlNode): CWLInput;
 /**
- * Decode and validate scatterMethod enum fields.
+ * Decode a YamlNode into an Input array. An $import stands for the inputs of a file, in the list or as the whole
+ * field.
  */
-export declare function Decode_scatterMethodFieldDecoder(field: string): ((arg0: YAMLElement_$union) => Option<ScatterMethod_$union>);
+export declare function Decode_inputArrayDecoderWithWarnings(warnings: Option<Decode_DecodeWarning[]>, scope: Decode_DecodeScope, path: string, value: YamlNode): ListEntry$1_$union<CWLInput>[];
+export declare const Decode_inputArrayDecoder: (value: YamlNode) => ListEntry$1_$union<CWLInput>[];
 /**
- * Decode optional expression-like fields, including schema-salad directive wrappers.
+ * Access the inputs field and decode the YamlNodes into an Input array
  */
-export declare function Decode_expressionStringOptionFieldDecoder(field: string): ((arg0: YAMLElement_$union) => Option<string>);
+export declare function Decode_inputsDecoderWithWarnings(warnings: Option<Decode_DecodeWarning[]>, scope: Decode_DecodeScope): ((arg0: YamlNode) => Option<ListEntry$1_$union<CWLInput>[]>);
+export declare const Decode_inputsDecoder: ((arg0: YamlNode) => Option<ListEntry$1_$union<CWLInput>[]>);
+export declare const Decode_baseCommandDecoder: (node_1: YamlNode) => Option<SchemaSaladString_$union[]>;
+export declare function Decode_stringOptionFieldDecoder(field: string): ((arg0: YamlNode) => Option<string>);
+export declare function Decode_rawYamlOptionFieldDecoder(field: string): ((arg0: YamlNode) => Option<RawYaml>);
+export declare function Decode_stringFieldDecoder(field: string): ((arg0: YamlNode) => string);
 /**
- * Decode a step input from map or scalar shorthand and preserve unknown step-input fields.
+ * Decode a YamlNode into the source of a step input, which is a single string or an array of strings
  */
-export declare function Decode_decodeStepInputFromValue(id: string, value: YAMLElement_$union, allowScalarSource: boolean): StepInput;
+export declare function Decode_sourceArrayFieldDecoder(field: string): ((arg0: YamlNode) => Option<OutputSource_$union>);
 /**
- * Decode map-form step inputs where the map key supplies the step input id.
+ * Decode and validate linkMerge enum fields. A directive stands for the symbol of a file.
  */
-export declare function Decode_decodeStepInputsFromMap(value: YAMLElement_$union): StepInput[];
+export declare function Decode_linkMergeFieldDecoder(field: string): ((arg0: YamlNode) => Option<LinkMergeMethod_$union>);
 /**
- * Decode sequence-form step inputs where the id must be present in the item.
+ * Decode and validate pickValue enum fields. A directive stands for the symbol of a file.
  */
-export declare function Decode_decodeStepInputFromArrayItem(item: YAMLElement_$union): StepInput;
+export declare function Decode_pickValueFieldDecoder(field: string): ((arg0: YamlNode) => Option<PickValueMethod_$union>);
+export declare function Decode_scatterFieldDecoder(field: string): ((arg0: YamlNode) => Option<SchemaSaladString_$union[]>);
 /**
- * Decode sequence-form step inputs, warning and skipping only malformed unnamed entries.
+ * Decode and validate scatterMethod enum fields. A directive stands for the symbol of a file.
  */
-export declare function Decode_decodeStepInputsFromArrayWithWarnings(warnings: Option<Decode_DecodeWarning[]>, path: string, items: FSharpList<YAMLElement_$union>): StepInput[];
-export declare function Decode_decodeStepInputsFromArray(items: FSharpList<YAMLElement_$union>): StepInput[];
+export declare function Decode_scatterMethodFieldDecoder(field: string): ((arg0: YamlNode) => Option<ScatterMethod_$union>);
 /**
- * Select the step input decoder based on CWL map-form versus sequence-form syntax.
- */
-export declare function Decode_inputStepDecoderWithWarnings(warnings: Option<Decode_DecodeWarning[]>, path: string, value: YAMLElement_$union): StepInput[];
-export declare const Decode_inputStepDecoder: (value: YAMLElement_$union) => StepInput[];
-/**
- * Decode step outputs from scalar shorthand or record form with extension fields.
+ * Decode optional expression-like fields, including schema-salad directive wrappers.
  */
-export declare function Decode_decodeStepOutputItem(value: YAMLElement_$union): StepOutput_$union;
-export declare const Decode_outputStepsDecoder: (value_2: YAMLElement_$union) => StepOutput_$union[];
-export declare const Decode_docDecoder: (value_1: YAMLElement_$union) => Option<string>;
-export declare const Decode_labelDecoder: (value_1: YAMLElement_$union) => Option<string>;
-export declare const Decode_idDecoder: (value_1: YAMLElement_$union) => Option<string>;
-export declare const Decode_intentDecoder: (value_1: YAMLElement_$union) => Option<string[]>;
+export declare function Decode_expressionStringOptionFieldDecoder(field: string): ((arg0: YamlNode) => Option<SchemaSaladString_$union>);
 /**
- * Test object mappings for an explicit field without invoking a typed decoder.
+ * Decode a step input from map or scalar shorthand and preserve unknown step-input fields.
  */
-export declare function Decode_hasField(fieldName: string, yamlElement: YAMLElement_$union): boolean;
+export declare function Decode_decodeStepInputFromValue(id: string, value: YamlNode, allowScalarSource: boolean): StepInput;
 /**
- * Inject the parent workflow cwlVersion into inline run objects that omit it.
+ * Decode map-form step inputs where the map key supplies the step input id.
  */
-export declare function Decode_withDefaultCwlVersion(defaultCwlVersion: string, yamlElement: YAMLElement_$union): YAMLElement_$union;
+export declare function Decode_decodeStepInputsFromMap(value: YamlNode): ListEntry$1_$union<StepInput>[];
 /**
- * Decode a workflow step run as either a path string or an inline CWL processing unit.
+ * Decode sequence-form step inputs, which are mappings with an id. An $import stands for the step inputs of a file.
  */
-export declare function Decode_workflowStepRunDecoder(warnings: Option<Decode_DecodeWarning[]>, defaultCwlVersion: string, runValue: YAMLElement_$union): WorkflowStepRun_$union;
+export declare function Decode_decodeStepInputsFromArrayWithWarnings(warnings: Option<Decode_DecodeWarning[]>, path: string, items: FSharpList<YamlNode>): ListEntry$1_$union<StepInput>[];
+export declare function Decode_decodeStepInputsFromArray(items: FSharpList<YamlNode>): ListEntry$1_$union<StepInput>[];
 /**
- * Decode a named workflow step and thread warnings into nested step inputs and inline runs.
+ * Select the step input decoder based on CWL map-form versus sequence-form syntax. An $import mapping as the whole
+ * field stands for the step inputs of a file.
  */
-export declare function Decode_decodeWorkflowStepFromValueWithId(warnings: Option<Decode_DecodeWarning[]>, defaultCwlVersion: string, path: string, stepId: string, value: YAMLElement_$union): WorkflowStep;
-export declare function Decode_decodeWorkflowStepFromArrayItem(defaultCwlVersion: string, item: YAMLElement_$union): WorkflowStep;
+export declare function Decode_inputStepDecoderWithWarnings(warnings: Option<Decode_DecodeWarning[]>, path: string, value: YamlNode): ListEntry$1_$union<StepInput>[];
+export declare const Decode_inputStepDecoder: (value: YamlNode) => ListEntry$1_$union<StepInput>[];
 /**
- * Decode one sequence-form workflow step, warning only for malformed unnamed entries.
+ * Decode a step output from the scalar shorthand or from the record form with extension fields. A directive stands
+ * for a file. A record with an id and a $mixin is the output that the id names, and a $mixin without an id stands
+ * for an entry of its own.
  */
-export declare function Decode_decodeWorkflowStepFromArrayItemWithWarnings(warnings: Option<Decode_DecodeWarning[]>, defaultCwlVersion: string, index: int32, item: YAMLElement_$union): Option<WorkflowStep>;
+export declare function Decode_decodeStepOutputItem(value: YamlNode): StepOutput_$union;
+export declare const Decode_outputStepsDecoder: (node_2: YamlNode) => StepOutput_$union[];
+export declare const Decode_idDecoder: (node_1: YamlNode) => Option<string>;
+export declare const Decode_intentDecoder: (node_1: YamlNode) => Option<SchemaSaladString_$union[]>;
 /**
- * Decode workflow steps from sequence-form or map-form syntax with version-aware inline runs.
+ * Test object mappings for an explicit field without invoking a typed decoder.
  */
-export declare function Decode_stepArrayDecoderWithVersion(warnings: Option<Decode_DecodeWarning[]>, defaultCwlVersion: string, value: YAMLElement_$union): WorkflowStep[];
-export declare function Decode_stepsDecoderWithVersion(warnings: Option<Decode_DecodeWarning[]>, defaultCwlVersion: string): ((arg0: YAMLElement_$union) => WorkflowStep[]);
+export declare function Decode_hasField(fieldName: string, node: YamlNode): boolean;
 /**
- * Decode a CommandLineTool and preserve unknown top-level metadata fields.
+ * The cwlVersion of a process. A process below the top level takes the default of the scope, which is the version of
+ * the enclosing process. CWL ignores a cwlVersion field anywhere else than at the top level (concepts.md), so the
+ * value of such a field changes nothing. CWL types the field as a string everywhere, so a plain scalar that the core
+ * schema reads as a number or a bool is a decode error, and so is a list or a mapping. A process below the top level
+ * may leave the field out or give it a null. The field of the root is required.
  */
-export declare function Decode_commandLineToolDecoder(warnings: Option<Decode_DecodeWarning[]>, yamlCWL: YAMLElement_$union): CWLToolDescription;
+export declare function Decode_versionDecoder(scope: Decode_DecodeScope, node: YamlNode): string;
 /**
- * Decode an ExpressionTool and preserve unknown top-level metadata fields.
+ * Decode a workflow step run as either a path string or an inline CWL processing unit.
  */
-export declare function Decode_expressionToolDecoder(warnings: Option<Decode_DecodeWarning[]>, yamlCWL: YAMLElement_$union): CWLExpressionToolDescription;
+export declare function Decode_workflowStepRunDecoder(warnings: Option<Decode_DecodeWarning[]>, scope: Decode_DecodeScope, runValue: YamlNode): WorkflowStepRun_$union;
 /**
- * Decode an Operation and enforce its required inputs collection.
+ * Decode a workflow step with or without an id and thread warnings into nested step inputs and inline runs.
  */
-export declare function Decode_operationDecoder(warnings: Option<Decode_DecodeWarning[]>, yamlCWL: YAMLElement_$union): CWLOperationDescription;
+export declare function Decode_decodeWorkflowStepFromValueWithId(warnings: Option<Decode_DecodeWarning[]>, scope: Decode_DecodeScope, path: string, stepId: Option<string>, value: YamlNode): WorkflowStep;
+export declare function Decode_decodeWorkflowStepFromArrayItem(scope: Decode_DecodeScope, item: YamlNode): WorkflowStep;
 /**
- * Decode a Workflow, including version-aware steps and preserved metadata fields.
+ * Decode one sequence-form workflow step. CWL makes the id of a step optional, so a step without an id key is a step
+ * without an id, and it decodes in full like any other step. A null id is an error, as it is for cwltool, and so is
+ * an entry that is no mapping.
  */
-export declare function Decode_workflowDecoder(warnings: Option<Decode_DecodeWarning[]>, yamlCWL: YAMLElement_$union): CWLWorkflowDescription;
+export declare function Decode_decodeWorkflowStepFromArrayItemWithWarnings(warnings: Option<Decode_DecodeWarning[]>, scope: Decode_DecodeScope, index: int32, item: YamlNode): WorkflowStep;
 /**
- * Dispatch a parsed CWL document to the processing-unit decoder declared by its class field.
+ * Decode workflow steps from sequence-form or map-form syntax with version-aware inline runs.
  */
-export declare function Decode_decodeCWLProcessingUnitElementWithWarnings(warnings: Option<Decode_DecodeWarning[]>, yamlCWL: YAMLElement_$union): CWLProcessingUnit_$union;
+export declare function Decode_stepArrayDecoderWithScope(warnings: Option<Decode_DecodeWarning[]>, scope: Decode_DecodeScope, value: YamlNode): ListEntry$1_$union<WorkflowStep>[];
+export declare function Decode_stepsDecoderWithScope(warnings: Option<Decode_DecodeWarning[]>, scope: Decode_DecodeScope): ((arg0: YamlNode) => ListEntry$1_$union<WorkflowStep>[]);
 /**
- * Decode an already-parsed CWL element without warning collection.
+ * Decode an already-parsed CWL element without warning collection. The tree has to pass the same check as a text, so the
+ * function applies rejectWhatTheSpecProhibits to it.
  */
-export declare function Decode_decodeCWLProcessingUnitElement(yamlCWL: YAMLElement_$union): CWLProcessingUnit_$union;
-export declare const Decode_stepArrayDecoder: (value: YAMLElement_$union) => WorkflowStep[];
-export declare const Decode_stepsDecoder: ((arg0: YAMLElement_$union) => WorkflowStep[]);
+export declare function Decode_decodeCWLProcessingUnitElement(yamlCWL: YamlNode): CWLProcessingUnit_$union;
+export declare const Decode_stepArrayDecoder: ((arg0: YamlNode) => ListEntry$1_$union<WorkflowStep>[]);
+export declare const Decode_stepsDecoder: ((arg0: YamlNode) => ListEntry$1_$union<WorkflowStep>[]);
 /**
  * Decode a CWL CommandLineTool YAML string and return recoverable warnings.
  */
@@ -449,9 +710,17 @@ export declare function Decode_decodeCWLProcessingUnitWithWarnings(cwl: string):
  * Decode any CWL processing unit and discard recoverable warnings.
  */
 export declare function Decode_decodeCWLProcessingUnit(cwl: string): CWLProcessingUnit_$union;
-export declare function DecodeParameters_decodeParameterValue(value: YAMLElement_$union): CWLParameterValue_$union;
-export declare function DecodeParameters_cwlParameterReferenceDecoder(get$: IGetters, key: string, yEle: YAMLElement_$union): CWLParameterReference;
-export declare const DecodeParameters_cwlparameterReferenceArrayDecoder: (value: YAMLElement_$union) => CWLParameterReference[];
+export declare function DecodeParameters_decodeParameterValue(value: YamlNode): CWLParameterValue_$union;
+/**
+ * A job file gives each input a plain CWL value. An object with the fields type and value is a record with these
+ * two fields, and the type of the input comes from the process.
+ */
+export declare function DecodeParameters_cwlParameterReferenceDecoder(key: string, yEle: YamlNode): CWLParameterReference;
+/**
+ * Decode the root of an already-parsed job file into parameter references. The tree has to pass the same check as a text, so
+ * the function applies rejectWhatTheSpecProhibits to it.
+ */
+export declare function DecodeParameters_cwlparameterReferenceArrayDecoder(root: YamlNode): CWLParameterReference[];
 /**
  * Decode a YAML parameter file string into parameter references.
  */