{-# 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.AdSense.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.AdSense.Internal.Product
  ( -- * Account
    Account (..),
    newAccount,

    -- * AdBlockingRecoveryTag
    AdBlockingRecoveryTag (..),
    newAdBlockingRecoveryTag,

    -- * AdClient
    AdClient (..),
    newAdClient,

    -- * AdClientAdCode
    AdClientAdCode (..),
    newAdClientAdCode,

    -- * AdUnit
    AdUnit (..),
    newAdUnit,

    -- * AdUnitAdCode
    AdUnitAdCode (..),
    newAdUnitAdCode,

    -- * Alert
    Alert (..),
    newAlert,

    -- * Cell
    Cell (..),
    newCell,

    -- * ContentAdsSettings
    ContentAdsSettings (..),
    newContentAdsSettings,

    -- * CustomChannel
    CustomChannel (..),
    newCustomChannel,

    -- * Date
    Date (..),
    newDate,

    -- * Empty
    Empty (..),
    newEmpty,

    -- * Header
    Header (..),
    newHeader,

    -- * HttpBody
    HttpBody (..),
    newHttpBody,

    -- * HttpBody_ExtensionsItem
    HttpBody_ExtensionsItem (..),
    newHttpBody_ExtensionsItem,

    -- * ListAccountsResponse
    ListAccountsResponse (..),
    newListAccountsResponse,

    -- * ListAdClientsResponse
    ListAdClientsResponse (..),
    newListAdClientsResponse,

    -- * ListAdUnitsResponse
    ListAdUnitsResponse (..),
    newListAdUnitsResponse,

    -- * ListAlertsResponse
    ListAlertsResponse (..),
    newListAlertsResponse,

    -- * ListChildAccountsResponse
    ListChildAccountsResponse (..),
    newListChildAccountsResponse,

    -- * ListCustomChannelsResponse
    ListCustomChannelsResponse (..),
    newListCustomChannelsResponse,

    -- * ListLinkedAdUnitsResponse
    ListLinkedAdUnitsResponse (..),
    newListLinkedAdUnitsResponse,

    -- * ListLinkedCustomChannelsResponse
    ListLinkedCustomChannelsResponse (..),
    newListLinkedCustomChannelsResponse,

    -- * ListPaymentsResponse
    ListPaymentsResponse (..),
    newListPaymentsResponse,

    -- * ListPolicyIssuesResponse
    ListPolicyIssuesResponse (..),
    newListPolicyIssuesResponse,

    -- * ListSavedReportsResponse
    ListSavedReportsResponse (..),
    newListSavedReportsResponse,

    -- * ListSitesResponse
    ListSitesResponse (..),
    newListSitesResponse,

    -- * ListUrlChannelsResponse
    ListUrlChannelsResponse (..),
    newListUrlChannelsResponse,

    -- * Payment
    Payment (..),
    newPayment,

    -- * PolicyIssue
    PolicyIssue (..),
    newPolicyIssue,

    -- * PolicyTopic
    PolicyTopic (..),
    newPolicyTopic,

    -- * ReportResult
    ReportResult (..),
    newReportResult,

    -- * Row
    Row (..),
    newRow,

    -- * SavedReport
    SavedReport (..),
    newSavedReport,

    -- * Site
    Site (..),
    newSite,

    -- * TimeZone
    TimeZone (..),
    newTimeZone,

    -- * UrlChannel
    UrlChannel (..),
    newUrlChannel,
  )
where

import Gogol.AdSense.Internal.Sum
import Gogol.Prelude qualified as Core

-- | Representation of an account.
--
-- /See:/ 'newAccount' smart constructor.
data Account = Account
  { -- | Output only. Creation time of the account.
    createTime :: (Core.Maybe Core.DateTime),
    -- | Output only. Display name of this account.
    displayName :: (Core.Maybe Core.Text),
    -- | Output only. Resource name of the account. Format: accounts\/pub-[0-9]+
    name :: (Core.Maybe Core.Text),
    -- | Output only. Outstanding tasks that need to be completed as part of the sign-up process for a new account. e.g. \"billing-profile-creation\", \"phone-pin-verification\".
    pendingTasks :: (Core.Maybe [Core.Text]),
    -- | Output only. Whether this account is premium.
    premium :: (Core.Maybe Core.Bool),
    -- | Output only. State of the account.
    state :: (Core.Maybe Account_State),
    -- | The account time zone, as used by reporting. For more information, see <https://support.google.com/adsense/answer/9830725 changing the time zone of your reports>.
    timeZone :: (Core.Maybe TimeZone)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Account' with the minimum fields required to make a request.
newAccount ::
  Account
newAccount =
  Account
    { createTime = Core.Nothing,
      displayName = Core.Nothing,
      name = Core.Nothing,
      pendingTasks = Core.Nothing,
      premium = Core.Nothing,
      state = Core.Nothing,
      timeZone = Core.Nothing
    }

instance Core.FromJSON Account where
  parseJSON =
    Core.withObject
      "Account"
      ( \o ->
          Account
            Core.<$> (o Core..:? "createTime")
            Core.<*> (o Core..:? "displayName")
            Core.<*> (o Core..:? "name")
            Core.<*> (o Core..:? "pendingTasks")
            Core.<*> (o Core..:? "premium")
            Core.<*> (o Core..:? "state")
            Core.<*> (o Core..:? "timeZone")
      )

instance Core.ToJSON Account where
  toJSON Account {..} =
    Core.object
      ( Core.catMaybes
          [ ("createTime" Core..=) Core.<$> createTime,
            ("displayName" Core..=) Core.<$> displayName,
            ("name" Core..=) Core.<$> name,
            ("pendingTasks" Core..=) Core.<$> pendingTasks,
            ("premium" Core..=) Core.<$> premium,
            ("state" Core..=) Core.<$> state,
            ("timeZone" Core..=) Core.<$> timeZone
          ]
      )

-- | Representation of an ad blocking recovery tag. See https:\/\/support.google.com\/adsense\/answer\/11575177.
--
-- /See:/ 'newAdBlockingRecoveryTag' smart constructor.
data AdBlockingRecoveryTag = AdBlockingRecoveryTag
  { -- | Error protection code that can be used in conjunction with the tag. It\'ll display a message to users if an <https://support.google.com/adsense/answer/11575480 ad blocking extension blocks their access to your site>.
    errorProtectionCode :: (Core.Maybe Core.Text),
    -- | The ad blocking recovery tag. Note that the message generated by the tag can be blocked by an ad blocking extension. If this is not your desired outcome, then you\'ll need to use it in conjunction with the error protection code.
    tag :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'AdBlockingRecoveryTag' with the minimum fields required to make a request.
newAdBlockingRecoveryTag ::
  AdBlockingRecoveryTag
newAdBlockingRecoveryTag =
  AdBlockingRecoveryTag
    { errorProtectionCode = Core.Nothing,
      tag = Core.Nothing
    }

instance Core.FromJSON AdBlockingRecoveryTag where
  parseJSON =
    Core.withObject
      "AdBlockingRecoveryTag"
      ( \o ->
          AdBlockingRecoveryTag
            Core.<$> (o Core..:? "errorProtectionCode")
            Core.<*> (o Core..:? "tag")
      )

instance Core.ToJSON AdBlockingRecoveryTag where
  toJSON AdBlockingRecoveryTag {..} =
    Core.object
      ( Core.catMaybes
          [ ("errorProtectionCode" Core..=) Core.<$> errorProtectionCode,
            ("tag" Core..=) Core.<$> tag
          ]
      )

-- | Representation of an ad client. An ad client represents a user\'s subscription with a specific AdSense product.
--
-- /See:/ 'newAdClient' smart constructor.
data AdClient = AdClient
  { -- | Output only. Resource name of the ad client. Format: accounts\/{account}\/adclients\/{adclient}
    name :: (Core.Maybe Core.Text),
    -- | Output only. Reporting product code of the ad client. For example, \"AFC\" for AdSense for Content. Corresponds to the @PRODUCT_CODE@ dimension, and present only if the ad client supports reporting.
    productCode :: (Core.Maybe Core.Text),
    -- | Output only. Unique ID of the ad client as used in the @AD_CLIENT_ID@ reporting dimension. Present only if the ad client supports reporting.
    reportingDimensionId :: (Core.Maybe Core.Text),
    -- | Output only. State of the ad client.
    state :: (Core.Maybe AdClient_State)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'AdClient' with the minimum fields required to make a request.
newAdClient ::
  AdClient
newAdClient =
  AdClient
    { name = Core.Nothing,
      productCode = Core.Nothing,
      reportingDimensionId = Core.Nothing,
      state = Core.Nothing
    }

instance Core.FromJSON AdClient where
  parseJSON =
    Core.withObject
      "AdClient"
      ( \o ->
          AdClient
            Core.<$> (o Core..:? "name")
            Core.<*> (o Core..:? "productCode")
            Core.<*> (o Core..:? "reportingDimensionId")
            Core.<*> (o Core..:? "state")
      )

instance Core.ToJSON AdClient where
  toJSON AdClient {..} =
    Core.object
      ( Core.catMaybes
          [ ("name" Core..=) Core.<$> name,
            ("productCode" Core..=) Core.<$> productCode,
            ("reportingDimensionId" Core..=) Core.<$> reportingDimensionId,
            ("state" Core..=) Core.<$> state
          ]
      )

-- | Representation of the AdSense code for a given ad client. For more information, see <https://support.google.com/adsense/answer/9274634 About the AdSense code>.
--
-- /See:/ 'newAdClientAdCode' smart constructor.
data AdClientAdCode = AdClientAdCode
  { -- | Output only. The AdSense code snippet to add to the head of an HTML page.
    adCode :: (Core.Maybe Core.Text),
    -- | Output only. The AdSense code snippet to add to the body of an AMP page.
    ampBody :: (Core.Maybe Core.Text),
    -- | Output only. The AdSense code snippet to add to the head of an AMP page.
    ampHead :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'AdClientAdCode' with the minimum fields required to make a request.
newAdClientAdCode ::
  AdClientAdCode
newAdClientAdCode =
  AdClientAdCode
    { adCode = Core.Nothing,
      ampBody = Core.Nothing,
      ampHead = Core.Nothing
    }

instance Core.FromJSON AdClientAdCode where
  parseJSON =
    Core.withObject
      "AdClientAdCode"
      ( \o ->
          AdClientAdCode
            Core.<$> (o Core..:? "adCode")
            Core.<*> (o Core..:? "ampBody")
            Core.<*> (o Core..:? "ampHead")
      )

instance Core.ToJSON AdClientAdCode where
  toJSON AdClientAdCode {..} =
    Core.object
      ( Core.catMaybes
          [ ("adCode" Core..=) Core.<$> adCode,
            ("ampBody" Core..=) Core.<$> ampBody,
            ("ampHead" Core..=) Core.<$> ampHead
          ]
      )

-- | Representation of an ad unit. An ad unit represents a saved ad unit with a specific set of ad settings that have been customized within an account.
--
-- /See:/ 'newAdUnit' smart constructor.
data AdUnit = AdUnit
  { -- | Required. Settings specific to content ads (AFC).
    contentAdsSettings :: (Core.Maybe ContentAdsSettings),
    -- | Required. Display name of the ad unit, as provided when the ad unit was created.
    displayName :: (Core.Maybe Core.Text),
    -- | Output only. Resource name of the ad unit. Format: accounts\/{account}\/adclients\/{adclient}\/adunits\/{adunit}
    name :: (Core.Maybe Core.Text),
    -- | Output only. Unique ID of the ad unit as used in the @AD_UNIT_ID@ reporting dimension.
    reportingDimensionId :: (Core.Maybe Core.Text),
    -- | Required. State of the ad unit.
    state :: (Core.Maybe AdUnit_State)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'AdUnit' with the minimum fields required to make a request.
newAdUnit ::
  AdUnit
newAdUnit =
  AdUnit
    { contentAdsSettings = Core.Nothing,
      displayName = Core.Nothing,
      name = Core.Nothing,
      reportingDimensionId = Core.Nothing,
      state = Core.Nothing
    }

instance Core.FromJSON AdUnit where
  parseJSON =
    Core.withObject
      "AdUnit"
      ( \o ->
          AdUnit
            Core.<$> (o Core..:? "contentAdsSettings")
            Core.<*> (o Core..:? "displayName")
            Core.<*> (o Core..:? "name")
            Core.<*> (o Core..:? "reportingDimensionId")
            Core.<*> (o Core..:? "state")
      )

instance Core.ToJSON AdUnit where
  toJSON AdUnit {..} =
    Core.object
      ( Core.catMaybes
          [ ("contentAdsSettings" Core..=) Core.<$> contentAdsSettings,
            ("displayName" Core..=) Core.<$> displayName,
            ("name" Core..=) Core.<$> name,
            ("reportingDimensionId" Core..=) Core.<$> reportingDimensionId,
            ("state" Core..=) Core.<$> state
          ]
      )

-- | Representation of the ad unit code for a given ad unit. For more information, see <https://support.google.com/adsense/answer/9274634 About the AdSense code> and <https://support.google.com/adsense/answer/9190028 Where to place the ad code in your HTML>.
--
-- /See:/ 'newAdUnitAdCode' smart constructor.
newtype AdUnitAdCode = AdUnitAdCode
  { -- | Output only. The code snippet to add to the body of an HTML page.
    adCode :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'AdUnitAdCode' with the minimum fields required to make a request.
newAdUnitAdCode ::
  AdUnitAdCode
newAdUnitAdCode = AdUnitAdCode {adCode = Core.Nothing}

instance Core.FromJSON AdUnitAdCode where
  parseJSON =
    Core.withObject
      "AdUnitAdCode"
      (\o -> AdUnitAdCode Core.<$> (o Core..:? "adCode"))

instance Core.ToJSON AdUnitAdCode where
  toJSON AdUnitAdCode {..} =
    Core.object (Core.catMaybes [("adCode" Core..=) Core.<$> adCode])

-- | Representation of an alert.
--
-- /See:/ 'newAlert' smart constructor.
data Alert = Alert
  { -- | Output only. The localized alert message. This may contain HTML markup, such as phrase elements or links.
    message :: (Core.Maybe Core.Text),
    -- | Output only. Resource name of the alert. Format: accounts\/{account}\/alerts\/{alert}
    name :: (Core.Maybe Core.Text),
    -- | Output only. Severity of this alert.
    severity :: (Core.Maybe Alert_Severity),
    -- | Output only. Type of alert. This identifies the broad type of this alert, and provides a stable machine-readable identifier that will not be translated. For example, \"payment-hold\".
    type' :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Alert' with the minimum fields required to make a request.
newAlert ::
  Alert
newAlert =
  Alert
    { message = Core.Nothing,
      name = Core.Nothing,
      severity = Core.Nothing,
      type' = Core.Nothing
    }

instance Core.FromJSON Alert where
  parseJSON =
    Core.withObject
      "Alert"
      ( \o ->
          Alert
            Core.<$> (o Core..:? "message")
            Core.<*> (o Core..:? "name")
            Core.<*> (o Core..:? "severity")
            Core.<*> (o Core..:? "type")
      )

instance Core.ToJSON Alert where
  toJSON Alert {..} =
    Core.object
      ( Core.catMaybes
          [ ("message" Core..=) Core.<$> message,
            ("name" Core..=) Core.<$> name,
            ("severity" Core..=) Core.<$> severity,
            ("type" Core..=) Core.<$> type'
          ]
      )

-- | Cell representation.
--
-- /See:/ 'newCell' smart constructor.
newtype Cell = Cell
  { -- | Value in the cell. The dimension cells contain strings, and the metric cells contain numbers.
    value :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Cell' with the minimum fields required to make a request.
newCell ::
  Cell
newCell = Cell {value = Core.Nothing}

instance Core.FromJSON Cell where
  parseJSON =
    Core.withObject
      "Cell"
      (\o -> Cell Core.<$> (o Core..:? "value"))

instance Core.ToJSON Cell where
  toJSON Cell {..} =
    Core.object (Core.catMaybes [("value" Core..=) Core.<$> value])

-- | Settings specific to content ads (AFC).
--
-- /See:/ 'newContentAdsSettings' smart constructor.
data ContentAdsSettings = ContentAdsSettings
  { -- | Required. Size of the ad unit. e.g. \"728x90\", \"1x3\" (for responsive ad units).
    size :: (Core.Maybe Core.Text),
    -- | Required. Type of the ad unit.
    type' :: (Core.Maybe ContentAdsSettings_Type)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ContentAdsSettings' with the minimum fields required to make a request.
newContentAdsSettings ::
  ContentAdsSettings
newContentAdsSettings =
  ContentAdsSettings {size = Core.Nothing, type' = Core.Nothing}

instance Core.FromJSON ContentAdsSettings where
  parseJSON =
    Core.withObject
      "ContentAdsSettings"
      ( \o ->
          ContentAdsSettings
            Core.<$> (o Core..:? "size")
            Core.<*> (o Core..:? "type")
      )

instance Core.ToJSON ContentAdsSettings where
  toJSON ContentAdsSettings {..} =
    Core.object
      ( Core.catMaybes
          [("size" Core..=) Core.<$> size, ("type" Core..=) Core.<$> type']
      )

-- | Representation of a custom channel.
--
-- /See:/ 'newCustomChannel' smart constructor.
data CustomChannel = CustomChannel
  { -- | Whether the custom channel is active and collecting data. See https:\/\/support.google.com\/adsense\/answer\/10077192.
    active :: (Core.Maybe Core.Bool),
    -- | Required. Display name of the custom channel.
    displayName :: (Core.Maybe Core.Text),
    -- | Output only. Resource name of the custom channel. Format: accounts\/{account}\/adclients\/{adclient}\/customchannels\/{customchannel}
    name :: (Core.Maybe Core.Text),
    -- | Output only. Unique ID of the custom channel as used in the @CUSTOM_CHANNEL_ID@ reporting dimension.
    reportingDimensionId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'CustomChannel' with the minimum fields required to make a request.
newCustomChannel ::
  CustomChannel
newCustomChannel =
  CustomChannel
    { active = Core.Nothing,
      displayName = Core.Nothing,
      name = Core.Nothing,
      reportingDimensionId = Core.Nothing
    }

instance Core.FromJSON CustomChannel where
  parseJSON =
    Core.withObject
      "CustomChannel"
      ( \o ->
          CustomChannel
            Core.<$> (o Core..:? "active")
            Core.<*> (o Core..:? "displayName")
            Core.<*> (o Core..:? "name")
            Core.<*> (o Core..:? "reportingDimensionId")
      )

instance Core.ToJSON CustomChannel where
  toJSON CustomChannel {..} =
    Core.object
      ( Core.catMaybes
          [ ("active" Core..=) Core.<$> active,
            ("displayName" Core..=) Core.<$> displayName,
            ("name" Core..=) Core.<$> name,
            ("reportingDimensionId" Core..=) Core.<$> reportingDimensionId
          ]
      )

-- | Represents a whole or partial calendar date, such as a birthday. The time of day and time zone are either specified elsewhere or are insignificant. The date is relative to the Gregorian Calendar. This can represent one of the following: * A full date, with non-zero year, month, and day values. * A month and day, with a zero year (for example, an anniversary). * A year on its own, with a zero month and a zero day. * A year and month, with a zero day (for example, a credit card expiration date). Related types: * google.type.TimeOfDay * google.type.DateTime * google.protobuf.Timestamp
--
-- /See:/ 'newDate' smart constructor.
data Date = Date
  { -- | Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn\'t significant.
    day :: (Core.Maybe Core.Int32),
    -- | Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.
    month :: (Core.Maybe Core.Int32),
    -- | Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.
    year :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Date' with the minimum fields required to make a request.
newDate ::
  Date
newDate =
  Date
    { day = Core.Nothing,
      month = Core.Nothing,
      year = Core.Nothing
    }

instance Core.FromJSON Date where
  parseJSON =
    Core.withObject
      "Date"
      ( \o ->
          Date
            Core.<$> (o Core..:? "day")
            Core.<*> (o Core..:? "month")
            Core.<*> (o Core..:? "year")
      )

instance Core.ToJSON Date where
  toJSON Date {..} =
    Core.object
      ( Core.catMaybes
          [ ("day" Core..=) Core.<$> day,
            ("month" Core..=) Core.<$> month,
            ("year" Core..=) Core.<$> year
          ]
      )

-- | 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

-- | The header information of the columns requested in the report.
--
-- /See:/ 'newHeader' smart constructor.
data Header = Header
  { -- | The <https://en.wikipedia.org/wiki/ISO_4217 ISO-4217 currency code> of this column. Only present if the header type is METRIC_CURRENCY.
    currencyCode :: (Core.Maybe Core.Text),
    -- | Required. Name of the header.
    name :: (Core.Maybe Core.Text),
    -- | Required. Type of the header.
    type' :: (Core.Maybe Header_Type)
  }
  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
    { currencyCode = Core.Nothing,
      name = Core.Nothing,
      type' = Core.Nothing
    }

instance Core.FromJSON Header where
  parseJSON =
    Core.withObject
      "Header"
      ( \o ->
          Header
            Core.<$> (o Core..:? "currencyCode")
            Core.<*> (o Core..:? "name")
            Core.<*> (o Core..:? "type")
      )

instance Core.ToJSON Header where
  toJSON Header {..} =
    Core.object
      ( Core.catMaybes
          [ ("currencyCode" Core..=) Core.<$> currencyCode,
            ("name" Core..=) Core.<$> name,
            ("type" Core..=) Core.<$> type'
          ]
      )

-- | Message that represents an arbitrary HTTP body. It should only be used for payload formats that can\'t be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { \/\/ A unique request id. string request/id = 1; \/\/ The raw HTTP body is bound to this field. google.api.HttpBody http/body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream
-- google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged.
--
-- /See:/ 'newHttpBody' smart constructor.
data HttpBody = HttpBody
  { -- | The HTTP Content-Type header value specifying the content type of the body.
    contentType :: (Core.Maybe Core.Text),
    -- | The HTTP request\/response body as raw binary.
    data' :: (Core.Maybe Core.Base64),
    -- | Application specific response metadata. Must be set in the first response for streaming APIs.
    extensions :: (Core.Maybe [HttpBody_ExtensionsItem])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'HttpBody' with the minimum fields required to make a request.
newHttpBody ::
  HttpBody
newHttpBody =
  HttpBody
    { contentType = Core.Nothing,
      data' = Core.Nothing,
      extensions = Core.Nothing
    }

instance Core.FromJSON HttpBody where
  parseJSON =
    Core.withObject
      "HttpBody"
      ( \o ->
          HttpBody
            Core.<$> (o Core..:? "contentType")
            Core.<*> (o Core..:? "data")
            Core.<*> (o Core..:? "extensions")
      )

instance Core.ToJSON HttpBody where
  toJSON HttpBody {..} =
    Core.object
      ( Core.catMaybes
          [ ("contentType" Core..=) Core.<$> contentType,
            ("data" Core..=) Core.<$> data',
            ("extensions" Core..=) Core.<$> extensions
          ]
      )

--
-- /See:/ 'newHttpBody_ExtensionsItem' smart constructor.
newtype HttpBody_ExtensionsItem = HttpBody_ExtensionsItem
  { -- | Properties of the object. Contains field \@type with type URL.
    additional :: (Core.HashMap Core.Text Core.Value)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'HttpBody_ExtensionsItem' with the minimum fields required to make a request.
newHttpBody_ExtensionsItem ::
  -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
  Core.HashMap Core.Text Core.Value ->
  HttpBody_ExtensionsItem
newHttpBody_ExtensionsItem additional =
  HttpBody_ExtensionsItem {additional = additional}

instance Core.FromJSON HttpBody_ExtensionsItem where
  parseJSON =
    Core.withObject
      "HttpBody_ExtensionsItem"
      (\o -> HttpBody_ExtensionsItem Core.<$> (Core.parseJSONObject o))

instance Core.ToJSON HttpBody_ExtensionsItem where
  toJSON HttpBody_ExtensionsItem {..} = Core.toJSON additional

-- | Response definition for the account list rpc.
--
-- /See:/ 'newListAccountsResponse' smart constructor.
data ListAccountsResponse = ListAccountsResponse
  { -- | The accounts returned in this list response.
    accounts :: (Core.Maybe [Account]),
    -- | Continuation token used to page through accounts. To retrieve the next page of the results, set the next request\'s \"page_token\" value to this.
    nextPageToken :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ListAccountsResponse' with the minimum fields required to make a request.
newListAccountsResponse ::
  ListAccountsResponse
newListAccountsResponse =
  ListAccountsResponse
    { accounts = Core.Nothing,
      nextPageToken = Core.Nothing
    }

instance Core.FromJSON ListAccountsResponse where
  parseJSON =
    Core.withObject
      "ListAccountsResponse"
      ( \o ->
          ListAccountsResponse
            Core.<$> (o Core..:? "accounts")
            Core.<*> (o Core..:? "nextPageToken")
      )

instance Core.ToJSON ListAccountsResponse where
  toJSON ListAccountsResponse {..} =
    Core.object
      ( Core.catMaybes
          [ ("accounts" Core..=) Core.<$> accounts,
            ("nextPageToken" Core..=) Core.<$> nextPageToken
          ]
      )

-- | Response definition for the ad client list rpc.
--
-- /See:/ 'newListAdClientsResponse' smart constructor.
data ListAdClientsResponse = ListAdClientsResponse
  { -- | The ad clients returned in this list response.
    adClients :: (Core.Maybe [AdClient]),
    -- | Continuation token used to page through ad clients. To retrieve the next page of the results, set the next request\'s \"page_token\" value to this.
    nextPageToken :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ListAdClientsResponse' with the minimum fields required to make a request.
newListAdClientsResponse ::
  ListAdClientsResponse
newListAdClientsResponse =
  ListAdClientsResponse
    { adClients = Core.Nothing,
      nextPageToken = Core.Nothing
    }

instance Core.FromJSON ListAdClientsResponse where
  parseJSON =
    Core.withObject
      "ListAdClientsResponse"
      ( \o ->
          ListAdClientsResponse
            Core.<$> (o Core..:? "adClients")
            Core.<*> (o Core..:? "nextPageToken")
      )

instance Core.ToJSON ListAdClientsResponse where
  toJSON ListAdClientsResponse {..} =
    Core.object
      ( Core.catMaybes
          [ ("adClients" Core..=) Core.<$> adClients,
            ("nextPageToken" Core..=) Core.<$> nextPageToken
          ]
      )

-- | Response definition for the adunit list rpc.
--
-- /See:/ 'newListAdUnitsResponse' smart constructor.
data ListAdUnitsResponse = ListAdUnitsResponse
  { -- | The ad units returned in the list response.
    adUnits :: (Core.Maybe [AdUnit]),
    -- | Continuation token used to page through ad units. To retrieve the next page of the results, set the next request\'s \"page_token\" value to this.
    nextPageToken :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ListAdUnitsResponse' with the minimum fields required to make a request.
newListAdUnitsResponse ::
  ListAdUnitsResponse
newListAdUnitsResponse =
  ListAdUnitsResponse
    { adUnits = Core.Nothing,
      nextPageToken = Core.Nothing
    }

instance Core.FromJSON ListAdUnitsResponse where
  parseJSON =
    Core.withObject
      "ListAdUnitsResponse"
      ( \o ->
          ListAdUnitsResponse
            Core.<$> (o Core..:? "adUnits")
            Core.<*> (o Core..:? "nextPageToken")
      )

instance Core.ToJSON ListAdUnitsResponse where
  toJSON ListAdUnitsResponse {..} =
    Core.object
      ( Core.catMaybes
          [ ("adUnits" Core..=) Core.<$> adUnits,
            ("nextPageToken" Core..=) Core.<$> nextPageToken
          ]
      )

-- | Response definition for the alerts list rpc.
--
-- /See:/ 'newListAlertsResponse' smart constructor.
newtype ListAlertsResponse = ListAlertsResponse
  { -- | The alerts returned in this list response.
    alerts :: (Core.Maybe [Alert])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ListAlertsResponse' with the minimum fields required to make a request.
newListAlertsResponse ::
  ListAlertsResponse
newListAlertsResponse = ListAlertsResponse {alerts = Core.Nothing}

instance Core.FromJSON ListAlertsResponse where
  parseJSON =
    Core.withObject
      "ListAlertsResponse"
      (\o -> ListAlertsResponse Core.<$> (o Core..:? "alerts"))

instance Core.ToJSON ListAlertsResponse where
  toJSON ListAlertsResponse {..} =
    Core.object (Core.catMaybes [("alerts" Core..=) Core.<$> alerts])

-- | Response definition for the child account list rpc.
--
-- /See:/ 'newListChildAccountsResponse' smart constructor.
data ListChildAccountsResponse = ListChildAccountsResponse
  { -- | The accounts returned in this list response.
    accounts :: (Core.Maybe [Account]),
    -- | Continuation token used to page through accounts. To retrieve the next page of the results, set the next request\'s \"page_token\" value to this.
    nextPageToken :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ListChildAccountsResponse' with the minimum fields required to make a request.
newListChildAccountsResponse ::
  ListChildAccountsResponse
newListChildAccountsResponse =
  ListChildAccountsResponse
    { accounts = Core.Nothing,
      nextPageToken = Core.Nothing
    }

instance Core.FromJSON ListChildAccountsResponse where
  parseJSON =
    Core.withObject
      "ListChildAccountsResponse"
      ( \o ->
          ListChildAccountsResponse
            Core.<$> (o Core..:? "accounts")
            Core.<*> (o Core..:? "nextPageToken")
      )

instance Core.ToJSON ListChildAccountsResponse where
  toJSON ListChildAccountsResponse {..} =
    Core.object
      ( Core.catMaybes
          [ ("accounts" Core..=) Core.<$> accounts,
            ("nextPageToken" Core..=) Core.<$> nextPageToken
          ]
      )

-- | Response definition for the custom channel list rpc.
--
-- /See:/ 'newListCustomChannelsResponse' smart constructor.
data ListCustomChannelsResponse = ListCustomChannelsResponse
  { -- | The custom channels returned in this list response.
    customChannels :: (Core.Maybe [CustomChannel]),
    -- | Continuation token used to page through alerts. To retrieve the next page of the results, set the next request\'s \"page_token\" value to this.
    nextPageToken :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ListCustomChannelsResponse' with the minimum fields required to make a request.
newListCustomChannelsResponse ::
  ListCustomChannelsResponse
newListCustomChannelsResponse =
  ListCustomChannelsResponse
    { customChannels = Core.Nothing,
      nextPageToken = Core.Nothing
    }

instance Core.FromJSON ListCustomChannelsResponse where
  parseJSON =
    Core.withObject
      "ListCustomChannelsResponse"
      ( \o ->
          ListCustomChannelsResponse
            Core.<$> (o Core..:? "customChannels")
            Core.<*> (o Core..:? "nextPageToken")
      )

instance Core.ToJSON ListCustomChannelsResponse where
  toJSON ListCustomChannelsResponse {..} =
    Core.object
      ( Core.catMaybes
          [ ("customChannels" Core..=) Core.<$> customChannels,
            ("nextPageToken" Core..=) Core.<$> nextPageToken
          ]
      )

-- | Response definition for the ad units linked to a custom channel list rpc.
--
-- /See:/ 'newListLinkedAdUnitsResponse' smart constructor.
data ListLinkedAdUnitsResponse = ListLinkedAdUnitsResponse
  { -- | The ad units returned in the list response.
    adUnits :: (Core.Maybe [AdUnit]),
    -- | Continuation token used to page through ad units. To retrieve the next page of the results, set the next request\'s \"page_token\" value to this.
    nextPageToken :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ListLinkedAdUnitsResponse' with the minimum fields required to make a request.
newListLinkedAdUnitsResponse ::
  ListLinkedAdUnitsResponse
newListLinkedAdUnitsResponse =
  ListLinkedAdUnitsResponse
    { adUnits = Core.Nothing,
      nextPageToken = Core.Nothing
    }

instance Core.FromJSON ListLinkedAdUnitsResponse where
  parseJSON =
    Core.withObject
      "ListLinkedAdUnitsResponse"
      ( \o ->
          ListLinkedAdUnitsResponse
            Core.<$> (o Core..:? "adUnits")
            Core.<*> (o Core..:? "nextPageToken")
      )

instance Core.ToJSON ListLinkedAdUnitsResponse where
  toJSON ListLinkedAdUnitsResponse {..} =
    Core.object
      ( Core.catMaybes
          [ ("adUnits" Core..=) Core.<$> adUnits,
            ("nextPageToken" Core..=) Core.<$> nextPageToken
          ]
      )

-- | Response definition for the custom channels linked to an adunit list rpc.
--
-- /See:/ 'newListLinkedCustomChannelsResponse' smart constructor.
data ListLinkedCustomChannelsResponse = ListLinkedCustomChannelsResponse
  { -- | The custom channels returned in this list response.
    customChannels :: (Core.Maybe [CustomChannel]),
    -- | Continuation token used to page through alerts. To retrieve the next page of the results, set the next request\'s \"page_token\" value to this.
    nextPageToken :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ListLinkedCustomChannelsResponse' with the minimum fields required to make a request.
newListLinkedCustomChannelsResponse ::
  ListLinkedCustomChannelsResponse
newListLinkedCustomChannelsResponse =
  ListLinkedCustomChannelsResponse
    { customChannels = Core.Nothing,
      nextPageToken = Core.Nothing
    }

instance Core.FromJSON ListLinkedCustomChannelsResponse where
  parseJSON =
    Core.withObject
      "ListLinkedCustomChannelsResponse"
      ( \o ->
          ListLinkedCustomChannelsResponse
            Core.<$> (o Core..:? "customChannels")
            Core.<*> (o Core..:? "nextPageToken")
      )

instance Core.ToJSON ListLinkedCustomChannelsResponse where
  toJSON ListLinkedCustomChannelsResponse {..} =
    Core.object
      ( Core.catMaybes
          [ ("customChannels" Core..=) Core.<$> customChannels,
            ("nextPageToken" Core..=) Core.<$> nextPageToken
          ]
      )

-- | Response definition for the payments list rpc.
--
-- /See:/ 'newListPaymentsResponse' smart constructor.
newtype ListPaymentsResponse = ListPaymentsResponse
  { -- | The payments returned in this list response.
    payments :: (Core.Maybe [Payment])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ListPaymentsResponse' with the minimum fields required to make a request.
newListPaymentsResponse ::
  ListPaymentsResponse
newListPaymentsResponse =
  ListPaymentsResponse {payments = Core.Nothing}

instance Core.FromJSON ListPaymentsResponse where
  parseJSON =
    Core.withObject
      "ListPaymentsResponse"
      (\o -> ListPaymentsResponse Core.<$> (o Core..:? "payments"))

instance Core.ToJSON ListPaymentsResponse where
  toJSON ListPaymentsResponse {..} =
    Core.object
      (Core.catMaybes [("payments" Core..=) Core.<$> payments])

-- | Response definition for the policy issues list rpc. Policy issues are reported only if the publisher has at least one AFC ad client in READY or GETTING_READY state. If the publisher has no such AFC ad client, the response will be an empty list.
--
-- /See:/ 'newListPolicyIssuesResponse' smart constructor.
data ListPolicyIssuesResponse = ListPolicyIssuesResponse
  { -- | Continuation token used to page through policy issues. To retrieve the next page of the results, set the next request\'s \"page_token\" value to this.
    nextPageToken :: (Core.Maybe Core.Text),
    -- | The policy issues returned in the list response.
    policyIssues :: (Core.Maybe [PolicyIssue])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ListPolicyIssuesResponse' with the minimum fields required to make a request.
newListPolicyIssuesResponse ::
  ListPolicyIssuesResponse
newListPolicyIssuesResponse =
  ListPolicyIssuesResponse
    { nextPageToken = Core.Nothing,
      policyIssues = Core.Nothing
    }

instance Core.FromJSON ListPolicyIssuesResponse where
  parseJSON =
    Core.withObject
      "ListPolicyIssuesResponse"
      ( \o ->
          ListPolicyIssuesResponse
            Core.<$> (o Core..:? "nextPageToken")
            Core.<*> (o Core..:? "policyIssues")
      )

instance Core.ToJSON ListPolicyIssuesResponse where
  toJSON ListPolicyIssuesResponse {..} =
    Core.object
      ( Core.catMaybes
          [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
            ("policyIssues" Core..=) Core.<$> policyIssues
          ]
      )

-- | Response definition for the saved reports list rpc.
--
-- /See:/ 'newListSavedReportsResponse' smart constructor.
data ListSavedReportsResponse = ListSavedReportsResponse
  { -- | Continuation token used to page through reports. To retrieve the next page of the results, set the next request\'s \"page_token\" value to this.
    nextPageToken :: (Core.Maybe Core.Text),
    -- | The reports returned in this list response.
    savedReports :: (Core.Maybe [SavedReport])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ListSavedReportsResponse' with the minimum fields required to make a request.
newListSavedReportsResponse ::
  ListSavedReportsResponse
newListSavedReportsResponse =
  ListSavedReportsResponse
    { nextPageToken = Core.Nothing,
      savedReports = Core.Nothing
    }

instance Core.FromJSON ListSavedReportsResponse where
  parseJSON =
    Core.withObject
      "ListSavedReportsResponse"
      ( \o ->
          ListSavedReportsResponse
            Core.<$> (o Core..:? "nextPageToken")
            Core.<*> (o Core..:? "savedReports")
      )

instance Core.ToJSON ListSavedReportsResponse where
  toJSON ListSavedReportsResponse {..} =
    Core.object
      ( Core.catMaybes
          [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
            ("savedReports" Core..=) Core.<$> savedReports
          ]
      )

-- | Response definition for the sites list rpc.
--
-- /See:/ 'newListSitesResponse' smart constructor.
data ListSitesResponse = ListSitesResponse
  { -- | Continuation token used to page through sites. To retrieve the next page of the results, set the next request\'s \"page_token\" value to this.
    nextPageToken :: (Core.Maybe Core.Text),
    -- | The sites returned in this list response.
    sites :: (Core.Maybe [Site])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ListSitesResponse' with the minimum fields required to make a request.
newListSitesResponse ::
  ListSitesResponse
newListSitesResponse =
  ListSitesResponse
    { nextPageToken = Core.Nothing,
      sites = Core.Nothing
    }

instance Core.FromJSON ListSitesResponse where
  parseJSON =
    Core.withObject
      "ListSitesResponse"
      ( \o ->
          ListSitesResponse
            Core.<$> (o Core..:? "nextPageToken")
            Core.<*> (o Core..:? "sites")
      )

instance Core.ToJSON ListSitesResponse where
  toJSON ListSitesResponse {..} =
    Core.object
      ( Core.catMaybes
          [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
            ("sites" Core..=) Core.<$> sites
          ]
      )

-- | Response definition for the url channels list rpc.
--
-- /See:/ 'newListUrlChannelsResponse' smart constructor.
data ListUrlChannelsResponse = ListUrlChannelsResponse
  { -- | Continuation token used to page through url channels. To retrieve the next page of the results, set the next request\'s \"page_token\" value to this.
    nextPageToken :: (Core.Maybe Core.Text),
    -- | The url channels returned in this list response.
    urlChannels :: (Core.Maybe [UrlChannel])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ListUrlChannelsResponse' with the minimum fields required to make a request.
newListUrlChannelsResponse ::
  ListUrlChannelsResponse
newListUrlChannelsResponse =
  ListUrlChannelsResponse
    { nextPageToken = Core.Nothing,
      urlChannels = Core.Nothing
    }

instance Core.FromJSON ListUrlChannelsResponse where
  parseJSON =
    Core.withObject
      "ListUrlChannelsResponse"
      ( \o ->
          ListUrlChannelsResponse
            Core.<$> (o Core..:? "nextPageToken")
            Core.<*> (o Core..:? "urlChannels")
      )

instance Core.ToJSON ListUrlChannelsResponse where
  toJSON ListUrlChannelsResponse {..} =
    Core.object
      ( Core.catMaybes
          [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
            ("urlChannels" Core..=) Core.<$> urlChannels
          ]
      )

-- | Representation of an unpaid or paid payment. See <https://support.google.com/adsense/answer/7164703 Payment timelines for AdSense> for more information about payments and the <https://support.google.com/adsense/answer/11622510 YouTube homepage and payments account> article for information about dedicated payments accounts for YouTube.
--
-- /See:/ 'newPayment' smart constructor.
data Payment = Payment
  { -- | Output only. The amount of unpaid or paid earnings, as a formatted string, including the currency. E.g. \"¥1,235 JPY\", \"$1,234.57\", \"£87.65\".
    amount :: (Core.Maybe Core.Text),
    -- | Output only. For paid earnings, the date that the payment was credited. For unpaid earnings, this field is empty. Payment dates are always returned in the billing timezone (America\/Los_Angeles).
    date :: (Core.Maybe Date),
    -- | Output only. Resource name of the payment. Format: - accounts\/{account}\/payments\/unpaid for unpaid (current) AdSense earnings. - accounts\/{account}\/payments\/youtube-unpaid for unpaid (current) YouTube earnings. - accounts\/{account}\/payments\/yyyy-MM-dd for paid AdSense earnings. - accounts\/{account}\/payments\/youtube-yyyy-MM-dd for paid YouTube earnings.
    name :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Payment' with the minimum fields required to make a request.
newPayment ::
  Payment
newPayment =
  Payment
    { amount = Core.Nothing,
      date = Core.Nothing,
      name = Core.Nothing
    }

instance Core.FromJSON Payment where
  parseJSON =
    Core.withObject
      "Payment"
      ( \o ->
          Payment
            Core.<$> (o Core..:? "amount")
            Core.<*> (o Core..:? "date")
            Core.<*> (o Core..:? "name")
      )

instance Core.ToJSON Payment where
  toJSON Payment {..} =
    Core.object
      ( Core.catMaybes
          [ ("amount" Core..=) Core.<$> amount,
            ("date" Core..=) Core.<$> date,
            ("name" Core..=) Core.<$> name
          ]
      )

-- | Representation of a policy issue for a single entity (site, site-section, or page). All issues for a single entity are represented by a single PolicyIssue resource, though that PolicyIssue can have multiple causes (or \"topics\") that can change over time. Policy issues are removed if there are no issues detected recently or if there\'s a recent successful appeal for the entity.
--
-- /See:/ 'newPolicyIssue' smart constructor.
data PolicyIssue = PolicyIssue
  { -- | Required. The most severe action taken on the entity over the past seven days.
    action :: (Core.Maybe PolicyIssue_Action),
    -- | Optional. List of ad clients associated with the policy issue (either as the primary ad client or an associated host\/secondary ad client). In the latter case, this will be an ad client that is not owned by the current account.
    adClients :: (Core.Maybe [Core.Text]),
    -- | Required. Total number of ad requests affected by the policy violations over the past seven days.
    adRequestCount :: (Core.Maybe Core.Int64),
    -- | Required. Type of the entity indicating if the entity is a site, site-section, or page.
    entityType :: (Core.Maybe PolicyIssue_EntityType),
    -- | Required. The date (in the America\/Los_Angeles timezone) when policy violations were first detected on the entity.
    firstDetectedDate :: (Core.Maybe Date),
    -- | Required. The date (in the America\/Los_Angeles timezone) when policy violations were last detected on the entity.
    lastDetectedDate :: (Core.Maybe Date),
    -- | Required. Resource name of the entity with policy issues. Format: accounts\/{account}\/policyIssues\/{policy_issue}
    name :: (Core.Maybe Core.Text),
    -- | Required. Unordered list. The policy topics that this entity was found to violate over the past seven days.
    policyTopics :: (Core.Maybe [PolicyTopic]),
    -- | Required. Hostname\/domain of the entity (for example \"foo.com\" or \"www.foo.com\"). This /should/ be a bare domain\/host name without any protocol. This will be present for all policy issues.
    site :: (Core.Maybe Core.Text),
    -- | Optional. Prefix of the site-section having policy issues (For example \"foo.com\/bar-section\"). This will be present if the @entity_type@ is @SITE_SECTION@ and will be absent for other entity types.
    siteSection :: (Core.Maybe Core.Text),
    -- | Optional. URI of the page having policy violations (for example \"foo.com\/bar\" or \"www.foo.com\/bar\"). This will be present if the @entity_type@ is @PAGE@ and will be absent for other entity types.
    uri :: (Core.Maybe Core.Text),
    -- | Optional. The date (in the America\/Los_Angeles timezone) when the entity will have ad serving demand restricted or ad serving disabled. This is present only for issues with a @WARNED@ enforcement action. See https:\/\/support.google.com\/adsense\/answer\/11066888.
    warningEscalationDate :: (Core.Maybe Date)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'PolicyIssue' with the minimum fields required to make a request.
newPolicyIssue ::
  PolicyIssue
newPolicyIssue =
  PolicyIssue
    { action = Core.Nothing,
      adClients = Core.Nothing,
      adRequestCount = Core.Nothing,
      entityType = Core.Nothing,
      firstDetectedDate = Core.Nothing,
      lastDetectedDate = Core.Nothing,
      name = Core.Nothing,
      policyTopics = Core.Nothing,
      site = Core.Nothing,
      siteSection = Core.Nothing,
      uri = Core.Nothing,
      warningEscalationDate = Core.Nothing
    }

instance Core.FromJSON PolicyIssue where
  parseJSON =
    Core.withObject
      "PolicyIssue"
      ( \o ->
          PolicyIssue
            Core.<$> (o Core..:? "action")
            Core.<*> (o Core..:? "adClients")
            Core.<*> (o Core..:? "adRequestCount" Core.<&> Core.fmap Core.fromAsText)
            Core.<*> (o Core..:? "entityType")
            Core.<*> (o Core..:? "firstDetectedDate")
            Core.<*> (o Core..:? "lastDetectedDate")
            Core.<*> (o Core..:? "name")
            Core.<*> (o Core..:? "policyTopics")
            Core.<*> (o Core..:? "site")
            Core.<*> (o Core..:? "siteSection")
            Core.<*> (o Core..:? "uri")
            Core.<*> (o Core..:? "warningEscalationDate")
      )

instance Core.ToJSON PolicyIssue where
  toJSON PolicyIssue {..} =
    Core.object
      ( Core.catMaybes
          [ ("action" Core..=) Core.<$> action,
            ("adClients" Core..=) Core.<$> adClients,
            ("adRequestCount" Core..=)
              Core.. Core.AsText
              Core.<$> adRequestCount,
            ("entityType" Core..=) Core.<$> entityType,
            ("firstDetectedDate" Core..=) Core.<$> firstDetectedDate,
            ("lastDetectedDate" Core..=) Core.<$> lastDetectedDate,
            ("name" Core..=) Core.<$> name,
            ("policyTopics" Core..=) Core.<$> policyTopics,
            ("site" Core..=) Core.<$> site,
            ("siteSection" Core..=) Core.<$> siteSection,
            ("uri" Core..=) Core.<$> uri,
            ("warningEscalationDate" Core..=) Core.<$> warningEscalationDate
          ]
      )

-- | Information about a particular policy topic. A policy topic represents a single class of policy issue that can impact ad serving for your site. For example, sexual content or having ads that obscure your content. A single policy issue can have multiple policy topics for a single entity.
--
-- /See:/ 'newPolicyTopic' smart constructor.
data PolicyTopic = PolicyTopic
  { -- | Required. Deprecated. Policy topics no longer have a \"must-fix\" classification.
    mustFix :: (Core.Maybe Core.Bool),
    -- | Required. The policy topic. For example, \"sexual-content\" or \"ads-obscuring-content\".\"
    topic :: (Core.Maybe Core.Text),
    -- | Optional. The type of policy topic. For example, \"POLICY\" represents all the policy topics that are related to the Google Publisher Policy (GPP). See https:\/\/support.google.com\/adsense\/answer\/15689616.
    type' :: (Core.Maybe PolicyTopic_Type)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'PolicyTopic' with the minimum fields required to make a request.
newPolicyTopic ::
  PolicyTopic
newPolicyTopic =
  PolicyTopic
    { mustFix = Core.Nothing,
      topic = Core.Nothing,
      type' = Core.Nothing
    }

instance Core.FromJSON PolicyTopic where
  parseJSON =
    Core.withObject
      "PolicyTopic"
      ( \o ->
          PolicyTopic
            Core.<$> (o Core..:? "mustFix")
            Core.<*> (o Core..:? "topic")
            Core.<*> (o Core..:? "type")
      )

instance Core.ToJSON PolicyTopic where
  toJSON PolicyTopic {..} =
    Core.object
      ( Core.catMaybes
          [ ("mustFix" Core..=) Core.<$> mustFix,
            ("topic" Core..=) Core.<$> topic,
            ("type" Core..=) Core.<$> type'
          ]
      )

-- | Result of a generated report.
--
-- /See:/ 'newReportResult' smart constructor.
data ReportResult = ReportResult
  { -- | The averages of the report. This is the same length as any other row in the report; cells corresponding to dimension columns are empty.
    averages :: (Core.Maybe Row),
    -- | Required. End date of the range (inclusive).
    endDate :: (Core.Maybe Date),
    -- | The header information; one for each dimension in the request, followed by one for each metric in the request.
    headers :: (Core.Maybe [Header]),
    -- | The output rows of the report. Each row is a list of cells; one for each dimension in the request, followed by one for each metric in the request.
    rows :: (Core.Maybe [Row]),
    -- | Required. Start date of the range (inclusive).
    startDate :: (Core.Maybe Date),
    -- | The total number of rows matched by the report request.
    totalMatchedRows :: (Core.Maybe Core.Int64),
    -- | The totals of the report. This is the same length as any other row in the report; cells corresponding to dimension columns are empty.
    totals :: (Core.Maybe Row),
    -- | Any warnings associated with generation of the report. These warnings are always returned in English.
    warnings :: (Core.Maybe [Core.Text])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ReportResult' with the minimum fields required to make a request.
newReportResult ::
  ReportResult
newReportResult =
  ReportResult
    { averages = Core.Nothing,
      endDate = Core.Nothing,
      headers = Core.Nothing,
      rows = Core.Nothing,
      startDate = Core.Nothing,
      totalMatchedRows = Core.Nothing,
      totals = Core.Nothing,
      warnings = Core.Nothing
    }

instance Core.FromJSON ReportResult where
  parseJSON =
    Core.withObject
      "ReportResult"
      ( \o ->
          ReportResult
            Core.<$> (o Core..:? "averages")
            Core.<*> (o Core..:? "endDate")
            Core.<*> (o Core..:? "headers")
            Core.<*> (o Core..:? "rows")
            Core.<*> (o Core..:? "startDate")
            Core.<*> (o Core..:? "totalMatchedRows" Core.<&> Core.fmap Core.fromAsText)
            Core.<*> (o Core..:? "totals")
            Core.<*> (o Core..:? "warnings")
      )

instance Core.ToJSON ReportResult where
  toJSON ReportResult {..} =
    Core.object
      ( Core.catMaybes
          [ ("averages" Core..=) Core.<$> averages,
            ("endDate" Core..=) Core.<$> endDate,
            ("headers" Core..=) Core.<$> headers,
            ("rows" Core..=) Core.<$> rows,
            ("startDate" Core..=) Core.<$> startDate,
            ("totalMatchedRows" Core..=)
              Core.. Core.AsText
              Core.<$> totalMatchedRows,
            ("totals" Core..=) Core.<$> totals,
            ("warnings" Core..=) Core.<$> warnings
          ]
      )

-- | Row representation.
--
-- /See:/ 'newRow' smart constructor.
newtype Row = Row
  { -- | Cells in the row.
    cells :: (Core.Maybe [Cell])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Row' with the minimum fields required to make a request.
newRow ::
  Row
newRow = Row {cells = Core.Nothing}

instance Core.FromJSON Row where
  parseJSON =
    Core.withObject "Row" (\o -> Row Core.<$> (o Core..:? "cells"))

instance Core.ToJSON Row where
  toJSON Row {..} =
    Core.object (Core.catMaybes [("cells" Core..=) Core.<$> cells])

-- | Representation of a saved report.
--
-- /See:/ 'newSavedReport' smart constructor.
data SavedReport = SavedReport
  { -- | Output only. Resource name of the report. Format: accounts\/{account}\/reports\/{report}
    name :: (Core.Maybe Core.Text),
    -- | Report title as specified by publisher.
    title :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SavedReport' with the minimum fields required to make a request.
newSavedReport ::
  SavedReport
newSavedReport =
  SavedReport {name = Core.Nothing, title = Core.Nothing}

instance Core.FromJSON SavedReport where
  parseJSON =
    Core.withObject
      "SavedReport"
      ( \o ->
          SavedReport
            Core.<$> (o Core..:? "name")
            Core.<*> (o Core..:? "title")
      )

instance Core.ToJSON SavedReport where
  toJSON SavedReport {..} =
    Core.object
      ( Core.catMaybes
          [("name" Core..=) Core.<$> name, ("title" Core..=) Core.<$> title]
      )

-- | Representation of a Site.
--
-- /See:/ 'newSite' smart constructor.
data Site = Site
  { -- | Whether auto ads is turned on for the site.
    autoAdsEnabled :: (Core.Maybe Core.Bool),
    -- | Domain (or subdomain) of the site, e.g. \"example.com\" or \"www.example.com\". This is used in the @OWNED_SITE_DOMAIN_NAME@ reporting dimension.
    domain :: (Core.Maybe Core.Text),
    -- | Output only. Resource name of a site. Format: accounts\/{account}\/sites\/{site}
    name :: (Core.Maybe Core.Text),
    -- | Output only. Unique ID of the site as used in the @OWNED_SITE_ID@ reporting dimension.
    reportingDimensionId :: (Core.Maybe Core.Text),
    -- | Output only. State of a site.
    state :: (Core.Maybe Site_State)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Site' with the minimum fields required to make a request.
newSite ::
  Site
newSite =
  Site
    { autoAdsEnabled = Core.Nothing,
      domain = Core.Nothing,
      name = Core.Nothing,
      reportingDimensionId = Core.Nothing,
      state = Core.Nothing
    }

instance Core.FromJSON Site where
  parseJSON =
    Core.withObject
      "Site"
      ( \o ->
          Site
            Core.<$> (o Core..:? "autoAdsEnabled")
            Core.<*> (o Core..:? "domain")
            Core.<*> (o Core..:? "name")
            Core.<*> (o Core..:? "reportingDimensionId")
            Core.<*> (o Core..:? "state")
      )

instance Core.ToJSON Site where
  toJSON Site {..} =
    Core.object
      ( Core.catMaybes
          [ ("autoAdsEnabled" Core..=) Core.<$> autoAdsEnabled,
            ("domain" Core..=) Core.<$> domain,
            ("name" Core..=) Core.<$> name,
            ("reportingDimensionId" Core..=) Core.<$> reportingDimensionId,
            ("state" Core..=) Core.<$> state
          ]
      )

-- | Represents a time zone from the <https://www.iana.org/time-zones IANA Time Zone Database>.
--
-- /See:/ 'newTimeZone' smart constructor.
data TimeZone = TimeZone
  { -- | IANA Time Zone Database time zone. For example \"America\/New_York\".
    id :: (Core.Maybe Core.Text),
    -- | Optional. IANA Time Zone Database version number. For example \"2019a\".
    version :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TimeZone' with the minimum fields required to make a request.
newTimeZone ::
  TimeZone
newTimeZone = TimeZone {id = Core.Nothing, version = Core.Nothing}

instance Core.FromJSON TimeZone where
  parseJSON =
    Core.withObject
      "TimeZone"
      ( \o ->
          TimeZone
            Core.<$> (o Core..:? "id")
            Core.<*> (o Core..:? "version")
      )

instance Core.ToJSON TimeZone where
  toJSON TimeZone {..} =
    Core.object
      ( Core.catMaybes
          [("id" Core..=) Core.<$> id, ("version" Core..=) Core.<$> version]
      )

-- | Representation of a URL channel. URL channels allow you to track the performance of particular pages in your site; see <https://support.google.com/adsense/answer/2923836 URL channels> for more information.
--
-- /See:/ 'newUrlChannel' smart constructor.
data UrlChannel = UrlChannel
  { -- | Output only. Resource name of the URL channel. Format: accounts\/{account}\/adclients\/{adclient}\/urlchannels\/{urlchannel}
    name :: (Core.Maybe Core.Text),
    -- | Output only. Unique ID of the custom channel as used in the @URL_CHANNEL_ID@ reporting dimension.
    reportingDimensionId :: (Core.Maybe Core.Text),
    -- | URI pattern of the channel. Does not include \"http:\/\/\" or \"https:\/\/\". Example: www.example.com\/home
    uriPattern :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'UrlChannel' with the minimum fields required to make a request.
newUrlChannel ::
  UrlChannel
newUrlChannel =
  UrlChannel
    { name = Core.Nothing,
      reportingDimensionId = Core.Nothing,
      uriPattern = Core.Nothing
    }

instance Core.FromJSON UrlChannel where
  parseJSON =
    Core.withObject
      "UrlChannel"
      ( \o ->
          UrlChannel
            Core.<$> (o Core..:? "name")
            Core.<*> (o Core..:? "reportingDimensionId")
            Core.<*> (o Core..:? "uriPattern")
      )

instance Core.ToJSON UrlChannel where
  toJSON UrlChannel {..} =
    Core.object
      ( Core.catMaybes
          [ ("name" Core..=) Core.<$> name,
            ("reportingDimensionId" Core..=) Core.<$> reportingDimensionId,
            ("uriPattern" Core..=) Core.<$> uriPattern
          ]
      )