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.SearchConsole.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.SearchConsole.Internal.Product
    ( -- * AmpInspectionResult
      AmpInspectionResult (..),
      newAmpInspectionResult,
  
      -- * AmpIssue
      AmpIssue (..),
      newAmpIssue,
  
      -- * ApiDataRow
      ApiDataRow (..),
      newApiDataRow,
  
      -- * ApiDimensionFilter
      ApiDimensionFilter (..),
      newApiDimensionFilter,
  
      -- * ApiDimensionFilterGroup
      ApiDimensionFilterGroup (..),
      newApiDimensionFilterGroup,
  
      -- * BlockedResource
      BlockedResource (..),
      newBlockedResource,
  
      -- * DetectedItems
      DetectedItems (..),
      newDetectedItems,
  
      -- * Image
      Image (..),
      newImage,
  
      -- * IndexStatusInspectionResult
      IndexStatusInspectionResult (..),
      newIndexStatusInspectionResult,
  
      -- * InspectUrlIndexRequest
      InspectUrlIndexRequest (..),
      newInspectUrlIndexRequest,
  
      -- * InspectUrlIndexResponse
      InspectUrlIndexResponse (..),
      newInspectUrlIndexResponse,
  
      -- * Item
      Item (..),
      newItem,
  
      -- * MobileFriendlyIssue
      MobileFriendlyIssue (..),
      newMobileFriendlyIssue,
  
      -- * MobileUsabilityInspectionResult
      MobileUsabilityInspectionResult (..),
      newMobileUsabilityInspectionResult,
  
      -- * MobileUsabilityIssue
      MobileUsabilityIssue (..),
      newMobileUsabilityIssue,
  
      -- * ResourceIssue
      ResourceIssue (..),
      newResourceIssue,
  
      -- * RichResultsInspectionResult
      RichResultsInspectionResult (..),
      newRichResultsInspectionResult,
  
      -- * RichResultsIssue
      RichResultsIssue (..),
      newRichResultsIssue,
  
      -- * RunMobileFriendlyTestRequest
      RunMobileFriendlyTestRequest (..),
      newRunMobileFriendlyTestRequest,
  
      -- * RunMobileFriendlyTestResponse
      RunMobileFriendlyTestResponse (..),
      newRunMobileFriendlyTestResponse,
  
      -- * SearchAnalyticsQueryRequest
      SearchAnalyticsQueryRequest (..),
      newSearchAnalyticsQueryRequest,
  
      -- * SearchAnalyticsQueryResponse
      SearchAnalyticsQueryResponse (..),
      newSearchAnalyticsQueryResponse,
  
      -- * SitemapsListResponse
      SitemapsListResponse (..),
      newSitemapsListResponse,
  
      -- * SitesListResponse
      SitesListResponse (..),
      newSitesListResponse,
  
      -- * TestStatus
      TestStatus (..),
      newTestStatus,
  
      -- * UrlInspectionResult
      UrlInspectionResult (..),
      newUrlInspectionResult,
  
      -- * WmxSite
      WmxSite (..),
      newWmxSite,
  
      -- * WmxSitemap
      WmxSitemap (..),
      newWmxSitemap,
  
      -- * WmxSitemapContent
      WmxSitemapContent (..),
      newWmxSitemapContent,
    )
  where
  
  import Gogol.Prelude qualified as Core
  import Gogol.SearchConsole.Internal.Sum
  
  -- | AMP inspection result of the live page or the current information from Google\'s index, depending on whether you requested a live inspection or not.
  --
  -- /See:/ 'newAmpInspectionResult' smart constructor.
  data AmpInspectionResult = AmpInspectionResult
    { -- | Index status of the AMP URL.
      ampIndexStatusVerdict :: (Core.Maybe AmpInspectionResult_AmpIndexStatusVerdict),
      -- | URL of the AMP that was inspected. If the submitted URL is a desktop page that refers to an AMP version, the AMP version will be inspected.
      ampUrl :: (Core.Maybe Core.Text),
      -- | Whether or not the page blocks indexing through a noindex rule.
      indexingState :: (Core.Maybe AmpInspectionResult_IndexingState),
      -- | A list of zero or more AMP issues found for the inspected URL.
      issues :: (Core.Maybe [AmpIssue]),
      -- | Last time this AMP version was crawled by Google. Absent if the URL was never crawled successfully.
      lastCrawlTime :: (Core.Maybe Core.DateTime),
      -- | Whether or not Google could fetch the AMP.
      pageFetchState :: (Core.Maybe AmpInspectionResult_PageFetchState),
      -- | Whether or not the page is blocked to Google by a robots.txt rule.
      robotsTxtState :: (Core.Maybe AmpInspectionResult_RobotsTxtState),
      -- | The status of the most severe error on the page. If a page has both warnings and errors, the page status is error. Error status means the page cannot be shown in Search results.
      verdict :: (Core.Maybe AmpInspectionResult_Verdict)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AmpInspectionResult' with the minimum fields required to make a request.
  newAmpInspectionResult ::
    AmpInspectionResult
  newAmpInspectionResult =
    AmpInspectionResult
      { ampIndexStatusVerdict = Core.Nothing,
        ampUrl = Core.Nothing,
        indexingState = Core.Nothing,
        issues = Core.Nothing,
        lastCrawlTime = Core.Nothing,
        pageFetchState = Core.Nothing,
        robotsTxtState = Core.Nothing,
        verdict = Core.Nothing
      }
  
  instance Core.FromJSON AmpInspectionResult where
    parseJSON =
      Core.withObject
        "AmpInspectionResult"
        ( \o ->
            AmpInspectionResult
              Core.<$> (o Core..:? "ampIndexStatusVerdict")
              Core.<*> (o Core..:? "ampUrl")
              Core.<*> (o Core..:? "indexingState")
              Core.<*> (o Core..:? "issues")
              Core.<*> (o Core..:? "lastCrawlTime")
              Core.<*> (o Core..:? "pageFetchState")
              Core.<*> (o Core..:? "robotsTxtState")
              Core.<*> (o Core..:? "verdict")
        )
  
  instance Core.ToJSON AmpInspectionResult where
    toJSON AmpInspectionResult {..} =
      Core.object
        ( Core.catMaybes
            [ ("ampIndexStatusVerdict" Core..=) Core.<$> ampIndexStatusVerdict,
              ("ampUrl" Core..=) Core.<$> ampUrl,
              ("indexingState" Core..=) Core.<$> indexingState,
              ("issues" Core..=) Core.<$> issues,
              ("lastCrawlTime" Core..=) Core.<$> lastCrawlTime,
              ("pageFetchState" Core..=) Core.<$> pageFetchState,
              ("robotsTxtState" Core..=) Core.<$> robotsTxtState,
              ("verdict" Core..=) Core.<$> verdict
            ]
        )
  
  -- | AMP issue.
  --
  -- /See:/ 'newAmpIssue' smart constructor.
  data AmpIssue = AmpIssue
    { -- | Brief description of this issue.
      issueMessage :: (Core.Maybe Core.Text),
      -- | Severity of this issue: WARNING or ERROR.
      severity :: (Core.Maybe AmpIssue_Severity)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AmpIssue' with the minimum fields required to make a request.
  newAmpIssue ::
    AmpIssue
  newAmpIssue =
    AmpIssue {issueMessage = Core.Nothing, severity = Core.Nothing}
  
  instance Core.FromJSON AmpIssue where
    parseJSON =
      Core.withObject
        "AmpIssue"
        ( \o ->
            AmpIssue
              Core.<$> (o Core..:? "issueMessage")
              Core.<*> (o Core..:? "severity")
        )
  
  instance Core.ToJSON AmpIssue where
    toJSON AmpIssue {..} =
      Core.object
        ( Core.catMaybes
            [ ("issueMessage" Core..=) Core.<$> issueMessage,
              ("severity" Core..=) Core.<$> severity
            ]
        )
  
  --
  -- /See:/ 'newApiDataRow' smart constructor.
  data ApiDataRow = ApiDataRow
    { clicks :: (Core.Maybe Core.Double),
      ctr :: (Core.Maybe Core.Double),
      impressions :: (Core.Maybe Core.Double),
      keys :: (Core.Maybe [Core.Text]),
      position :: (Core.Maybe Core.Double)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ApiDataRow' with the minimum fields required to make a request.
  newApiDataRow ::
    ApiDataRow
  newApiDataRow =
    ApiDataRow
      { clicks = Core.Nothing,
        ctr = Core.Nothing,
        impressions = Core.Nothing,
        keys = Core.Nothing,
        position = Core.Nothing
      }
  
  instance Core.FromJSON ApiDataRow where
    parseJSON =
      Core.withObject
        "ApiDataRow"
        ( \o ->
            ApiDataRow
              Core.<$> (o Core..:? "clicks")
              Core.<*> (o Core..:? "ctr")
              Core.<*> (o Core..:? "impressions")
              Core.<*> (o Core..:? "keys")
              Core.<*> (o Core..:? "position")
        )
  
  instance Core.ToJSON ApiDataRow where
    toJSON ApiDataRow {..} =
      Core.object
        ( Core.catMaybes
            [ ("clicks" Core..=) Core.<$> clicks,
              ("ctr" Core..=) Core.<$> ctr,
              ("impressions" Core..=) Core.<$> impressions,
              ("keys" Core..=) Core.<$> keys,
              ("position" Core..=) Core.<$> position
            ]
        )
  
  -- | A filter test to be applied to each row in the data set, where a match can return the row. Filters are string comparisons, and values and dimension names are not case-sensitive. Individual filters are either AND\'ed or OR\'ed within their parent filter group, according to the group\'s group type. You do not need to group by a specified dimension to filter against it.
  --
  -- /See:/ 'newApiDimensionFilter' smart constructor.
  data ApiDimensionFilter = ApiDimensionFilter
    { dimension :: (Core.Maybe ApiDimensionFilter_Dimension),
      expression :: (Core.Maybe Core.Text),
      operator :: (Core.Maybe ApiDimensionFilter_Operator)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ApiDimensionFilter' with the minimum fields required to make a request.
  newApiDimensionFilter ::
    ApiDimensionFilter
  newApiDimensionFilter =
    ApiDimensionFilter
      { dimension = Core.Nothing,
        expression = Core.Nothing,
        operator = Core.Nothing
      }
  
  instance Core.FromJSON ApiDimensionFilter where
    parseJSON =
      Core.withObject
        "ApiDimensionFilter"
        ( \o ->
            ApiDimensionFilter
              Core.<$> (o Core..:? "dimension")
              Core.<*> (o Core..:? "expression")
              Core.<*> (o Core..:? "operator")
        )
  
  instance Core.ToJSON ApiDimensionFilter where
    toJSON ApiDimensionFilter {..} =
      Core.object
        ( Core.catMaybes
            [ ("dimension" Core..=) Core.<$> dimension,
              ("expression" Core..=) Core.<$> expression,
              ("operator" Core..=) Core.<$> operator
            ]
        )
  
  -- | A set of dimension value filters to test against each row. Only rows that pass all filter groups will be returned. All results within a filter group are either AND\'ed or OR\'ed together, depending on the group type selected. All filter groups are AND\'ed together.
  --
  -- /See:/ 'newApiDimensionFilterGroup' smart constructor.
  data ApiDimensionFilterGroup = ApiDimensionFilterGroup
    { filters :: (Core.Maybe [ApiDimensionFilter]),
      groupType :: (Core.Maybe ApiDimensionFilterGroup_GroupType)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ApiDimensionFilterGroup' with the minimum fields required to make a request.
  newApiDimensionFilterGroup ::
    ApiDimensionFilterGroup
  newApiDimensionFilterGroup =
    ApiDimensionFilterGroup
      { filters = Core.Nothing,
        groupType = Core.Nothing
      }
  
  instance Core.FromJSON ApiDimensionFilterGroup where
    parseJSON =
      Core.withObject
        "ApiDimensionFilterGroup"
        ( \o ->
            ApiDimensionFilterGroup
              Core.<$> (o Core..:? "filters")
              Core.<*> (o Core..:? "groupType")
        )
  
  instance Core.ToJSON ApiDimensionFilterGroup where
    toJSON ApiDimensionFilterGroup {..} =
      Core.object
        ( Core.catMaybes
            [ ("filters" Core..=) Core.<$> filters,
              ("groupType" Core..=) Core.<$> groupType
            ]
        )
  
  -- | Blocked resource.
  --
  -- /See:/ 'newBlockedResource' smart constructor.
  newtype BlockedResource = BlockedResource
    { -- | URL of the blocked resource.
      url :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'BlockedResource' with the minimum fields required to make a request.
  newBlockedResource ::
    BlockedResource
  newBlockedResource = BlockedResource {url = Core.Nothing}
  
  instance Core.FromJSON BlockedResource where
    parseJSON =
      Core.withObject
        "BlockedResource"
        (\o -> BlockedResource Core.<$> (o Core..:? "url"))
  
  instance Core.ToJSON BlockedResource where
    toJSON BlockedResource {..} =
      Core.object (Core.catMaybes [("url" Core..=) Core.<$> url])
  
  -- | Rich Results items grouped by type.
  --
  -- /See:/ 'newDetectedItems' smart constructor.
  data DetectedItems = DetectedItems
    { -- | List of Rich Results items.
      items :: (Core.Maybe [Item]),
      -- | Rich Results type
      richResultType :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DetectedItems' with the minimum fields required to make a request.
  newDetectedItems ::
    DetectedItems
  newDetectedItems =
    DetectedItems
      { items = Core.Nothing,
        richResultType = Core.Nothing
      }
  
  instance Core.FromJSON DetectedItems where
    parseJSON =
      Core.withObject
        "DetectedItems"
        ( \o ->
            DetectedItems
              Core.<$> (o Core..:? "items")
              Core.<*> (o Core..:? "richResultType")
        )
  
  instance Core.ToJSON DetectedItems where
    toJSON DetectedItems {..} =
      Core.object
        ( Core.catMaybes
            [ ("items" Core..=) Core.<$> items,
              ("richResultType" Core..=) Core.<$> richResultType
            ]
        )
  
  -- | Describe image data.
  --
  -- /See:/ 'newImage' smart constructor.
  data Image = Image
    { -- | Image data in format determined by the mime type. Currently, the format will always be \"image\/png\", but this might change in the future.
      data' :: (Core.Maybe Core.Base64),
      -- | The mime-type of the image data.
      mimeType :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Image' with the minimum fields required to make a request.
  newImage ::
    Image
  newImage = Image {data' = Core.Nothing, mimeType = Core.Nothing}
  
  instance Core.FromJSON Image where
    parseJSON =
      Core.withObject
        "Image"
        ( \o ->
            Image
              Core.<$> (o Core..:? "data")
              Core.<*> (o Core..:? "mimeType")
        )
  
  instance Core.ToJSON Image where
    toJSON Image {..} =
      Core.object
        ( Core.catMaybes
            [ ("data" Core..=) Core.<$> data',
              ("mimeType" Core..=) Core.<$> mimeType
            ]
        )
  
  -- | Results of index status inspection for either the live page or the version in Google\'s index, depending on whether you requested a live inspection or not. For more information, see the <https://support.google.com/webmasters/answer/7440203 Index coverage report documentation>.
  --
  -- /See:/ 'newIndexStatusInspectionResult' smart constructor.
  data IndexStatusInspectionResult = IndexStatusInspectionResult
    { -- | Could Google find and index the page. More details about page indexing appear in \'indexing_state\'.
      coverageState :: (Core.Maybe Core.Text),
      -- | Primary crawler that was used by Google to crawl your site.
      crawledAs :: (Core.Maybe IndexStatusInspectionResult_CrawledAs),
      -- | The URL of the page that Google selected as canonical. If the page was not indexed, this field is absent.
      googleCanonical :: (Core.Maybe Core.Text),
      -- | Whether or not the page blocks indexing through a noindex rule.
      indexingState :: (Core.Maybe IndexStatusInspectionResult_IndexingState),
      -- | Last time this URL was crawled by Google using the <https://support.google.com/webmasters/answer/7440203#primary_crawler primary crawler>. Absent if the URL was never crawled successfully.
      lastCrawlTime :: (Core.Maybe Core.DateTime),
      -- | Whether or not Google could retrieve the page from your server. Equivalent to <https://support.google.com/webmasters/answer/9012289#index_coverage \"page fetch\"> in the URL inspection report.
      pageFetchState :: (Core.Maybe IndexStatusInspectionResult_PageFetchState),
      -- | URLs that link to the inspected URL, directly and indirectly.
      referringUrls :: (Core.Maybe [Core.Text]),
      -- | Whether or not the page is blocked to Google by a robots.txt rule.
      robotsTxtState :: (Core.Maybe IndexStatusInspectionResult_RobotsTxtState),
      -- | Any sitemaps that this URL was listed in, as known by Google. Not guaranteed to be an exhaustive list, especially if Google did not discover this URL through a sitemap. Absent if no sitemaps were found.
      sitemap :: (Core.Maybe [Core.Text]),
      -- | The URL that your page or site <https://developers.google.com/search/docs/advanced/crawling/consolidate-duplicate-urls?#define-canonical declares as canonical>. If you did not declare a canonical URL, this field is absent.
      userCanonical :: (Core.Maybe Core.Text),
      -- | High level verdict about whether the URL /is/ indexed (indexed status), or /can be/ indexed (live inspection).
      verdict :: (Core.Maybe IndexStatusInspectionResult_Verdict)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'IndexStatusInspectionResult' with the minimum fields required to make a request.
  newIndexStatusInspectionResult ::
    IndexStatusInspectionResult
  newIndexStatusInspectionResult =
    IndexStatusInspectionResult
      { coverageState = Core.Nothing,
        crawledAs = Core.Nothing,
        googleCanonical = Core.Nothing,
        indexingState = Core.Nothing,
        lastCrawlTime = Core.Nothing,
        pageFetchState = Core.Nothing,
        referringUrls = Core.Nothing,
        robotsTxtState = Core.Nothing,
        sitemap = Core.Nothing,
        userCanonical = Core.Nothing,
        verdict = Core.Nothing
      }
  
  instance Core.FromJSON IndexStatusInspectionResult where
    parseJSON =
      Core.withObject
        "IndexStatusInspectionResult"
        ( \o ->
            IndexStatusInspectionResult
              Core.<$> (o Core..:? "coverageState")
              Core.<*> (o Core..:? "crawledAs")
              Core.<*> (o Core..:? "googleCanonical")
              Core.<*> (o Core..:? "indexingState")
              Core.<*> (o Core..:? "lastCrawlTime")
              Core.<*> (o Core..:? "pageFetchState")
              Core.<*> (o Core..:? "referringUrls")
              Core.<*> (o Core..:? "robotsTxtState")
              Core.<*> (o Core..:? "sitemap")
              Core.<*> (o Core..:? "userCanonical")
              Core.<*> (o Core..:? "verdict")
        )
  
  instance Core.ToJSON IndexStatusInspectionResult where
    toJSON IndexStatusInspectionResult {..} =
      Core.object
        ( Core.catMaybes
            [ ("coverageState" Core..=) Core.<$> coverageState,
              ("crawledAs" Core..=) Core.<$> crawledAs,
              ("googleCanonical" Core..=) Core.<$> googleCanonical,
              ("indexingState" Core..=) Core.<$> indexingState,
              ("lastCrawlTime" Core..=) Core.<$> lastCrawlTime,
              ("pageFetchState" Core..=) Core.<$> pageFetchState,
              ("referringUrls" Core..=) Core.<$> referringUrls,
              ("robotsTxtState" Core..=) Core.<$> robotsTxtState,
              ("sitemap" Core..=) Core.<$> sitemap,
              ("userCanonical" Core..=) Core.<$> userCanonical,
              ("verdict" Core..=) Core.<$> verdict
            ]
        )
  
  -- | Index inspection request.
  --
  -- /See:/ 'newInspectUrlIndexRequest' smart constructor.
  data InspectUrlIndexRequest = InspectUrlIndexRequest
    { -- | Required. URL to inspect. Must be under the property specified in \"site_url\".
      inspectionUrl :: (Core.Maybe Core.Text),
      -- | Optional. An <https://en.wikipedia.org/wiki/IETF_language_tag IETF BCP-47> language code representing the requested language for translated issue messages, e.g. \"en-US\", \"or \"de-CH\". Default value is \"en-US\".
      languageCode :: (Core.Maybe Core.Text),
      -- | Required. The URL of the property as defined in Search Console. __Examples:__ @http:\/\/www.example.com\/@ for a URL-prefix property, or @sc-domain:example.com@ for a Domain property.
      siteUrl :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'InspectUrlIndexRequest' with the minimum fields required to make a request.
  newInspectUrlIndexRequest ::
    InspectUrlIndexRequest
  newInspectUrlIndexRequest =
    InspectUrlIndexRequest
      { inspectionUrl = Core.Nothing,
        languageCode = Core.Nothing,
        siteUrl = Core.Nothing
      }
  
  instance Core.FromJSON InspectUrlIndexRequest where
    parseJSON =
      Core.withObject
        "InspectUrlIndexRequest"
        ( \o ->
            InspectUrlIndexRequest
              Core.<$> (o Core..:? "inspectionUrl")
              Core.<*> (o Core..:? "languageCode")
              Core.<*> (o Core..:? "siteUrl")
        )
  
  instance Core.ToJSON InspectUrlIndexRequest where
    toJSON InspectUrlIndexRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("inspectionUrl" Core..=) Core.<$> inspectionUrl,
              ("languageCode" Core..=) Core.<$> languageCode,
              ("siteUrl" Core..=) Core.<$> siteUrl
            ]
        )
  
  -- | Index-Status inspection response.
  --
  -- /See:/ 'newInspectUrlIndexResponse' smart constructor.
  newtype InspectUrlIndexResponse = InspectUrlIndexResponse
    { -- | URL inspection results.
      inspectionResult :: (Core.Maybe UrlInspectionResult)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'InspectUrlIndexResponse' with the minimum fields required to make a request.
  newInspectUrlIndexResponse ::
    InspectUrlIndexResponse
  newInspectUrlIndexResponse =
    InspectUrlIndexResponse {inspectionResult = Core.Nothing}
  
  instance Core.FromJSON InspectUrlIndexResponse where
    parseJSON =
      Core.withObject
        "InspectUrlIndexResponse"
        ( \o ->
            InspectUrlIndexResponse Core.<$> (o Core..:? "inspectionResult")
        )
  
  instance Core.ToJSON InspectUrlIndexResponse where
    toJSON InspectUrlIndexResponse {..} =
      Core.object
        ( Core.catMaybes
            [("inspectionResult" Core..=) Core.<$> inspectionResult]
        )
  
  -- | A specific rich result found on the page.
  --
  -- /See:/ 'newItem' smart constructor.
  data Item = Item
    { -- | A list of zero or more rich result issues found for this instance.
      issues :: (Core.Maybe [RichResultsIssue]),
      -- | The user-provided name of this item.
      name :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Item' with the minimum fields required to make a request.
  newItem ::
    Item
  newItem = Item {issues = Core.Nothing, name = Core.Nothing}
  
  instance Core.FromJSON Item where
    parseJSON =
      Core.withObject
        "Item"
        ( \o ->
            Item Core.<$> (o Core..:? "issues") Core.<*> (o Core..:? "name")
        )
  
  instance Core.ToJSON Item where
    toJSON Item {..} =
      Core.object
        ( Core.catMaybes
            [ ("issues" Core..=) Core.<$> issues,
              ("name" Core..=) Core.<$> name
            ]
        )
  
  -- | Mobile-friendly issue.
  --
  -- /See:/ 'newMobileFriendlyIssue' smart constructor.
  newtype MobileFriendlyIssue = MobileFriendlyIssue
    { -- | Rule violated.
      rule :: (Core.Maybe MobileFriendlyIssue_Rule)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MobileFriendlyIssue' with the minimum fields required to make a request.
  newMobileFriendlyIssue ::
    MobileFriendlyIssue
  newMobileFriendlyIssue = MobileFriendlyIssue {rule = Core.Nothing}
  
  instance Core.FromJSON MobileFriendlyIssue where
    parseJSON =
      Core.withObject
        "MobileFriendlyIssue"
        (\o -> MobileFriendlyIssue Core.<$> (o Core..:? "rule"))
  
  instance Core.ToJSON MobileFriendlyIssue where
    toJSON MobileFriendlyIssue {..} =
      Core.object (Core.catMaybes [("rule" Core..=) Core.<$> rule])
  
  -- | Mobile-usability inspection results.
  --
  -- /See:/ 'newMobileUsabilityInspectionResult' smart constructor.
  data MobileUsabilityInspectionResult = MobileUsabilityInspectionResult
    { -- | A list of zero or more mobile-usability issues detected for this URL.
      issues :: (Core.Maybe [MobileUsabilityIssue]),
      -- | High-level mobile-usability inspection result for this URL.
      verdict :: (Core.Maybe MobileUsabilityInspectionResult_Verdict)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MobileUsabilityInspectionResult' with the minimum fields required to make a request.
  newMobileUsabilityInspectionResult ::
    MobileUsabilityInspectionResult
  newMobileUsabilityInspectionResult =
    MobileUsabilityInspectionResult
      { issues = Core.Nothing,
        verdict = Core.Nothing
      }
  
  instance Core.FromJSON MobileUsabilityInspectionResult where
    parseJSON =
      Core.withObject
        "MobileUsabilityInspectionResult"
        ( \o ->
            MobileUsabilityInspectionResult
              Core.<$> (o Core..:? "issues")
              Core.<*> (o Core..:? "verdict")
        )
  
  instance Core.ToJSON MobileUsabilityInspectionResult where
    toJSON MobileUsabilityInspectionResult {..} =
      Core.object
        ( Core.catMaybes
            [ ("issues" Core..=) Core.<$> issues,
              ("verdict" Core..=) Core.<$> verdict
            ]
        )
  
  -- | Mobile-usability issue.
  --
  -- /See:/ 'newMobileUsabilityIssue' smart constructor.
  data MobileUsabilityIssue = MobileUsabilityIssue
    { -- | Mobile-usability issue type.
      issueType :: (Core.Maybe MobileUsabilityIssue_IssueType),
      -- | Additional information regarding the issue.
      message :: (Core.Maybe Core.Text),
      -- | Not returned; reserved for future use.
      severity :: (Core.Maybe MobileUsabilityIssue_Severity)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MobileUsabilityIssue' with the minimum fields required to make a request.
  newMobileUsabilityIssue ::
    MobileUsabilityIssue
  newMobileUsabilityIssue =
    MobileUsabilityIssue
      { issueType = Core.Nothing,
        message = Core.Nothing,
        severity = Core.Nothing
      }
  
  instance Core.FromJSON MobileUsabilityIssue where
    parseJSON =
      Core.withObject
        "MobileUsabilityIssue"
        ( \o ->
            MobileUsabilityIssue
              Core.<$> (o Core..:? "issueType")
              Core.<*> (o Core..:? "message")
              Core.<*> (o Core..:? "severity")
        )
  
  instance Core.ToJSON MobileUsabilityIssue where
    toJSON MobileUsabilityIssue {..} =
      Core.object
        ( Core.catMaybes
            [ ("issueType" Core..=) Core.<$> issueType,
              ("message" Core..=) Core.<$> message,
              ("severity" Core..=) Core.<$> severity
            ]
        )
  
  -- | Information about a resource with issue.
  --
  -- /See:/ 'newResourceIssue' smart constructor.
  newtype ResourceIssue = ResourceIssue
    { -- | Describes a blocked resource issue.
      blockedResource :: (Core.Maybe BlockedResource)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ResourceIssue' with the minimum fields required to make a request.
  newResourceIssue ::
    ResourceIssue
  newResourceIssue = ResourceIssue {blockedResource = Core.Nothing}
  
  instance Core.FromJSON ResourceIssue where
    parseJSON =
      Core.withObject
        "ResourceIssue"
        (\o -> ResourceIssue Core.<$> (o Core..:? "blockedResource"))
  
  instance Core.ToJSON ResourceIssue where
    toJSON ResourceIssue {..} =
      Core.object
        ( Core.catMaybes
            [("blockedResource" Core..=) Core.<$> blockedResource]
        )
  
  -- | Rich-Results inspection result, including any rich results found at this URL.
  --
  -- /See:/ 'newRichResultsInspectionResult' smart constructor.
  data RichResultsInspectionResult = RichResultsInspectionResult
    { -- | A list of zero or more rich results detected on this page. Rich results that cannot even be parsed due to syntactic issues will not be listed here.
      detectedItems :: (Core.Maybe [DetectedItems]),
      -- | High-level rich results inspection result for this URL.
      verdict :: (Core.Maybe RichResultsInspectionResult_Verdict)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RichResultsInspectionResult' with the minimum fields required to make a request.
  newRichResultsInspectionResult ::
    RichResultsInspectionResult
  newRichResultsInspectionResult =
    RichResultsInspectionResult
      { detectedItems = Core.Nothing,
        verdict = Core.Nothing
      }
  
  instance Core.FromJSON RichResultsInspectionResult where
    parseJSON =
      Core.withObject
        "RichResultsInspectionResult"
        ( \o ->
            RichResultsInspectionResult
              Core.<$> (o Core..:? "detectedItems")
              Core.<*> (o Core..:? "verdict")
        )
  
  instance Core.ToJSON RichResultsInspectionResult where
    toJSON RichResultsInspectionResult {..} =
      Core.object
        ( Core.catMaybes
            [ ("detectedItems" Core..=) Core.<$> detectedItems,
              ("verdict" Core..=) Core.<$> verdict
            ]
        )
  
  -- | Severity and status of a single issue affecting a single rich result instance on a page.
  --
  -- /See:/ 'newRichResultsIssue' smart constructor.
  data RichResultsIssue = RichResultsIssue
    { -- | Rich Results issue type.
      issueMessage :: (Core.Maybe Core.Text),
      -- | Severity of this issue: WARNING, or ERROR. Items with an issue of status ERROR cannot appear with rich result features in Google Search results.
      severity :: (Core.Maybe RichResultsIssue_Severity)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RichResultsIssue' with the minimum fields required to make a request.
  newRichResultsIssue ::
    RichResultsIssue
  newRichResultsIssue =
    RichResultsIssue
      { issueMessage = Core.Nothing,
        severity = Core.Nothing
      }
  
  instance Core.FromJSON RichResultsIssue where
    parseJSON =
      Core.withObject
        "RichResultsIssue"
        ( \o ->
            RichResultsIssue
              Core.<$> (o Core..:? "issueMessage")
              Core.<*> (o Core..:? "severity")
        )
  
  instance Core.ToJSON RichResultsIssue where
    toJSON RichResultsIssue {..} =
      Core.object
        ( Core.catMaybes
            [ ("issueMessage" Core..=) Core.<$> issueMessage,
              ("severity" Core..=) Core.<$> severity
            ]
        )
  
  -- | Mobile-friendly test request.
  --
  -- /See:/ 'newRunMobileFriendlyTestRequest' smart constructor.
  data RunMobileFriendlyTestRequest = RunMobileFriendlyTestRequest
    { -- | Whether or not screenshot is requested. Default is false.
      requestScreenshot :: (Core.Maybe Core.Bool),
      -- | URL for inspection.
      url :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RunMobileFriendlyTestRequest' with the minimum fields required to make a request.
  newRunMobileFriendlyTestRequest ::
    RunMobileFriendlyTestRequest
  newRunMobileFriendlyTestRequest =
    RunMobileFriendlyTestRequest
      { requestScreenshot = Core.Nothing,
        url = Core.Nothing
      }
  
  instance Core.FromJSON RunMobileFriendlyTestRequest where
    parseJSON =
      Core.withObject
        "RunMobileFriendlyTestRequest"
        ( \o ->
            RunMobileFriendlyTestRequest
              Core.<$> (o Core..:? "requestScreenshot")
              Core.<*> (o Core..:? "url")
        )
  
  instance Core.ToJSON RunMobileFriendlyTestRequest where
    toJSON RunMobileFriendlyTestRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("requestScreenshot" Core..=) Core.<$> requestScreenshot,
              ("url" Core..=) Core.<$> url
            ]
        )
  
  -- | Mobile-friendly test response, including mobile-friendly issues and resource issues.
  --
  -- /See:/ 'newRunMobileFriendlyTestResponse' smart constructor.
  data RunMobileFriendlyTestResponse = RunMobileFriendlyTestResponse
    { -- | Test verdict, whether the page is mobile friendly or not.
      mobileFriendliness :: (Core.Maybe RunMobileFriendlyTestResponse_MobileFriendliness),
      -- | List of mobile-usability issues.
      mobileFriendlyIssues :: (Core.Maybe [MobileFriendlyIssue]),
      -- | Information about embedded resources issues.
      resourceIssues :: (Core.Maybe [ResourceIssue]),
      -- | Screenshot of the requested URL.
      screenshot :: (Core.Maybe Image),
      -- | Final state of the test, can be either complete or an error.
      testStatus :: (Core.Maybe TestStatus)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RunMobileFriendlyTestResponse' with the minimum fields required to make a request.
  newRunMobileFriendlyTestResponse ::
    RunMobileFriendlyTestResponse
  newRunMobileFriendlyTestResponse =
    RunMobileFriendlyTestResponse
      { mobileFriendliness = Core.Nothing,
        mobileFriendlyIssues = Core.Nothing,
        resourceIssues = Core.Nothing,
        screenshot = Core.Nothing,
        testStatus = Core.Nothing
      }
  
  instance Core.FromJSON RunMobileFriendlyTestResponse where
    parseJSON =
      Core.withObject
        "RunMobileFriendlyTestResponse"
        ( \o ->
            RunMobileFriendlyTestResponse
              Core.<$> (o Core..:? "mobileFriendliness")
              Core.<*> (o Core..:? "mobileFriendlyIssues")
              Core.<*> (o Core..:? "resourceIssues")
              Core.<*> (o Core..:? "screenshot")
              Core.<*> (o Core..:? "testStatus")
        )
  
  instance Core.ToJSON RunMobileFriendlyTestResponse where
    toJSON RunMobileFriendlyTestResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("mobileFriendliness" Core..=) Core.<$> mobileFriendliness,
              ("mobileFriendlyIssues" Core..=) Core.<$> mobileFriendlyIssues,
              ("resourceIssues" Core..=) Core.<$> resourceIssues,
              ("screenshot" Core..=) Core.<$> screenshot,
              ("testStatus" Core..=) Core.<$> testStatus
            ]
        )
  
  --
  -- /See:/ 'newSearchAnalyticsQueryRequest' smart constructor.
  data SearchAnalyticsQueryRequest = SearchAnalyticsQueryRequest
    { -- | [Optional; Default is \\\"auto\\\"] How data is aggregated. If aggregated by property, all data for the same property is aggregated; if aggregated by page, all data is aggregated by canonical URI. If you filter or group by page, choose AUTO; otherwise you can aggregate either by property or by page, depending on how you want your data calculated; see the help documentation to learn how data is calculated differently by site versus by page. __Note:__ If you group or filter by page, you cannot aggregate by property. If you specify any value other than AUTO, the aggregation type in the result will match the requested type, or if you request an invalid type, you will get an error. The API will never change your aggregation type if the requested type is invalid.
      aggregationType :: (Core.Maybe SearchAnalyticsQueryRequest_AggregationType),
      -- | The data state to be fetched, can be full or all, the latter including full and partial data.
      dataState :: (Core.Maybe SearchAnalyticsQueryRequest_DataState),
      -- | [Optional] Zero or more filters to apply to the dimension grouping values; for example, \'query contains \\\"buy\\\"\' to see only data where the query string contains the substring \\\"buy\\\" (not case-sensitive). You can filter by a dimension without grouping by it.
      dimensionFilterGroups :: (Core.Maybe [ApiDimensionFilterGroup]),
      -- | [Optional] Zero or more dimensions to group results by. Dimensions are the group-by values in the Search Analytics page. Dimensions are combined to create a unique row key for each row. Results are grouped in the order that you supply these dimensions.
      dimensions :: (Core.Maybe [SearchAnalyticsQueryRequest_DimensionsItem]),
      -- | [Required] End date of the requested date range, in YYYY-MM-DD format, in PST (UTC - 8:00). Must be greater than or equal to the start date. This value is included in the range.
      endDate :: (Core.Maybe Core.Text),
      -- | [Optional; Default is 1000] The maximum number of rows to return. Must be a number from 1 to 25,000 (inclusive).
      rowLimit :: (Core.Maybe Core.Int32),
      -- | [Optional; Default is \\\"web\\\"] The search type to filter for.
      searchType :: (Core.Maybe SearchAnalyticsQueryRequest_SearchType),
      -- | [Required] Start date of the requested date range, in YYYY-MM-DD format, in PST time (UTC - 8:00). Must be less than or equal to the end date. This value is included in the range.
      startDate :: (Core.Maybe Core.Text),
      -- | [Optional; Default is 0] Zero-based index of the first row in the response. Must be a non-negative number.
      startRow :: (Core.Maybe Core.Int32),
      -- | Optional. [Optional; Default is \\\"web\\\"] Type of report: search type, or either Discover or Gnews.
      type' :: (Core.Maybe SearchAnalyticsQueryRequest_Type)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SearchAnalyticsQueryRequest' with the minimum fields required to make a request.
  newSearchAnalyticsQueryRequest ::
    SearchAnalyticsQueryRequest
  newSearchAnalyticsQueryRequest =
    SearchAnalyticsQueryRequest
      { aggregationType = Core.Nothing,
        dataState = Core.Nothing,
        dimensionFilterGroups = Core.Nothing,
        dimensions = Core.Nothing,
        endDate = Core.Nothing,
        rowLimit = Core.Nothing,
        searchType = Core.Nothing,
        startDate = Core.Nothing,
        startRow = Core.Nothing,
        type' = Core.Nothing
      }
  
  instance Core.FromJSON SearchAnalyticsQueryRequest where
    parseJSON =
      Core.withObject
        "SearchAnalyticsQueryRequest"
        ( \o ->
            SearchAnalyticsQueryRequest
              Core.<$> (o Core..:? "aggregationType")
              Core.<*> (o Core..:? "dataState")
              Core.<*> (o Core..:? "dimensionFilterGroups")
              Core.<*> (o Core..:? "dimensions")
              Core.<*> (o Core..:? "endDate")
              Core.<*> (o Core..:? "rowLimit")
              Core.<*> (o Core..:? "searchType")
              Core.<*> (o Core..:? "startDate")
              Core.<*> (o Core..:? "startRow")
              Core.<*> (o Core..:? "type")
        )
  
  instance Core.ToJSON SearchAnalyticsQueryRequest where
    toJSON SearchAnalyticsQueryRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("aggregationType" Core..=) Core.<$> aggregationType,
              ("dataState" Core..=) Core.<$> dataState,
              ("dimensionFilterGroups" Core..=) Core.<$> dimensionFilterGroups,
              ("dimensions" Core..=) Core.<$> dimensions,
              ("endDate" Core..=) Core.<$> endDate,
              ("rowLimit" Core..=) Core.<$> rowLimit,
              ("searchType" Core..=) Core.<$> searchType,
              ("startDate" Core..=) Core.<$> startDate,
              ("startRow" Core..=) Core.<$> startRow,
              ("type" Core..=) Core.<$> type'
            ]
        )
  
  -- | A list of rows, one per result, grouped by key. Metrics in each row are aggregated for all data grouped by that key either by page or property, as specified by the aggregation type parameter.
  --
  -- /See:/ 'newSearchAnalyticsQueryResponse' smart constructor.
  data SearchAnalyticsQueryResponse = SearchAnalyticsQueryResponse
    { -- | How the results were aggregated.
      responseAggregationType :: (Core.Maybe SearchAnalyticsQueryResponse_ResponseAggregationType),
      -- | A list of rows grouped by the key values in the order given in the query.
      rows :: (Core.Maybe [ApiDataRow])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SearchAnalyticsQueryResponse' with the minimum fields required to make a request.
  newSearchAnalyticsQueryResponse ::
    SearchAnalyticsQueryResponse
  newSearchAnalyticsQueryResponse =
    SearchAnalyticsQueryResponse
      { responseAggregationType =
          Core.Nothing,
        rows = Core.Nothing
      }
  
  instance Core.FromJSON SearchAnalyticsQueryResponse where
    parseJSON =
      Core.withObject
        "SearchAnalyticsQueryResponse"
        ( \o ->
            SearchAnalyticsQueryResponse
              Core.<$> (o Core..:? "responseAggregationType")
              Core.<*> (o Core..:? "rows")
        )
  
  instance Core.ToJSON SearchAnalyticsQueryResponse where
    toJSON SearchAnalyticsQueryResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("responseAggregationType" Core..=)
                Core.<$> responseAggregationType,
              ("rows" Core..=) Core.<$> rows
            ]
        )
  
  -- | List of sitemaps.
  --
  -- /See:/ 'newSitemapsListResponse' smart constructor.
  newtype SitemapsListResponse = SitemapsListResponse
    { -- | Contains detailed information about a specific URL submitted as a <https://support.google.com/webmasters/answer/156184 sitemap>.
      sitemap :: (Core.Maybe [WmxSitemap])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SitemapsListResponse' with the minimum fields required to make a request.
  newSitemapsListResponse ::
    SitemapsListResponse
  newSitemapsListResponse =
    SitemapsListResponse {sitemap = Core.Nothing}
  
  instance Core.FromJSON SitemapsListResponse where
    parseJSON =
      Core.withObject
        "SitemapsListResponse"
        (\o -> SitemapsListResponse Core.<$> (o Core..:? "sitemap"))
  
  instance Core.ToJSON SitemapsListResponse where
    toJSON SitemapsListResponse {..} =
      Core.object
        (Core.catMaybes [("sitemap" Core..=) Core.<$> sitemap])
  
  -- | List of sites with access level information.
  --
  -- /See:/ 'newSitesListResponse' smart constructor.
  newtype SitesListResponse = SitesListResponse
    { -- | Contains permission level information about a Search Console site. For more information, see <https://support.google.com/webmasters/answer/2451999 Permissions in Search Console>.
      siteEntry :: (Core.Maybe [WmxSite])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SitesListResponse' with the minimum fields required to make a request.
  newSitesListResponse ::
    SitesListResponse
  newSitesListResponse = SitesListResponse {siteEntry = Core.Nothing}
  
  instance Core.FromJSON SitesListResponse where
    parseJSON =
      Core.withObject
        "SitesListResponse"
        (\o -> SitesListResponse Core.<$> (o Core..:? "siteEntry"))
  
  instance Core.ToJSON SitesListResponse where
    toJSON SitesListResponse {..} =
      Core.object
        (Core.catMaybes [("siteEntry" Core..=) Core.<$> siteEntry])
  
  -- | Final state of the test, including error details if necessary.
  --
  -- /See:/ 'newTestStatus' smart constructor.
  data TestStatus = TestStatus
    { -- | Error details if applicable.
      details :: (Core.Maybe Core.Text),
      -- | Status of the test.
      status :: (Core.Maybe TestStatus_Status)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TestStatus' with the minimum fields required to make a request.
  newTestStatus ::
    TestStatus
  newTestStatus =
    TestStatus {details = Core.Nothing, status = Core.Nothing}
  
  instance Core.FromJSON TestStatus where
    parseJSON =
      Core.withObject
        "TestStatus"
        ( \o ->
            TestStatus
              Core.<$> (o Core..:? "details")
              Core.<*> (o Core..:? "status")
        )
  
  instance Core.ToJSON TestStatus where
    toJSON TestStatus {..} =
      Core.object
        ( Core.catMaybes
            [ ("details" Core..=) Core.<$> details,
              ("status" Core..=) Core.<$> status
            ]
        )
  
  -- | URL inspection result, including all inspection results.
  --
  -- /See:/ 'newUrlInspectionResult' smart constructor.
  data UrlInspectionResult = UrlInspectionResult
    { -- | Result of the AMP analysis. Absent if the page is not an AMP page.
      ampResult :: (Core.Maybe AmpInspectionResult),
      -- | Result of the index status analysis.
      indexStatusResult :: (Core.Maybe IndexStatusInspectionResult),
      -- | Link to Search Console URL inspection.
      inspectionResultLink :: (Core.Maybe Core.Text),
      -- | Result of the Mobile usability analysis.
      mobileUsabilityResult :: (Core.Maybe MobileUsabilityInspectionResult),
      -- | Result of the Rich Results analysis. Absent if there are no rich results found.
      richResultsResult :: (Core.Maybe RichResultsInspectionResult)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'UrlInspectionResult' with the minimum fields required to make a request.
  newUrlInspectionResult ::
    UrlInspectionResult
  newUrlInspectionResult =
    UrlInspectionResult
      { ampResult = Core.Nothing,
        indexStatusResult = Core.Nothing,
        inspectionResultLink = Core.Nothing,
        mobileUsabilityResult = Core.Nothing,
        richResultsResult = Core.Nothing
      }
  
  instance Core.FromJSON UrlInspectionResult where
    parseJSON =
      Core.withObject
        "UrlInspectionResult"
        ( \o ->
            UrlInspectionResult
              Core.<$> (o Core..:? "ampResult")
              Core.<*> (o Core..:? "indexStatusResult")
              Core.<*> (o Core..:? "inspectionResultLink")
              Core.<*> (o Core..:? "mobileUsabilityResult")
              Core.<*> (o Core..:? "richResultsResult")
        )
  
  instance Core.ToJSON UrlInspectionResult where
    toJSON UrlInspectionResult {..} =
      Core.object
        ( Core.catMaybes
            [ ("ampResult" Core..=) Core.<$> ampResult,
              ("indexStatusResult" Core..=) Core.<$> indexStatusResult,
              ("inspectionResultLink" Core..=) Core.<$> inspectionResultLink,
              ("mobileUsabilityResult" Core..=) Core.<$> mobileUsabilityResult,
              ("richResultsResult" Core..=) Core.<$> richResultsResult
            ]
        )
  
  -- | Contains permission level information about a Search Console site. For more information, see <https://support.google.com/webmasters/answer/2451999 Permissions in Search Console>.
  --
  -- /See:/ 'newWmxSite' smart constructor.
  data WmxSite = WmxSite
    { -- | The user\'s permission level for the site.
      permissionLevel :: (Core.Maybe WmxSite_PermissionLevel),
      -- | The URL of the site.
      siteUrl :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WmxSite' with the minimum fields required to make a request.
  newWmxSite ::
    WmxSite
  newWmxSite =
    WmxSite {permissionLevel = Core.Nothing, siteUrl = Core.Nothing}
  
  instance Core.FromJSON WmxSite where
    parseJSON =
      Core.withObject
        "WmxSite"
        ( \o ->
            WmxSite
              Core.<$> (o Core..:? "permissionLevel")
              Core.<*> (o Core..:? "siteUrl")
        )
  
  instance Core.ToJSON WmxSite where
    toJSON WmxSite {..} =
      Core.object
        ( Core.catMaybes
            [ ("permissionLevel" Core..=) Core.<$> permissionLevel,
              ("siteUrl" Core..=) Core.<$> siteUrl
            ]
        )
  
  -- | Contains detailed information about a specific URL submitted as a <https://support.google.com/webmasters/answer/156184 sitemap>.
  --
  -- /See:/ 'newWmxSitemap' smart constructor.
  data WmxSitemap = WmxSitemap
    { -- | The various content types in the sitemap.
      contents :: (Core.Maybe [WmxSitemapContent]),
      -- | Number of errors in the sitemap. These are issues with the sitemap itself that need to be fixed before it can be processed correctly.
      errors :: (Core.Maybe Core.Int64),
      -- | If true, the sitemap has not been processed.
      isPending :: (Core.Maybe Core.Bool),
      -- | If true, the sitemap is a collection of sitemaps.
      isSitemapsIndex :: (Core.Maybe Core.Bool),
      -- | Date & time in which this sitemap was last downloaded. Date format is in RFC 3339 format (yyyy-mm-dd).
      lastDownloaded :: (Core.Maybe Core.DateTime),
      -- | Date & time in which this sitemap was submitted. Date format is in RFC 3339 format (yyyy-mm-dd).
      lastSubmitted :: (Core.Maybe Core.DateTime),
      -- | The url of the sitemap.
      path :: (Core.Maybe Core.Text),
      -- | The type of the sitemap. For example: @rssFeed@.
      type' :: (Core.Maybe WmxSitemap_Type),
      -- | Number of warnings for the sitemap. These are generally non-critical issues with URLs in the sitemaps.
      warnings :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WmxSitemap' with the minimum fields required to make a request.
  newWmxSitemap ::
    WmxSitemap
  newWmxSitemap =
    WmxSitemap
      { contents = Core.Nothing,
        errors = Core.Nothing,
        isPending = Core.Nothing,
        isSitemapsIndex = Core.Nothing,
        lastDownloaded = Core.Nothing,
        lastSubmitted = Core.Nothing,
        path = Core.Nothing,
        type' = Core.Nothing,
        warnings = Core.Nothing
      }
  
  instance Core.FromJSON WmxSitemap where
    parseJSON =
      Core.withObject
        "WmxSitemap"
        ( \o ->
            WmxSitemap
              Core.<$> (o Core..:? "contents")
              Core.<*> (o Core..:? "errors" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "isPending")
              Core.<*> (o Core..:? "isSitemapsIndex")
              Core.<*> (o Core..:? "lastDownloaded")
              Core.<*> (o Core..:? "lastSubmitted")
              Core.<*> (o Core..:? "path")
              Core.<*> (o Core..:? "type")
              Core.<*> (o Core..:? "warnings" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON WmxSitemap where
    toJSON WmxSitemap {..} =
      Core.object
        ( Core.catMaybes
            [ ("contents" Core..=) Core.<$> contents,
              ("errors" Core..=) Core.. Core.AsText Core.<$> errors,
              ("isPending" Core..=) Core.<$> isPending,
              ("isSitemapsIndex" Core..=) Core.<$> isSitemapsIndex,
              ("lastDownloaded" Core..=) Core.<$> lastDownloaded,
              ("lastSubmitted" Core..=) Core.<$> lastSubmitted,
              ("path" Core..=) Core.<$> path,
              ("type" Core..=) Core.<$> type',
              ("warnings" Core..=) Core.. Core.AsText Core.<$> warnings
            ]
        )
  
  -- | Information about the various content types in the sitemap.
  --
  -- /See:/ 'newWmxSitemapContent' smart constructor.
  data WmxSitemapContent = WmxSitemapContent
    { -- | /Deprecated; do not use./
      indexed :: (Core.Maybe Core.Int64),
      -- | The number of URLs in the sitemap (of the content type).
      submitted :: (Core.Maybe Core.Int64),
      -- | The specific type of content in this sitemap. For example: @web@.
      type' :: (Core.Maybe WmxSitemapContent_Type)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WmxSitemapContent' with the minimum fields required to make a request.
  newWmxSitemapContent ::
    WmxSitemapContent
  newWmxSitemapContent =
    WmxSitemapContent
      { indexed = Core.Nothing,
        submitted = Core.Nothing,
        type' = Core.Nothing
      }
  
  instance Core.FromJSON WmxSitemapContent where
    parseJSON =
      Core.withObject
        "WmxSitemapContent"
        ( \o ->
            WmxSitemapContent
              Core.<$> (o Core..:? "indexed" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "submitted" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "type")
        )
  
  instance Core.ToJSON WmxSitemapContent where
    toJSON WmxSitemapContent {..} =
      Core.object
        ( Core.catMaybes
            [ ("indexed" Core..=) Core.. Core.AsText Core.<$> indexed,
              ("submitted" Core..=) Core.. Core.AsText Core.<$> submitted,
              ("type" Core..=) Core.<$> type'
            ]
        )
  