{
    "description": "Execute an expression as a process step.",
    "type": "object",
    "properties": {
        "class": {
            "type": "string"
        },
        "expression": {
            "description": "The expression to execute.  The expression must return a JSON object which\n\nmatches the output parameters of the ExpressionTool.",
            "anyOf": [
                {
                    "type": "string"
                },
                {
                    "type": "string",
                    "enum": [
                        "ExpressionPlaceholder"
                    ]
                }
            ]
        },
        "id": {
            "description": "The unique identifier for this process object.",
            "type": "string"
        },
        "inputs": {
            "description": "Defines the input parameters of the process.  The process is ready to\n\nrun when all required input parameters are associated with concrete\n\nvalues.  Input parameters include a schema for each parameter which is\n\nused to validate the input object.  It may also be used to build a user\n\ninterface for constructing the input object.",
            "type": "array",
            "items": {
                "$ref": "#/definitions/InputParameter"
            }
        },
        "outputs": {
            "description": "Defines the parameters representing the output of the process.  May be\n\nused to generate and/or validate the output object.",
            "type": "array",
            "items": {
                "$ref": "#/definitions/OutputParameter"
            }
        },
        "requirements": {
            "description": "Declares requirements that apply to either the runtime environment or the\n\nworkflow engine that must be met in order to execute this process.  If\n\nan implementation cannot satisfy all requirements, or a requirement is\n\nlisted which is not recognized by the implementation, it is a fatal\n\nerror and the implementation must not attempt to run the process,\n\nunless overridden at user option.",
            "type": "array",
            "items": {
                "$ref": "#/definitions/ProcessRequirement"
            }
        },
        "hints": {
            "description": "Declares hints applying to either the runtime environment or the\n\nworkflow engine that may be helpful in executing this process.  It is\n\nnot an error if an implementation cannot satisfy all hints, however\n\nthe implementation may report a warning.",
            "type": "array",
            "items": {}
        },
        "label": {
            "description": "A short, human-readable label of this process object.",
            "type": "string"
        },
        "description": {
            "description": "A long, human-readable description of this process object.",
            "type": "string"
        },
        "cwlVersion": {
            "$ref": "#/definitions/CWLVersions",
            "description": "CWL document version"
        }
    },
    "required": [
        "class",
        "expression",
        "inputs",
        "outputs"
    ],
    "definitions": {
        "InputParameter": {
            "type": "object",
            "properties": {
                "id": {
                    "description": "The unique identifier for this parameter object.",
                    "type": "string"
                },
                "inputBinding": {
                    "$ref": "#/definitions/InputBinding",
                    "description": "Describes how to handle the inputs of a process and convert them\n\ninto a concrete form for execution, such as command line parameters."
                },
                "default": {
                    "description": "The default value for this parameter if not provided in the input\n\nobject."
                },
                "type": {
                    "description": "Specify valid types of data that may be assigned to this parameter.",
                    "anyOf": [
                        {
                            "type": "string",
                            "enum": [
                                "File"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "null"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "boolean"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "int"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "long"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "float"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "double"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "string"
                            ]
                        },
                        {
                            "$ref": "#/definitions/InputRecordSchema"
                        },
                        {
                            "$ref": "#/definitions/InputEnumSchema"
                        },
                        {
                            "$ref": "#/definitions/InputArraySchema"
                        },
                        {
                            "type": "string"
                        },
                        {
                            "type": "array",
                            "items": {
                                "anyOf": [
                                    {
                                        "type": "string",
                                        "enum": [
                                            "File"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "null"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "boolean"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "int"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "long"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "float"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "double"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "string"
                                        ]
                                    },
                                    {
                                        "$ref": "#/definitions/InputRecordSchema"
                                    },
                                    {
                                        "$ref": "#/definitions/InputEnumSchema"
                                    },
                                    {
                                        "$ref": "#/definitions/InputArraySchema"
                                    },
                                    {
                                        "type": "string"
                                    }
                                ]
                            }
                        }
                    ]
                },
                "label": {
                    "description": "A short, human-readable label of this parameter object.",
                    "type": "string"
                },
                "description": {
                    "description": "A long, human-readable description of this parameter object.",
                    "type": "string"
                },
                "secondaryFiles": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nDescribes files that must be included alongside the primary file(s).\n\n\n\nIf the value is an expression, the value of `self` in the expression\n\nmust be the primary input or output File to which this binding applies.\n\n\n\nIf the value is a string, it specifies that the following pattern\n\nshould be applied to the primary file:\n\n\n\n1. If string begins with one or more caret `^` characters, for each\n\ncaret, remove the last file extension from the path (the last\n\nperiod `.` and all following characters).  If there are no file\n\nextensions, the path is unchanged.\n\n2. Append the remainder of the string to the end of the file path.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "string",
                            "enum": [
                                "ExpressionPlaceholder"
                            ]
                        },
                        {
                            "type": "array",
                            "items": {
                                "anyOf": [
                                    {
                                        "type": "string"
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "ExpressionPlaceholder"
                                        ]
                                    }
                                ]
                            }
                        }
                    ]
                },
                "format": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nFor input parameters, this must be one or more URIs of a concept nodes\n\nthat represents file formats which are allowed as input to this\n\nparameter, preferrably defined within an ontology.  If no ontology is\n\navailable, file formats may be tested by exact match.\n\n\n\nFor output parameters, this is the file format that will be assigned to\n\nthe output parameter.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        {
                            "type": "string",
                            "enum": [
                                "ExpressionPlaceholder"
                            ]
                        }
                    ]
                },
                "streamable": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nA value of `true` indicates that the file is read or written\n\nsequentially without seeking.  An implementation may use this flag to\n\nindicate whether it is valid to stream file contents using a named\n\npipe.  Default: `false`.",
                    "type": "boolean"
                }
            },
            "required": [
                "id"
            ]
        },
        "InputBinding": {
            "type": "object",
            "properties": {
                "loadContents": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nRead up to the first 64 KiB of text from the file and place it in the\n\n\"contents\" field of the file object for use by expressions.",
                    "type": "boolean"
                }
            }
        },
        "InputRecordSchema": {
            "type": "object",
            "properties": {
                "fields": {
                    "description": "Defines the fields of the record.",
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/InputRecordField"
                    }
                },
                "type": {
                    "description": "Must be `record`",
                    "type": "string",
                    "enum": [
                        "record"
                    ]
                },
                "secondaryFiles": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nDescribes files that must be included alongside the primary file(s).\n\n\n\nIf the value is an expression, the value of `self` in the expression\n\nmust be the primary input or output File to which this binding applies.\n\n\n\nIf the value is a string, it specifies that the following pattern\n\nshould be applied to the primary file:\n\n\n\n1. If string begins with one or more caret `^` characters, for each\n\ncaret, remove the last file extension from the path (the last\n\nperiod `.` and all following characters).  If there are no file\n\nextensions, the path is unchanged.\n\n2. Append the remainder of the string to the end of the file path.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "string",
                            "enum": [
                                "ExpressionPlaceholder"
                            ]
                        },
                        {
                            "type": "array",
                            "items": {
                                "anyOf": [
                                    {
                                        "type": "string"
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "ExpressionPlaceholder"
                                        ]
                                    }
                                ]
                            }
                        }
                    ]
                },
                "format": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nFor input parameters, this must be one or more URIs of a concept nodes\n\nthat represents file formats which are allowed as input to this\n\nparameter, preferrably defined within an ontology.  If no ontology is\n\navailable, file formats may be tested by exact match.\n\n\n\nFor output parameters, this is the file format that will be assigned to\n\nthe output parameter.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        {
                            "type": "string",
                            "enum": [
                                "ExpressionPlaceholder"
                            ]
                        }
                    ]
                },
                "streamable": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nA value of `true` indicates that the file is read or written\n\nsequentially without seeking.  An implementation may use this flag to\n\nindicate whether it is valid to stream file contents using a named\n\npipe.  Default: `false`.",
                    "type": "boolean"
                }
            },
            "required": [
                "type"
            ]
        },
        "InputRecordField": {
            "type": "object",
            "properties": {
                "inputBinding": {
                    "$ref": "#/definitions/InputBinding"
                },
                "type": {
                    "description": "The field type",
                    "anyOf": [
                        {
                            "type": "string",
                            "enum": [
                                "null"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "boolean"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "int"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "long"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "float"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "double"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "string"
                            ]
                        },
                        {
                            "$ref": "#/definitions/InputRecordSchema"
                        },
                        {
                            "$ref": "#/definitions/InputEnumSchema"
                        },
                        {
                            "$ref": "#/definitions/InputArraySchema"
                        },
                        {
                            "type": "string"
                        },
                        {
                            "type": "array",
                            "items": {
                                "anyOf": [
                                    {
                                        "type": "string",
                                        "enum": [
                                            "null"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "boolean"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "int"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "long"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "float"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "double"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "string"
                                        ]
                                    },
                                    {
                                        "$ref": "#/definitions/InputRecordSchema"
                                    },
                                    {
                                        "$ref": "#/definitions/InputEnumSchema"
                                    },
                                    {
                                        "$ref": "#/definitions/InputArraySchema"
                                    },
                                    {
                                        "type": "string"
                                    }
                                ]
                            }
                        }
                    ]
                },
                "name": {
                    "description": "The name of the field",
                    "type": "string"
                },
                "doc": {
                    "description": "A documentation string for this field",
                    "type": "string"
                }
            },
            "required": [
                "type",
                "name"
            ]
        },
        "InputEnumSchema": {
            "type": "object",
            "properties": {
                "inputBinding": {
                    "$ref": "#/definitions/InputBinding"
                },
                "type": {
                    "description": "Must be `enum`",
                    "type": "string",
                    "enum": [
                        "enum"
                    ]
                },
                "symbols": {
                    "description": "Defines the set of valid symbols.",
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                },
                "secondaryFiles": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nDescribes files that must be included alongside the primary file(s).\n\n\n\nIf the value is an expression, the value of `self` in the expression\n\nmust be the primary input or output File to which this binding applies.\n\n\n\nIf the value is a string, it specifies that the following pattern\n\nshould be applied to the primary file:\n\n\n\n1. If string begins with one or more caret `^` characters, for each\n\ncaret, remove the last file extension from the path (the last\n\nperiod `.` and all following characters).  If there are no file\n\nextensions, the path is unchanged.\n\n2. Append the remainder of the string to the end of the file path.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "string",
                            "enum": [
                                "ExpressionPlaceholder"
                            ]
                        },
                        {
                            "type": "array",
                            "items": {
                                "anyOf": [
                                    {
                                        "type": "string"
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "ExpressionPlaceholder"
                                        ]
                                    }
                                ]
                            }
                        }
                    ]
                },
                "format": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nFor input parameters, this must be one or more URIs of a concept nodes\n\nthat represents file formats which are allowed as input to this\n\nparameter, preferrably defined within an ontology.  If no ontology is\n\navailable, file formats may be tested by exact match.\n\n\n\nFor output parameters, this is the file format that will be assigned to\n\nthe output parameter.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        {
                            "type": "string",
                            "enum": [
                                "ExpressionPlaceholder"
                            ]
                        }
                    ]
                },
                "streamable": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nA value of `true` indicates that the file is read or written\n\nsequentially without seeking.  An implementation may use this flag to\n\nindicate whether it is valid to stream file contents using a named\n\npipe.  Default: `false`.",
                    "type": "boolean"
                }
            },
            "required": [
                "type",
                "symbols"
            ]
        },
        "InputArraySchema": {
            "type": "object",
            "properties": {
                "inputBinding": {
                    "$ref": "#/definitions/InputBinding"
                },
                "items": {
                    "description": "Defines the type of the array elements.",
                    "anyOf": [
                        {
                            "type": "string",
                            "enum": [
                                "null"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "boolean"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "int"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "long"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "float"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "double"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "string"
                            ]
                        },
                        {
                            "$ref": "#/definitions/InputRecordSchema"
                        },
                        {
                            "$ref": "#/definitions/InputEnumSchema"
                        },
                        {
                            "$ref": "#/definitions/InputArraySchema"
                        },
                        {
                            "type": "string"
                        },
                        {
                            "type": "array",
                            "items": {
                                "anyOf": [
                                    {
                                        "type": "string",
                                        "enum": [
                                            "null"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "boolean"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "int"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "long"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "float"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "double"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "string"
                                        ]
                                    },
                                    {
                                        "$ref": "#/definitions/InputRecordSchema"
                                    },
                                    {
                                        "$ref": "#/definitions/InputEnumSchema"
                                    },
                                    {
                                        "$ref": "#/definitions/InputArraySchema"
                                    },
                                    {
                                        "type": "string"
                                    }
                                ]
                            }
                        }
                    ]
                },
                "type": {
                    "description": "Must be `array`",
                    "type": "string",
                    "enum": [
                        "array"
                    ]
                },
                "secondaryFiles": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nDescribes files that must be included alongside the primary file(s).\n\n\n\nIf the value is an expression, the value of `self` in the expression\n\nmust be the primary input or output File to which this binding applies.\n\n\n\nIf the value is a string, it specifies that the following pattern\n\nshould be applied to the primary file:\n\n\n\n1. If string begins with one or more caret `^` characters, for each\n\ncaret, remove the last file extension from the path (the last\n\nperiod `.` and all following characters).  If there are no file\n\nextensions, the path is unchanged.\n\n2. Append the remainder of the string to the end of the file path.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "string",
                            "enum": [
                                "ExpressionPlaceholder"
                            ]
                        },
                        {
                            "type": "array",
                            "items": {
                                "anyOf": [
                                    {
                                        "type": "string"
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "ExpressionPlaceholder"
                                        ]
                                    }
                                ]
                            }
                        }
                    ]
                },
                "format": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nFor input parameters, this must be one or more URIs of a concept nodes\n\nthat represents file formats which are allowed as input to this\n\nparameter, preferrably defined within an ontology.  If no ontology is\n\navailable, file formats may be tested by exact match.\n\n\n\nFor output parameters, this is the file format that will be assigned to\n\nthe output parameter.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        {
                            "type": "string",
                            "enum": [
                                "ExpressionPlaceholder"
                            ]
                        }
                    ]
                },
                "streamable": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nA value of `true` indicates that the file is read or written\n\nsequentially without seeking.  An implementation may use this flag to\n\nindicate whether it is valid to stream file contents using a named\n\npipe.  Default: `false`.",
                    "type": "boolean"
                }
            },
            "required": [
                "items",
                "type"
            ]
        },
        "OutputParameter": {
            "type": "object",
            "properties": {
                "id": {
                    "description": "The unique identifier for this parameter object.",
                    "type": "string"
                },
                "outputBinding": {
                    "$ref": "#/definitions/OutputBinding",
                    "description": "Describes how to handle the outputs of a process."
                },
                "type": {
                    "description": "Specify valid types of data that may be assigned to this parameter.",
                    "anyOf": [
                        {
                            "type": "string",
                            "enum": [
                                "File"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "null"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "boolean"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "int"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "long"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "float"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "double"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "string"
                            ]
                        },
                        {
                            "$ref": "#/definitions/OutputRecordSchema"
                        },
                        {
                            "$ref": "#/definitions/OutputEnumSchema"
                        },
                        {
                            "$ref": "#/definitions/OutputArraySchema"
                        },
                        {
                            "type": "string"
                        },
                        {
                            "type": "array",
                            "items": {
                                "anyOf": [
                                    {
                                        "type": "string",
                                        "enum": [
                                            "File"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "null"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "boolean"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "int"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "long"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "float"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "double"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "string"
                                        ]
                                    },
                                    {
                                        "$ref": "#/definitions/OutputRecordSchema"
                                    },
                                    {
                                        "$ref": "#/definitions/OutputEnumSchema"
                                    },
                                    {
                                        "$ref": "#/definitions/OutputArraySchema"
                                    },
                                    {
                                        "type": "string"
                                    }
                                ]
                            }
                        }
                    ]
                },
                "label": {
                    "description": "A short, human-readable label of this parameter object.",
                    "type": "string"
                },
                "description": {
                    "description": "A long, human-readable description of this parameter object.",
                    "type": "string"
                },
                "secondaryFiles": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nDescribes files that must be included alongside the primary file(s).\n\n\n\nIf the value is an expression, the value of `self` in the expression\n\nmust be the primary input or output File to which this binding applies.\n\n\n\nIf the value is a string, it specifies that the following pattern\n\nshould be applied to the primary file:\n\n\n\n1. If string begins with one or more caret `^` characters, for each\n\ncaret, remove the last file extension from the path (the last\n\nperiod `.` and all following characters).  If there are no file\n\nextensions, the path is unchanged.\n\n2. Append the remainder of the string to the end of the file path.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "string",
                            "enum": [
                                "ExpressionPlaceholder"
                            ]
                        },
                        {
                            "type": "array",
                            "items": {
                                "anyOf": [
                                    {
                                        "type": "string"
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "ExpressionPlaceholder"
                                        ]
                                    }
                                ]
                            }
                        }
                    ]
                },
                "format": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nFor input parameters, this must be one or more URIs of a concept nodes\n\nthat represents file formats which are allowed as input to this\n\nparameter, preferrably defined within an ontology.  If no ontology is\n\navailable, file formats may be tested by exact match.\n\n\n\nFor output parameters, this is the file format that will be assigned to\n\nthe output parameter.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        {
                            "type": "string",
                            "enum": [
                                "ExpressionPlaceholder"
                            ]
                        }
                    ]
                },
                "streamable": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nA value of `true` indicates that the file is read or written\n\nsequentially without seeking.  An implementation may use this flag to\n\nindicate whether it is valid to stream file contents using a named\n\npipe.  Default: `false`.",
                    "type": "boolean"
                }
            },
            "required": [
                "id"
            ]
        },
        "OutputBinding": {
            "type": "object",
            "properties": {}
        },
        "OutputRecordSchema": {
            "type": "object",
            "properties": {
                "fields": {
                    "description": "Defines the fields of the record.",
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/OutputRecordField"
                    }
                },
                "type": {
                    "description": "Must be `record`",
                    "type": "string",
                    "enum": [
                        "record"
                    ]
                },
                "secondaryFiles": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nDescribes files that must be included alongside the primary file(s).\n\n\n\nIf the value is an expression, the value of `self` in the expression\n\nmust be the primary input or output File to which this binding applies.\n\n\n\nIf the value is a string, it specifies that the following pattern\n\nshould be applied to the primary file:\n\n\n\n1. If string begins with one or more caret `^` characters, for each\n\ncaret, remove the last file extension from the path (the last\n\nperiod `.` and all following characters).  If there are no file\n\nextensions, the path is unchanged.\n\n2. Append the remainder of the string to the end of the file path.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "string",
                            "enum": [
                                "ExpressionPlaceholder"
                            ]
                        },
                        {
                            "type": "array",
                            "items": {
                                "anyOf": [
                                    {
                                        "type": "string"
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "ExpressionPlaceholder"
                                        ]
                                    }
                                ]
                            }
                        }
                    ]
                },
                "format": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nFor input parameters, this must be one or more URIs of a concept nodes\n\nthat represents file formats which are allowed as input to this\n\nparameter, preferrably defined within an ontology.  If no ontology is\n\navailable, file formats may be tested by exact match.\n\n\n\nFor output parameters, this is the file format that will be assigned to\n\nthe output parameter.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        {
                            "type": "string",
                            "enum": [
                                "ExpressionPlaceholder"
                            ]
                        }
                    ]
                },
                "streamable": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nA value of `true` indicates that the file is read or written\n\nsequentially without seeking.  An implementation may use this flag to\n\nindicate whether it is valid to stream file contents using a named\n\npipe.  Default: `false`.",
                    "type": "boolean"
                }
            },
            "required": [
                "type"
            ]
        },
        "OutputRecordField": {
            "type": "object",
            "properties": {
                "outputBinding": {
                    "$ref": "#/definitions/OutputBinding"
                },
                "type": {
                    "description": "The field type",
                    "anyOf": [
                        {
                            "type": "string",
                            "enum": [
                                "null"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "boolean"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "int"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "long"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "float"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "double"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "string"
                            ]
                        },
                        {
                            "$ref": "#/definitions/OutputRecordSchema"
                        },
                        {
                            "$ref": "#/definitions/OutputEnumSchema"
                        },
                        {
                            "$ref": "#/definitions/OutputArraySchema"
                        },
                        {
                            "type": "string"
                        },
                        {
                            "type": "array",
                            "items": {
                                "anyOf": [
                                    {
                                        "type": "string",
                                        "enum": [
                                            "null"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "boolean"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "int"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "long"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "float"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "double"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "string"
                                        ]
                                    },
                                    {
                                        "$ref": "#/definitions/OutputRecordSchema"
                                    },
                                    {
                                        "$ref": "#/definitions/OutputEnumSchema"
                                    },
                                    {
                                        "$ref": "#/definitions/OutputArraySchema"
                                    },
                                    {
                                        "type": "string"
                                    }
                                ]
                            }
                        }
                    ]
                },
                "name": {
                    "description": "The name of the field",
                    "type": "string"
                },
                "doc": {
                    "description": "A documentation string for this field",
                    "type": "string"
                }
            },
            "required": [
                "type",
                "name"
            ]
        },
        "OutputEnumSchema": {
            "type": "object",
            "properties": {
                "outputBinding": {
                    "$ref": "#/definitions/OutputBinding"
                },
                "type": {
                    "description": "Must be `enum`",
                    "type": "string",
                    "enum": [
                        "enum"
                    ]
                },
                "symbols": {
                    "description": "Defines the set of valid symbols.",
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                },
                "secondaryFiles": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nDescribes files that must be included alongside the primary file(s).\n\n\n\nIf the value is an expression, the value of `self` in the expression\n\nmust be the primary input or output File to which this binding applies.\n\n\n\nIf the value is a string, it specifies that the following pattern\n\nshould be applied to the primary file:\n\n\n\n1. If string begins with one or more caret `^` characters, for each\n\ncaret, remove the last file extension from the path (the last\n\nperiod `.` and all following characters).  If there are no file\n\nextensions, the path is unchanged.\n\n2. Append the remainder of the string to the end of the file path.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "string",
                            "enum": [
                                "ExpressionPlaceholder"
                            ]
                        },
                        {
                            "type": "array",
                            "items": {
                                "anyOf": [
                                    {
                                        "type": "string"
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "ExpressionPlaceholder"
                                        ]
                                    }
                                ]
                            }
                        }
                    ]
                },
                "format": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nFor input parameters, this must be one or more URIs of a concept nodes\n\nthat represents file formats which are allowed as input to this\n\nparameter, preferrably defined within an ontology.  If no ontology is\n\navailable, file formats may be tested by exact match.\n\n\n\nFor output parameters, this is the file format that will be assigned to\n\nthe output parameter.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        {
                            "type": "string",
                            "enum": [
                                "ExpressionPlaceholder"
                            ]
                        }
                    ]
                },
                "streamable": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nA value of `true` indicates that the file is read or written\n\nsequentially without seeking.  An implementation may use this flag to\n\nindicate whether it is valid to stream file contents using a named\n\npipe.  Default: `false`.",
                    "type": "boolean"
                }
            },
            "required": [
                "type",
                "symbols"
            ]
        },
        "OutputArraySchema": {
            "type": "object",
            "properties": {
                "outputBinding": {
                    "$ref": "#/definitions/OutputBinding"
                },
                "items": {
                    "description": "Defines the type of the array elements.",
                    "anyOf": [
                        {
                            "type": "string",
                            "enum": [
                                "null"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "boolean"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "int"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "long"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "float"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "double"
                            ]
                        },
                        {
                            "type": "string",
                            "enum": [
                                "string"
                            ]
                        },
                        {
                            "$ref": "#/definitions/OutputRecordSchema"
                        },
                        {
                            "$ref": "#/definitions/OutputEnumSchema"
                        },
                        {
                            "$ref": "#/definitions/OutputArraySchema"
                        },
                        {
                            "type": "string"
                        },
                        {
                            "type": "array",
                            "items": {
                                "anyOf": [
                                    {
                                        "type": "string",
                                        "enum": [
                                            "null"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "boolean"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "int"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "long"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "float"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "double"
                                        ]
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "string"
                                        ]
                                    },
                                    {
                                        "$ref": "#/definitions/OutputRecordSchema"
                                    },
                                    {
                                        "$ref": "#/definitions/OutputEnumSchema"
                                    },
                                    {
                                        "$ref": "#/definitions/OutputArraySchema"
                                    },
                                    {
                                        "type": "string"
                                    }
                                ]
                            }
                        }
                    ]
                },
                "type": {
                    "description": "Must be `array`",
                    "type": "string",
                    "enum": [
                        "array"
                    ]
                },
                "secondaryFiles": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nDescribes files that must be included alongside the primary file(s).\n\n\n\nIf the value is an expression, the value of `self` in the expression\n\nmust be the primary input or output File to which this binding applies.\n\n\n\nIf the value is a string, it specifies that the following pattern\n\nshould be applied to the primary file:\n\n\n\n1. If string begins with one or more caret `^` characters, for each\n\ncaret, remove the last file extension from the path (the last\n\nperiod `.` and all following characters).  If there are no file\n\nextensions, the path is unchanged.\n\n2. Append the remainder of the string to the end of the file path.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "string",
                            "enum": [
                                "ExpressionPlaceholder"
                            ]
                        },
                        {
                            "type": "array",
                            "items": {
                                "anyOf": [
                                    {
                                        "type": "string"
                                    },
                                    {
                                        "type": "string",
                                        "enum": [
                                            "ExpressionPlaceholder"
                                        ]
                                    }
                                ]
                            }
                        }
                    ]
                },
                "format": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nFor input parameters, this must be one or more URIs of a concept nodes\n\nthat represents file formats which are allowed as input to this\n\nparameter, preferrably defined within an ontology.  If no ontology is\n\navailable, file formats may be tested by exact match.\n\n\n\nFor output parameters, this is the file format that will be assigned to\n\nthe output parameter.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        {
                            "type": "string",
                            "enum": [
                                "ExpressionPlaceholder"
                            ]
                        }
                    ]
                },
                "streamable": {
                    "description": "Only valid when `type: File` or is an array of `items: File`.\n\n\n\nA value of `true` indicates that the file is read or written\n\nsequentially without seeking.  An implementation may use this flag to\n\nindicate whether it is valid to stream file contents using a named\n\npipe.  Default: `false`.",
                    "type": "boolean"
                }
            },
            "required": [
                "items",
                "type"
            ]
        },
        "ProcessRequirement": {
            "description": "A process requirement declares a prerequisite that may or must be fulfilled\n\nbefore executing a process.  See [`Process.hints`](#process) and\n\n[`Process.requirements`](#process).\n\n\n\nProcess requirements are the primary mechanism for specifying extensions to\n\nthe CWL core specification.",
            "type": "object",
            "properties": {
                "class": {
                    "description": "The specific requirement type.",
                    "type": "string"
                }
            },
            "required": [
                "class"
            ]
        },
        "CWLVersions": {
            "type": "string",
            "enum": [
                "draft-3"
            ]
        }
    },
    "$schema": "http://json-schema.org/draft-04/schema#"
}