{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "additionalProperties": false,
  "definitions": {
    "annotatedCodeLocation": {
      "description": "An annotation used to express code flows through a method or other locations that are related to a result.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "id": {
          "description": "OBSOLETE (use \"step\" instead): An identifier for the location, unique within the scope of the code flow within which it occurs.",
          "type": ["integer", "string"],
          "pattern": "^[1-9][0-9]*$",
          "minimum": 1
        },
        "step": {
          "description": "The 0-based sequence number of the location in the code flow within which it occurs.",
          "type": "integer",
          "minimum": 0
        },
        "physicalLocation": {
          "description": "A file location to which this annotation refers.",
          "$ref": "#/definitions/physicalLocation"
        },
        "fullyQualifiedLogicalName": {
          "description": "The fully qualified name of the method or function that is executing.",
          "type": "string"
        },
        "logicalLocationKey": {
          "description": "A key used to retrieve the annotation's logicalLocation from the logicalLocations dictionary.",
          "type": "string"
        },
        "module": {
          "description": "The name of the module that contains the code that is executing.",
          "type": "string"
        },
        "threadId": {
          "description": "The thread identifier of the code that is executing.",
          "type": "integer"
        },
        "message": {
          "description": "A message relevant to this annotation.",
          "type": "string"
        },
        "kind": {
          "description": "Categorizes the location.",
          "enum": [
            "alias",
            "assignment",
            "branch",
            "call",
            "callReturn",
            "continuation",
            "declaration",
            "functionEnter",
            "functionExit",
            "functionReturn",
            "usage"
          ]
        },
        "taintKind": {
          "description": "Classifies state transitions in code locations relevant to a taint analysis.",
          "enum": ["source", "sink", "sanitizer"]
        },
        "target": {
          "description": "The fully qualified name of the target on which this location operates. For an annotation of kind 'call', for example, the target refers to the fully qualified logical name of the function called from this location.",
          "type": "string"
        },
        "values": {
          "description": "An ordered set of strings that comprise input or return values for the current operation. For an annotation of kind 'call', for example, this property may hold the ordered list of arguments passed to the callee.",
          "type": "array",
          "default": [],
          "items": {
            "type": "string"
          }
        },
        "state": {
          "description": "A dictionary, each of whose keys specifies a variable or expression, the associated value of which represents the variable or expression value. For an annotation of kind 'continuation', for example, this dictionary might hold the current assumed values of a set of global variables.",
          "type": "object"
        },
        "targetKey": {
          "description": "A key used to retrieve the target's logicalLocation from the logicalLocations dictionary.",
          "type": "string"
        },
        "essential": {
          "description": "OBSOLETE (use \"importance\" instead): True if this location is essential to understanding the code flow in which it occurs.",
          "type": "boolean"
        },
        "importance": {
          "description": "Specifies the importance of this location in understanding the code flow in which it occurs. The order from most to least important is \"essential\", \"important\", \"unimportant\". Default: \"important\".",
          "enum": ["important", "essential", "unimportant"]
        },
        "snippet": {
          "description": "The source code at the specified location.",
          "type": "string"
        },
        "annotations": {
          "description": "A set of messages relevant to the current annotated code location.",
          "type": "array",
          "minItems": 1,
          "uniqueItems": true,
          "items": {
            "$ref": "#/definitions/annotation"
          }
        },
        "properties": {
          "description": "Key/value pairs that provide additional information about the code location.",
          "type": "object",
          "additionalProperties": true,
          "properties": {
            "tags": {
              "description": "A set of distinct strings that provide additional information.",
              "type": "array",
              "uniqueItems": true,
              "default": [],
              "items": {
                "type": "string"
              }
            }
          }
        }
      }
    },
    "annotation": {
      "type": "object",
      "properties": {
        "message": {
          "description": "A message relevant to a code location",
          "type": "string"
        },
        "locations": {
          "description": "An array of 'physicalLocation' objects associated with the annotation.",
          "type": "array",
          "minItems": 1,
          "items": {
            "$ref": "#/definitions/physicalLocation"
          }
        }
      },
      "required": ["message", "locations"]
    },
    "codeFlow": {
      "type": "object",
      "properties": {
        "message": {
          "description": "A message relevant to the code flow",
          "type": "string"
        },
        "locations": {
          "description": "An array of 'annotatedCodeLocation' objects, each of which describes a single location visited by the tool in the course of producing the result.",
          "type": "array",
          "minItems": 1,
          "items": {
            "$ref": "#/definitions/annotatedCodeLocation"
          }
        },
        "properties": {
          "description": "Key/value pairs that provide additional information about the code flow.",
          "type": "object",
          "additionalProperties": true,
          "properties": {
            "tags": {
              "description": "A set of distinct strings that provide additional information.",
              "type": "array",
              "uniqueItems": true,
              "default": [],
              "items": {
                "type": "string"
              }
            }
          }
        }
      },
      "required": ["locations"]
    },
    "exception": {
      "type": "object",
      "properties": {
        "kind": {
          "type": "string",
          "description": "A string that identifies the kind of exception, for example, the fully qualified type name of an object that was thrown, or the symbolic name of a signal."
        },
        "message": {
          "type": "string",
          "description": "A string that describes the exception."
        },
        "stack": {
          "description": "The sequence of function calls leading to the exception.",
          "$ref": "#/definitions/stack"
        },
        "innerExceptions": {
          "type": "array",
          "description": "An array of exception objects each of which is considered a cause of this exception.",
          "items": {
            "$ref": "#/definitions/exception"
          }
        }
      }
    },
    "fileChange": {
      "description": "A change to a single file.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "uri": {
          "description": "A string that represents the location of the file to change as a valid URI.",
          "type": "string",
          "format": "uri"
        },
        "uriBaseId": {
          "description": "A string that identifies the conceptual base for the 'uri' property (if it is relative), e.g.,'$(SolutionDir)' or '%SRCROOT%'.",
          "type": "string"
        },
        "replacements": {
          "description": "An array of replacement objects, each of which represents the replacement of a single range of bytes in a single file specified by 'uri'.",
          "type": "array",
          "minItems": 1,
          "items": {
            "$ref": "#/definitions/replacement"
          }
        }
      },
      "required": ["uri", "replacements"],
      "dependencies": {
        "uriBaseId": ["uri"]
      }
    },
    "file": {
      "description": "A single file. In some cases, this file might be nested within another file.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "uri": {
          "description": "The path to the file within its containing file.",
          "type": "string",
          "format": "uri"
        },
        "uriBaseId": {
          "description": "A string that identifies the conceptual base for the 'uri' property (if it is relative), e.g.,'$(SolutionDir)' or '%SRCROOT%'.",
          "type": "string"
        },
        "parentKey": {
          "description": "Identifies the key of the immediate parent of the file, if this file is nested.",
          "type": "string"
        },
        "offset": {
          "description": "The offset in bytes of the file within its containing file.",
          "type": "integer"
        },
        "length": {
          "description": "The length of the file in bytes.",
          "type": "integer"
        },
        "mimeType": {
          "description": "The MIME type (RFC 2045) of the file.",
          "type": "string",
          "pattern": "[^/]+/.+"
        },
        "contents": {
          "description": "The contents of the file, expressed as a MIME Base64-encoded byte sequence.",
          "type": "string"
        },
        "hashes": {
          "description": "An array of hash objects, each of which specifies a hashed value for the file, along with the name of the algorithm used to compute the hash.",
          "type": "array",
          "minItems": 1,
          "uniqueItems": true,
          "items": {
            "$ref": "#/definitions/hash"
          }
        },
        "properties": {
          "description": "Key/value pairs that provide additional information about the file.",
          "type": "object",
          "additionalProperties": true,
          "properties": {
            "tags": {
              "description": "A set of distinct strings that provide additional information.",
              "type": "array",
              "uniqueItems": true,
              "default": [],
              "items": {
                "type": "string"
              }
            }
          }
        }
      },
      "dependencies": {
        "uriBaseId": ["uri"]
      }
    },
    "fix": {
      "description": "A proposed fix for the problem represented by a result object. A fix specifies a set of file to modify. For each file, it specifies a set of bytes to remove, and provides a set of new bytes to replace them.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "description": {
          "description": "A string that describes the proposed fix, enabling viewers to present a proposed change to an end user.",
          "type": "string"
        },
        "fileChanges": {
          "description": "One or more file changes that comprise a fix for a result.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/fileChange"
          }
        }
      },
      "required": ["description", "fileChanges"]
    },
    "formattedRuleMessage": {
      "description": "Contains information that can be used to construct a formatted message that describes a result.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "formatId": {
          "description": "A string that identifies the message format used to format the message that describes this result. The value of formatId must correspond to one of the names in the set of name/value pairs contained in the 'messageFormats' property of the rule object whose 'id' property matches the 'ruleId' property of this result.",
          "type": "string"
        },
        "arguments": {
          "description": "An array of strings that will be used, in combination with a message format, to construct a result message.",
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      },
      "required": ["formatId"]
    },
    "hash": {
      "description": "A hash value of some file or collection of files, together with the algorithm used to compute the hash.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "value": {
          "description": "The hash value of some file or collection of files, computed by the algorithm named in the 'algorithm' property.",
          "type": "string"
        },
        "algorithm": {
          "description": "The name of the algorithm used to compute the hash value specified in the 'value' property.",
          "enum": [
            "authentihash",
            "blake256",
            "blake512",
            "ecoh",
            "fsb",
            "gost",
            "groestl",
            "has160",
            "haval",
            "jh",
            "md2",
            "md4",
            "md5",
            "md6",
            "radioGatun",
            "ripeMD",
            "ripeMD128",
            "ripeMD160",
            "ripeMD320",
            "sdhash",
            "sha1",
            "sha224",
            "sha256",
            "sha384",
            "sha512",
            "sha3",
            "skein",
            "snefru",
            "spectralHash",
            "ssdeep",
            "swifft",
            "tiger",
            "tlsh",
            "whirlpool"
          ]
        }
      },
      "required": ["value", "algorithm"]
    },
    "invocation": {
      "description": "The runtime environment of the analysis tool run.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "commandLine": {
          "description": "The command line used to invoke the tool.",
          "type": "string"
        },
        "responseFiles": {
          "description": "The contents of any response files specified on the tool's command line.",
          "type": "object",
          "additionalProperties": true
        },
        "startTime": {
          "description": "The date and time at which the run started. See \"Date/time properties\" in the SARIF spec for the required format.",
          "type": "string",
          "format": "date-time"
        },
        "endTime": {
          "description": "The date and time at which the run ended. See \"Date/time properties\" in the  SARIF spec for the required format.",
          "type": "string",
          "format": "date-time"
        },
        "machine": {
          "description": "The machine that hosted the analysis tool run.",
          "type": "string"
        },
        "account": {
          "description": "The account that ran the analysis tool.",
          "type": "string"
        },
        "processId": {
          "description": "The process id for the analysis tool run.",
          "type": "integer"
        },
        "fileName": {
          "description": "The fully qualified path to the analysis tool.",
          "type": "string"
        },
        "workingDirectory": {
          "description": "The working directory for the analysis rool run.",
          "type": "string"
        },
        "environmentVariables": {
          "description": "The environment variables associated with the analysis tool process, expressed as key/value pairs.",
          "type": "object",
          "additionalProperties": true,
          "default": {}
        },
        "properties": {
          "description": "Key/value pairs that provide additional information about the run.",
          "type": "object",
          "additionalProperties": true,
          "properties": {
            "tags": {
              "description": "A set of distinct strings that provide additional information.",
              "type": "array",
              "uniqueItems": true,
              "default": [],
              "items": {
                "type": "string"
              }
            }
          }
        }
      }
    },
    "location": {
      "description": "The location where an analysis tool produced a result.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "analysisTarget": {
          "description": "Identifies the file that the analysis tool was instructed to scan. This need not be the same as the file where the result actually occurred.",
          "$ref": "#/definitions/physicalLocation"
        },
        "resultFile": {
          "description": "Identifies the file where the analysis tool produced the result.",
          "$ref": "#/definitions/physicalLocation"
        },
        "fullyQualifiedLogicalName": {
          "description": "The human-readable fully qualified name of the logical location where the analysis tool produced the result. If 'logicalLocationKey' is not specified, this member is can used to retrieve the location logicalLocation from the logicalLocations dictionary, if one exists.",
          "type": "string"
        },
        "logicalLocationKey": {
          "description": "A key used to retrieve the location logicalLocation from the logicalLocations dictionary, when the string specified by 'fullyQualifiedLogicalName' is not unique.",
          "type": "string"
        },
        "decoratedName": {
          "description": "The machine-readable fully qualified name for the logical location where the analysis tool produced the result, such as the mangled function name provided by a C++ compiler that encodes calling convention, return type and other details along with the function name.",
          "type": "string"
        },
        "properties": {
          "description": "Key/value pairs that provide additional information about the location.",
          "type": "object",
          "additionalProperties": true,
          "properties": {
            "tags": {
              "description": "A set of distinct strings that provide additional information.",
              "type": "array",
              "uniqueItems": true,
              "default": [],
              "items": {
                "type": "string"
              }
            }
          }
        }
      }
    },
    "logicalLocation": {
      "description": "A logical location of a construct that produced a result.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "name": {
          "description": "Identifies the construct in which the result occurred. For example, this property might contain the name of a class or a method.",
          "type": "string"
        },
        "parentKey": {
          "description": "Identifies the key of the immediate parent of the construct in which the result was detected. For example, this property might point to a logical location that represents the namespace that holds a type.",
          "type": "string"
        },
        "kind": {
          "description": "The type of construct this logicalLocationComponent refers to. Should be one of 'function', 'member', 'module', 'namespace', 'package', 'resource', or 'type', if any of those accurately describe the construct.",
          "type": "string"
        }
      }
    },
    "notification": {
      "type": "object",
      "description": "Describes a condition relevant to the tool itself, as opposed to being relevant to a target being analyzed by the tool.",
      "additionalProperties": false,
      "properties": {
        "id": {
          "description": "An identifier for the condition that was encountered.",
          "type": "string"
        },
        "ruleId": {
          "description": "The stable, unique identifier of the rule (if any) to which this notification is relevant. If 'ruleKey' is not specified, this member can be used to retrieve rule metadata from the rules dictionary, if it exists.",
          "type": "string"
        },
        "ruleKey": {
          "description": "A key used to retrieve the rule metadata from the rules dictionary that is relevant to the notification.",
          "type": "string"
        },
        "physicalLocation": {
          "description": "The file and region relevant to this notification.",
          "$ref": "#/definitions/physicalLocation"
        },
        "message": {
          "description": "A string that describes the condition that was encountered.",
          "type": "string"
        },
        "level": {
          "description": "A value specifying the severity level of the notification.",
          "default": "warning",
          "enum": ["note", "warning", "error"]
        },
        "threadId": {
          "description": "The thread identifier of the code that generated the notification.",
          "type": "integer"
        },
        "time": {
          "description": "The date and time at which the analysis tool generated the notification.",
          "type": "string",
          "format": "date-time"
        },
        "exception": {
          "description": "The runtime exception, if any, relevant to this notification.",
          "$ref": "#/definitions/exception"
        },
        "properties": {
          "description": "Key/value pairs that provide additional information about the notification.",
          "type": "object",
          "additionalProperties": true,
          "properties": {
            "tags": {
              "description": "A set of distinct strings that provide additional information.",
              "type": "array",
              "uniqueItems": true,
              "default": [],
              "items": {
                "type": "string"
              }
            }
          }
        }
      },
      "required": ["message"]
    },
    "physicalLocation": {
      "description": "A physical location relevant to a result. Specifies a reference to a programming artifact together with a range of bytes or characters within that artifact.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "uri": {
          "description": "The location of the file as a valid URI.",
          "type": "string",
          "format": "uri"
        },
        "uriBaseId": {
          "description": "A string that identifies the conceptual base for the 'uri' property (if it is relative), e.g.,'$(SolutionDir)' or '%SRCROOT%'.",
          "type": "string"
        },
        "region": {
          "description": "The region within the file where the result was detected.",
          "$ref": "#/definitions/region"
        }
      },
      "dependencies": {
        "uriBaseId": ["uri"]
      }
    },
    "region": {
      "description": "A region within a file where a result was detected.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "startLine": {
          "description": "The line number of the first character in the region.",
          "type": "integer",
          "minimum": 1
        },
        "startColumn": {
          "description": "The column number of the first character in the region.",
          "type": "integer",
          "minimum": 1
        },
        "endLine": {
          "description": "The line number of the last character in the region.",
          "type": "integer",
          "minimum": 1
        },
        "endColumn": {
          "description": "The column number of the last character in the region.",
          "type": "integer",
          "minimum": 1
        },
        "offset": {
          "description": "The zero-based offset from the beginning of the file of the first byte or character in the region.",
          "type": "integer",
          "minimum": 0
        },
        "length": {
          "description": "The length of the region in bytes or characters.",
          "type": "integer",
          "minimum": 0
        }
      }
    },
    "replacement": {
      "description": "The replacement of a single range of bytes in a file. Specifies the location within the file where the replacement is to be made, the number of bytes to remove at that location, and a sequence of bytes to insert at that location.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "offset": {
          "description": "A non-negative integer specifying the offset in bytes from the beginning of the file at which bytes are to be removed, inserted or both. An offset of 0 shall denote the first byte in the file.",
          "type": "integer",
          "minimum": 0
        },
        "deletedLength": {
          "description": "The number of bytes to delete, starting at the byte offset specified by offset, measured from the beginning of the file.",
          "type": "integer",
          "minimum": 1
        },
        "insertedBytes": {
          "description": "The MIME Base64-encoded byte sequence to be inserted at the byte offset specified by the 'offset' property, measured from the beginning of the file.",
          "type": "string"
        }
      },
      "required": ["offset"]
    },
    "result": {
      "description": "A result produced by an analysis tool.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "ruleId": {
          "description": "The stable, unique identifier of the rule (if any) to which this notification is relevant. If 'ruleKey' is not specified, this member can be used to retrieve rule metadata from the rules dictionary, if it exists.",
          "type": "string"
        },
        "ruleKey": {
          "description": "A key used to retrieve the rule metadata from the rules dictionary that is relevant to the notification.",
          "type": "string"
        },
        "level": {
          "description": "A value specifying the severity level of the result. If this property is not present, its implied value is 'warning'.",
          "default": "warning",
          "enum": ["notApplicable", "pass", "note", "warning", "error"]
        },
        "message": {
          "description": "A string that describes the result. The first sentence of the message only will be displayed when visible space is limited.",
          "type": "string"
        },
        "formattedRuleMessage": {
          "description": "A 'formattedRuleMessage' object that can be used to construct a formatted message that describes the result. If the 'formattedMessage' property is present on a result, the 'fullMessage' property shall not be present. If the 'fullMessage' property is present on an result, the 'formattedMessage' property shall not be present",
          "$ref": "#/definitions/formattedRuleMessage"
        },
        "locations": {
          "description": "One or more locations where the result occurred. Specify only one location unless the problem indicated by the result can only be corrected by making a change at every specified location.",
          "type": "array",
          "minItems": 1,
          "uniqueItems": true,
          "items": {
            "$ref": "#/definitions/location"
          }
        },
        "snippet": {
          "description": "A source code or other file fragment that illustrates the result.",
          "type": "string"
        },
        "id": {
          "description": "A unique identifier for the result.",
          "type": "string"
        },
        "toolFingerprintContribution": {
          "description": "A string that contributes to the unique identity of the result.",
          "type": "string"
        },
        "stacks": {
          "description": "An array of 'stack' objects relevant to the result.",
          "type": "array",
          "minItems": 1,
          "uniqueItems": true,
          "items": {
            "$ref": "#/definitions/stack"
          }
        },
        "codeFlows": {
          "description": "An array of 'codeFlow' objects relevant to the result.",
          "type": "array",
          "minItems": 1,
          "uniqueItems": true,
          "items": {
            "$ref": "#/definitions/codeFlow"
          }
        },
        "relatedLocations": {
          "description": "A grouped set of locations and messages, if available, that represent code areas that are related to this result.",
          "type": "array",
          "minItems": 1,
          "uniqueItems": true,
          "items": {
            "$ref": "#/definitions/annotatedCodeLocation"
          }
        },
        "suppressionStates": {
          "type": "array",
          "items": {
            "description": "A flag value indicating one or more suppression conditions.",
            "enum": ["suppressedInSource", "suppressedExternally"]
          }
        },
        "baselineState": {
          "description": "The state of a result relative to a baseline of a previous run.",
          "enum": ["new", "existing", "absent"]
        },
        "fixes": {
          "description": "An array of 'fix' objects, each of which represents a proposed fix to the problem indicated by the result.",
          "type": "array",
          "minItems": 1,
          "uniqueItems": true,
          "items": {
            "$ref": "#/definitions/fix"
          }
        },
        "properties": {
          "description": "Key/value pairs that provide additional information about the result.",
          "type": "object",
          "additionalProperties": true,
          "properties": {
            "tags": {
              "description": "A set of distinct strings that provide additional information.",
              "type": "array",
              "uniqueItems": true,
              "default": [],
              "items": {
                "type": "string"
              }
            }
          }
        }
      }
    },
    "rule": {
      "description": "Describes an analysis rule.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "id": {
          "description": "A stable, opaque identifier for the rule.",
          "type": "string"
        },
        "name": {
          "description": "A rule identifier that is understandable to an end user.",
          "type": "string"
        },
        "shortDescription": {
          "description": "A concise description of the rule. Should be a single sentence that is understandable when visible space is limited to a single line of text.",
          "type": "string"
        },
        "fullDescription": {
          "description": "A string that describes the rule. Should, as far as possible, provide details sufficient to enable resolution of any problem indicated by the result.",
          "type": "string"
        },
        "messageFormats": {
          "description": "A set of name/value pairs with arbitrary names. The value within each name/value pair shall consist of plain text interspersed with placeholders, which can be used to format a message in combination with an arbitrary number of additional string arguments.",
          "type": "object"
        },
        "defaultLevel": {
          "description": "A value specifying the default severity level of the result.",
          "default": "warning",
          "enum": ["note", "warning", "error"]
        },
        "helpUri": {
          "description": "A URI where the primary documentation for the rule can be found.",
          "type": "string",
          "format": "uri"
        },
        "properties": {
          "description": "Key/value pairs that provide additional information about the rule.",
          "type": "object",
          "additionalProperties": true,
          "properties": {
            "tags": {
              "description": "A set of distinct strings that provide additional information.",
              "type": "array",
              "uniqueItems": true,
              "default": [],
              "items": {
                "type": "string"
              }
            }
          }
        }
      },
      "required": ["id"]
    },
    "run": {
      "description": "Describes a single run of an analysis tool, and contains the output of that run.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "tool": {
          "description": "Information about the tool or tool pipeline that generated the results in this run. A run can only contain results produced by a single tool or tool pipeline. A run can aggregate results from multiple log files, as long as context around the tool run (tool command-line arguments and the like) is identical for all aggregated files.",
          "$ref": "#/definitions/tool"
        },
        "invocation": {
          "description": "Describes the runtime environment, including parameterization, of the analysis tool run.",
          "$ref": "#/definitions/invocation"
        },
        "files": {
          "description": "A dictionary, each of whose keys is a URI and each of whose values is an array of file objects representing the location of a single file scanned during the run.",
          "type": "object",
          "additionalProperties": {
            "$ref": "#/definitions/file"
          }
        },
        "logicalLocations": {
          "description": "A dictionary, each of whose keys specifies a logical location such as a namespace, type or function.",
          "type": "object",
          "additionalProperties": {
            "$ref": "#/definitions/logicalLocation"
          }
        },
        "results": {
          "description": "The set of results contained in an SARIF log. The results array can be omitted when a run is solely exporting rules metadata. It must be present (but may be empty) in the event that a log file represents an actual scan.",
          "type": "array",
          "minItems": 0,
          "uniqueItems": true,
          "items": {
            "$ref": "#/definitions/result"
          }
        },
        "toolNotifications": {
          "description": "A list of runtime conditions detected by the tool in the course of the analysis.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/notification"
          }
        },
        "configurationNotifications": {
          "description": "A list of conditions detected by the tool that are relevant to the tool's configuration.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/notification"
          }
        },
        "rules": {
          "description": "A dictionary, each of whose keys is a string and each of whose values is a 'rule' object, that describe all rules associated with an analysis tool or a specific run of an analysis tool.",
          "type": "object",
          "additionalProperties": {
            "$ref": "#/definitions/rule"
          }
        },
        "id": {
          "description": "An identifier for the run.",
          "type": "string"
        },
        "stableId": {
          "description": "A stable identifier for a run, for example, 'nightly Clang analyzer run'. Multiple runs of the same type can have the same stableId.",
          "type": "string"
        },
        "automationId": {
          "description": "A global identifier that allows the run to be correlated with other artifacts produced by a larger automation process.",
          "type": "string"
        },
        "baselineId": {
          "description": "The 'id' property of a separate (potentially external) SARIF 'run' instance that comprises the baseline that was used to compute result 'baselineState' properties for the run.",
          "type": "string"
        },
        "architecture": {
          "description": "The hardware architecture for which the run was targeted.",
          "type": "string"
        }
      },
      "required": ["tool"]
    },
    "stack": {
      "description": "A call stack that is relevant to a result.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "message": {
          "description": "A message relevant to this call stack.",
          "type": "string"
        },
        "frames": {
          "description": "An array of stack frames that represent a sequence of calls, rendered in reverse chronological order, that comprise the call stack.",
          "type": "array",
          "minItems": 1,
          "items": {
            "$ref": "#/definitions/stackFrame"
          }
        },
        "properties": {
          "description": "Key/value pairs that provide additional information about the stack.",
          "type": "object",
          "additionalProperties": true,
          "properties": {
            "tags": {
              "description": "A set of distinct strings that provide additional information.",
              "type": "array",
              "uniqueItems": true,
              "default": [],
              "items": {
                "type": "string"
              }
            }
          }
        }
      },
      "required": ["frames"]
    },
    "stackFrame": {
      "description": "A function call within a stack trace.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "message": {
          "description": "A message relevant to this stack frame.",
          "type": "string"
        },
        "uri": {
          "description": "The uri of the source code file to which this stack frame refers.",
          "type": "string",
          "format": "uri"
        },
        "uriBaseId": {
          "description": "A string that identifies the conceptual base for the 'uri' property (if it is relative), e.g.,'$(SolutionDir)' or '%SRCROOT%'.",
          "type": "string"
        },
        "line": {
          "description": "The line of the location to which this stack frame refers.",
          "type": "integer"
        },
        "column": {
          "description": "The line of the location to which this stack frame refers.",
          "type": "integer"
        },
        "module": {
          "description": "The name of the module that contains the code of this stack frame.",
          "type": "string"
        },
        "threadId": {
          "description": "The thread identifier of the stack frame.",
          "type": "integer"
        },
        "fullyQualifiedLogicalName": {
          "description": "The fully qualified name of the method or function that is executing.",
          "type": "string"
        },
        "logicalLocationKey": {
          "description": "A key used to retrieve the stack frame logicalLocation from the logicalLocations dictionary, when the 'fullyQualifiedLogicalName' is not unique.",
          "type": "string"
        },
        "address": {
          "description": "The address of the method or function that is executing.",
          "type": "integer"
        },
        "offset": {
          "description": "The offset from the method or function that is executing.",
          "type": "integer"
        },
        "parameters": {
          "description": "The parameters of the call that is executing.",
          "type": "array",
          "items": {
            "type": "string",
            "default": []
          }
        },
        "properties": {
          "description": "Key/value pairs that provide additional information about the stack frame.",
          "type": "object",
          "additionalProperties": true,
          "properties": {
            "tags": {
              "description": "A set of distinct strings that provide additional information.",
              "type": "array",
              "uniqueItems": true,
              "default": [],
              "items": {
                "type": "string"
              }
            }
          }
        }
      },
      "required": ["fullyQualifiedLogicalName"],
      "dependencies": {
        "uriBaseId": ["uri"],
        "line": ["uri"],
        "column": ["line"]
      }
    },
    "tool": {
      "description": "The analysis tool that was run.",
      "additionalProperties": false,
      "type": "object",
      "properties": {
        "name": {
          "description": "The name of the tool.",
          "type": "string"
        },
        "fullName": {
          "description": "The name of the tool along with its version and any other useful identifying information, such as its locale.",
          "type": "string"
        },
        "version": {
          "description": "The tool version, in whatever format the tool natively provides.",
          "type": "string"
        },
        "semanticVersion": {
          "description": "The tool version in the format specified by Semantic Versioning 2.0.",
          "type": "string"
        },
        "fileVersion": {
          "description": "The binary version of the tool's primary executable file (for operating systems such as Windows that provide that information).",
          "type": "string",
          "pattern": "[0-9]+(\\.[0-9]+){3}"
        },
        "sarifLoggerVersion": {
          "description": "A version that uniquely identifies the SARIF logging component that generated this file, if it is versioned separately from the tool.",
          "type": "string"
        },
        "language": {
          "description": "The tool language (expressed as an ISO 649 two-letter lowercase culture code) and region (expressed as an ISO 3166 two-letter uppercase subculture code associated with a country or region).",
          "type": "string"
        },
        "properties": {
          "description": "Key/value pairs that provide additional information about the tool.",
          "type": "object",
          "additionalProperties": true,
          "properties": {
            "tags": {
              "description": "A set of distinct strings that provide additional information.",
              "type": "array",
              "uniqueItems": true,
              "default": [],
              "items": {
                "type": "string"
              }
            }
          }
        }
      },
      "required": ["name"]
    }
  },
  "description": "Static Analysis Results Format (SARIF) Version 1.0.0 JSON Schema: a standard format for the output of static analysis and other tools.",
  "id": "https://json.schemastore.org/sarif-1.0.0.json",
  "properties": {
    "$schema": {
      "description": "The URI of the JSON schema corresponding to the version.",
      "type": "string",
      "format": "uri"
    },
    "version": {
      "description": "The SARIF format version of this log file.",
      "enum": ["1.0.0"]
    },
    "runs": {
      "description": "The set of runs contained in this log file.",
      "type": "array",
      "minItems": 1,
      "items": {
        "$ref": "#/definitions/run"
      }
    }
  },
  "required": ["version", "runs"],
  "title": "Static Analysis Results Format (SARIF) Version 1.0.0 JSON Schema",
  "type": "object"
}
