Skip to content

Public data schemas

The scanner uses the following data schemas, described in JSON format.

Endpoint

View the schema
{
  "title": "Fuchsia HAR schema",
  "description": "Schema to describe Fuchsia HAR",
  "definitions": {
    "allowedHarFields": {
      "description": "Describe all fields allowed in HAR, check for required ones, deny any others",
      "type": "object",
      "required": [
        "method",
        "httpVersion",
        "url",
        "headers",
        "queryString",
        "bodySize"
      ],
      "properties": {
        "method": {"$ref": "har-types.json#/definitions/method"},
        "httpVersion": {"$ref": "har-types.json#/definitions/httpVersion"},
        "url": {"$ref": "common.json#/definitions/url"},
        "headers": {"$ref": "har-types.json#/definitions/headers"},
        "cookies": {"$ref": "har-types.json#/definitions/cookies"},
        "queryString": {"$ref": "har-types.json#/definitions/queryString"},
        "bodySize": {"type": "integer", "minimum": -1},
        "headersSize": {"type": "integer", "minimum": -1},
        "postData": {"$ref": "har-types.json#/definitions/postData"},
        "initiator": {
          "oneOf": [
            {"$ref": "har-initiator.json#/definitions/jsaInitiator"},
            {"$ref": "har-initiator.json#/definitions/dcInitiator"}
          ]
        },
        "jsonParamsInfo": {
          "type": "array",
          "items": {"$ref": "har-initiator.json#/definitions/jsonParamsInfo"}
        }
      },
      "additionalProperties": false
    },
    "onlyBaseHarFields": {
      "description": "Allow only base HAR fields & initiator, deny other analyzer-specific fields",
      "type": "object",
      "properties": {
        "method": {},
        "httpVersion": {},
        "url": {},
        "headers": {},
        "cookies": {},
        "queryString": {},
        "bodySize": {},
        "headersSize": {},
        "postData": {},
        "initiator": {}
      },
      "additionalProperties": false
    }
  },
  "allOf": [
    {"$ref": "#/definitions/allowedHarFields"},
    {
      "oneOf": [
        {"$ref": "#/definitions/onlyBaseHarFields"},
        {
          "type": "object",
          "required": ["initiator", "jsonParamsInfo", "postData"],
          "properties": {
            "initiator": {
              "$ref": "har-initiator.json#/definitions/dcInitiator"
            },
            "jsonParamsInfo": {},
            "postData": {
              "type": "object",
              "required": ["mimeType"],
              "properties": {
                "mimeType": {
                  "type": "string",
                  "pattern": "^application/json"
                }
              }
            }
          }
        }
      ]
    }
  ]
}

Issue

For the Dashboard

The public issue schema for the dashboard is available in Swagger in Schemas section.

For the Scanner

The scanner uses both the general issue schema and schemas that depend on the scanned object.

General issue schema

View the schema
{
  "title": "Fuchsia web application scanner issue schema",
  "description": "Old schema to describe web application scanner issue report for backward compatibility",
  "allOf": [
    {
      "type": "object",
      "required": ["issue", "analyzer", "url"],
      "properties": {
        "issue": {
          "$ref": "issue-common.json#/definitions/issueName"
        },
        "description": {
          "$ref": "issue-common.json#/definitions/issueDescription"
        },
        "analyzer": {
          "$ref": "issue-common.json#/definitions/analyzer"
        },
        "moduleName": {
          "$ref": "issue-common.json#/definitions/moduleName"
        },
        "url": {
          "$ref": "issue-common.json#/definitions/issueUrl"
        },
        "date": {
          "$ref": "issue-common.json#/definitions/issueDate"
        },
        "payloads": {
          "$ref": "issue-webapp.json#/definitions/payloads"
        },
        "dataflows": {
          "$ref": "issue-webapp.json#/definitions/dataflows"
        },
        "details": {
          "$ref": "issue-common.json#/definitions/details"
        }
      }
    },
    {
      "oneOf": [
        {"$ref": "issue-common.json#/definitions/issueNotFound"},
        {
          "allOf": [
            {"$ref": "issue-common.json#/definitions/issueFound"},
            {"$ref": "issue-common.json#/definitions/issueWithId"},
            {"$ref": "issue-common.json#/definitions/issueScore"},
            {"$ref": "issue-references.json#/definitions/issueReferences"}
          ]
        }
      ]
    }
  ]
}

Web application issue

