content: {-# LANGUAGE DataKinds #-}
  {-# LANGUAGE DerivingStrategies #-}
  {-# LANGUAGE DuplicateRecordFields #-}
  {-# LANGUAGE ImportQualifiedPost #-}
  {-# LANGUAGE LambdaCase #-}
  {-# LANGUAGE OverloadedStrings #-}
  {-# LANGUAGE PatternSynonyms #-}
  {-# LANGUAGE RecordWildCards #-}
  {-# LANGUAGE StrictData #-}
  {-# LANGUAGE TypeFamilies #-}
  {-# LANGUAGE NoImplicitPrelude #-}
  {-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
  {-# OPTIONS_GHC -fno-warn-name-shadowing #-}
  {-# OPTIONS_GHC -fno-warn-unused-binds #-}
  {-# OPTIONS_GHC -fno-warn-unused-imports #-}
  {-# OPTIONS_GHC -fno-warn-unused-matches #-}
  
  -- |
  -- Module      : Gogol.WebSecurityScanner.Internal.Product
  -- Copyright   : (c) 2015-2025 Brendan Hay
  -- License     : Mozilla Public License, v. 2.0.
  -- Maintainer  : Brendan Hay <brendan.g.hay+gogol@gmail.com>
  --               Toni Cebrián <toni@tonicebrian.com>
  -- Stability   : auto-generated
  -- Portability : non-portable (GHC extensions)
  module Gogol.WebSecurityScanner.Internal.Product
    ( -- * Authentication
      Authentication (..),
      newAuthentication,
  
      -- * CrawledUrl
      CrawledUrl (..),
      newCrawledUrl,
  
      -- * CustomAccount
      CustomAccount (..),
      newCustomAccount,
  
      -- * Empty
      Empty (..),
      newEmpty,
  
      -- * Finding
      Finding (..),
      newFinding,
  
      -- * FindingTypeStats
      FindingTypeStats (..),
      newFindingTypeStats,
  
      -- * Form
      Form (..),
      newForm,
  
      -- * GoogleAccount
      GoogleAccount (..),
      newGoogleAccount,
  
      -- * Header
      Header (..),
      newHeader,
  
      -- * IapCredential
      IapCredential (..),
      newIapCredential,
  
      -- * IapTestServiceAccountInfo
      IapTestServiceAccountInfo (..),
      newIapTestServiceAccountInfo,
  
      -- * ListCrawledUrlsResponse
      ListCrawledUrlsResponse (..),
      newListCrawledUrlsResponse,
  
      -- * ListFindingTypeStatsResponse
      ListFindingTypeStatsResponse (..),
      newListFindingTypeStatsResponse,
  
      -- * ListFindingsResponse
      ListFindingsResponse (..),
      newListFindingsResponse,
  
      -- * ListScanConfigsResponse
      ListScanConfigsResponse (..),
      newListScanConfigsResponse,
  
      -- * ListScanRunsResponse
      ListScanRunsResponse (..),
      newListScanRunsResponse,
  
      -- * OutdatedLibrary
      OutdatedLibrary (..),
      newOutdatedLibrary,
  
      -- * ScanConfig
      ScanConfig (..),
      newScanConfig,
  
      -- * ScanConfigError
      ScanConfigError (..),
      newScanConfigError,
  
      -- * ScanRun
      ScanRun (..),
      newScanRun,
  
      -- * ScanRunErrorTrace
      ScanRunErrorTrace (..),
      newScanRunErrorTrace,
  
      -- * ScanRunWarningTrace
      ScanRunWarningTrace (..),
      newScanRunWarningTrace,
  
      -- * Schedule
      Schedule (..),
      newSchedule,
  
      -- * StartScanRunRequest
      StartScanRunRequest (..),
      newStartScanRunRequest,
  
      -- * StopScanRunRequest
      StopScanRunRequest (..),
      newStopScanRunRequest,
  
      -- * ViolatingResource
      ViolatingResource (..),
      newViolatingResource,
  
      -- * VulnerableHeaders
      VulnerableHeaders (..),
      newVulnerableHeaders,
  
      -- * VulnerableParameters
      VulnerableParameters (..),
      newVulnerableParameters,
  
      -- * Xss
      Xss (..),
      newXss,
  
      -- * Xxe
      Xxe (..),
      newXxe,
    )
  where
  
  import Gogol.Prelude qualified as Core
  import Gogol.WebSecurityScanner.Internal.Sum
  
  -- | Scan authentication configuration.
  --
  -- /See:/ 'newAuthentication' smart constructor.
  data Authentication = Authentication
    { -- | Authentication using a custom account.
      customAccount :: (Core.Maybe CustomAccount),
      -- | Authentication using a Google account.
      googleAccount :: (Core.Maybe GoogleAccount),
      -- | Authentication using Identity-Aware-Proxy (IAP).
      iapCredential :: (Core.Maybe IapCredential)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Authentication' with the minimum fields required to make a request.
  newAuthentication ::
    Authentication
  newAuthentication =
    Authentication
      { customAccount = Core.Nothing,
        googleAccount = Core.Nothing,
        iapCredential = Core.Nothing
      }
  
  instance Core.FromJSON Authentication where
    parseJSON =
      Core.withObject
        "Authentication"
        ( \o ->
            Authentication
              Core.<$> (o Core..:? "customAccount")
              Core.<*> (o Core..:? "googleAccount")
              Core.<*> (o Core..:? "iapCredential")
        )
  
  instance Core.ToJSON Authentication where
    toJSON Authentication {..} =
      Core.object
        ( Core.catMaybes
            [ ("customAccount" Core..=) Core.<$> customAccount,
              ("googleAccount" Core..=) Core.<$> googleAccount,
              ("iapCredential" Core..=) Core.<$> iapCredential
            ]
        )
  
  -- | A CrawledUrl resource represents a URL that was crawled during a ScanRun. Web Security Scanner Service crawls the web applications, following all links within the scope of sites, to find the URLs to test against.
  --
  -- /See:/ 'newCrawledUrl' smart constructor.
  data CrawledUrl = CrawledUrl
    { -- | Output only. The body of the request that was used to visit the URL.
      body :: (Core.Maybe Core.Text),
      -- | Output only. The http method of the request that was used to visit the URL, in uppercase.
      httpMethod :: (Core.Maybe Core.Text),
      -- | Output only. The URL that was crawled.
      url :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CrawledUrl' with the minimum fields required to make a request.
  newCrawledUrl ::
    CrawledUrl
  newCrawledUrl =
    CrawledUrl
      { body = Core.Nothing,
        httpMethod = Core.Nothing,
        url = Core.Nothing
      }
  
  instance Core.FromJSON CrawledUrl where
    parseJSON =
      Core.withObject
        "CrawledUrl"
        ( \o ->
            CrawledUrl
              Core.<$> (o Core..:? "body")
              Core.<*> (o Core..:? "httpMethod")
              Core.<*> (o Core..:? "url")
        )
  
  instance Core.ToJSON CrawledUrl where
    toJSON CrawledUrl {..} =
      Core.object
        ( Core.catMaybes
            [ ("body" Core..=) Core.<$> body,
              ("httpMethod" Core..=) Core.<$> httpMethod,
              ("url" Core..=) Core.<$> url
            ]
        )
  
  -- | Describes authentication configuration that uses a custom account.
  --
  -- /See:/ 'newCustomAccount' smart constructor.
  data CustomAccount = CustomAccount
    { -- | Required. The login form URL of the website.
      loginUrl :: (Core.Maybe Core.Text),
      -- | Required. Input only. The password of the custom account. The credential is stored encrypted and not returned in any response nor included in audit logs.
      password :: (Core.Maybe Core.Text),
      -- | Required. The user name of the custom account.
      username :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CustomAccount' with the minimum fields required to make a request.
  newCustomAccount ::
    CustomAccount
  newCustomAccount =
    CustomAccount
      { loginUrl = Core.Nothing,
        password = Core.Nothing,
        username = Core.Nothing
      }
  
  instance Core.FromJSON CustomAccount where
    parseJSON =
      Core.withObject
        "CustomAccount"
        ( \o ->
            CustomAccount
              Core.<$> (o Core..:? "loginUrl")
              Core.<*> (o Core..:? "password")
              Core.<*> (o Core..:? "username")
        )
  
  instance Core.ToJSON CustomAccount where
    toJSON CustomAccount {..} =
      Core.object
        ( Core.catMaybes
            [ ("loginUrl" Core..=) Core.<$> loginUrl,
              ("password" Core..=) Core.<$> password,
              ("username" Core..=) Core.<$> username
            ]
        )
  
  -- | A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }
  --
  -- /See:/ 'newEmpty' smart constructor.
  data Empty = Empty
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Empty' with the minimum fields required to make a request.
  newEmpty ::
    Empty
  newEmpty = Empty
  
  instance Core.FromJSON Empty where
    parseJSON = Core.withObject "Empty" (\o -> Core.pure Empty)
  
  instance Core.ToJSON Empty where
    toJSON = Core.const Core.emptyObject
  
  -- | A Finding resource represents a vulnerability instance identified during a ScanRun.
  --
  -- /See:/ 'newFinding' smart constructor.
  data Finding = Finding
    { -- | Output only. The body of the request that triggered the vulnerability.
      body :: (Core.Maybe Core.Text),
      -- | Output only. The description of the vulnerability.
      description :: (Core.Maybe Core.Text),
      -- | Output only. The URL where the browser lands when the vulnerability is detected.
      finalUrl :: (Core.Maybe Core.Text),
      -- | Output only. The type of the Finding. Detailed and up-to-date information on findings can be found here: https:\/\/cloud.google.com\/security-command-center\/docs\/how-to-remediate-web-security-scanner-findings
      findingType :: (Core.Maybe Core.Text),
      -- | Output only. An addon containing information reported for a vulnerability with an HTML form, if any.
      form :: (Core.Maybe Form),
      -- | Output only. If the vulnerability was originated from nested IFrame, the immediate parent IFrame is reported.
      frameUrl :: (Core.Maybe Core.Text),
      -- | Output only. The URL produced by the server-side fuzzer and used in the request that triggered the vulnerability.
      fuzzedUrl :: (Core.Maybe Core.Text),
      -- | Output only. The http method of the request that triggered the vulnerability, in uppercase.
      httpMethod :: (Core.Maybe Core.Text),
      -- | Output only. The resource name of the Finding. The name follows the format of \'projects\/{projectId}\/scanConfigs\/{scanConfigId}\/scanruns\/{scanRunId}\/findings\/{findingId}\'. The finding IDs are generated by the system.
      name :: (Core.Maybe Core.Text),
      -- | Output only. An addon containing information about outdated libraries.
      outdatedLibrary :: (Core.Maybe OutdatedLibrary),
      -- | Output only. The URL containing human-readable payload that user can leverage to reproduce the vulnerability.
      reproductionUrl :: (Core.Maybe Core.Text),
      -- | Output only. The severity level of the reported vulnerability.
      severity :: (Core.Maybe Finding_Severity),
      -- | Output only. The tracking ID uniquely identifies a vulnerability instance across multiple ScanRuns.
      trackingId :: (Core.Maybe Core.Text),
      -- | Output only. An addon containing detailed information regarding any resource causing the vulnerability such as JavaScript sources, image, audio files, etc.
      violatingResource :: (Core.Maybe ViolatingResource),
      -- | Output only. An addon containing information about vulnerable or missing HTTP headers.
      vulnerableHeaders :: (Core.Maybe VulnerableHeaders),
      -- | Output only. An addon containing information about request parameters which were found to be vulnerable.
      vulnerableParameters :: (Core.Maybe VulnerableParameters),
      -- | Output only. An addon containing information reported for an XSS, if any.
      xss :: (Core.Maybe Xss),
      -- | Output only. An addon containing information reported for an XXE, if any.
      xxe :: (Core.Maybe Xxe)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Finding' with the minimum fields required to make a request.
  newFinding ::
    Finding
  newFinding =
    Finding
      { body = Core.Nothing,
        description = Core.Nothing,
        finalUrl = Core.Nothing,
        findingType = Core.Nothing,
        form = Core.Nothing,
        frameUrl = Core.Nothing,
        fuzzedUrl = Core.Nothing,
        httpMethod = Core.Nothing,
        name = Core.Nothing,
        outdatedLibrary = Core.Nothing,
        reproductionUrl = Core.Nothing,
        severity = Core.Nothing,
        trackingId = Core.Nothing,
        violatingResource = Core.Nothing,
        vulnerableHeaders = Core.Nothing,
        vulnerableParameters = Core.Nothing,
        xss = Core.Nothing,
        xxe = Core.Nothing
      }
  
  instance Core.FromJSON Finding where
    parseJSON =
      Core.withObject
        "Finding"
        ( \o ->
            Finding
              Core.<$> (o Core..:? "body")
              Core.<*> (o Core..:? "description")
              Core.<*> (o Core..:? "finalUrl")
              Core.<*> (o Core..:? "findingType")
              Core.<*> (o Core..:? "form")
              Core.<*> (o Core..:? "frameUrl")
              Core.<*> (o Core..:? "fuzzedUrl")
              Core.<*> (o Core..:? "httpMethod")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "outdatedLibrary")
              Core.<*> (o Core..:? "reproductionUrl")
              Core.<*> (o Core..:? "severity")
              Core.<*> (o Core..:? "trackingId")
              Core.<*> (o Core..:? "violatingResource")
              Core.<*> (o Core..:? "vulnerableHeaders")
              Core.<*> (o Core..:? "vulnerableParameters")
              Core.<*> (o Core..:? "xss")
              Core.<*> (o Core..:? "xxe")
        )
  
  instance Core.ToJSON Finding where
    toJSON Finding {..} =
      Core.object
        ( Core.catMaybes
            [ ("body" Core..=) Core.<$> body,
              ("description" Core..=) Core.<$> description,
              ("finalUrl" Core..=) Core.<$> finalUrl,
              ("findingType" Core..=) Core.<$> findingType,
              ("form" Core..=) Core.<$> form,
              ("frameUrl" Core..=) Core.<$> frameUrl,
              ("fuzzedUrl" Core..=) Core.<$> fuzzedUrl,
              ("httpMethod" Core..=) Core.<$> httpMethod,
              ("name" Core..=) Core.<$> name,
              ("outdatedLibrary" Core..=) Core.<$> outdatedLibrary,
              ("reproductionUrl" Core..=) Core.<$> reproductionUrl,
              ("severity" Core..=) Core.<$> severity,
              ("trackingId" Core..=) Core.<$> trackingId,
              ("violatingResource" Core..=) Core.<$> violatingResource,
              ("vulnerableHeaders" Core..=) Core.<$> vulnerableHeaders,
              ("vulnerableParameters" Core..=) Core.<$> vulnerableParameters,
              ("xss" Core..=) Core.<$> xss,
              ("xxe" Core..=) Core.<$> xxe
            ]
        )
  
  -- | A FindingTypeStats resource represents stats regarding a specific FindingType of Findings under a given ScanRun.
  --
  -- /See:/ 'newFindingTypeStats' smart constructor.
  data FindingTypeStats = FindingTypeStats
    { -- | Output only. The count of findings belonging to this finding type.
      findingCount :: (Core.Maybe Core.Int32),
      -- | Output only. The finding type associated with the stats.
      findingType :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FindingTypeStats' with the minimum fields required to make a request.
  newFindingTypeStats ::
    FindingTypeStats
  newFindingTypeStats =
    FindingTypeStats
      { findingCount = Core.Nothing,
        findingType = Core.Nothing
      }
  
  instance Core.FromJSON FindingTypeStats where
    parseJSON =
      Core.withObject
        "FindingTypeStats"
        ( \o ->
            FindingTypeStats
              Core.<$> (o Core..:? "findingCount")
              Core.<*> (o Core..:? "findingType")
        )
  
  instance Core.ToJSON FindingTypeStats where
    toJSON FindingTypeStats {..} =
      Core.object
        ( Core.catMaybes
            [ ("findingCount" Core..=) Core.<$> findingCount,
              ("findingType" Core..=) Core.<$> findingType
            ]
        )
  
  -- | ! Information about a vulnerability with an HTML.
  --
  -- /See:/ 'newForm' smart constructor.
  data Form = Form
    { -- | ! The URI where to send the form when it\'s submitted.
      actionUri :: (Core.Maybe Core.Text),
      -- | ! The names of form fields related to the vulnerability.
      fields :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Form' with the minimum fields required to make a request.
  newForm ::
    Form
  newForm = Form {actionUri = Core.Nothing, fields = Core.Nothing}
  
  instance Core.FromJSON Form where
    parseJSON =
      Core.withObject
        "Form"
        ( \o ->
            Form
              Core.<$> (o Core..:? "actionUri")
              Core.<*> (o Core..:? "fields")
        )
  
  instance Core.ToJSON Form where
    toJSON Form {..} =
      Core.object
        ( Core.catMaybes
            [ ("actionUri" Core..=) Core.<$> actionUri,
              ("fields" Core..=) Core.<$> fields
            ]
        )
  
  -- | Describes authentication configuration that uses a Google account.
  --
  -- /See:/ 'newGoogleAccount' smart constructor.
  data GoogleAccount = GoogleAccount
    { -- | Required. Input only. The password of the Google account. The credential is stored encrypted and not returned in any response nor included in audit logs.
      password :: (Core.Maybe Core.Text),
      -- | Required. The user name of the Google account.
      username :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleAccount' with the minimum fields required to make a request.
  newGoogleAccount ::
    GoogleAccount
  newGoogleAccount =
    GoogleAccount {password = Core.Nothing, username = Core.Nothing}
  
  instance Core.FromJSON GoogleAccount where
    parseJSON =
      Core.withObject
        "GoogleAccount"
        ( \o ->
            GoogleAccount
              Core.<$> (o Core..:? "password")
              Core.<*> (o Core..:? "username")
        )
  
  instance Core.ToJSON GoogleAccount where
    toJSON GoogleAccount {..} =
      Core.object
        ( Core.catMaybes
            [ ("password" Core..=) Core.<$> password,
              ("username" Core..=) Core.<$> username
            ]
        )
  
  -- | Describes a HTTP Header.
  --
  -- /See:/ 'newHeader' smart constructor.
  data Header = Header
    { -- | Header name.
      name :: (Core.Maybe Core.Text),
      -- | Header value.
      value :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Header' with the minimum fields required to make a request.
  newHeader ::
    Header
  newHeader = Header {name = Core.Nothing, value = Core.Nothing}
  
  instance Core.FromJSON Header where
    parseJSON =
      Core.withObject
        "Header"
        ( \o ->
            Header Core.<$> (o Core..:? "name") Core.<*> (o Core..:? "value")
        )
  
  instance Core.ToJSON Header where
    toJSON Header {..} =
      Core.object
        ( Core.catMaybes
            [("name" Core..=) Core.<$> name, ("value" Core..=) Core.<$> value]
        )
  
  -- | Describes authentication configuration for Identity-Aware-Proxy (IAP).
  --
  -- /See:/ 'newIapCredential' smart constructor.
  newtype IapCredential = IapCredential
    { -- | Authentication configuration when Web-Security-Scanner service account is added in Identity-Aware-Proxy (IAP) access policies.
      iapTestServiceAccountInfo :: (Core.Maybe IapTestServiceAccountInfo)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'IapCredential' with the minimum fields required to make a request.
  newIapCredential ::
    IapCredential
  newIapCredential =
    IapCredential {iapTestServiceAccountInfo = Core.Nothing}
  
  instance Core.FromJSON IapCredential where
    parseJSON =
      Core.withObject
        "IapCredential"
        ( \o ->
            IapCredential Core.<$> (o Core..:? "iapTestServiceAccountInfo")
        )
  
  instance Core.ToJSON IapCredential where
    toJSON IapCredential {..} =
      Core.object
        ( Core.catMaybes
            [ ("iapTestServiceAccountInfo" Core..=)
                Core.<$> iapTestServiceAccountInfo
            ]
        )
  
  -- | Describes authentication configuration when Web-Security-Scanner service account is added in Identity-Aware-Proxy (IAP) access policies.
  --
  -- /See:/ 'newIapTestServiceAccountInfo' smart constructor.
  newtype IapTestServiceAccountInfo = IapTestServiceAccountInfo
    { -- | Required. Describes OAuth2 client id of resources protected by Identity-Aware-Proxy (IAP).
      targetAudienceClientId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'IapTestServiceAccountInfo' with the minimum fields required to make a request.
  newIapTestServiceAccountInfo ::
    IapTestServiceAccountInfo
  newIapTestServiceAccountInfo =
    IapTestServiceAccountInfo {targetAudienceClientId = Core.Nothing}
  
  instance Core.FromJSON IapTestServiceAccountInfo where
    parseJSON =
      Core.withObject
        "IapTestServiceAccountInfo"
        ( \o ->
            IapTestServiceAccountInfo
              Core.<$> (o Core..:? "targetAudienceClientId")
        )
  
  instance Core.ToJSON IapTestServiceAccountInfo where
    toJSON IapTestServiceAccountInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("targetAudienceClientId" Core..=)
                Core.<$> targetAudienceClientId
            ]
        )
  
  -- | Response for the @ListCrawledUrls@ method.
  --
  -- /See:/ 'newListCrawledUrlsResponse' smart constructor.
  data ListCrawledUrlsResponse = ListCrawledUrlsResponse
    { -- | The list of CrawledUrls returned.
      crawledUrls :: (Core.Maybe [CrawledUrl]),
      -- | Token to retrieve the next page of results, or empty if there are no more results in the list.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListCrawledUrlsResponse' with the minimum fields required to make a request.
  newListCrawledUrlsResponse ::
    ListCrawledUrlsResponse
  newListCrawledUrlsResponse =
    ListCrawledUrlsResponse
      { crawledUrls = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListCrawledUrlsResponse where
    parseJSON =
      Core.withObject
        "ListCrawledUrlsResponse"
        ( \o ->
            ListCrawledUrlsResponse
              Core.<$> (o Core..:? "crawledUrls")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListCrawledUrlsResponse where
    toJSON ListCrawledUrlsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("crawledUrls" Core..=) Core.<$> crawledUrls,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | Response for the @ListFindingTypeStats@ method.
  --
  -- /See:/ 'newListFindingTypeStatsResponse' smart constructor.
  newtype ListFindingTypeStatsResponse = ListFindingTypeStatsResponse
    { -- | The list of FindingTypeStats returned.
      findingTypeStats :: (Core.Maybe [FindingTypeStats])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListFindingTypeStatsResponse' with the minimum fields required to make a request.
  newListFindingTypeStatsResponse ::
    ListFindingTypeStatsResponse
  newListFindingTypeStatsResponse =
    ListFindingTypeStatsResponse {findingTypeStats = Core.Nothing}
  
  instance Core.FromJSON ListFindingTypeStatsResponse where
    parseJSON =
      Core.withObject
        "ListFindingTypeStatsResponse"
        ( \o ->
            ListFindingTypeStatsResponse
              Core.<$> (o Core..:? "findingTypeStats")
        )
  
  instance Core.ToJSON ListFindingTypeStatsResponse where
    toJSON ListFindingTypeStatsResponse {..} =
      Core.object
        ( Core.catMaybes
            [("findingTypeStats" Core..=) Core.<$> findingTypeStats]
        )
  
  -- | Response for the @ListFindings@ method.
  --
  -- /See:/ 'newListFindingsResponse' smart constructor.
  data ListFindingsResponse = ListFindingsResponse
    { -- | The list of Findings returned.
      findings :: (Core.Maybe [Finding]),
      -- | Token to retrieve the next page of results, or empty if there are no more results in the list.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListFindingsResponse' with the minimum fields required to make a request.
  newListFindingsResponse ::
    ListFindingsResponse
  newListFindingsResponse =
    ListFindingsResponse
      { findings = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListFindingsResponse where
    parseJSON =
      Core.withObject
        "ListFindingsResponse"
        ( \o ->
            ListFindingsResponse
              Core.<$> (o Core..:? "findings")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListFindingsResponse where
    toJSON ListFindingsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("findings" Core..=) Core.<$> findings,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | Response for the @ListScanConfigs@ method.
  --
  -- /See:/ 'newListScanConfigsResponse' smart constructor.
  data ListScanConfigsResponse = ListScanConfigsResponse
    { -- | Token to retrieve the next page of results, or empty if there are no more results in the list.
      nextPageToken :: (Core.Maybe Core.Text),
      -- | The list of ScanConfigs returned.
      scanConfigs :: (Core.Maybe [ScanConfig])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListScanConfigsResponse' with the minimum fields required to make a request.
  newListScanConfigsResponse ::
    ListScanConfigsResponse
  newListScanConfigsResponse =
    ListScanConfigsResponse
      { nextPageToken = Core.Nothing,
        scanConfigs = Core.Nothing
      }
  
  instance Core.FromJSON ListScanConfigsResponse where
    parseJSON =
      Core.withObject
        "ListScanConfigsResponse"
        ( \o ->
            ListScanConfigsResponse
              Core.<$> (o Core..:? "nextPageToken")
              Core.<*> (o Core..:? "scanConfigs")
        )
  
  instance Core.ToJSON ListScanConfigsResponse where
    toJSON ListScanConfigsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
              ("scanConfigs" Core..=) Core.<$> scanConfigs
            ]
        )
  
  -- | Response for the @ListScanRuns@ method.
  --
  -- /See:/ 'newListScanRunsResponse' smart constructor.
  data ListScanRunsResponse = ListScanRunsResponse
    { -- | Token to retrieve the next page of results, or empty if there are no more results in the list.
      nextPageToken :: (Core.Maybe Core.Text),
      -- | The list of ScanRuns returned.
      scanRuns :: (Core.Maybe [ScanRun])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListScanRunsResponse' with the minimum fields required to make a request.
  newListScanRunsResponse ::
    ListScanRunsResponse
  newListScanRunsResponse =
    ListScanRunsResponse
      { nextPageToken = Core.Nothing,
        scanRuns = Core.Nothing
      }
  
  instance Core.FromJSON ListScanRunsResponse where
    parseJSON =
      Core.withObject
        "ListScanRunsResponse"
        ( \o ->
            ListScanRunsResponse
              Core.<$> (o Core..:? "nextPageToken")
              Core.<*> (o Core..:? "scanRuns")
        )
  
  instance Core.ToJSON ListScanRunsResponse where
    toJSON ListScanRunsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
              ("scanRuns" Core..=) Core.<$> scanRuns
            ]
        )
  
  -- | Information reported for an outdated library.
  --
  -- /See:/ 'newOutdatedLibrary' smart constructor.
  data OutdatedLibrary = OutdatedLibrary
    { -- | URLs to learn more information about the vulnerabilities in the library.
      learnMoreUrls :: (Core.Maybe [Core.Text]),
      -- | The name of the outdated library.
      libraryName :: (Core.Maybe Core.Text),
      -- | The version number.
      version :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'OutdatedLibrary' with the minimum fields required to make a request.
  newOutdatedLibrary ::
    OutdatedLibrary
  newOutdatedLibrary =
    OutdatedLibrary
      { learnMoreUrls = Core.Nothing,
        libraryName = Core.Nothing,
        version = Core.Nothing
      }
  
  instance Core.FromJSON OutdatedLibrary where
    parseJSON =
      Core.withObject
        "OutdatedLibrary"
        ( \o ->
            OutdatedLibrary
              Core.<$> (o Core..:? "learnMoreUrls")
              Core.<*> (o Core..:? "libraryName")
              Core.<*> (o Core..:? "version")
        )
  
  instance Core.ToJSON OutdatedLibrary where
    toJSON OutdatedLibrary {..} =
      Core.object
        ( Core.catMaybes
            [ ("learnMoreUrls" Core..=) Core.<$> learnMoreUrls,
              ("libraryName" Core..=) Core.<$> libraryName,
              ("version" Core..=) Core.<$> version
            ]
        )
  
  -- | A ScanConfig resource contains the configurations to launch a scan.
  --
  -- /See:/ 'newScanConfig' smart constructor.
  data ScanConfig = ScanConfig
    { -- | The authentication configuration. If specified, service will use the authentication configuration during scanning.
      authentication :: (Core.Maybe Authentication),
      -- | The excluded URL patterns as described in https:\/\/cloud.google.com\/security-command-center\/docs\/how-to-use-web-security-scanner#excluding_urls
      blacklistPatterns :: (Core.Maybe [Core.Text]),
      -- | Required. The user provided display name of the ScanConfig.
      displayName :: (Core.Maybe Core.Text),
      -- | Controls export of scan configurations and results to Security Command Center.
      exportToSecurityCommandCenter :: (Core.Maybe ScanConfig_ExportToSecurityCommandCenter),
      -- | Whether to keep scanning even if most requests return HTTP error codes.
      ignoreHttpStatusErrors :: (Core.Maybe Core.Bool),
      latestRun :: (Core.Maybe ScanRun),
      -- | Whether the scan config is managed by Web Security Scanner, output only.
      managedScan :: (Core.Maybe Core.Bool),
      -- | The maximum QPS during scanning. A valid value ranges from 5 to 20 inclusively. If the field is unspecified or its value is set 0, server will default to 15. Other values outside of [5, 20] range will be rejected with INVALID_ARGUMENT error.
      maxQps :: (Core.Maybe Core.Int32),
      -- | Identifier. The resource name of the ScanConfig. The name follows the format of \'projects\/{projectId}\/scanConfigs\/{scanConfigId}\'. The ScanConfig IDs are generated by the system.
      name :: (Core.Maybe Core.Text),
      -- | The risk level selected for the scan
      riskLevel :: (Core.Maybe ScanConfig_RiskLevel),
      -- | The schedule of the ScanConfig.
      schedule :: (Core.Maybe Schedule),
      -- | Required. The starting URLs from which the scanner finds site pages.
      startingUrls :: (Core.Maybe [Core.Text]),
      -- | Whether the scan configuration has enabled static IP address scan feature. If enabled, the scanner will access applications from static IP addresses.
      staticIpScan :: (Core.Maybe Core.Bool),
      -- | Set of Google Cloud platforms targeted by the scan. If empty, APP_ENGINE will be used as a default.
      targetPlatforms :: (Core.Maybe [ScanConfig_TargetPlatformsItem]),
      -- | The user agent used during scanning.
      userAgent :: (Core.Maybe ScanConfig_UserAgent)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ScanConfig' with the minimum fields required to make a request.
  newScanConfig ::
    ScanConfig
  newScanConfig =
    ScanConfig
      { authentication = Core.Nothing,
        blacklistPatterns = Core.Nothing,
        displayName = Core.Nothing,
        exportToSecurityCommandCenter = Core.Nothing,
        ignoreHttpStatusErrors = Core.Nothing,
        latestRun = Core.Nothing,
        managedScan = Core.Nothing,
        maxQps = Core.Nothing,
        name = Core.Nothing,
        riskLevel = Core.Nothing,
        schedule = Core.Nothing,
        startingUrls = Core.Nothing,
        staticIpScan = Core.Nothing,
        targetPlatforms = Core.Nothing,
        userAgent = Core.Nothing
      }
  
  instance Core.FromJSON ScanConfig where
    parseJSON =
      Core.withObject
        "ScanConfig"
        ( \o ->
            ScanConfig
              Core.<$> (o Core..:? "authentication")
              Core.<*> (o Core..:? "blacklistPatterns")
              Core.<*> (o Core..:? "displayName")
              Core.<*> (o Core..:? "exportToSecurityCommandCenter")
              Core.<*> (o Core..:? "ignoreHttpStatusErrors")
              Core.<*> (o Core..:? "latestRun")
              Core.<*> (o Core..:? "managedScan")
              Core.<*> (o Core..:? "maxQps")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "riskLevel")
              Core.<*> (o Core..:? "schedule")
              Core.<*> (o Core..:? "startingUrls")
              Core.<*> (o Core..:? "staticIpScan")
              Core.<*> (o Core..:? "targetPlatforms")
              Core.<*> (o Core..:? "userAgent")
        )
  
  instance Core.ToJSON ScanConfig where
    toJSON ScanConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("authentication" Core..=) Core.<$> authentication,
              ("blacklistPatterns" Core..=) Core.<$> blacklistPatterns,
              ("displayName" Core..=) Core.<$> displayName,
              ("exportToSecurityCommandCenter" Core..=)
                Core.<$> exportToSecurityCommandCenter,
              ("ignoreHttpStatusErrors" Core..=) Core.<$> ignoreHttpStatusErrors,
              ("latestRun" Core..=) Core.<$> latestRun,
              ("managedScan" Core..=) Core.<$> managedScan,
              ("maxQps" Core..=) Core.<$> maxQps,
              ("name" Core..=) Core.<$> name,
              ("riskLevel" Core..=) Core.<$> riskLevel,
              ("schedule" Core..=) Core.<$> schedule,
              ("startingUrls" Core..=) Core.<$> startingUrls,
              ("staticIpScan" Core..=) Core.<$> staticIpScan,
              ("targetPlatforms" Core..=) Core.<$> targetPlatforms,
              ("userAgent" Core..=) Core.<$> userAgent
            ]
        )
  
  -- | Defines a custom error message used by CreateScanConfig and UpdateScanConfig APIs when scan configuration validation fails. It is also reported as part of a ScanRunErrorTrace message if scan validation fails due to a scan configuration error.
  --
  -- /See:/ 'newScanConfigError' smart constructor.
  data ScanConfigError = ScanConfigError
    { -- | Output only. Indicates the reason code for a configuration failure.
      code :: (Core.Maybe ScanConfigError_Code),
      -- | Output only. Indicates the full name of the ScanConfig field that triggers this error, for example \"scan/config.max/qps\". This field is provided for troubleshooting purposes only and its actual value can change in the future.
      fieldName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ScanConfigError' with the minimum fields required to make a request.
  newScanConfigError ::
    ScanConfigError
  newScanConfigError =
    ScanConfigError {code = Core.Nothing, fieldName = Core.Nothing}
  
  instance Core.FromJSON ScanConfigError where
    parseJSON =
      Core.withObject
        "ScanConfigError"
        ( \o ->
            ScanConfigError
              Core.<$> (o Core..:? "code")
              Core.<*> (o Core..:? "fieldName")
        )
  
  instance Core.ToJSON ScanConfigError where
    toJSON ScanConfigError {..} =
      Core.object
        ( Core.catMaybes
            [ ("code" Core..=) Core.<$> code,
              ("fieldName" Core..=) Core.<$> fieldName
            ]
        )
  
  -- | A ScanRun is a output-only resource representing an actual run of the scan. Next id: 12
  --
  -- /See:/ 'newScanRun' smart constructor.
  data ScanRun = ScanRun
    { -- | Output only. The time at which the ScanRun reached termination state - that the ScanRun is either finished or stopped by user.
      endTime :: (Core.Maybe Core.DateTime),
      -- | Output only. If result_state is an ERROR, this field provides the primary reason for scan\'s termination and more details, if such are available.
      errorTrace :: (Core.Maybe ScanRunErrorTrace),
      -- | Output only. The execution state of the ScanRun.
      executionState :: (Core.Maybe ScanRun_ExecutionState),
      -- | Output only. Whether the scan run has found any vulnerabilities.
      hasVulnerabilities :: (Core.Maybe Core.Bool),
      -- | Output only. The resource name of the ScanRun. The name follows the format of \'projects\/{projectId}\/scanConfigs\/{scanConfigId}\/scanRuns\/{scanRunId}\'. The ScanRun IDs are generated by the system.
      name :: (Core.Maybe Core.Text),
      -- | Output only. The percentage of total completion ranging from 0 to 100. If the scan is in queue, the value is 0. If the scan is running, the value ranges from 0 to 100. If the scan is finished, the value is 100.
      progressPercent :: (Core.Maybe Core.Int32),
      -- | Output only. The result state of the ScanRun. This field is only available after the execution state reaches \"FINISHED\".
      resultState :: (Core.Maybe ScanRun_ResultState),
      -- | Output only. The time at which the ScanRun started.
      startTime :: (Core.Maybe Core.DateTime),
      -- | Output only. The number of URLs crawled during this ScanRun. If the scan is in progress, the value represents the number of URLs crawled up to now.
      urlsCrawledCount :: (Core.Maybe Core.Int64),
      -- | Output only. The number of URLs tested during this ScanRun. If the scan is in progress, the value represents the number of URLs tested up to now. The number of URLs tested is usually larger than the number URLS crawled because typically a crawled URL is tested with multiple test payloads.
      urlsTestedCount :: (Core.Maybe Core.Int64),
      -- | Output only. A list of warnings, if such are encountered during this scan run.
      warningTraces :: (Core.Maybe [ScanRunWarningTrace])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ScanRun' with the minimum fields required to make a request.
  newScanRun ::
    ScanRun
  newScanRun =
    ScanRun
      { endTime = Core.Nothing,
        errorTrace = Core.Nothing,
        executionState = Core.Nothing,
        hasVulnerabilities = Core.Nothing,
        name = Core.Nothing,
        progressPercent = Core.Nothing,
        resultState = Core.Nothing,
        startTime = Core.Nothing,
        urlsCrawledCount = Core.Nothing,
        urlsTestedCount = Core.Nothing,
        warningTraces = Core.Nothing
      }
  
  instance Core.FromJSON ScanRun where
    parseJSON =
      Core.withObject
        "ScanRun"
        ( \o ->
            ScanRun
              Core.<$> (o Core..:? "endTime")
              Core.<*> (o Core..:? "errorTrace")
              Core.<*> (o Core..:? "executionState")
              Core.<*> (o Core..:? "hasVulnerabilities")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "progressPercent")
              Core.<*> (o Core..:? "resultState")
              Core.<*> (o Core..:? "startTime")
              Core.<*> (o Core..:? "urlsCrawledCount" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "urlsTestedCount" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "warningTraces")
        )
  
  instance Core.ToJSON ScanRun where
    toJSON ScanRun {..} =
      Core.object
        ( Core.catMaybes
            [ ("endTime" Core..=) Core.<$> endTime,
              ("errorTrace" Core..=) Core.<$> errorTrace,
              ("executionState" Core..=) Core.<$> executionState,
              ("hasVulnerabilities" Core..=) Core.<$> hasVulnerabilities,
              ("name" Core..=) Core.<$> name,
              ("progressPercent" Core..=) Core.<$> progressPercent,
              ("resultState" Core..=) Core.<$> resultState,
              ("startTime" Core..=) Core.<$> startTime,
              ("urlsCrawledCount" Core..=)
                Core.. Core.AsText
                Core.<$> urlsCrawledCount,
              ("urlsTestedCount" Core..=)
                Core.. Core.AsText
                Core.<$> urlsTestedCount,
              ("warningTraces" Core..=) Core.<$> warningTraces
            ]
        )
  
  -- | Output only. Defines an error trace message for a ScanRun.
  --
  -- /See:/ 'newScanRunErrorTrace' smart constructor.
  data ScanRunErrorTrace = ScanRunErrorTrace
    { -- | Output only. Indicates the error reason code.
      code :: (Core.Maybe ScanRunErrorTrace_Code),
      -- | Output only. If the scan encounters TOO/MANY/HTTP/ERRORS, this field indicates the most common HTTP error code, if such is available. For example, if this code is 404, the scan has encountered too many NOT/FOUND responses.
      mostCommonHttpErrorCode :: (Core.Maybe Core.Int32),
      -- | Output only. If the scan encounters SCAN/CONFIG/ISSUE error, this field has the error message encountered during scan configuration validation that is performed before each scan run.
      scanConfigError :: (Core.Maybe ScanConfigError)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ScanRunErrorTrace' with the minimum fields required to make a request.
  newScanRunErrorTrace ::
    ScanRunErrorTrace
  newScanRunErrorTrace =
    ScanRunErrorTrace
      { code = Core.Nothing,
        mostCommonHttpErrorCode = Core.Nothing,
        scanConfigError = Core.Nothing
      }
  
  instance Core.FromJSON ScanRunErrorTrace where
    parseJSON =
      Core.withObject
        "ScanRunErrorTrace"
        ( \o ->
            ScanRunErrorTrace
              Core.<$> (o Core..:? "code")
              Core.<*> (o Core..:? "mostCommonHttpErrorCode")
              Core.<*> (o Core..:? "scanConfigError")
        )
  
  instance Core.ToJSON ScanRunErrorTrace where
    toJSON ScanRunErrorTrace {..} =
      Core.object
        ( Core.catMaybes
            [ ("code" Core..=) Core.<$> code,
              ("mostCommonHttpErrorCode" Core..=)
                Core.<$> mostCommonHttpErrorCode,
              ("scanConfigError" Core..=) Core.<$> scanConfigError
            ]
        )
  
  -- | Output only. Defines a warning trace message for ScanRun. Warning traces provide customers with useful information that helps make the scanning process more effective.
  --
  -- /See:/ 'newScanRunWarningTrace' smart constructor.
  newtype ScanRunWarningTrace = ScanRunWarningTrace
    { -- | Output only. Indicates the warning code.
      code :: (Core.Maybe ScanRunWarningTrace_Code)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ScanRunWarningTrace' with the minimum fields required to make a request.
  newScanRunWarningTrace ::
    ScanRunWarningTrace
  newScanRunWarningTrace = ScanRunWarningTrace {code = Core.Nothing}
  
  instance Core.FromJSON ScanRunWarningTrace where
    parseJSON =
      Core.withObject
        "ScanRunWarningTrace"
        (\o -> ScanRunWarningTrace Core.<$> (o Core..:? "code"))
  
  instance Core.ToJSON ScanRunWarningTrace where
    toJSON ScanRunWarningTrace {..} =
      Core.object (Core.catMaybes [("code" Core..=) Core.<$> code])
  
  -- | Scan schedule configuration.
  --
  -- /See:/ 'newSchedule' smart constructor.
  data Schedule = Schedule
    { -- | Required. The duration of time between executions in days.
      intervalDurationDays :: (Core.Maybe Core.Int32),
      -- | A timestamp indicates when the next run will be scheduled. The value is refreshed by the server after each run. If unspecified, it will default to current server time, which means the scan will be scheduled to start immediately.
      scheduleTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Schedule' with the minimum fields required to make a request.
  newSchedule ::
    Schedule
  newSchedule =
    Schedule
      { intervalDurationDays = Core.Nothing,
        scheduleTime = Core.Nothing
      }
  
  instance Core.FromJSON Schedule where
    parseJSON =
      Core.withObject
        "Schedule"
        ( \o ->
            Schedule
              Core.<$> (o Core..:? "intervalDurationDays")
              Core.<*> (o Core..:? "scheduleTime")
        )
  
  instance Core.ToJSON Schedule where
    toJSON Schedule {..} =
      Core.object
        ( Core.catMaybes
            [ ("intervalDurationDays" Core..=) Core.<$> intervalDurationDays,
              ("scheduleTime" Core..=) Core.<$> scheduleTime
            ]
        )
  
  -- | Request for the @StartScanRun@ method.
  --
  -- /See:/ 'newStartScanRunRequest' smart constructor.
  data StartScanRunRequest = StartScanRunRequest
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StartScanRunRequest' with the minimum fields required to make a request.
  newStartScanRunRequest ::
    StartScanRunRequest
  newStartScanRunRequest = StartScanRunRequest
  
  instance Core.FromJSON StartScanRunRequest where
    parseJSON =
      Core.withObject
        "StartScanRunRequest"
        (\o -> Core.pure StartScanRunRequest)
  
  instance Core.ToJSON StartScanRunRequest where
    toJSON = Core.const Core.emptyObject
  
  -- | Request for the @StopScanRun@ method.
  --
  -- /See:/ 'newStopScanRunRequest' smart constructor.
  data StopScanRunRequest = StopScanRunRequest
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StopScanRunRequest' with the minimum fields required to make a request.
  newStopScanRunRequest ::
    StopScanRunRequest
  newStopScanRunRequest = StopScanRunRequest
  
  instance Core.FromJSON StopScanRunRequest where
    parseJSON =
      Core.withObject
        "StopScanRunRequest"
        (\o -> Core.pure StopScanRunRequest)
  
  instance Core.ToJSON StopScanRunRequest where
    toJSON = Core.const Core.emptyObject
  
  -- | Information regarding any resource causing the vulnerability such as JavaScript sources, image, audio files, etc.
  --
  -- /See:/ 'newViolatingResource' smart constructor.
  data ViolatingResource = ViolatingResource
    { -- | The MIME type of this resource.
      contentType :: (Core.Maybe Core.Text),
      -- | URL of this violating resource.
      resourceUrl :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ViolatingResource' with the minimum fields required to make a request.
  newViolatingResource ::
    ViolatingResource
  newViolatingResource =
    ViolatingResource
      { contentType = Core.Nothing,
        resourceUrl = Core.Nothing
      }
  
  instance Core.FromJSON ViolatingResource where
    parseJSON =
      Core.withObject
        "ViolatingResource"
        ( \o ->
            ViolatingResource
              Core.<$> (o Core..:? "contentType")
              Core.<*> (o Core..:? "resourceUrl")
        )
  
  instance Core.ToJSON ViolatingResource where
    toJSON ViolatingResource {..} =
      Core.object
        ( Core.catMaybes
            [ ("contentType" Core..=) Core.<$> contentType,
              ("resourceUrl" Core..=) Core.<$> resourceUrl
            ]
        )
  
  -- | Information about vulnerable or missing HTTP Headers.
  --
  -- /See:/ 'newVulnerableHeaders' smart constructor.
  data VulnerableHeaders = VulnerableHeaders
    { -- | List of vulnerable headers.
      headers :: (Core.Maybe [Header]),
      -- | List of missing headers.
      missingHeaders :: (Core.Maybe [Header])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'VulnerableHeaders' with the minimum fields required to make a request.
  newVulnerableHeaders ::
    VulnerableHeaders
  newVulnerableHeaders =
    VulnerableHeaders
      { headers = Core.Nothing,
        missingHeaders = Core.Nothing
      }
  
  instance Core.FromJSON VulnerableHeaders where
    parseJSON =
      Core.withObject
        "VulnerableHeaders"
        ( \o ->
            VulnerableHeaders
              Core.<$> (o Core..:? "headers")
              Core.<*> (o Core..:? "missingHeaders")
        )
  
  instance Core.ToJSON VulnerableHeaders where
    toJSON VulnerableHeaders {..} =
      Core.object
        ( Core.catMaybes
            [ ("headers" Core..=) Core.<$> headers,
              ("missingHeaders" Core..=) Core.<$> missingHeaders
            ]
        )
  
  -- | Information about vulnerable request parameters.
  --
  -- /See:/ 'newVulnerableParameters' smart constructor.
  newtype VulnerableParameters = VulnerableParameters
    { -- | The vulnerable parameter names.
      parameterNames :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'VulnerableParameters' with the minimum fields required to make a request.
  newVulnerableParameters ::
    VulnerableParameters
  newVulnerableParameters =
    VulnerableParameters {parameterNames = Core.Nothing}
  
  instance Core.FromJSON VulnerableParameters where
    parseJSON =
      Core.withObject
        "VulnerableParameters"
        ( \o ->
            VulnerableParameters Core.<$> (o Core..:? "parameterNames")
        )
  
  instance Core.ToJSON VulnerableParameters where
    toJSON VulnerableParameters {..} =
      Core.object
        ( Core.catMaybes
            [("parameterNames" Core..=) Core.<$> parameterNames]
        )
  
  -- | Information reported for an XSS.
  --
  -- /See:/ 'newXss' smart constructor.
  data Xss = Xss
    { -- | The attack vector of the payload triggering this XSS.
      attackVector :: (Core.Maybe Xss_AttackVector),
      -- | An error message generated by a javascript breakage.
      errorMessage :: (Core.Maybe Core.Text),
      -- | Stack traces leading to the point where the XSS occurred.
      stackTraces :: (Core.Maybe [Core.Text]),
      -- | The reproduction url for the seeding POST request of a Stored XSS.
      storedXssSeedingUrl :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Xss' with the minimum fields required to make a request.
  newXss ::
    Xss
  newXss =
    Xss
      { attackVector = Core.Nothing,
        errorMessage = Core.Nothing,
        stackTraces = Core.Nothing,
        storedXssSeedingUrl = Core.Nothing
      }
  
  instance Core.FromJSON Xss where
    parseJSON =
      Core.withObject
        "Xss"
        ( \o ->
            Xss
              Core.<$> (o Core..:? "attackVector")
              Core.<*> (o Core..:? "errorMessage")
              Core.<*> (o Core..:? "stackTraces")
              Core.<*> (o Core..:? "storedXssSeedingUrl")
        )
  
  instance Core.ToJSON Xss where
    toJSON Xss {..} =
      Core.object
        ( Core.catMaybes
            [ ("attackVector" Core..=) Core.<$> attackVector,
              ("errorMessage" Core..=) Core.<$> errorMessage,
              ("stackTraces" Core..=) Core.<$> stackTraces,
              ("storedXssSeedingUrl" Core..=) Core.<$> storedXssSeedingUrl
            ]
        )
  
  -- | Information reported for an XXE.
  --
  -- /See:/ 'newXxe' smart constructor.
  data Xxe = Xxe
    { -- | Location within the request where the payload was placed.
      payloadLocation :: (Core.Maybe Xxe_PayloadLocation),
      -- | The XML string that triggered the XXE vulnerability. Non-payload values might be redacted.
      payloadValue :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Xxe' with the minimum fields required to make a request.
  newXxe ::
    Xxe
  newXxe =
    Xxe {payloadLocation = Core.Nothing, payloadValue = Core.Nothing}
  
  instance Core.FromJSON Xxe where
    parseJSON =
      Core.withObject
        "Xxe"
        ( \o ->
            Xxe
              Core.<$> (o Core..:? "payloadLocation")
              Core.<*> (o Core..:? "payloadValue")
        )
  
  instance Core.ToJSON Xxe where
    toJSON Xxe {..} =
      Core.object
        ( Core.catMaybes
            [ ("payloadLocation" Core..=) Core.<$> payloadLocation,
              ("payloadValue" Core..=) Core.<$> payloadValue
            ]
        )
  