View the schema
{
  "title": "Fuchsia web application issue schema",
  "description": "Schema to describe issue report produced by one of Fuchsia scanners for web application",
  "definitions": {
    "payload": {
      "title": "Single scanner payload",
      "description": "Single payload data inserted by scanner into HTTP request",
      "type": "object",
      "required": ["selector", "data"],
      "properties": {
        "selector": {
          "title": "Selector",
          "description": "Selector describes HTTP request part where payload was inserted to",
          "oneOf": [
            {
              "type": "string",
              "examples": [
                "old -> selector -> version",
                "for -> grace-period -> only"
              ]
            },
            {
              "type": "object",
              "required": ["type", "path"],
              "properties": {
                "type": {
                  "type": "string",
                  "enum": ["key", "value"]
                },
                "path": {
                  "type": "array",
                  "items": {
                    "type": ["string", "integer"],
                    "minimum": 0,
                    "minLength": 1
                  }
                }
              },
              "examples": [
                {
                  "type": "value",
                  "path": ["headers", "cookie", "user-token"]
                },
                {
                  "type": "value",
                  "path": ["cookies", "user-token"]
                },
                {
                  "type": "value",
                  "path": ["postData", "params", 1]
                },
                {
                  "type": "value",
                  "path": ["postData", "params", "LOGIN"]
                },
                {
                  "type": "value",
                  "path": ["url", "query", "foo"]
                },
                {
                  "type": "value",
                  "path": ["queryString", 0]
                },
                {
                  "type": "key",
                  "path": ["queryString", "foo"]
                }
              ]
            }
          ]
        },
        "data": {
          "title": "Attack vector",
          "description": "Payload data (attack vector) inserted into HTTP request",
          "type": "string",
          "examples": ["%3Cimg%20src=nonexist1%20onerror=alert()%3E"]
        }
      },
      "additionalProperties": false
    },
    "blobRef": {
      "title": "Blob reference",
      "description": "Reference to blob with single HTTP request/response data",
      "type": "object",
      "required": ["type", "ref"],
      "properties": {
        "type": {
          "type": "string",
          "enum": ["ref"]
        },
        "ref": {
          "$ref": "common.json#/definitions/url"
        }
      },
      "additionalProperties": false
    },
    "blobData": {
      "title": "Blob data",
      "description": "Base64-encoded blob with single HTTP request/response data",
      "type": "object",
      "required": ["type", "blob"],
      "properties": {
        "type": {
          "type": "string",
          "enum": ["blob"]
        },
        "blob": {
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "httpBlobOrRef": {
      "title": "HTTP blob or reference",
      "description": "Blob or reference to blob with single HTTP request/response data",
      "oneOf": [
        {
          "$ref": "#/definitions/blobRef"
        },
        {
          "$ref": "#/definitions/blobData"
        }
      ]
    },
    "request": {
      "title": "HTTP request",
      "description": "Single HTTP request data",
      "$ref": "#/definitions/httpBlobOrRef"
    },
    "response": {
      "title": "HTTP response",
      "description": "Single HTTP response data",
      "$ref": "#/definitions/httpBlobOrRef"
    },
    "transaction": {
      "title": "HTTP transaction",
      "description": "Single pair of HTTP request and response between scanner and web application",
      "type": "object",
      "properties": {
        "request": {"$ref": "#/definitions/request"},
        "response": {"$ref": "#/definitions/response"},
        "payload": {
          "type": "array",
          "items": {"$ref": "#/definitions/payload"}
        }
      }
    },
    "scannerProbe": {
      "title": "Scanner probe",
      "description": "Represent single scanner probe (some transactions with some payload) used to detect issue",
      "allOf": [
        {
          "type": "object",
          "properties": {
            "details": {
              "title": "Details",
              "description": "Human readable text with details about payload or vulnerability detecting/fingerprinting technique used by scanner",
              "type": "string",
              "examples": [
                "The application appears to evaluate user input as code..."
              ]
            }
          }
        },
        {
          "anyOf": [
            {
              "type": "object",
              "$ref": "#/definitions/transaction",
              "properties": {
                "request": {},
                "response": {},
                "payload": {},
                "details": {}
              },
              "additionalProperties": false
            },
            {
              "type": "object",
              "properties": {
                "transactions": {
                  "type": "array",
                  "items": {
                    "$ref": "#/definitions/transaction",
                    "additionalProperties": false
                  }
                },
                "details": {}
              },
              "additionalProperties": false
            }
          ]
        }
      ]
    },
    "payloads": {
      "title": "Payloads",
      "description": "Traffic between scanner and web application that demonstrates the presence of an issue",
      "type": "array",
      "items": {
        "$ref": "#/definitions/scannerProbe"
      }
    },
    "sourceCodeLocation": {
      "title": "Source code location",
      "description": "Source code location used to describe dataflow source or sink",
      "type": "object",
      "required": ["fileName", "column", "line"],
      "properties": {
        "functionName": {
          "title": "Location function name",
          "description": "Name of the function whose body contains source code location",
          "type": "string"
        },
        "fileName": {
          "title": "Location file name",
          "description": "Name of the source file that contains source code location",
          "type": "string"
        },
        "column": {
          "title": "Location column",
          "description": "Column in the file that refers to the source code location",
          "type": "number"
        },
        "line": {
          "title": "Location line",
          "description": "Column in the file that refers to the source code location",
          "type": "number"
        }
      }
    },
    "sourceOrSink": {
      "title": "Dataflow source or sink description",
      "description": "Sink or source description that contains its name and may contain its source code location",
      "type": "object",
      "required": ["name"],
      "properties": {
        "location": {
          "$ref": "#/definitions/sourceCodeLocation"
        },
        "name": {
          "title": "Source or sink name",
          "description": "Some label that identifies source or sink type",
          "type": "string"
        }
      }
    },
    "dataflows": {
      "title": "Webapp dataflows",
      "description": "Dataflows found in web application",
      "type": "array",
      "items": {
        "required": ["source", "sink", "value"],
        "type": "object",
        "properties": {
          "source": {
            "$ref": "#/definitions/sourceOrSink"
          },
          "sink": {
            "$ref": "#/definitions/sourceOrSink"
          },
          "value": {
            "title": "Dataflow final value",
            "description": "Data that has reached the sink",
            "oneOf": [
              {
                "title": "Stringified representation",
                "description": "Used in DOM XSS dataflows",
                "type": "string"
              },
              {
                "title": "Complex representation",
                "description": "Used in CSPP joint dataflows",
                "type": "object"
              }
            ]
          }
        }
      }
    },
    "issueWithUrl": {
      "title": "Issue URL",
      "description": "For web application issue specific URL is required in scanner report",
      "type": "object",
      "required": ["url"],
      "properties": {
        "url": {
          "$ref": "common.json#/definitions/url",
          "examples": ["https://example.com/admin/reset_password"]
        }
      }
    },
    "issueDetection": {
      "title": "Issue detection",
      "description": "Method used to detect issue: both method summary, traffic samples etc",
      "type": "object",
      "properties": {
        "detectionMethod": {
          "type": "object",
          "properties": {
            "summary": {
              "$ref": "issue-common.json#/definitions/issueDetectionSummary"
            },
            "payloads": {"$ref": "#/definitions/payloads"},
            "dataflows": {"$ref": "#/definitions/dataflows"}
          }
        }
      }
    },
    "issueTypeWebapp": {
      "type": "object",
      "required": ["issueType"],
      "properties": {
        "issueType": {
          "type": "string",
          "enum": ["Web Application"]
        }
      }
    }
  },
  "allOf": [
    {"$ref": "#/definitions/issueTypeWebapp"},
    {"$ref": "issue-common.json#/definitions/issueScanner"},
    {
      "oneOf": [
        {"$ref": "issue-common.json#/definitions/issueNotFound"},
        {
          "allOf": [
            {"$ref": "issue-common.json#/definitions/issueFound"},
            {"$ref": "issue-common.json#/definitions/issueWithId"},
            {"$ref": "#/definitions/issueWithUrl"},
            {"$ref": "#/definitions/issueDetection"},
            {"$ref": "issue-common.json#/definitions/issueScore"},
            {"$ref": "issue-references.json#/definitions/issueReferences"}
          ]
        }
      ]
    }
  ]
}

Network service issue

View the schema
{
  "title": "Fuchsia network service issue schema",
  "description": "Schema to describe issue report produced by one of Fuchsia scanners for network service",
  "definitions": {
    "issueFQDN": {
      "title": "FQDN",
      "description": "FQDN of scanned host",
      "type": "string",
      "format": "hostname"
    },
    "issueIP": {
      "title": "IP address",
      "description": "IP address of scanned host",
      "oneOf": [
        {
          "type": "string",
          "format": "ipv4"
        },
        {
          "type": "string",
          "format": "ipv6"
        }
      ]
    },
    "issuePort": {
      "title": "Network port",
      "description": "Port of service where issue was found",
      "type": "integer",
      "minimum": 1,
      "maximum": 65535
    },
    "issueOS": {
      "title": "OS",
      "description": "OS running the scanned service",
      "type": "string"
    },
    "issueServiceProtocol": {
      "title": "Service or protocol",
      "description": "Name of service and/or protocol on scanned port",
      "type": "string"
    },
    "issueSoftware": {
      "title": "Software",
      "description": "Name and version of scanned software",
      "type": "string"
    },
    "issueService": {
      "title": "Issue Service",
      "description": "Description of network service where issue was found",
      "type": "object",
      "required": ["port"],
      "properties": {
        "fqdn": {
          "$ref": "#/definitions/issueFQDN"
        },
        "ip": {
          "$ref": "#/definitions/issueIP"
        },
        "port": {
          "$ref": "#/definitions/issuePort"
        },
        "os": {
          "$ref": "#/definitions/issueOS"
        },
        "service": {
          "$ref": "#/definitions/issueServiceProtocol"
        },
        "software": {
          "$ref": "#/definitions/issueSoftware"
        }
      }
    },
    "issueDetection": {
      "title": "Issue detection",
      "description": "Method used to detect issue: both method summary, traffic samples etc",
      "type": "object",
      "properties": {
        "detectionMethod": {
          "type": "object",
          "properties": {
            "summary": {
              "$ref": "issue-common.json#/definitions/issueDetectionSummary"
            }
          }
        }
      }
    },
    "issueTypeNetworkService": {
      "type": "object",
      "required": ["issueType"],
      "properties": {
        "issueType": {
          "type": "string",
          "enum": ["Network Service"]
        }
      }
    }
  },
  "allOf": [
    {"$ref": "#/definitions/issueTypeNetworkService"},
    {"$ref": "issue-common.json#/definitions/issueScanner"},
    {
      "oneOf": [
        {"$ref": "issue-common.json#/definitions/issueNotFound"},
        {
          "allOf": [
            {"$ref": "issue-common.json#/definitions/issueFound"},
            {"$ref": "issue-common.json#/definitions/issueWithId"},
            {"$ref": "#/definitions/issueService"},
            {"$ref": "#/definitions/issueDetection"},
            {"$ref": "issue-common.json#/definitions/issueScore"},
            {"$ref": "issue-references.json#/definitions/issueReferences"}
          ]
        }
      ]
    }
  ]
}

Supporting schemas

Contain common descriptions for fields across different schemas.

issue-common schema

View the schema
{
  "title": "Fuchsia issue schema",
  "description": "Common definitions to describe Fuchsia issue report",
  "definitions": {
    "cveId": {
      "title": "CVE ID",
      "description": "CVE ID of issue found",
      "type": "string",
      "pattern": "CVE-[0-9]{4}-[0-9]{4,}",
      "examples": ["CVE-2021-44228"]
    },
    "cweId": {
      "title": "CWE ID",
      "description": "CWE ID of issue found",
      "type": "string",
      "pattern": "CWE-[0-9]+",
      "examples": ["CWE-89"]
    },
    "cvssMetrics": {
      "title": "CVSS metrics",
      "description": "CVSS Metrics of issue found",
      "type": "string",
      "examples": ["3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H"]
    },
    "cvssScore": {
      "title": "CVSS score",
      "description": "CVSS Score of issue found",
      "type": "number",
      "minimum": 0.0,
      "maximum": 10.0
    },
    "severity": {
      "title": "Severity",
      "description": "Severity of issue found",
      "type": "string",
      "enum": ["info", "low", "medium", "high", "critical", "unknown"]
    },
    "confidence": {
      "title": "Confidence",
      "description": "Confidence of analyzer tool that issue is actually present",
      "type": "string",
      "enum": ["tentative", "firm", "certain"]
    },
    "cve": {
      "title": "CVE list",
      "description": "List of CVE IDs associated with issue found",
      "type": "array",
      "items": {
        "$ref": "#/definitions/cveId"
      }
    },
    "cwe": {
      "title": "CWE list",
      "description": "List of CWE IDs associated with issue found",
      "type": "array",
      "items": {
        "$ref": "#/definitions/cweId"
      }
    },
    "cvss": {
      "title": "CVSS list",
      "description": "List of CVSS metrics and scores associated with issue found",
      "type": "array",
      "items": {
        "type": "object",
        "required": ["score", "metrics"],
        "properties": {
          "score": {
            "$ref": "#/definitions/cvssScore"
          },
          "metrics": {
            "$ref": "#/definitions/cvssMetrics"
          }
        },
        "additionalProperties": false
      }
    },
    "issueScore": {
      "type": "object",
      "required": ["severity", "confidence", "cvss", "cve", "cwe"],
      "properties": {
        "severity": {
          "$ref": "#/definitions/severity"
        },
        "confidence": {
          "$ref": "#/definitions/confidence"
        },
        "cvss": {
          "$ref": "#/definitions/cvss"
        },
        "cve": {
          "$ref": "#/definitions/cve"
        },
        "cwe": {
          "$ref": "#/definitions/cwe"
        }
      }
    },
    "issueDate": {
      "title": "Issue date",
      "description": "Date and time when issue was found or scanner detected an absence of issue",
      "type": "string",
      "format": "date-time"
    },
    "issueId": {
      "title": "Issue ID",
      "description": "Unique ID of issue (the same for multiple scanner runs against single target)",
      "type": "string"
    },
    "issueWithId": {
      "type": "object",
      "required": ["issueId"],
      "properties": {
        "issueId": {
          "$ref": "#/definitions/issueId"
        }
      }
    },
    "issueName": {
      "title": "Issue name",
      "description": "Short name of issue (like SQLi, DOM-based XSS, etc.)",
      "type": "string"
    },
    "issueDescription": {
      "title": "Issue description",
      "description": "Human-readable description of issue found",
      "type": "string"
    },
    "analyzer": {
      "title": "Analyzer name",
      "description": "Name of analyzer (scanner tool) found the issue",
      "type": "string"
    },
    "moduleName": {
      "title": "Module name",
      "description": "Technical name of module found the issue",
      "type": "string"
    },
    "issueUrl": {
      "title": "Issue URL",
      "description": "Specific URL of web application where issue was found",
      "$ref": "common.json#/definitions/url",
      "examples": ["https://example.com/admin/reset_password"]
    },
    "details": {
      "title": "Additional details",
      "description": "Additional optional details about issue",
      "type": "object"
    },
    "issueDetectionSummary": {
      "title": "Detection method summary",
      "description": "Short or full summary of method used to detect issue",
      "type": "string"
    },
    "issueScanner": {
      "type": "object",
      "required": ["issue", "analyzer"],
      "properties": {
        "issue": {
          "$ref": "#/definitions/issueName"
        },
        "description": {
          "$ref": "#/definitions/issueDescription"
        },
        "analyzer": {
          "$ref": "#/definitions/analyzer"
        },
        "moduleName": {
          "$ref": "#/definitions/moduleName"
        },
        "date": {
          "$ref": "#/definitions/issueDate"
        },
        "details": {
          "$ref": "#/definitions/details"
        }
      }
    },
    "issueFound": {
      "type": "object",
      "required": ["type"],
      "properties": {
        "type": {
          "type": "string",
          "enum": ["IssueFound"]
        }
      }
    },
    "issueNotFound": {
      "type": "object",
      "required": ["type"],
      "properties": {
        "type": {
          "type": "string",
          "enum": ["IssueNotFound"]
        }
      }
    }
  }
}

issue-references schema

View the schema
{
  "title": "Fuchsia issue references schema",
  "description": "Schema to describe issue meta-info and additional references",
  "definitions": {
    "issueImpact": {
      "title": "Impact",
      "description": "Possible impact of issue found",
      "type": "string"
    },
    "issueRemediation": {
      "title": "Remediation",
      "description": "Remediation steps for issue found",
      "type": "string"
    },
    "issueRefs": {
      "title": "References",
      "description": "References to additional information about issue found",
      "type": "array",
      "items": {
        "anyOf": [{"$ref": "common.json#/definitions/url"}, {"type": "string"}]
      }
    },
    "issuePatch": {
      "title": "Known patch",
      "description": "Known patch for service, software, framework or web application with given issue",
      "type": "object",
      "properties": {
        "link": {
          "title": "Link to patch",
          "description": "Reference to known patch",
          "$ref": "common.json#/definitions/url"
        },
        "date": {
          "title": "Release date",
          "description": "Known patch release date",
          "type": "string",
          "format": "date-time"
        },
        "installed": {
          "title": "Installed flag",
          "description": "Is known patch installed or not",
          "type": "boolean"
        }
      }
    },
    "issueReferences": {
      "title": "Issue references",
      "description": "Set of references and meta information about issue found",
      "type": "object",
      "required": [],
      "properties": {
        "impact": {
          "$ref": "#/definitions/issueImpact"
        },
        "remediation": {
          "$ref": "#/definitions/issueRemediation"
        },
        "references": {
          "$ref": "#/definitions/issueRefs"
        },
        "patches": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/issuePatch"
          }
        }
      }
    }
  }
}

Scan request

View the schema
{
  "definitions": {
    "ScanRequest": {
      "properties": {
        "url": {
          "type": "string",
          "description": "Base URL to scan."
        },
        "php": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.Php",
          "additionalProperties": true,
          "description": "Settings for the PHP scanner."
        },
        "expoSEAddress": {
          "type": "string",
          "description": "ExpoSE server base URL, including http:// and trailing /."
        },
        "modules": {
          "items": {
            "type": "string"
          },
          "type": "array",
          "description": "List of Fuchsia modules to run. If not set, all modules (except experimental) will be enabled. See ListModules method."
        },
        "proxyParams": {
          "items": {
            "$ref": "#/definitions/fuchsiad.ScanRequest.ProxyParams"
          },
          "type": "array"
        },
        "withDirbuster": {
          "type": "boolean",
          "description": "Enable dirbusting for static-crawler (enabled by default)."
        },
        "moduleParameters": {
          "additionalProperties": {
            "$ref": "#/definitions/fuchsiad.ModuleParameters",
            "additionalProperties": true
          },
          "type": "object",
          "description": "Per-module settings."
        },
        "proxyModuleParameters": {
          "$ref": "#/definitions/fuchsiad.ModuleParameters",
          "additionalProperties": true,
          "description": "Settings for the internal proxy server."
        },
        "rpsLimit": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.RPSLimit",
          "additionalProperties": true,
          "description": "RPS limit settings. If not set, no RPS limit is enforced."
        },
        "authCheckingConfig": {
          "items": {
            "$ref": "#/definitions/fuchsiad.ScanRequest.AuthCriterion"
          },
          "type": "array",
          "description": "List of auth checker conditions. If any of them fails (taking AuthCriterionKind and rounds settings into account), authentication checker calls auth refresher (if configured), or cancels the scan."
        },
        "domainScope": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.DomainScope",
          "additionalProperties": true,
          "description": "If not set, defaults to either second level (if it's ordinary domain) or exact match (if it's IP address or single label) of base scan URL."
        },
        "pageDeduplication": {
          "enum": [
            "PAGE_DEDUPLICATION_ENABLED",
            0,
            "PAGE_DEDUPLICATION_DISABLED",
            1
          ],
          "oneOf": [
            {
              "type": "string"
            },
            {
              "type": "integer"
            }
          ],
          "title": "Page Deduplication"
        },
        "depDeduplication": {
          "enum": [
            "DEP_DEDUPLICATION_DEFAULT",
            0,
            "DEP_DEDUPLICATION_NONE",
            1,
            "DEP_DEDUPLICATION_EXTENDED",
            2,
            "DEP_DEDUPLICATION_SIMPLE",
            3
          ],
          "oneOf": [
            {
              "type": "string"
            },
            {
              "type": "integer"
            }
          ],
          "title": "Dep Deduplication"
        },
        "regexpAuthRefresherConfig": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.RegexpAuthRefresherConfig",
          "additionalProperties": true
        },
        "browserAuthRefresherConfig": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.BrowserAuthRefresherConfig",
          "additionalProperties": true
        },
        "upstreamProxy": {
          "type": "string",
          "description": "Upstream proxy server to use. Supported protocols are \"http\", \"https\", and \"socks5\"."
        },
        "pageDedupUrlRegexps": {
          "items": {
            "type": "string"
          },
          "type": "array",
          "description": "Deduplicate HTML pages by regular expressions. The first page with URL matching the regular expression will be processed, the rest will be ignored."
        },
        "depDedupUrlRegexps": {
          "items": {
            "type": "string"
          },
          "type": "array",
          "description": "Deduplicate DEPs by regular expressions. The first DEP with URL matching the regular expression will be processed, the rest will be ignored."
        },
        "anomalyCheckerConfig": {
          "type": "string",
          "description": "Create anomaly checker with specified config. If this field is absent than no anomaly checker will be created. This feature is experimental, and the file format may change without notice.",
          "format": "binary",
          "binaryEncoding": "base64"
        },
        "dirbusterConfig": {
          "$ref": "#/definitions/dirbuster.proto.DirbusterConfig",
          "additionalProperties": true,
          "description": "Settings for dirbuster. Applied only if with_dirbuster is true."
        },
        "dumpRequests": {
          "type": "boolean",
          "description": "Dump full HTTP requests in log storage. Not enabled by default because we dont need to do it every scan and it takes a lot of space."
        },
        "scanTag": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.Tag",
          "additionalProperties": true,
          "description": "Tag describing the scan."
        },
        "webScanId": {
          "type": "string",
          "description": "ID of the parent web scan. Automatically set for scans created with `rescan`."
        },
        "networkScanId": {
          "type": "string",
          "description": "ID of the parent network scan."
        },
        "scanGroupId": {
          "type": "string",
          "description": "The scan group ID \u003e 0 that scan is a member of. Default / zero value means that the scan does not belong to any of the scan groups."
        },
        "pageDeduplicationSettings": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.PageDeduplicationSettings",
          "additionalProperties": true,
          "description": "Advanced page deduplication settings, applied only if page_deduplication is PAGE_DEDUPLICATION_ENABLED."
        },
        "dumpResponses": {
          "type": "boolean",
          "description": "Dump full HTTP responses in log storage. Not enabled by default because we dont need to do it every scan and it takes a lot of space."
        },
        "staticCrawlerMaxDepth": {
          "type": "integer",
          "description": "Maximum depth of visited pages during static crawling. If not set, the default from the crawler is used."
        },
        "staticCrawlerMaxLinks": {
          "type": "integer",
          "description": "Maximum number of links to follow during static crawling. If not set, the default from the crawler is used."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Scan Request",
      "description": "ScanRequest describes scan parameters."
    },
    "dirbuster.proto.DirbusterConfig": {
      "properties": {
        "wordlist": {
          "enum": ["WORDLIST_DEFAULT", 0],
          "oneOf": [
            {
              "type": "string"
            },
            {
              "type": "integer"
            }
          ],
          "title": "Wordlist",
          "description": "Predefined worldlists. One can pass custom wordlist via ScanRequest.module_parameters for module 'static-crawler' using extra_files entry named 'DirbusterWordlist'. Custom wordlist replaces the predefined one"
        },
        "rpsConfig": {
          "$ref": "#/definitions/dirbuster.proto.DirbusterConfig.RPSConfig",
          "additionalProperties": true,
          "description": "Config for RPS limiting and backoffs if critical status codes received (e.g. 429, 503)"
        },
        "statusCodesBlacklist": {
          "items": {
            "type": "integer"
          },
          "type": "array",
          "description": "Status codes excluded from dirbuster output. 404 is always blacklisted"
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Dirbuster Config"
    },
    "dirbuster.proto.DirbusterConfig.RPSConfig": {
      "properties": {
        "maxRps": {
          "type": "number",
          "description": "Initial RPS limit"
        },
        "baseExpDelay": {
          "pattern": "^([0-9]+\\.?[0-9]*|\\.[0-9]+)s$",
          "type": "string",
          "description": "Initial delay value for exponential backoff. The value must satisfy base_exp_delay \u003c= max_exp_delay",
          "format": "regex"
        },
        "maxExpDelay": {
          "pattern": "^([0-9]+\\.?[0-9]*|\\.[0-9]+)s$",
          "type": "string",
          "description": "Maximum delay value for exponential backoff. The value must satisfy base_exp_delay \u003c= max_exp_delay",
          "format": "regex"
        },
        "expDelayMultiplier": {
          "type": "number",
          "description": "Coefficient for step-by-step exponentiall backoff delay increase. `current_delay = previous_delay * exp_delay_multiplier`. The value must satisfy exp_delay_multiplier \u003e 0"
        },
        "backoffJitterMultiplier": {
          "type": "number",
          "description": "Coefficient for exponential backoff delay randomization. `randomized_delay = current_delay * (1 + rand([0,1]) * backoff_jitter_multiplier)`. The value must satisfy 0 \u003c= backoff_jitter_multiplier \u003c= 1"
        },
        "minRps": {
          "type": "number",
          "description": "RPS limit value, below which we will not fall in any case. The value must satisfy 0 \u003c min_rps \u003c= max_rps"
        },
        "maxFiniteRps": {
          "type": "number",
          "description": "When max_rps is +Inf, it is used as RPS decrease starting point"
        },
        "rpsDecreaseRatio": {
          "type": "number",
          "description": "Coefficient for RPS decrease. `current_rps = previous_rps * rps_decrease_ratio`. The value must satisfy 0 \u003c rps_decrease_ratio \u003c= 1"
        },
        "maxBackoffNum": {
          "type": "integer",
          "description": "RPS decrease attempts number after that RateController tells workers to stop. The value must satisfy max_backoff_num \u003e 0"
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "RPS Config",
      "description": "Default/non-present field values will be replaced with defaults defined in scanrequest/dirbuster.go."
    },
    "fuchsiad.ModuleParameters": {
      "properties": {
        "extraFiles": {
          "additionalProperties": {
            "$ref": "#/definitions/fuchsiad.ModuleParameters.FileInfo",
            "additionalProperties": true
          },
          "type": "object",
          "description": "Extra files to pass give to the module. Their interpretation depends on the specific module. The key is file name."
        },
        "extraSettings": {
          "additionalProperties": {
            "oneOf": [
              {
                "type": "array"
              },
              {
                "type": "boolean"
              },
              {
                "type": "number"
              },
              {
                "type": "object"
              },
              {
                "type": "string"
              }
            ],
            "title": "Value",
            "description": "`Value` represents a dynamically typed value which can be either null, a number, a string, a boolean, a recursive struct value, or a list of values. A producer of value is expected to set one of these variants. Absence of any variant indicates an error. The JSON representation for `Value` is JSON value."
          },
          "type": "object",
          "description": "Extra structured JSON data to pass to the module. Their interpretation depends on the specific module. The key is object name."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Module Parameters"
    },
    "fuchsiad.ModuleParameters.FileInfo": {
      "properties": {
        "inline": {
          "type": "string",
          "description": "File content specified inline in the Protobuf message.",
          "format": "binary",
          "binaryEncoding": "base64"
        },
        "s3object": {
          "type": "string",
          "description": "S3 object base name, i.e. excluding the extrafiles/ prefix."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "File Info"
    },
    "fuchsiad.RetryOptions": {
      "properties": {
        "maxRetries": {
          "type": "integer",
          "description": "Max attempts to retry an action."
        },
        "delay": {
          "pattern": "^([0-9]+\\.?[0-9]*|\\.[0-9]+)s$",
          "type": "string",
          "description": "Delay between retries.",
          "format": "regex"
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Retry Options",
      "description": "Basic retry options configurable through Protobuf."
    },
    "fuchsiad.ScanRequest.AuthCriterion": {
      "properties": {
        "kind": {
          "enum": ["UNSPECIFIED", 0, "PASSED", 1, "FAILED", 2],
          "oneOf": [
            {
              "type": "string"
            },
            {
              "type": "integer"
            }
          ],
          "title": "Auth Criterion Kind"
        },
        "request": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.Request",
          "additionalProperties": true,
          "description": "HTTP request to be made."
        },
        "responseConditions": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.AuthCriterion.ResponseConditions",
          "additionalProperties": true
        },
        "interval": {
          "pattern": "^([0-9]+\\.?[0-9]*|\\.[0-9]+)s$",
          "type": "string",
          "description": "Time interval for checking the criterion. Not set is equivalent to some default value.",
          "format": "regex"
        },
        "rounds": {
          "type": "integer",
          "description": "How many times in a row the check must be unfulfilled (or fulfilled for FAILED AuthCriterionKind respectively) for the authentication check to fail. Not set or zero is equivalent to some default value."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Auth Criterion"
    },
    "fuchsiad.ScanRequest.AuthCriterion.ResponseConditions": {
      "properties": {
        "statusCode": {
          "type": "integer",
          "description": "Criterion subject response HTTP status. If not equal, then criterion not fulfilled."
        },
        "body": {
          "type": "string",
          "description": "Criterion subject response body regexp. If not set, the check is skipped. If the regexp doesn't match, then criterion not fulfilled."
        },
        "headers": {
          "additionalProperties": {
            "type": "string"
          },
          "type": "object",
          "description": "Criterion subject response headers regexps. Any of the regexps doesn't match, the criterion not fulfilled."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Response Conditions"
    },
    "fuchsiad.ScanRequest.BrowserAuthRefresherConfig": {
      "properties": {
        "browserAuthenticatorName": {
          "type": "string",
          "description": "Base name of the browser authenticator executable. Must match with a file in /usr/libexec/fuchsia-external-authenticators/ dir."
        },
        "loginScript": {
          "$ref": "#/definitions/fuchsiad.ModuleParameters.FileInfo",
          "additionalProperties": true,
          "description": "File containing input for browser authenticator."
        },
        "outputExtractors": {
          "items": {
            "$ref": "#/definitions/fuchsiad.ScanRequest.BrowserAuthRefresherConfig.OutputExtractor"
          },
          "type": "array",
          "description": "List of directives describing how and from to extract the authentication data and how and where to inject it during the scan."
        },
        "retryOptions": {
          "$ref": "#/definitions/fuchsiad.RetryOptions",
          "additionalProperties": true,
          "description": "Describes how should we manage auth refreshing retries. Retry attempt is made after any refresh error (e.g. network errors, inability of access token retrieval, etc)."
        },
        "totpConfig": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.TotpConfig",
          "additionalProperties": true,
          "description": "TOTP configuration for placeholder replacement in the login script. If set, activates \u003c\u003cTOTP_CODE\u003e\u003e / \u003c\u003cTOTP_DIGIT_i\u003e\u003e placeholders replacement in the browser authenticator script."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Browser Auth Refresher Config"
    },
    "fuchsiad.ScanRequest.BrowserAuthRefresherConfig.OutputExtractor": {
      "properties": {
        "type": {
          "enum": [
            "TYPE_UNSPECIFIED",
            0,
            "TYPE_COOKIE",
            1,
            "TYPE_LOCAL_STORAGE",
            2,
            "TYPE_SESSION_STORAGE",
            3
          ],
          "oneOf": [
            {
              "type": "string"
            },
            {
              "type": "integer"
            }
          ],
          "title": "Type"
        },
        "selectors": {
          "items": {
            "type": "string"
          },
          "type": "array",
          "description": "Names of the entities that should be matched (i.e. cookie name or local storage key). If at least one of the selectors not matched, the refresh will be considered failed. Empty selectors mean there are no any requirements and refresher should use all the source data."
        },
        "extractSelectorsOnly": {
          "type": "boolean",
          "description": "Is it necessary to use all the data extracted from the source, or only those that are matched by selectors. Must not be true with empty selectors."
        },
        "proxyParams": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.ProxyParams",
          "additionalProperties": true,
          "description": "Proxy parameter to add after success. Depending on the ProxyParams.args, cookie value, header value, password, or JSON replacement value will be set, respectively. Supported only when type is TYPE_LOCAL_STORAGE or TYPE_SESSION_STORAGE. If proxy_params are nil when type is TYPE_LOCAL_STORAGE such extractor will put retrieved local storage (or its subset) into the ExtraFiles.BrowserSettings file which is passed to local storage depending modules via --browser-settings-file. proxy_params must be set when type is TYPE_SESSION_STORAGE."
        },
        "valueTransformationTemplate": {
          "type": "string",
          "description": "Template string (Go text/template) to post-process the extracted values. It will be rendered to named action `{{ .someSelectorName }} {{ .anotherSelectorName }}` parametrized by matched entities' names from selectors. E.g. extracted value of entity named \"auth_token\" should be substituted to Authorization header after `Bearer` special word, then ValueTransformationTemplate will be `Bearer {{ .auth_token }}`. Additional helper functions are available in templates: - extractJSON RAW_JSON \"field\" \"nested\" \"0\" for map keys and array indexes. - extractRegexp RAW_STRING \"pattern\" to extract by regular expression   (first capturing group if present, otherwise full match). Example for local storage key \"auth-data\": `Bearer {{ extractJSON (index . \"auth-data\") \"accessKey\" }}`. It is strongly recommended to use template form `{{ index . \"some-name\" }}` because text/template interprets some symbols (e.g. dashes) as control characters. Supported only when type is TYPE_LOCAL_STORAGE or TYPE_SESSION_STORAGE, and non-nil proxy_params."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Output Extractor",
      "description": "OutputExtractor describes how to process the output of the browser authenticator to refresh authentication during the scan."
    },
    "fuchsiad.ScanRequest.DomainScope": {
      "properties": {
        "domainFilteringMode": {
          "enum": ["Any", 0, "Same", 1, "Subdomain", 2, "SecondLevel", 3],
          "oneOf": [
            {
              "type": "string"
            },
            {
              "type": "integer"
            }
          ],
          "title": "Domain Filtering Mode"
        },
        "domainList": {
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Domain Scope"
    },
    "fuchsiad.ScanRequest.PageDeduplicationSettings": {
      "properties": {
        "maxPagesNumber": {
          "type": "integer",
          "description": "Max desired pages number that should remain after deduplication (0 for unlimited) The total number of pages may exceed this threshold in very rare cases but it will be close enough to it."
        },
        "minPagesNumber": {
          "type": "integer",
          "description": "When page deduplication is enabled, it will be applied only if the page count exceeds this value (0 means applied always). Default value is 10."
        },
        "urlPatternLearning": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.PageDeduplicationSettings.URLPatternLearningConfig",
          "additionalProperties": true,
          "description": "URL-pattern learning config for content-supervised clustering. When set, enables advanced URL-pattern generalization based on content similarity of sibling pages. All settings inside are optional, and empty URLPatternLearningConfig will set some adequate defaults."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Page Deduplication Settings",
      "description": "Advanced settings for page deduplication"
    },
    "fuchsiad.ScanRequest.PageDeduplicationSettings.URLPatternLearningConfig": {
      "properties": {
        "structThreshold": {
          "type": "integer",
          "description": "StructThreshold is the max median Hamming distance between sibling cluster medoids for a path position to be generalized to a wildcard. If nil, defaults to 2 * FingerprintThreshold."
        },
        "generalizationQuorum": {
          "type": "number",
          "description": "GeneralizationQuorum is the minimum fraction of homogeneous sibling groups required to declare a path position variable. If nil, defaults to 0.6."
        },
        "minSiblings": {
          "type": "integer",
          "description": "MinSiblings is the minimum number of sibling clusters in a context for it to count toward the generalization decision. A meaningful value is \u003e= 2. If 0, defaults to 2."
        },
        "minGroups": {
          "type": "integer",
          "description": "MinGroups is the minimum number of valid sibling groups that must vote on a path position before its homogeneity ratio is trusted. If 0, defaults to 1."
        },
        "deepCollapseLen": {
          "type": "integer",
          "description": "DeepCollapseLen, when \u003e 0, short-circuits per-position generalization for base clusters whose parentDir arity is \u003e= this depth: they are pooled into a single \"deep\" cluster per {host, kind} and left to greedy set cover. 0 (default) disables it."
        },
        "emergencyCollapseFloor": {
          "type": "integer",
          "description": "EmergencyCollapseFloor enables a last-resort cluster-merging escalation used only when MaxTotalPagesNum cannot otherwise be met. 0 (default) disables it."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "URL Pattern Learning Config"
    },
    "fuchsiad.ScanRequest.Php": {
      "properties": {
        "sources": {
          "type": "string",
          "description": "URL or local file path to PHP sources."
        },
        "entrypoints": {
          "type": "string",
          "description": "Comma-separated list of entrypoints."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Php"
    },
    "fuchsiad.ScanRequest.ProxyParams": {
      "properties": {
        "hostname": {
          "type": "string",
          "description": "Hostname to match. Hostname must not include a port. If not set, matches any hostname, and port has no effect as well."
        },
        "path": {
          "type": "string",
          "description": "Path prefix to match. Matches any path if not set."
        },
        "scheme": {
          "type": "string",
          "description": "Protocol scheme to match, e.g. http or https. Matches any scheme if not set. Ignored for cookies."
        },
        "port": {
          "type": "string",
          "description": "Port to match. If not set, assumes the default port of the scheme, i.e. 80 and 443 for http and https respectively. Has no effect if hostname is not specified. Ignored for cookies."
        },
        "regexp": {
          "type": "string",
          "description": "Regular expression to match against fully reconstructed request URI, e.g. https://example.com/a/b/c?whatever. Matches any URI if not set."
        },
        "bodyRegexp": {
          "type": "string",
          "description": "Regular expression to match against request body. If not set, matches any body."
        },
        "isAuth": {
          "type": "boolean",
          "description": "Whether the hook is related to authentication. If not set, it will be true for cookies and HTTP auth, and false in all other cases."
        },
        "cookie": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.ProxyParams.Cookie",
          "additionalProperties": true,
          "description": "Add specified cookie."
        },
        "header": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.ProxyParams.Header",
          "additionalProperties": true,
          "description": "Add specified header."
        },
        "httpAuth": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.ProxyParams.HTTPAuth",
          "additionalProperties": true,
          "description": "Add HTTP basic authentication header."
        },
        "blacklist": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.ProxyParams.Blacklist",
          "additionalProperties": true,
          "description": "Block HTTP request, return an error to the module."
        },
        "jsonReplacer": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.ProxyParams.JSONReplacer",
          "additionalProperties": true,
          "description": "Assuming request body is JSON, replace a value inside said JSON."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Proxy Params"
    },
    "fuchsiad.ScanRequest.ProxyParams.Blacklist": {
      "properties": {
        "exceptions": {
          "items": {
            "$ref": "#/definitions/fuchsiad.ScanRequest.ProxyParams.Blacklist.Exception"
          },
          "type": "array"
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Blacklist",
      "description": "Note that for blacklist, the only supported match condition is regexp."
    },
    "fuchsiad.ScanRequest.ProxyParams.Blacklist.Exception": {
      "properties": {
        "urlRegexp": {
          "type": "string",
          "description": "Regular expression to match against fully reconstructed request URI. If matched, the blacklist rule is skipped for this request."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Exception"
    },
    "fuchsiad.ScanRequest.ProxyParams.Cookie": {
      "properties": {
        "name": {
          "type": "string"
        },
        "value": {
          "type": "string"
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Cookie"
    },
    "fuchsiad.ScanRequest.ProxyParams.HTTPAuth": {
      "properties": {
        "username": {
          "type": "string"
        },
        "password": {
          "type": "string"
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "HTTP Auth"
    },
    "fuchsiad.ScanRequest.ProxyParams.Header": {
      "properties": {
        "name": {
          "type": "string"
        },
        "value": {
          "type": "string"
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Header"
    },
    "fuchsiad.ScanRequest.ProxyParams.JSONReplacer": {
      "properties": {
        "value": {
          "oneOf": [
            {
              "type": "array"
            },
            {
              "type": "boolean"
            },
            {
              "type": "number"
            },
            {
              "type": "object"
            },
            {
              "type": "string"
            }
          ],
          "title": "Value",
          "description": "`Value` represents a dynamically typed value which can be either null, a number, a string, a boolean, a recursive struct value, or a list of values. A producer of value is expected to set one of these variants. Absence of any variant indicates an error. The JSON representation for `Value` is JSON value."
        },
        "path": {
          "items": {
            "type": "string"
          },
          "type": "array",
          "description": "Path to JSON value. E.g. [\"auth\", \"token\"] for things like {\"auth\": {\"token\": \u003cINSERT HERE\u003e}}."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "JSON Replacer"
    },
    "fuchsiad.ScanRequest.RPSLimit": {
      "properties": {
        "rate": {
          "type": "number",
          "description": "Requests per second."
        },
        "burst": {
          "type": "integer",
          "description": "Burst value for the limiter. 1 is good default. 0 is invalid value. See https://en.wikipedia.org/wiki/Token_bucket."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "RPS Limit"
    },
    "fuchsiad.ScanRequest.RegexpAuthRefresherConfig": {
      "properties": {
        "request": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.Request",
          "additionalProperties": true,
          "description": "HTTP request to make to refresh authentication data. URL, headers, and body may contain Go templates."
        },
        "responseExtractors": {
          "items": {
            "$ref": "#/definitions/fuchsiad.ScanRequest.RegexpAuthRefresherConfig.ResponseExtractor"
          },
          "type": "array",
          "description": "Rules to extract proxy parameters and/or variables."
        },
        "placeholdersInitValues": {
          "additionalProperties": {
            "type": "string"
          },
          "type": "object",
          "description": "Initial values for variables (refresh tokens, etc.)."
        },
        "dropHooksBeforeRefreshRequest": {
          "type": "boolean",
          "description": "Ignore proxy_params created by the auth refresher itself when making HTTP request."
        },
        "retryOptions": {
          "$ref": "#/definitions/fuchsiad.RetryOptions",
          "additionalProperties": true,
          "description": "Describes how should we manage auth refreshing retries. Retry attempt is made after any refresh error (e.g. network errors, inability of access token retrieval, etc)."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Regexp Auth Refresher Config"
    },
    "fuchsiad.ScanRequest.RegexpAuthRefresherConfig.ResponseExtractor": {
      "properties": {
        "extractor": {
          "type": "string",
          "description": "Regular expression to match. Must contain exactly one capturing group, which will be used in proxy_params below."
        },
        "proxyParams": {
          "$ref": "#/definitions/fuchsiad.ScanRequest.ProxyParams",
          "additionalProperties": true,
          "description": "Proxy parameter to add after success. Depending on the ProxyParams.args, cookie value, header value, password, or JSON replacement value will be set, respectively."
        },
        "placeholderVariableName": {
          "type": "string",
          "description": "Variable name to save matched value. Can be used to save updated refresh token for later requests, for example."
        },
        "valueTransformationTemplate": {
          "type": "string",
          "description": "Template string (Go text/template) to post-process the value. E.g. \"Bearer {{ .Matched }}\" for Authorization header. Additional helper functions are available in templates: - extractJSON RAW_JSON \"field\" \"nested\" \"0\" for map keys and array indexes. - extractRegexp RAW_STRING \"pattern\" to extract by regular expression   (first capturing group if present, otherwise full match). If not set, matched value will be used as is."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Response Extractor"
    },
    "fuchsiad.ScanRequest.Request": {
      "properties": {
        "url": {
          "type": "string",
          "description": "URL of the criterion/refresh subject request"
        },
        "method": {
          "type": "string",
          "description": "Criterion/refresh subject request method"
        },
        "headers": {
          "additionalProperties": {
            "type": "string"
          },
          "type": "object",
          "description": "Criterion/refresh subject request headers"
        },
        "body": {
          "type": "string",
          "description": "Criterion/refresh subject request body"
        },
        "timeout": {
          "pattern": "^([0-9]+\\.?[0-9]*|\\.[0-9]+)s$",
          "type": "string",
          "description": "HTTP request timeout.",
          "format": "regex"
        },
        "ignoreRedirects": {
          "type": "boolean",
          "description": "Whether the client should ignore the redirects and stop at the first response. Implemented in auth checker only"
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Request",
      "description": "Request describes HTTP request for auth checker and refresher."
    },
    "fuchsiad.ScanRequest.Tag": {
      "properties": {
        "label": {
          "type": "string"
        },
        "attributes": {
          "oneOf": [
            {
              "type": "array"
            },
            {
              "type": "boolean"
            },
            {
              "type": "number"
            },
            {
              "type": "object"
            },
            {
              "type": "string"
            }
          ],
          "title": "Value",
          "description": "`Value` represents a dynamically typed value which can be either null, a number, a string, a boolean, a recursive struct value, or a list of values. A producer of value is expected to set one of these variants. Absence of any variant indicates an error. The JSON representation for `Value` is JSON value."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Tag"
    },
    "fuchsiad.ScanRequest.TotpConfig": {
      "properties": {
        "seed": {
          "type": "string",
          "description": "TOTP seed/secret (base32 encoded)."
        },
        "algorithm": {
          "enum": [
            "TOTP_ALGORITHM_UNSPECIFIED",
            0,
            "TOTP_ALGORITHM_SHA1",
            1,
            "TOTP_ALGORITHM_SHA256",
            2,
            "TOTP_ALGORITHM_SHA512",
            3
          ],
          "oneOf": [
            {
              "type": "string"
            },
            {
              "type": "integer"
            }
          ],
          "title": "Totp Algorithm",
          "description": "TOTP algorithm for generating one-time passwords."
        },
        "digits": {
          "type": "integer",
          "description": "Number of digits in the TOTP code (6, 7, 8). Default is 6."
        },
        "period": {
          "type": "integer",
          "description": "TOTP period in seconds (typically 30). Default is 30."
        }
      },
      "additionalProperties": true,
      "type": "object",
      "title": "Totp Config",
      "description": "TOTP configuration for placeholder replacement in the login script. If set, activates \u003c\u003cTOTP_CODE\u003e\u003e / \u003c\u003cTOTP_DIGIT_i\u003e\u003e placeholders replacement in the browser authenticator script."
    }
  }
}