{-# 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.Books.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.Books.Internal.Product
  ( -- * Annotation
    Annotation (..),
    newAnnotation,

    -- * Annotation_ClientVersionRanges
    Annotation_ClientVersionRanges (..),
    newAnnotation_ClientVersionRanges,

    -- * Annotation_CurrentVersionRanges
    Annotation_CurrentVersionRanges (..),
    newAnnotation_CurrentVersionRanges,

    -- * Annotation_LayerSummary
    Annotation_LayerSummary (..),
    newAnnotation_LayerSummary,

    -- * Annotations
    Annotations (..),
    newAnnotations,

    -- * AnnotationsSummary
    AnnotationsSummary (..),
    newAnnotationsSummary,

    -- * AnnotationsSummary_LayersItem
    AnnotationsSummary_LayersItem (..),
    newAnnotationsSummary_LayersItem,

    -- * Annotationsdata
    Annotationsdata (..),
    newAnnotationsdata,

    -- * BooksAnnotationsRange
    BooksAnnotationsRange (..),
    newBooksAnnotationsRange,

    -- * BooksCloudloadingResource
    BooksCloudloadingResource (..),
    newBooksCloudloadingResource,

    -- * BooksVolumesRecommendedRateResponse
    BooksVolumesRecommendedRateResponse (..),
    newBooksVolumesRecommendedRateResponse,

    -- * Bookshelf
    Bookshelf (..),
    newBookshelf,

    -- * Bookshelves
    Bookshelves (..),
    newBookshelves,

    -- * Category
    Category (..),
    newCategory,

    -- * Category_ItemsItem
    Category_ItemsItem (..),
    newCategory_ItemsItem,

    -- * ConcurrentAccessRestriction
    ConcurrentAccessRestriction (..),
    newConcurrentAccessRestriction,

    -- * DictionaryAnnotationdata
    DictionaryAnnotationdata (..),
    newDictionaryAnnotationdata,

    -- * Dictlayerdata
    Dictlayerdata (..),
    newDictlayerdata,

    -- * Dictlayerdata_Common
    Dictlayerdata_Common (..),
    newDictlayerdata_Common,

    -- * Dictlayerdata_Dict
    Dictlayerdata_Dict (..),
    newDictlayerdata_Dict,

    -- * Dictlayerdata_Dict_Source
    Dictlayerdata_Dict_Source (..),
    newDictlayerdata_Dict_Source,

    -- * Dictlayerdata_Dict_WordsItem
    Dictlayerdata_Dict_WordsItem (..),
    newDictlayerdata_Dict_WordsItem,

    -- * Dictlayerdata_Dict_WordsItem_DerivativesItem
    Dictlayerdata_Dict_WordsItem_DerivativesItem (..),
    newDictlayerdata_Dict_WordsItem_DerivativesItem,

    -- * Dictlayerdata_Dict_WordsItem_DerivativesItem_Source
    Dictlayerdata_Dict_WordsItem_DerivativesItem_Source (..),
    newDictlayerdata_Dict_WordsItem_DerivativesItem_Source,

    -- * Dictlayerdata_Dict_WordsItem_ExamplesItem
    Dictlayerdata_Dict_WordsItem_ExamplesItem (..),
    newDictlayerdata_Dict_WordsItem_ExamplesItem,

    -- * Dictlayerdata_Dict_WordsItem_ExamplesItem_Source
    Dictlayerdata_Dict_WordsItem_ExamplesItem_Source (..),
    newDictlayerdata_Dict_WordsItem_ExamplesItem_Source,

    -- * Dictlayerdata_Dict_WordsItem_SensesItem
    Dictlayerdata_Dict_WordsItem_SensesItem (..),
    newDictlayerdata_Dict_WordsItem_SensesItem,

    -- * Dictlayerdata_Dict_WordsItem_SensesItem_ConjugationsItem
    Dictlayerdata_Dict_WordsItem_SensesItem_ConjugationsItem (..),
    newDictlayerdata_Dict_WordsItem_SensesItem_ConjugationsItem,

    -- * Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem
    Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem (..),
    newDictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem,

    -- * Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem
    Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem (..),
    newDictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem,

    -- * Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source
    Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source (..),
    newDictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source,

    -- * Dictlayerdata_Dict_WordsItem_SensesItem_Source
    Dictlayerdata_Dict_WordsItem_SensesItem_Source (..),
    newDictlayerdata_Dict_WordsItem_SensesItem_Source,

    -- * Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem
    Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem (..),
    newDictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem,

    -- * Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source
    Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source (..),
    newDictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source,

    -- * Dictlayerdata_Dict_WordsItem_Source
    Dictlayerdata_Dict_WordsItem_Source (..),
    newDictlayerdata_Dict_WordsItem_Source,

    -- * Discoveryclusters
    Discoveryclusters (..),
    newDiscoveryclusters,

    -- * Discoveryclusters_ClustersItem
    Discoveryclusters_ClustersItem (..),
    newDiscoveryclusters_ClustersItem,

    -- * Discoveryclusters_ClustersItem_Banner_with_content_container
    Discoveryclusters_ClustersItem_Banner_with_content_container (..),
    newDiscoveryclusters_ClustersItem_Banner_with_content_container,

    -- * DownloadAccessRestriction
    DownloadAccessRestriction (..),
    newDownloadAccessRestriction,

    -- * DownloadAccesses
    DownloadAccesses (..),
    newDownloadAccesses,

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

    -- * FamilyInfo
    FamilyInfo (..),
    newFamilyInfo,

    -- * FamilyInfo_Membership
    FamilyInfo_Membership (..),
    newFamilyInfo_Membership,

    -- * GeoAnnotationdata
    GeoAnnotationdata (..),
    newGeoAnnotationdata,

    -- * Geolayerdata
    Geolayerdata (..),
    newGeolayerdata,

    -- * Geolayerdata_Common
    Geolayerdata_Common (..),
    newGeolayerdata_Common,

    -- * Geolayerdata_Geo
    Geolayerdata_Geo (..),
    newGeolayerdata_Geo,

    -- * Geolayerdata_Geo_Viewport
    Geolayerdata_Geo_Viewport (..),
    newGeolayerdata_Geo_Viewport,

    -- * Geolayerdata_Geo_Viewport_Hi
    Geolayerdata_Geo_Viewport_Hi (..),
    newGeolayerdata_Geo_Viewport_Hi,

    -- * Geolayerdata_Geo_Viewport_Lo
    Geolayerdata_Geo_Viewport_Lo (..),
    newGeolayerdata_Geo_Viewport_Lo,

    -- * Layersummaries
    Layersummaries (..),
    newLayersummaries,

    -- * Layersummary
    Layersummary (..),
    newLayersummary,

    -- * Metadata
    Metadata (..),
    newMetadata,

    -- * Metadata_ItemsItem
    Metadata_ItemsItem (..),
    newMetadata_ItemsItem,

    -- * Notification
    Notification (..),
    newNotification,

    -- * Offers
    Offers (..),
    newOffers,

    -- * Offers_ItemsItem
    Offers_ItemsItem (..),
    newOffers_ItemsItem,

    -- * Offers_ItemsItem_ItemsItem
    Offers_ItemsItem_ItemsItem (..),
    newOffers_ItemsItem_ItemsItem,

    -- * ReadingPosition
    ReadingPosition (..),
    newReadingPosition,

    -- * RequestAccessData
    RequestAccessData (..),
    newRequestAccessData,

    -- * Review
    Review (..),
    newReview,

    -- * Review_Author
    Review_Author (..),
    newReview_Author,

    -- * Review_Source
    Review_Source (..),
    newReview_Source,

    -- * Series
    Series (..),
    newSeries,

    -- * Series_SeriesItem
    Series_SeriesItem (..),
    newSeries_SeriesItem,

    -- * Series_SeriesItem_SeriesSubscriptionReleaseInfo
    Series_SeriesItem_SeriesSubscriptionReleaseInfo (..),
    newSeries_SeriesItem_SeriesSubscriptionReleaseInfo,

    -- * Series_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo
    Series_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo (..),
    newSeries_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo,

    -- * Series_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo
    Series_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo (..),
    newSeries_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo,

    -- * Seriesmembership
    Seriesmembership (..),
    newSeriesmembership,

    -- * Usersettings
    Usersettings (..),
    newUsersettings,

    -- * Usersettings_NotesExport
    Usersettings_NotesExport (..),
    newUsersettings_NotesExport,

    -- * Usersettings_Notification
    Usersettings_Notification (..),
    newUsersettings_Notification,

    -- * Usersettings_Notification_MatchMyInterests
    Usersettings_Notification_MatchMyInterests (..),
    newUsersettings_Notification_MatchMyInterests,

    -- * Usersettings_Notification_MoreFromAuthors
    Usersettings_Notification_MoreFromAuthors (..),
    newUsersettings_Notification_MoreFromAuthors,

    -- * Usersettings_Notification_MoreFromSeries
    Usersettings_Notification_MoreFromSeries (..),
    newUsersettings_Notification_MoreFromSeries,

    -- * Usersettings_Notification_PriceDrop
    Usersettings_Notification_PriceDrop (..),
    newUsersettings_Notification_PriceDrop,

    -- * Usersettings_Notification_RewardExpirations
    Usersettings_Notification_RewardExpirations (..),
    newUsersettings_Notification_RewardExpirations,

    -- * Volume
    Volume (..),
    newVolume,

    -- * Volume_AccessInfo
    Volume_AccessInfo (..),
    newVolume_AccessInfo,

    -- * Volume_AccessInfo_Epub
    Volume_AccessInfo_Epub (..),
    newVolume_AccessInfo_Epub,

    -- * Volume_AccessInfo_Pdf
    Volume_AccessInfo_Pdf (..),
    newVolume_AccessInfo_Pdf,

    -- * Volume_LayerInfo
    Volume_LayerInfo (..),
    newVolume_LayerInfo,

    -- * Volume_LayerInfo_LayersItem
    Volume_LayerInfo_LayersItem (..),
    newVolume_LayerInfo_LayersItem,

    -- * Volume_RecommendedInfo
    Volume_RecommendedInfo (..),
    newVolume_RecommendedInfo,

    -- * Volume_SaleInfo
    Volume_SaleInfo (..),
    newVolume_SaleInfo,

    -- * Volume_SaleInfo_ListPrice
    Volume_SaleInfo_ListPrice (..),
    newVolume_SaleInfo_ListPrice,

    -- * Volume_SaleInfo_OffersItem
    Volume_SaleInfo_OffersItem (..),
    newVolume_SaleInfo_OffersItem,

    -- * Volume_SaleInfo_OffersItem_ListPrice
    Volume_SaleInfo_OffersItem_ListPrice (..),
    newVolume_SaleInfo_OffersItem_ListPrice,

    -- * Volume_SaleInfo_OffersItem_RentalDuration
    Volume_SaleInfo_OffersItem_RentalDuration (..),
    newVolume_SaleInfo_OffersItem_RentalDuration,

    -- * Volume_SaleInfo_OffersItem_RetailPrice
    Volume_SaleInfo_OffersItem_RetailPrice (..),
    newVolume_SaleInfo_OffersItem_RetailPrice,

    -- * Volume_SaleInfo_RetailPrice
    Volume_SaleInfo_RetailPrice (..),
    newVolume_SaleInfo_RetailPrice,

    -- * Volume_SearchInfo
    Volume_SearchInfo (..),
    newVolume_SearchInfo,

    -- * Volume_UserInfo
    Volume_UserInfo (..),
    newVolume_UserInfo,

    -- * Volume_UserInfo_Copy
    Volume_UserInfo_Copy (..),
    newVolume_UserInfo_Copy,

    -- * Volume_UserInfo_FamilySharing
    Volume_UserInfo_FamilySharing (..),
    newVolume_UserInfo_FamilySharing,

    -- * Volume_UserInfo_RentalPeriod
    Volume_UserInfo_RentalPeriod (..),
    newVolume_UserInfo_RentalPeriod,

    -- * Volume_UserInfo_UserUploadedVolumeInfo
    Volume_UserInfo_UserUploadedVolumeInfo (..),
    newVolume_UserInfo_UserUploadedVolumeInfo,

    -- * Volume_VolumeInfo
    Volume_VolumeInfo (..),
    newVolume_VolumeInfo,

    -- * Volume_VolumeInfo_Dimensions
    Volume_VolumeInfo_Dimensions (..),
    newVolume_VolumeInfo_Dimensions,

    -- * Volume_VolumeInfo_ImageLinks
    Volume_VolumeInfo_ImageLinks (..),
    newVolume_VolumeInfo_ImageLinks,

    -- * Volume_VolumeInfo_IndustryIdentifiersItem
    Volume_VolumeInfo_IndustryIdentifiersItem (..),
    newVolume_VolumeInfo_IndustryIdentifiersItem,

    -- * Volume_VolumeInfo_PanelizationSummary
    Volume_VolumeInfo_PanelizationSummary (..),
    newVolume_VolumeInfo_PanelizationSummary,

    -- * Volume_VolumeInfo_ReadingModes
    Volume_VolumeInfo_ReadingModes (..),
    newVolume_VolumeInfo_ReadingModes,

    -- * Volume2
    Volume2 (..),
    newVolume2,

    -- * Volumeannotation
    Volumeannotation (..),
    newVolumeannotation,

    -- * Volumeannotation_ContentRanges
    Volumeannotation_ContentRanges (..),
    newVolumeannotation_ContentRanges,

    -- * Volumeannotations
    Volumeannotations (..),
    newVolumeannotations,

    -- * Volumes
    Volumes (..),
    newVolumes,

    -- * Volumeseriesinfo
    Volumeseriesinfo (..),
    newVolumeseriesinfo,

    -- * Volumeseriesinfo_VolumeSeriesItem
    Volumeseriesinfo_VolumeSeriesItem (..),
    newVolumeseriesinfo_VolumeSeriesItem,

    -- * Volumeseriesinfo_VolumeSeriesItem_IssueItem
    Volumeseriesinfo_VolumeSeriesItem_IssueItem (..),
    newVolumeseriesinfo_VolumeSeriesItem_IssueItem,
  )
where

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

--
-- /See:/ 'newAnnotation' smart constructor.
data Annotation = Annotation
  { -- | Anchor text after excerpt. For requests, if the user bookmarked a screen that has no flowing text on it, then this field should be empty.
    afterSelectedText :: (Core.Maybe Core.Text),
    -- | Anchor text before excerpt. For requests, if the user bookmarked a screen that has no flowing text on it, then this field should be empty.
    beforeSelectedText :: (Core.Maybe Core.Text),
    -- | Selection ranges sent from the client.
    clientVersionRanges :: (Core.Maybe Annotation_ClientVersionRanges),
    -- | Timestamp for the created time of this annotation.
    created :: (Core.Maybe Core.Text),
    -- | Selection ranges for the most recent content version.
    currentVersionRanges :: (Core.Maybe Annotation_CurrentVersionRanges),
    -- | User-created data for this annotation.
    data' :: (Core.Maybe Core.Text),
    -- | Indicates that this annotation is deleted.
    deleted :: (Core.Maybe Core.Bool),
    -- | The highlight style for this annotation.
    highlightStyle :: (Core.Maybe Core.Text),
    -- | Id of this annotation, in the form of a GUID.
    id :: (Core.Maybe Core.Text),
    -- | Resource type.
    kind :: (Core.Maybe Core.Text),
    -- | The layer this annotation is for.
    layerId :: (Core.Maybe Core.Text),
    layerSummary :: (Core.Maybe Annotation_LayerSummary),
    -- | Pages that this annotation spans.
    pageIds :: (Core.Maybe [Core.Text]),
    -- | Excerpt from the volume.
    selectedText :: (Core.Maybe Core.Text),
    -- | URL to this resource.
    selfLink :: (Core.Maybe Core.Text),
    -- | Timestamp for the last time this annotation was modified.
    updated :: (Core.Maybe Core.Text),
    -- | The volume that this annotation belongs to.
    volumeId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Annotation' with the minimum fields required to make a request.
newAnnotation ::
  Annotation
newAnnotation =
  Annotation
    { afterSelectedText = Core.Nothing,
      beforeSelectedText = Core.Nothing,
      clientVersionRanges = Core.Nothing,
      created = Core.Nothing,
      currentVersionRanges = Core.Nothing,
      data' = Core.Nothing,
      deleted = Core.Nothing,
      highlightStyle = Core.Nothing,
      id = Core.Nothing,
      kind = Core.Nothing,
      layerId = Core.Nothing,
      layerSummary = Core.Nothing,
      pageIds = Core.Nothing,
      selectedText = Core.Nothing,
      selfLink = Core.Nothing,
      updated = Core.Nothing,
      volumeId = Core.Nothing
    }

instance Core.FromJSON Annotation where
  parseJSON =
    Core.withObject
      "Annotation"
      ( \o ->
          Annotation
            Core.<$> (o Core..:? "afterSelectedText")
            Core.<*> (o Core..:? "beforeSelectedText")
            Core.<*> (o Core..:? "clientVersionRanges")
            Core.<*> (o Core..:? "created")
            Core.<*> (o Core..:? "currentVersionRanges")
            Core.<*> (o Core..:? "data")
            Core.<*> (o Core..:? "deleted")
            Core.<*> (o Core..:? "highlightStyle")
            Core.<*> (o Core..:? "id")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "layerId")
            Core.<*> (o Core..:? "layerSummary")
            Core.<*> (o Core..:? "pageIds")
            Core.<*> (o Core..:? "selectedText")
            Core.<*> (o Core..:? "selfLink")
            Core.<*> (o Core..:? "updated")
            Core.<*> (o Core..:? "volumeId")
      )

instance Core.ToJSON Annotation where
  toJSON Annotation {..} =
    Core.object
      ( Core.catMaybes
          [ ("afterSelectedText" Core..=) Core.<$> afterSelectedText,
            ("beforeSelectedText" Core..=) Core.<$> beforeSelectedText,
            ("clientVersionRanges" Core..=) Core.<$> clientVersionRanges,
            ("created" Core..=) Core.<$> created,
            ("currentVersionRanges" Core..=) Core.<$> currentVersionRanges,
            ("data" Core..=) Core.<$> data',
            ("deleted" Core..=) Core.<$> deleted,
            ("highlightStyle" Core..=) Core.<$> highlightStyle,
            ("id" Core..=) Core.<$> id,
            ("kind" Core..=) Core.<$> kind,
            ("layerId" Core..=) Core.<$> layerId,
            ("layerSummary" Core..=) Core.<$> layerSummary,
            ("pageIds" Core..=) Core.<$> pageIds,
            ("selectedText" Core..=) Core.<$> selectedText,
            ("selfLink" Core..=) Core.<$> selfLink,
            ("updated" Core..=) Core.<$> updated,
            ("volumeId" Core..=) Core.<$> volumeId
          ]
      )

-- | Selection ranges sent from the client.
--
-- /See:/ 'newAnnotation_ClientVersionRanges' smart constructor.
data Annotation_ClientVersionRanges = Annotation_ClientVersionRanges
  { -- | Range in CFI format for this annotation sent by client.
    cfiRange :: (Core.Maybe BooksAnnotationsRange),
    -- | Content version the client sent in.
    contentVersion :: (Core.Maybe Core.Text),
    -- | Range in GB image format for this annotation sent by client.
    gbImageRange :: (Core.Maybe BooksAnnotationsRange),
    -- | Range in GB text format for this annotation sent by client.
    gbTextRange :: (Core.Maybe BooksAnnotationsRange),
    -- | Range in image CFI format for this annotation sent by client.
    imageCfiRange :: (Core.Maybe BooksAnnotationsRange)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Annotation_ClientVersionRanges' with the minimum fields required to make a request.
newAnnotation_ClientVersionRanges ::
  Annotation_ClientVersionRanges
newAnnotation_ClientVersionRanges =
  Annotation_ClientVersionRanges
    { cfiRange = Core.Nothing,
      contentVersion = Core.Nothing,
      gbImageRange = Core.Nothing,
      gbTextRange = Core.Nothing,
      imageCfiRange = Core.Nothing
    }

instance Core.FromJSON Annotation_ClientVersionRanges where
  parseJSON =
    Core.withObject
      "Annotation_ClientVersionRanges"
      ( \o ->
          Annotation_ClientVersionRanges
            Core.<$> (o Core..:? "cfiRange")
            Core.<*> (o Core..:? "contentVersion")
            Core.<*> (o Core..:? "gbImageRange")
            Core.<*> (o Core..:? "gbTextRange")
            Core.<*> (o Core..:? "imageCfiRange")
      )

instance Core.ToJSON Annotation_ClientVersionRanges where
  toJSON Annotation_ClientVersionRanges {..} =
    Core.object
      ( Core.catMaybes
          [ ("cfiRange" Core..=) Core.<$> cfiRange,
            ("contentVersion" Core..=) Core.<$> contentVersion,
            ("gbImageRange" Core..=) Core.<$> gbImageRange,
            ("gbTextRange" Core..=) Core.<$> gbTextRange,
            ("imageCfiRange" Core..=) Core.<$> imageCfiRange
          ]
      )

-- | Selection ranges for the most recent content version.
--
-- /See:/ 'newAnnotation_CurrentVersionRanges' smart constructor.
data Annotation_CurrentVersionRanges = Annotation_CurrentVersionRanges
  { -- | Range in CFI format for this annotation for version above.
    cfiRange :: (Core.Maybe BooksAnnotationsRange),
    -- | Content version applicable to ranges below.
    contentVersion :: (Core.Maybe Core.Text),
    -- | Range in GB image format for this annotation for version above.
    gbImageRange :: (Core.Maybe BooksAnnotationsRange),
    -- | Range in GB text format for this annotation for version above.
    gbTextRange :: (Core.Maybe BooksAnnotationsRange),
    -- | Range in image CFI format for this annotation for version above.
    imageCfiRange :: (Core.Maybe BooksAnnotationsRange)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Annotation_CurrentVersionRanges' with the minimum fields required to make a request.
newAnnotation_CurrentVersionRanges ::
  Annotation_CurrentVersionRanges
newAnnotation_CurrentVersionRanges =
  Annotation_CurrentVersionRanges
    { cfiRange = Core.Nothing,
      contentVersion = Core.Nothing,
      gbImageRange = Core.Nothing,
      gbTextRange = Core.Nothing,
      imageCfiRange = Core.Nothing
    }

instance Core.FromJSON Annotation_CurrentVersionRanges where
  parseJSON =
    Core.withObject
      "Annotation_CurrentVersionRanges"
      ( \o ->
          Annotation_CurrentVersionRanges
            Core.<$> (o Core..:? "cfiRange")
            Core.<*> (o Core..:? "contentVersion")
            Core.<*> (o Core..:? "gbImageRange")
            Core.<*> (o Core..:? "gbTextRange")
            Core.<*> (o Core..:? "imageCfiRange")
      )

instance Core.ToJSON Annotation_CurrentVersionRanges where
  toJSON Annotation_CurrentVersionRanges {..} =
    Core.object
      ( Core.catMaybes
          [ ("cfiRange" Core..=) Core.<$> cfiRange,
            ("contentVersion" Core..=) Core.<$> contentVersion,
            ("gbImageRange" Core..=) Core.<$> gbImageRange,
            ("gbTextRange" Core..=) Core.<$> gbTextRange,
            ("imageCfiRange" Core..=) Core.<$> imageCfiRange
          ]
      )

--
-- /See:/ 'newAnnotation_LayerSummary' smart constructor.
data Annotation_LayerSummary = Annotation_LayerSummary
  { -- | Maximum allowed characters on this layer, especially for the \"copy\" layer.
    allowedCharacterCount :: (Core.Maybe Core.Int32),
    -- | Type of limitation on this layer. \"limited\" or \"unlimited\" for the \"copy\" layer.
    limitType :: (Core.Maybe Core.Text),
    -- | Remaining allowed characters on this layer, especially for the \"copy\" layer.
    remainingCharacterCount :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Annotation_LayerSummary' with the minimum fields required to make a request.
newAnnotation_LayerSummary ::
  Annotation_LayerSummary
newAnnotation_LayerSummary =
  Annotation_LayerSummary
    { allowedCharacterCount = Core.Nothing,
      limitType = Core.Nothing,
      remainingCharacterCount = Core.Nothing
    }

instance Core.FromJSON Annotation_LayerSummary where
  parseJSON =
    Core.withObject
      "Annotation_LayerSummary"
      ( \o ->
          Annotation_LayerSummary
            Core.<$> (o Core..:? "allowedCharacterCount")
            Core.<*> (o Core..:? "limitType")
            Core.<*> (o Core..:? "remainingCharacterCount")
      )

instance Core.ToJSON Annotation_LayerSummary where
  toJSON Annotation_LayerSummary {..} =
    Core.object
      ( Core.catMaybes
          [ ("allowedCharacterCount" Core..=) Core.<$> allowedCharacterCount,
            ("limitType" Core..=) Core.<$> limitType,
            ("remainingCharacterCount" Core..=)
              Core.<$> remainingCharacterCount
          ]
      )

--
-- /See:/ 'newAnnotations' smart constructor.
data Annotations = Annotations
  { -- | A list of annotations.
    items :: (Core.Maybe [Annotation]),
    -- | Resource type.
    kind :: (Core.Maybe Core.Text),
    -- | Token to pass in for pagination for the next page. This will not be present if this request does not have more results.
    nextPageToken :: (Core.Maybe Core.Text),
    -- | Total number of annotations found. This may be greater than the number of notes returned in this response if results have been paginated.
    totalItems :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Annotations' with the minimum fields required to make a request.
newAnnotations ::
  Annotations
newAnnotations =
  Annotations
    { items = Core.Nothing,
      kind = Core.Nothing,
      nextPageToken = Core.Nothing,
      totalItems = Core.Nothing
    }

instance Core.FromJSON Annotations where
  parseJSON =
    Core.withObject
      "Annotations"
      ( \o ->
          Annotations
            Core.<$> (o Core..:? "items")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "nextPageToken")
            Core.<*> (o Core..:? "totalItems")
      )

instance Core.ToJSON Annotations where
  toJSON Annotations {..} =
    Core.object
      ( Core.catMaybes
          [ ("items" Core..=) Core.<$> items,
            ("kind" Core..=) Core.<$> kind,
            ("nextPageToken" Core..=) Core.<$> nextPageToken,
            ("totalItems" Core..=) Core.<$> totalItems
          ]
      )

--
-- /See:/ 'newAnnotationsSummary' smart constructor.
data AnnotationsSummary = AnnotationsSummary
  { kind :: (Core.Maybe Core.Text),
    layers :: (Core.Maybe [AnnotationsSummary_LayersItem])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'AnnotationsSummary' with the minimum fields required to make a request.
newAnnotationsSummary ::
  AnnotationsSummary
newAnnotationsSummary =
  AnnotationsSummary {kind = Core.Nothing, layers = Core.Nothing}

instance Core.FromJSON AnnotationsSummary where
  parseJSON =
    Core.withObject
      "AnnotationsSummary"
      ( \o ->
          AnnotationsSummary
            Core.<$> (o Core..:? "kind")
            Core.<*> (o Core..:? "layers")
      )

instance Core.ToJSON AnnotationsSummary where
  toJSON AnnotationsSummary {..} =
    Core.object
      ( Core.catMaybes
          [ ("kind" Core..=) Core.<$> kind,
            ("layers" Core..=) Core.<$> layers
          ]
      )

--
-- /See:/ 'newAnnotationsSummary_LayersItem' smart constructor.
data AnnotationsSummary_LayersItem = AnnotationsSummary_LayersItem
  { allowedCharacterCount :: (Core.Maybe Core.Int32),
    layerId :: (Core.Maybe Core.Text),
    limitType :: (Core.Maybe Core.Text),
    remainingCharacterCount :: (Core.Maybe Core.Int32),
    updated :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'AnnotationsSummary_LayersItem' with the minimum fields required to make a request.
newAnnotationsSummary_LayersItem ::
  AnnotationsSummary_LayersItem
newAnnotationsSummary_LayersItem =
  AnnotationsSummary_LayersItem
    { allowedCharacterCount =
        Core.Nothing,
      layerId = Core.Nothing,
      limitType = Core.Nothing,
      remainingCharacterCount = Core.Nothing,
      updated = Core.Nothing
    }

instance Core.FromJSON AnnotationsSummary_LayersItem where
  parseJSON =
    Core.withObject
      "AnnotationsSummary_LayersItem"
      ( \o ->
          AnnotationsSummary_LayersItem
            Core.<$> (o Core..:? "allowedCharacterCount")
            Core.<*> (o Core..:? "layerId")
            Core.<*> (o Core..:? "limitType")
            Core.<*> (o Core..:? "remainingCharacterCount")
            Core.<*> (o Core..:? "updated")
      )

instance Core.ToJSON AnnotationsSummary_LayersItem where
  toJSON AnnotationsSummary_LayersItem {..} =
    Core.object
      ( Core.catMaybes
          [ ("allowedCharacterCount" Core..=) Core.<$> allowedCharacterCount,
            ("layerId" Core..=) Core.<$> layerId,
            ("limitType" Core..=) Core.<$> limitType,
            ("remainingCharacterCount" Core..=)
              Core.<$> remainingCharacterCount,
            ("updated" Core..=) Core.<$> updated
          ]
      )

--
-- /See:/ 'newAnnotationsdata' smart constructor.
data Annotationsdata = Annotationsdata
  { -- | A list of Annotation Data.
    items :: (Core.Maybe [GeoAnnotationdata]),
    -- | Resource type
    kind :: (Core.Maybe Core.Text),
    -- | Token to pass in for pagination for the next page. This will not be present if this request does not have more results.
    nextPageToken :: (Core.Maybe Core.Text),
    -- | The total number of volume annotations found.
    totalItems :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Annotationsdata' with the minimum fields required to make a request.
newAnnotationsdata ::
  Annotationsdata
newAnnotationsdata =
  Annotationsdata
    { items = Core.Nothing,
      kind = Core.Nothing,
      nextPageToken = Core.Nothing,
      totalItems = Core.Nothing
    }

instance Core.FromJSON Annotationsdata where
  parseJSON =
    Core.withObject
      "Annotationsdata"
      ( \o ->
          Annotationsdata
            Core.<$> (o Core..:? "items")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "nextPageToken")
            Core.<*> (o Core..:? "totalItems")
      )

instance Core.ToJSON Annotationsdata where
  toJSON Annotationsdata {..} =
    Core.object
      ( Core.catMaybes
          [ ("items" Core..=) Core.<$> items,
            ("kind" Core..=) Core.<$> kind,
            ("nextPageToken" Core..=) Core.<$> nextPageToken,
            ("totalItems" Core..=) Core.<$> totalItems
          ]
      )

--
-- /See:/ 'newBooksAnnotationsRange' smart constructor.
data BooksAnnotationsRange = BooksAnnotationsRange
  { -- | The offset from the ending position.
    endOffset :: (Core.Maybe Core.Text),
    -- | The ending position for the range.
    endPosition :: (Core.Maybe Core.Text),
    -- | The offset from the starting position.
    startOffset :: (Core.Maybe Core.Text),
    -- | The starting position for the range.
    startPosition :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'BooksAnnotationsRange' with the minimum fields required to make a request.
newBooksAnnotationsRange ::
  BooksAnnotationsRange
newBooksAnnotationsRange =
  BooksAnnotationsRange
    { endOffset = Core.Nothing,
      endPosition = Core.Nothing,
      startOffset = Core.Nothing,
      startPosition = Core.Nothing
    }

instance Core.FromJSON BooksAnnotationsRange where
  parseJSON =
    Core.withObject
      "BooksAnnotationsRange"
      ( \o ->
          BooksAnnotationsRange
            Core.<$> (o Core..:? "endOffset")
            Core.<*> (o Core..:? "endPosition")
            Core.<*> (o Core..:? "startOffset")
            Core.<*> (o Core..:? "startPosition")
      )

instance Core.ToJSON BooksAnnotationsRange where
  toJSON BooksAnnotationsRange {..} =
    Core.object
      ( Core.catMaybes
          [ ("endOffset" Core..=) Core.<$> endOffset,
            ("endPosition" Core..=) Core.<$> endPosition,
            ("startOffset" Core..=) Core.<$> startOffset,
            ("startPosition" Core..=) Core.<$> startPosition
          ]
      )

--
-- /See:/ 'newBooksCloudloadingResource' smart constructor.
data BooksCloudloadingResource = BooksCloudloadingResource
  { author :: (Core.Maybe Core.Text),
    processingState :: (Core.Maybe Core.Text),
    title :: (Core.Maybe Core.Text),
    volumeId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'BooksCloudloadingResource' with the minimum fields required to make a request.
newBooksCloudloadingResource ::
  BooksCloudloadingResource
newBooksCloudloadingResource =
  BooksCloudloadingResource
    { author = Core.Nothing,
      processingState = Core.Nothing,
      title = Core.Nothing,
      volumeId = Core.Nothing
    }

instance Core.FromJSON BooksCloudloadingResource where
  parseJSON =
    Core.withObject
      "BooksCloudloadingResource"
      ( \o ->
          BooksCloudloadingResource
            Core.<$> (o Core..:? "author")
            Core.<*> (o Core..:? "processingState")
            Core.<*> (o Core..:? "title")
            Core.<*> (o Core..:? "volumeId")
      )

instance Core.ToJSON BooksCloudloadingResource where
  toJSON BooksCloudloadingResource {..} =
    Core.object
      ( Core.catMaybes
          [ ("author" Core..=) Core.<$> author,
            ("processingState" Core..=) Core.<$> processingState,
            ("title" Core..=) Core.<$> title,
            ("volumeId" Core..=) Core.<$> volumeId
          ]
      )

--
-- /See:/ 'newBooksVolumesRecommendedRateResponse' smart constructor.
newtype BooksVolumesRecommendedRateResponse = BooksVolumesRecommendedRateResponse
  { consistencyToken :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

instance Core.ToJSON BooksVolumesRecommendedRateResponse where
  toJSON BooksVolumesRecommendedRateResponse {..} =
    Core.object
      ( Core.catMaybes
          [("consistency_token" Core..=) Core.<$> consistencyToken]
      )

--
-- /See:/ 'newBookshelf' smart constructor.
data Bookshelf = Bookshelf
  { -- | Whether this bookshelf is PUBLIC or PRIVATE.
    access :: (Core.Maybe Core.Text),
    -- | Created time for this bookshelf (formatted UTC timestamp with millisecond resolution).
    created :: (Core.Maybe Core.Text),
    -- | Description of this bookshelf.
    description :: (Core.Maybe Core.Text),
    -- | Id of this bookshelf, only unique by user.
    id :: (Core.Maybe Core.Int32),
    -- | Resource type for bookshelf metadata.
    kind :: (Core.Maybe Core.Text),
    -- | URL to this resource.
    selfLink :: (Core.Maybe Core.Text),
    -- | Title of this bookshelf.
    title :: (Core.Maybe Core.Text),
    -- | Last modified time of this bookshelf (formatted UTC timestamp with millisecond resolution).
    updated :: (Core.Maybe Core.Text),
    -- | Number of volumes in this bookshelf.
    volumeCount :: (Core.Maybe Core.Int32),
    -- | Last time a volume was added or removed from this bookshelf (formatted UTC timestamp with millisecond resolution).
    volumesLastUpdated :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Bookshelf' with the minimum fields required to make a request.
newBookshelf ::
  Bookshelf
newBookshelf =
  Bookshelf
    { access = Core.Nothing,
      created = Core.Nothing,
      description = Core.Nothing,
      id = Core.Nothing,
      kind = Core.Nothing,
      selfLink = Core.Nothing,
      title = Core.Nothing,
      updated = Core.Nothing,
      volumeCount = Core.Nothing,
      volumesLastUpdated = Core.Nothing
    }

instance Core.FromJSON Bookshelf where
  parseJSON =
    Core.withObject
      "Bookshelf"
      ( \o ->
          Bookshelf
            Core.<$> (o Core..:? "access")
            Core.<*> (o Core..:? "created")
            Core.<*> (o Core..:? "description")
            Core.<*> (o Core..:? "id")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "selfLink")
            Core.<*> (o Core..:? "title")
            Core.<*> (o Core..:? "updated")
            Core.<*> (o Core..:? "volumeCount")
            Core.<*> (o Core..:? "volumesLastUpdated")
      )

instance Core.ToJSON Bookshelf where
  toJSON Bookshelf {..} =
    Core.object
      ( Core.catMaybes
          [ ("access" Core..=) Core.<$> access,
            ("created" Core..=) Core.<$> created,
            ("description" Core..=) Core.<$> description,
            ("id" Core..=) Core.<$> id,
            ("kind" Core..=) Core.<$> kind,
            ("selfLink" Core..=) Core.<$> selfLink,
            ("title" Core..=) Core.<$> title,
            ("updated" Core..=) Core.<$> updated,
            ("volumeCount" Core..=) Core.<$> volumeCount,
            ("volumesLastUpdated" Core..=) Core.<$> volumesLastUpdated
          ]
      )

--
-- /See:/ 'newBookshelves' smart constructor.
data Bookshelves = Bookshelves
  { -- | A list of bookshelves.
    items :: (Core.Maybe [Bookshelf]),
    -- | Resource type.
    kind :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Bookshelves' with the minimum fields required to make a request.
newBookshelves ::
  Bookshelves
newBookshelves =
  Bookshelves {items = Core.Nothing, kind = Core.Nothing}

instance Core.FromJSON Bookshelves where
  parseJSON =
    Core.withObject
      "Bookshelves"
      ( \o ->
          Bookshelves
            Core.<$> (o Core..:? "items")
            Core.<*> (o Core..:? "kind")
      )

instance Core.ToJSON Bookshelves where
  toJSON Bookshelves {..} =
    Core.object
      ( Core.catMaybes
          [("items" Core..=) Core.<$> items, ("kind" Core..=) Core.<$> kind]
      )

--
-- /See:/ 'newCategory' smart constructor.
data Category = Category
  { -- | A list of onboarding categories.
    items :: (Core.Maybe [Category_ItemsItem]),
    -- | Resource type.
    kind :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Category' with the minimum fields required to make a request.
newCategory ::
  Category
newCategory = Category {items = Core.Nothing, kind = Core.Nothing}

instance Core.FromJSON Category where
  parseJSON =
    Core.withObject
      "Category"
      ( \o ->
          Category
            Core.<$> (o Core..:? "items")
            Core.<*> (o Core..:? "kind")
      )

instance Core.ToJSON Category where
  toJSON Category {..} =
    Core.object
      ( Core.catMaybes
          [("items" Core..=) Core.<$> items, ("kind" Core..=) Core.<$> kind]
      )

--
-- /See:/ 'newCategory_ItemsItem' smart constructor.
data Category_ItemsItem = Category_ItemsItem
  { badgeUrl :: (Core.Maybe Core.Text),
    categoryId :: (Core.Maybe Core.Text),
    name :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Category_ItemsItem' with the minimum fields required to make a request.
newCategory_ItemsItem ::
  Category_ItemsItem
newCategory_ItemsItem =
  Category_ItemsItem
    { badgeUrl = Core.Nothing,
      categoryId = Core.Nothing,
      name = Core.Nothing
    }

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

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

--
-- /See:/ 'newConcurrentAccessRestriction' smart constructor.
data ConcurrentAccessRestriction = ConcurrentAccessRestriction
  { -- | Whether access is granted for this (user, device, volume).
    deviceAllowed :: (Core.Maybe Core.Bool),
    -- | Resource type.
    kind :: (Core.Maybe Core.Text),
    -- | The maximum number of concurrent access licenses for this volume.
    maxConcurrentDevices :: (Core.Maybe Core.Int32),
    -- | Error\/warning message.
    message :: (Core.Maybe Core.Text),
    -- | Client nonce for verification. Download access and client-validation only.
    nonce :: (Core.Maybe Core.Text),
    -- | Error\/warning reason code.
    reasonCode :: (Core.Maybe Core.Text),
    -- | Whether this volume has any concurrent access restrictions.
    restricted :: (Core.Maybe Core.Bool),
    -- | Response signature.
    signature :: (Core.Maybe Core.Text),
    -- | Client app identifier for verification. Download access and client-validation only.
    source :: (Core.Maybe Core.Text),
    -- | Time in seconds for license auto-expiration.
    timeWindowSeconds :: (Core.Maybe Core.Int32),
    -- | Identifies the volume for which this entry applies.
    volumeId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ConcurrentAccessRestriction' with the minimum fields required to make a request.
newConcurrentAccessRestriction ::
  ConcurrentAccessRestriction
newConcurrentAccessRestriction =
  ConcurrentAccessRestriction
    { deviceAllowed = Core.Nothing,
      kind = Core.Nothing,
      maxConcurrentDevices = Core.Nothing,
      message = Core.Nothing,
      nonce = Core.Nothing,
      reasonCode = Core.Nothing,
      restricted = Core.Nothing,
      signature = Core.Nothing,
      source = Core.Nothing,
      timeWindowSeconds = Core.Nothing,
      volumeId = Core.Nothing
    }

instance Core.FromJSON ConcurrentAccessRestriction where
  parseJSON =
    Core.withObject
      "ConcurrentAccessRestriction"
      ( \o ->
          ConcurrentAccessRestriction
            Core.<$> (o Core..:? "deviceAllowed")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "maxConcurrentDevices")
            Core.<*> (o Core..:? "message")
            Core.<*> (o Core..:? "nonce")
            Core.<*> (o Core..:? "reasonCode")
            Core.<*> (o Core..:? "restricted")
            Core.<*> (o Core..:? "signature")
            Core.<*> (o Core..:? "source")
            Core.<*> (o Core..:? "timeWindowSeconds")
            Core.<*> (o Core..:? "volumeId")
      )

instance Core.ToJSON ConcurrentAccessRestriction where
  toJSON ConcurrentAccessRestriction {..} =
    Core.object
      ( Core.catMaybes
          [ ("deviceAllowed" Core..=) Core.<$> deviceAllowed,
            ("kind" Core..=) Core.<$> kind,
            ("maxConcurrentDevices" Core..=) Core.<$> maxConcurrentDevices,
            ("message" Core..=) Core.<$> message,
            ("nonce" Core..=) Core.<$> nonce,
            ("reasonCode" Core..=) Core.<$> reasonCode,
            ("restricted" Core..=) Core.<$> restricted,
            ("signature" Core..=) Core.<$> signature,
            ("source" Core..=) Core.<$> source,
            ("timeWindowSeconds" Core..=) Core.<$> timeWindowSeconds,
            ("volumeId" Core..=) Core.<$> volumeId
          ]
      )

--
-- /See:/ 'newDictionaryAnnotationdata' smart constructor.
data DictionaryAnnotationdata = DictionaryAnnotationdata
  { -- | The type of annotation this data is for.
    annotationType :: (Core.Maybe Core.Text),
    -- | JSON encoded data for this dictionary annotation data. Emitted with name \'data\' in JSON output. Either this or geo_data will be populated.
    data' :: (Core.Maybe Dictlayerdata),
    -- | Base64 encoded data for this annotation data.
    encodedData :: (Core.Maybe Core.Base64),
    -- | Unique id for this annotation data.
    id :: (Core.Maybe Core.Text),
    -- | Resource Type
    kind :: (Core.Maybe Core.Text),
    -- | The Layer id for this data. *
    layerId :: (Core.Maybe Core.Text),
    -- | URL for this resource. *
    selfLink :: (Core.Maybe Core.Text),
    -- | Timestamp for the last time this data was updated. (RFC 3339 UTC date-time format).
    updated :: (Core.Maybe Core.Text),
    -- | The volume id for this data. *
    volumeId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DictionaryAnnotationdata' with the minimum fields required to make a request.
newDictionaryAnnotationdata ::
  DictionaryAnnotationdata
newDictionaryAnnotationdata =
  DictionaryAnnotationdata
    { annotationType = Core.Nothing,
      data' = Core.Nothing,
      encodedData = Core.Nothing,
      id = Core.Nothing,
      kind = Core.Nothing,
      layerId = Core.Nothing,
      selfLink = Core.Nothing,
      updated = Core.Nothing,
      volumeId = Core.Nothing
    }

instance Core.FromJSON DictionaryAnnotationdata where
  parseJSON =
    Core.withObject
      "DictionaryAnnotationdata"
      ( \o ->
          DictionaryAnnotationdata
            Core.<$> (o Core..:? "annotationType")
            Core.<*> (o Core..:? "data")
            Core.<*> (o Core..:? "encodedData")
            Core.<*> (o Core..:? "id")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "layerId")
            Core.<*> (o Core..:? "selfLink")
            Core.<*> (o Core..:? "updated")
            Core.<*> (o Core..:? "volumeId")
      )

instance Core.ToJSON DictionaryAnnotationdata where
  toJSON DictionaryAnnotationdata {..} =
    Core.object
      ( Core.catMaybes
          [ ("annotationType" Core..=) Core.<$> annotationType,
            ("data" Core..=) Core.<$> data',
            ("encodedData" Core..=) Core.<$> encodedData,
            ("id" Core..=) Core.<$> id,
            ("kind" Core..=) Core.<$> kind,
            ("layerId" Core..=) Core.<$> layerId,
            ("selfLink" Core..=) Core.<$> selfLink,
            ("updated" Core..=) Core.<$> updated,
            ("volumeId" Core..=) Core.<$> volumeId
          ]
      )

--
-- /See:/ 'newDictlayerdata' smart constructor.
data Dictlayerdata = Dictlayerdata
  { common :: (Core.Maybe Dictlayerdata_Common),
    dict :: (Core.Maybe Dictlayerdata_Dict),
    kind :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Dictlayerdata' with the minimum fields required to make a request.
newDictlayerdata ::
  Dictlayerdata
newDictlayerdata =
  Dictlayerdata
    { common = Core.Nothing,
      dict = Core.Nothing,
      kind = Core.Nothing
    }

instance Core.FromJSON Dictlayerdata where
  parseJSON =
    Core.withObject
      "Dictlayerdata"
      ( \o ->
          Dictlayerdata
            Core.<$> (o Core..:? "common")
            Core.<*> (o Core..:? "dict")
            Core.<*> (o Core..:? "kind")
      )

instance Core.ToJSON Dictlayerdata where
  toJSON Dictlayerdata {..} =
    Core.object
      ( Core.catMaybes
          [ ("common" Core..=) Core.<$> common,
            ("dict" Core..=) Core.<$> dict,
            ("kind" Core..=) Core.<$> kind
          ]
      )

--
-- /See:/ 'newDictlayerdata_Common' smart constructor.
newtype Dictlayerdata_Common = Dictlayerdata_Common
  { -- | The display title and localized canonical name to use when searching for this entity on Google search.
    title :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

--
-- /See:/ 'newDictlayerdata_Dict' smart constructor.
data Dictlayerdata_Dict = Dictlayerdata_Dict
  { -- | The source, url and attribution for this dictionary data.
    source :: (Core.Maybe Dictlayerdata_Dict_Source),
    words :: (Core.Maybe [Dictlayerdata_Dict_WordsItem])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Dictlayerdata_Dict' with the minimum fields required to make a request.
newDictlayerdata_Dict ::
  Dictlayerdata_Dict
newDictlayerdata_Dict =
  Dictlayerdata_Dict {source = Core.Nothing, words = Core.Nothing}

instance Core.FromJSON Dictlayerdata_Dict where
  parseJSON =
    Core.withObject
      "Dictlayerdata_Dict"
      ( \o ->
          Dictlayerdata_Dict
            Core.<$> (o Core..:? "source")
            Core.<*> (o Core..:? "words")
      )

instance Core.ToJSON Dictlayerdata_Dict where
  toJSON Dictlayerdata_Dict {..} =
    Core.object
      ( Core.catMaybes
          [ ("source" Core..=) Core.<$> source,
            ("words" Core..=) Core.<$> words
          ]
      )

-- | The source, url and attribution for this dictionary data.
--
-- /See:/ 'newDictlayerdata_Dict_Source' smart constructor.
data Dictlayerdata_Dict_Source = Dictlayerdata_Dict_Source
  { attribution :: (Core.Maybe Core.Text),
    url :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Dictlayerdata_Dict_Source' with the minimum fields required to make a request.
newDictlayerdata_Dict_Source ::
  Dictlayerdata_Dict_Source
newDictlayerdata_Dict_Source =
  Dictlayerdata_Dict_Source
    { attribution = Core.Nothing,
      url = Core.Nothing
    }

instance Core.FromJSON Dictlayerdata_Dict_Source where
  parseJSON =
    Core.withObject
      "Dictlayerdata_Dict_Source"
      ( \o ->
          Dictlayerdata_Dict_Source
            Core.<$> (o Core..:? "attribution")
            Core.<*> (o Core..:? "url")
      )

instance Core.ToJSON Dictlayerdata_Dict_Source where
  toJSON Dictlayerdata_Dict_Source {..} =
    Core.object
      ( Core.catMaybes
          [ ("attribution" Core..=) Core.<$> attribution,
            ("url" Core..=) Core.<$> url
          ]
      )

--
-- /See:/ 'newDictlayerdata_Dict_WordsItem' smart constructor.
data Dictlayerdata_Dict_WordsItem = Dictlayerdata_Dict_WordsItem
  { derivatives :: (Core.Maybe [Dictlayerdata_Dict_WordsItem_DerivativesItem]),
    examples :: (Core.Maybe [Dictlayerdata_Dict_WordsItem_ExamplesItem]),
    senses :: (Core.Maybe [Dictlayerdata_Dict_WordsItem_SensesItem]),
    -- | The words with different meanings but not related words, e.g. \"go\" (game) and \"go\" (verb).
    source :: (Core.Maybe Dictlayerdata_Dict_WordsItem_Source)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Dictlayerdata_Dict_WordsItem' with the minimum fields required to make a request.
newDictlayerdata_Dict_WordsItem ::
  Dictlayerdata_Dict_WordsItem
newDictlayerdata_Dict_WordsItem =
  Dictlayerdata_Dict_WordsItem
    { derivatives = Core.Nothing,
      examples = Core.Nothing,
      senses = Core.Nothing,
      source = Core.Nothing
    }

instance Core.FromJSON Dictlayerdata_Dict_WordsItem where
  parseJSON =
    Core.withObject
      "Dictlayerdata_Dict_WordsItem"
      ( \o ->
          Dictlayerdata_Dict_WordsItem
            Core.<$> (o Core..:? "derivatives")
            Core.<*> (o Core..:? "examples")
            Core.<*> (o Core..:? "senses")
            Core.<*> (o Core..:? "source")
      )

instance Core.ToJSON Dictlayerdata_Dict_WordsItem where
  toJSON Dictlayerdata_Dict_WordsItem {..} =
    Core.object
      ( Core.catMaybes
          [ ("derivatives" Core..=) Core.<$> derivatives,
            ("examples" Core..=) Core.<$> examples,
            ("senses" Core..=) Core.<$> senses,
            ("source" Core..=) Core.<$> source
          ]
      )

--
-- /See:/ 'newDictlayerdata_Dict_WordsItem_DerivativesItem' smart constructor.
data Dictlayerdata_Dict_WordsItem_DerivativesItem = Dictlayerdata_Dict_WordsItem_DerivativesItem
  { source :: (Core.Maybe Dictlayerdata_Dict_WordsItem_DerivativesItem_Source),
    text :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Dictlayerdata_Dict_WordsItem_DerivativesItem' with the minimum fields required to make a request.
newDictlayerdata_Dict_WordsItem_DerivativesItem ::
  Dictlayerdata_Dict_WordsItem_DerivativesItem
newDictlayerdata_Dict_WordsItem_DerivativesItem =
  Dictlayerdata_Dict_WordsItem_DerivativesItem
    { source =
        Core.Nothing,
      text = Core.Nothing
    }

instance Core.FromJSON Dictlayerdata_Dict_WordsItem_DerivativesItem where
  parseJSON =
    Core.withObject
      "Dictlayerdata_Dict_WordsItem_DerivativesItem"
      ( \o ->
          Dictlayerdata_Dict_WordsItem_DerivativesItem
            Core.<$> (o Core..:? "source")
            Core.<*> (o Core..:? "text")
      )

instance Core.ToJSON Dictlayerdata_Dict_WordsItem_DerivativesItem where
  toJSON Dictlayerdata_Dict_WordsItem_DerivativesItem {..} =
    Core.object
      ( Core.catMaybes
          [ ("source" Core..=) Core.<$> source,
            ("text" Core..=) Core.<$> text
          ]
      )

--
-- /See:/ 'newDictlayerdata_Dict_WordsItem_DerivativesItem_Source' smart constructor.
data Dictlayerdata_Dict_WordsItem_DerivativesItem_Source = Dictlayerdata_Dict_WordsItem_DerivativesItem_Source
  { attribution :: (Core.Maybe Core.Text),
    url :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Dictlayerdata_Dict_WordsItem_DerivativesItem_Source' with the minimum fields required to make a request.
newDictlayerdata_Dict_WordsItem_DerivativesItem_Source ::
  Dictlayerdata_Dict_WordsItem_DerivativesItem_Source
newDictlayerdata_Dict_WordsItem_DerivativesItem_Source =
  Dictlayerdata_Dict_WordsItem_DerivativesItem_Source
    { attribution =
        Core.Nothing,
      url = Core.Nothing
    }

instance
  Core.FromJSON
    Dictlayerdata_Dict_WordsItem_DerivativesItem_Source
  where
  parseJSON =
    Core.withObject
      "Dictlayerdata_Dict_WordsItem_DerivativesItem_Source"
      ( \o ->
          Dictlayerdata_Dict_WordsItem_DerivativesItem_Source
            Core.<$> (o Core..:? "attribution")
            Core.<*> (o Core..:? "url")
      )

instance
  Core.ToJSON
    Dictlayerdata_Dict_WordsItem_DerivativesItem_Source
  where
  toJSON Dictlayerdata_Dict_WordsItem_DerivativesItem_Source {..} =
    Core.object
      ( Core.catMaybes
          [ ("attribution" Core..=) Core.<$> attribution,
            ("url" Core..=) Core.<$> url
          ]
      )

--
-- /See:/ 'newDictlayerdata_Dict_WordsItem_ExamplesItem' smart constructor.
data Dictlayerdata_Dict_WordsItem_ExamplesItem = Dictlayerdata_Dict_WordsItem_ExamplesItem
  { source :: (Core.Maybe Dictlayerdata_Dict_WordsItem_ExamplesItem_Source),
    text :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Dictlayerdata_Dict_WordsItem_ExamplesItem' with the minimum fields required to make a request.
newDictlayerdata_Dict_WordsItem_ExamplesItem ::
  Dictlayerdata_Dict_WordsItem_ExamplesItem
newDictlayerdata_Dict_WordsItem_ExamplesItem =
  Dictlayerdata_Dict_WordsItem_ExamplesItem
    { source = Core.Nothing,
      text = Core.Nothing
    }

instance Core.FromJSON Dictlayerdata_Dict_WordsItem_ExamplesItem where
  parseJSON =
    Core.withObject
      "Dictlayerdata_Dict_WordsItem_ExamplesItem"
      ( \o ->
          Dictlayerdata_Dict_WordsItem_ExamplesItem
            Core.<$> (o Core..:? "source")
            Core.<*> (o Core..:? "text")
      )

instance Core.ToJSON Dictlayerdata_Dict_WordsItem_ExamplesItem where
  toJSON Dictlayerdata_Dict_WordsItem_ExamplesItem {..} =
    Core.object
      ( Core.catMaybes
          [ ("source" Core..=) Core.<$> source,
            ("text" Core..=) Core.<$> text
          ]
      )

--
-- /See:/ 'newDictlayerdata_Dict_WordsItem_ExamplesItem_Source' smart constructor.
data Dictlayerdata_Dict_WordsItem_ExamplesItem_Source = Dictlayerdata_Dict_WordsItem_ExamplesItem_Source
  { attribution :: (Core.Maybe Core.Text),
    url :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Dictlayerdata_Dict_WordsItem_ExamplesItem_Source' with the minimum fields required to make a request.
newDictlayerdata_Dict_WordsItem_ExamplesItem_Source ::
  Dictlayerdata_Dict_WordsItem_ExamplesItem_Source
newDictlayerdata_Dict_WordsItem_ExamplesItem_Source =
  Dictlayerdata_Dict_WordsItem_ExamplesItem_Source
    { attribution =
        Core.Nothing,
      url = Core.Nothing
    }

instance
  Core.FromJSON
    Dictlayerdata_Dict_WordsItem_ExamplesItem_Source
  where
  parseJSON =
    Core.withObject
      "Dictlayerdata_Dict_WordsItem_ExamplesItem_Source"
      ( \o ->
          Dictlayerdata_Dict_WordsItem_ExamplesItem_Source
            Core.<$> (o Core..:? "attribution")
            Core.<*> (o Core..:? "url")
      )

instance
  Core.ToJSON
    Dictlayerdata_Dict_WordsItem_ExamplesItem_Source
  where
  toJSON Dictlayerdata_Dict_WordsItem_ExamplesItem_Source {..} =
    Core.object
      ( Core.catMaybes
          [ ("attribution" Core..=) Core.<$> attribution,
            ("url" Core..=) Core.<$> url
          ]
      )

--
-- /See:/ 'newDictlayerdata_Dict_WordsItem_SensesItem' smart constructor.
data Dictlayerdata_Dict_WordsItem_SensesItem = Dictlayerdata_Dict_WordsItem_SensesItem
  { conjugations ::
      ( Core.Maybe
          [Dictlayerdata_Dict_WordsItem_SensesItem_ConjugationsItem]
      ),
    definitions ::
      ( Core.Maybe
          [Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem]
      ),
    partOfSpeech :: (Core.Maybe Core.Text),
    pronunciation :: (Core.Maybe Core.Text),
    pronunciationUrl :: (Core.Maybe Core.Text),
    source :: (Core.Maybe Dictlayerdata_Dict_WordsItem_SensesItem_Source),
    syllabification :: (Core.Maybe Core.Text),
    synonyms :: (Core.Maybe [Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Dictlayerdata_Dict_WordsItem_SensesItem' with the minimum fields required to make a request.
newDictlayerdata_Dict_WordsItem_SensesItem ::
  Dictlayerdata_Dict_WordsItem_SensesItem
newDictlayerdata_Dict_WordsItem_SensesItem =
  Dictlayerdata_Dict_WordsItem_SensesItem
    { conjugations =
        Core.Nothing,
      definitions = Core.Nothing,
      partOfSpeech = Core.Nothing,
      pronunciation = Core.Nothing,
      pronunciationUrl = Core.Nothing,
      source = Core.Nothing,
      syllabification = Core.Nothing,
      synonyms = Core.Nothing
    }

instance Core.FromJSON Dictlayerdata_Dict_WordsItem_SensesItem where
  parseJSON =
    Core.withObject
      "Dictlayerdata_Dict_WordsItem_SensesItem"
      ( \o ->
          Dictlayerdata_Dict_WordsItem_SensesItem
            Core.<$> (o Core..:? "conjugations")
            Core.<*> (o Core..:? "definitions")
            Core.<*> (o Core..:? "partOfSpeech")
            Core.<*> (o Core..:? "pronunciation")
            Core.<*> (o Core..:? "pronunciationUrl")
            Core.<*> (o Core..:? "source")
            Core.<*> (o Core..:? "syllabification")
            Core.<*> (o Core..:? "synonyms")
      )

instance Core.ToJSON Dictlayerdata_Dict_WordsItem_SensesItem where
  toJSON Dictlayerdata_Dict_WordsItem_SensesItem {..} =
    Core.object
      ( Core.catMaybes
          [ ("conjugations" Core..=) Core.<$> conjugations,
            ("definitions" Core..=) Core.<$> definitions,
            ("partOfSpeech" Core..=) Core.<$> partOfSpeech,
            ("pronunciation" Core..=) Core.<$> pronunciation,
            ("pronunciationUrl" Core..=) Core.<$> pronunciationUrl,
            ("source" Core..=) Core.<$> source,
            ("syllabification" Core..=) Core.<$> syllabification,
            ("synonyms" Core..=) Core.<$> synonyms
          ]
      )

--
-- /See:/ 'newDictlayerdata_Dict_WordsItem_SensesItem_ConjugationsItem' smart constructor.
data Dictlayerdata_Dict_WordsItem_SensesItem_ConjugationsItem = Dictlayerdata_Dict_WordsItem_SensesItem_ConjugationsItem
  { type' :: (Core.Maybe Core.Text),
    value :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

--
-- /See:/ 'newDictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem' smart constructor.
data Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem = Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem
  { definition :: (Core.Maybe Core.Text),
    examples ::
      ( Core.Maybe
          [Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem]
      )
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem' with the minimum fields required to make a request.
newDictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem ::
  Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem
newDictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem =
  Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem
    { definition =
        Core.Nothing,
      examples = Core.Nothing
    }

instance
  Core.FromJSON
    Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem
  where
  parseJSON =
    Core.withObject
      "Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem"
      ( \o ->
          Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem
            Core.<$> (o Core..:? "definition")
            Core.<*> (o Core..:? "examples")
      )

instance
  Core.ToJSON
    Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem
  where
  toJSON Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem {..} =
    Core.object
      ( Core.catMaybes
          [ ("definition" Core..=) Core.<$> definition,
            ("examples" Core..=) Core.<$> examples
          ]
      )

--
-- /See:/ 'newDictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem' smart constructor.
data Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem = Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem
  { source ::
      ( Core.Maybe
          Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source
      ),
    text :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem' with the minimum fields required to make a request.
newDictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem ::
  Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem
newDictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem =
  Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem
    { source =
        Core.Nothing,
      text = Core.Nothing
    }

instance
  Core.FromJSON
    Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem
  where
  parseJSON =
    Core.withObject
      "Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem"
      ( \o ->
          Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem
            Core.<$> (o Core..:? "source")
            Core.<*> (o Core..:? "text")
      )

instance
  Core.ToJSON
    Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem
  where
  toJSON
    Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem {..} =
      Core.object
        ( Core.catMaybes
            [ ("source" Core..=) Core.<$> source,
              ("text" Core..=) Core.<$> text
            ]
        )

--
-- /See:/ 'newDictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source' smart constructor.
data Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source = Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source
  { attribution :: (Core.Maybe Core.Text),
    url :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source' with the minimum fields required to make a request.
newDictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source ::
  Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source
newDictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source =
  Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source
    { attribution =
        Core.Nothing,
      url = Core.Nothing
    }

instance
  Core.FromJSON
    Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source
  where
  parseJSON =
    Core.withObject
      "Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source"
      ( \o ->
          Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source
            Core.<$> (o Core..:? "attribution")
            Core.<*> (o Core..:? "url")
      )

instance
  Core.ToJSON
    Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source
  where
  toJSON
    Dictlayerdata_Dict_WordsItem_SensesItem_DefinitionsItem_ExamplesItem_Source {..} =
      Core.object
        ( Core.catMaybes
            [ ("attribution" Core..=) Core.<$> attribution,
              ("url" Core..=) Core.<$> url
            ]
        )

--
-- /See:/ 'newDictlayerdata_Dict_WordsItem_SensesItem_Source' smart constructor.
data Dictlayerdata_Dict_WordsItem_SensesItem_Source = Dictlayerdata_Dict_WordsItem_SensesItem_Source
  { attribution :: (Core.Maybe Core.Text),
    url :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Dictlayerdata_Dict_WordsItem_SensesItem_Source' with the minimum fields required to make a request.
newDictlayerdata_Dict_WordsItem_SensesItem_Source ::
  Dictlayerdata_Dict_WordsItem_SensesItem_Source
newDictlayerdata_Dict_WordsItem_SensesItem_Source =
  Dictlayerdata_Dict_WordsItem_SensesItem_Source
    { attribution =
        Core.Nothing,
      url = Core.Nothing
    }

instance
  Core.FromJSON
    Dictlayerdata_Dict_WordsItem_SensesItem_Source
  where
  parseJSON =
    Core.withObject
      "Dictlayerdata_Dict_WordsItem_SensesItem_Source"
      ( \o ->
          Dictlayerdata_Dict_WordsItem_SensesItem_Source
            Core.<$> (o Core..:? "attribution")
            Core.<*> (o Core..:? "url")
      )

instance Core.ToJSON Dictlayerdata_Dict_WordsItem_SensesItem_Source where
  toJSON Dictlayerdata_Dict_WordsItem_SensesItem_Source {..} =
    Core.object
      ( Core.catMaybes
          [ ("attribution" Core..=) Core.<$> attribution,
            ("url" Core..=) Core.<$> url
          ]
      )

--
-- /See:/ 'newDictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem' smart constructor.
data Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem = Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem
  { source ::
      ( Core.Maybe
          Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source
      ),
    text :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem' with the minimum fields required to make a request.
newDictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem ::
  Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem
newDictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem =
  Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem
    { source =
        Core.Nothing,
      text = Core.Nothing
    }

instance
  Core.FromJSON
    Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem
  where
  parseJSON =
    Core.withObject
      "Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem"
      ( \o ->
          Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem
            Core.<$> (o Core..:? "source")
            Core.<*> (o Core..:? "text")
      )

instance
  Core.ToJSON
    Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem
  where
  toJSON Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem {..} =
    Core.object
      ( Core.catMaybes
          [ ("source" Core..=) Core.<$> source,
            ("text" Core..=) Core.<$> text
          ]
      )

--
-- /See:/ 'newDictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source' smart constructor.
data Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source = Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source
  { attribution :: (Core.Maybe Core.Text),
    url :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source' with the minimum fields required to make a request.
newDictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source ::
  Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source
newDictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source =
  Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source
    { attribution =
        Core.Nothing,
      url = Core.Nothing
    }

instance
  Core.FromJSON
    Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source
  where
  parseJSON =
    Core.withObject
      "Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source"
      ( \o ->
          Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source
            Core.<$> (o Core..:? "attribution")
            Core.<*> (o Core..:? "url")
      )

instance
  Core.ToJSON
    Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source
  where
  toJSON
    Dictlayerdata_Dict_WordsItem_SensesItem_SynonymsItem_Source {..} =
      Core.object
        ( Core.catMaybes
            [ ("attribution" Core..=) Core.<$> attribution,
              ("url" Core..=) Core.<$> url
            ]
        )

-- | The words with different meanings but not related words, e.g. \"go\" (game) and \"go\" (verb).
--
-- /See:/ 'newDictlayerdata_Dict_WordsItem_Source' smart constructor.
data Dictlayerdata_Dict_WordsItem_Source = Dictlayerdata_Dict_WordsItem_Source
  { attribution :: (Core.Maybe Core.Text),
    url :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Dictlayerdata_Dict_WordsItem_Source' with the minimum fields required to make a request.
newDictlayerdata_Dict_WordsItem_Source ::
  Dictlayerdata_Dict_WordsItem_Source
newDictlayerdata_Dict_WordsItem_Source =
  Dictlayerdata_Dict_WordsItem_Source
    { attribution = Core.Nothing,
      url = Core.Nothing
    }

instance Core.FromJSON Dictlayerdata_Dict_WordsItem_Source where
  parseJSON =
    Core.withObject
      "Dictlayerdata_Dict_WordsItem_Source"
      ( \o ->
          Dictlayerdata_Dict_WordsItem_Source
            Core.<$> (o Core..:? "attribution")
            Core.<*> (o Core..:? "url")
      )

instance Core.ToJSON Dictlayerdata_Dict_WordsItem_Source where
  toJSON Dictlayerdata_Dict_WordsItem_Source {..} =
    Core.object
      ( Core.catMaybes
          [ ("attribution" Core..=) Core.<$> attribution,
            ("url" Core..=) Core.<$> url
          ]
      )

--
-- /See:/ 'newDiscoveryclusters' smart constructor.
data Discoveryclusters = Discoveryclusters
  { clusters :: (Core.Maybe [Discoveryclusters_ClustersItem]),
    -- | Resorce type.
    kind :: (Core.Maybe Core.Text),
    totalClusters :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Discoveryclusters' with the minimum fields required to make a request.
newDiscoveryclusters ::
  Discoveryclusters
newDiscoveryclusters =
  Discoveryclusters
    { clusters = Core.Nothing,
      kind = Core.Nothing,
      totalClusters = Core.Nothing
    }

instance Core.FromJSON Discoveryclusters where
  parseJSON =
    Core.withObject
      "Discoveryclusters"
      ( \o ->
          Discoveryclusters
            Core.<$> (o Core..:? "clusters")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "totalClusters")
      )

instance Core.ToJSON Discoveryclusters where
  toJSON Discoveryclusters {..} =
    Core.object
      ( Core.catMaybes
          [ ("clusters" Core..=) Core.<$> clusters,
            ("kind" Core..=) Core.<$> kind,
            ("totalClusters" Core..=) Core.<$> totalClusters
          ]
      )

--
-- /See:/ 'newDiscoveryclusters_ClustersItem' smart constructor.
data Discoveryclusters_ClustersItem = Discoveryclusters_ClustersItem
  { bannerWithContentContainer ::
      ( Core.Maybe
          Discoveryclusters_ClustersItem_Banner_with_content_container
      ),
    subTitle :: (Core.Maybe Core.Text),
    title :: (Core.Maybe Core.Text),
    totalVolumes :: (Core.Maybe Core.Int32),
    uid :: (Core.Maybe Core.Text),
    volumes :: (Core.Maybe [Volume])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Discoveryclusters_ClustersItem' with the minimum fields required to make a request.
newDiscoveryclusters_ClustersItem ::
  Discoveryclusters_ClustersItem
newDiscoveryclusters_ClustersItem =
  Discoveryclusters_ClustersItem
    { bannerWithContentContainer =
        Core.Nothing,
      subTitle = Core.Nothing,
      title = Core.Nothing,
      totalVolumes = Core.Nothing,
      uid = Core.Nothing,
      volumes = Core.Nothing
    }

instance Core.FromJSON Discoveryclusters_ClustersItem where
  parseJSON =
    Core.withObject
      "Discoveryclusters_ClustersItem"
      ( \o ->
          Discoveryclusters_ClustersItem
            Core.<$> (o Core..:? "banner_with_content_container")
            Core.<*> (o Core..:? "subTitle")
            Core.<*> (o Core..:? "title")
            Core.<*> (o Core..:? "totalVolumes")
            Core.<*> (o Core..:? "uid")
            Core.<*> (o Core..:? "volumes")
      )

instance Core.ToJSON Discoveryclusters_ClustersItem where
  toJSON Discoveryclusters_ClustersItem {..} =
    Core.object
      ( Core.catMaybes
          [ ("banner_with_content_container" Core..=)
              Core.<$> bannerWithContentContainer,
            ("subTitle" Core..=) Core.<$> subTitle,
            ("title" Core..=) Core.<$> title,
            ("totalVolumes" Core..=) Core.<$> totalVolumes,
            ("uid" Core..=) Core.<$> uid,
            ("volumes" Core..=) Core.<$> volumes
          ]
      )

--
-- /See:/ 'newDiscoveryclusters_ClustersItem_Banner_with_content_container' smart constructor.
data Discoveryclusters_ClustersItem_Banner_with_content_container = Discoveryclusters_ClustersItem_Banner_with_content_container
  { fillColorArgb :: (Core.Maybe Core.Text),
    imageUrl :: (Core.Maybe Core.Text),
    maskColorArgb :: (Core.Maybe Core.Text),
    moreButtonText :: (Core.Maybe Core.Text),
    moreButtonUrl :: (Core.Maybe Core.Text),
    textColorArgb :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Discoveryclusters_ClustersItem_Banner_with_content_container' with the minimum fields required to make a request.
newDiscoveryclusters_ClustersItem_Banner_with_content_container ::
  Discoveryclusters_ClustersItem_Banner_with_content_container
newDiscoveryclusters_ClustersItem_Banner_with_content_container =
  Discoveryclusters_ClustersItem_Banner_with_content_container
    { fillColorArgb =
        Core.Nothing,
      imageUrl = Core.Nothing,
      maskColorArgb = Core.Nothing,
      moreButtonText = Core.Nothing,
      moreButtonUrl = Core.Nothing,
      textColorArgb = Core.Nothing
    }

instance
  Core.FromJSON
    Discoveryclusters_ClustersItem_Banner_with_content_container
  where
  parseJSON =
    Core.withObject
      "Discoveryclusters_ClustersItem_Banner_with_content_container"
      ( \o ->
          Discoveryclusters_ClustersItem_Banner_with_content_container
            Core.<$> (o Core..:? "fillColorArgb")
            Core.<*> (o Core..:? "imageUrl")
            Core.<*> (o Core..:? "maskColorArgb")
            Core.<*> (o Core..:? "moreButtonText")
            Core.<*> (o Core..:? "moreButtonUrl")
            Core.<*> (o Core..:? "textColorArgb")
      )

instance
  Core.ToJSON
    Discoveryclusters_ClustersItem_Banner_with_content_container
  where
  toJSON
    Discoveryclusters_ClustersItem_Banner_with_content_container {..} =
      Core.object
        ( Core.catMaybes
            [ ("fillColorArgb" Core..=) Core.<$> fillColorArgb,
              ("imageUrl" Core..=) Core.<$> imageUrl,
              ("maskColorArgb" Core..=) Core.<$> maskColorArgb,
              ("moreButtonText" Core..=) Core.<$> moreButtonText,
              ("moreButtonUrl" Core..=) Core.<$> moreButtonUrl,
              ("textColorArgb" Core..=) Core.<$> textColorArgb
            ]
        )

--
-- /See:/ 'newDownloadAccessRestriction' smart constructor.
data DownloadAccessRestriction = DownloadAccessRestriction
  { -- | If restricted, whether access is granted for this (user, device, volume).
    deviceAllowed :: (Core.Maybe Core.Bool),
    -- | If restricted, the number of content download licenses already acquired (including the requesting client, if licensed).
    downloadsAcquired :: (Core.Maybe Core.Int32),
    -- | If deviceAllowed, whether access was just acquired with this request.
    justAcquired :: (Core.Maybe Core.Bool),
    -- | Resource type.
    kind :: (Core.Maybe Core.Text),
    -- | If restricted, the maximum number of content download licenses for this volume.
    maxDownloadDevices :: (Core.Maybe Core.Int32),
    -- | Error\/warning message.
    message :: (Core.Maybe Core.Text),
    -- | Client nonce for verification. Download access and client-validation only.
    nonce :: (Core.Maybe Core.Text),
    -- | Error\/warning reason code. Additional codes may be added in the future. 0 OK 100 ACCESS/DENIED/PUBLISHER/LIMIT 101 ACCESS/DENIED/LIMIT 200 WARNING/USED/LAST/ACCESS
    reasonCode :: (Core.Maybe Core.Text),
    -- | Whether this volume has any download access restrictions.
    restricted :: (Core.Maybe Core.Bool),
    -- | Response signature.
    signature :: (Core.Maybe Core.Text),
    -- | Client app identifier for verification. Download access and client-validation only.
    source :: (Core.Maybe Core.Text),
    -- | Identifies the volume for which this entry applies.
    volumeId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DownloadAccessRestriction' with the minimum fields required to make a request.
newDownloadAccessRestriction ::
  DownloadAccessRestriction
newDownloadAccessRestriction =
  DownloadAccessRestriction
    { deviceAllowed = Core.Nothing,
      downloadsAcquired = Core.Nothing,
      justAcquired = Core.Nothing,
      kind = Core.Nothing,
      maxDownloadDevices = Core.Nothing,
      message = Core.Nothing,
      nonce = Core.Nothing,
      reasonCode = Core.Nothing,
      restricted = Core.Nothing,
      signature = Core.Nothing,
      source = Core.Nothing,
      volumeId = Core.Nothing
    }

instance Core.FromJSON DownloadAccessRestriction where
  parseJSON =
    Core.withObject
      "DownloadAccessRestriction"
      ( \o ->
          DownloadAccessRestriction
            Core.<$> (o Core..:? "deviceAllowed")
            Core.<*> (o Core..:? "downloadsAcquired")
            Core.<*> (o Core..:? "justAcquired")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "maxDownloadDevices")
            Core.<*> (o Core..:? "message")
            Core.<*> (o Core..:? "nonce")
            Core.<*> (o Core..:? "reasonCode")
            Core.<*> (o Core..:? "restricted")
            Core.<*> (o Core..:? "signature")
            Core.<*> (o Core..:? "source")
            Core.<*> (o Core..:? "volumeId")
      )

instance Core.ToJSON DownloadAccessRestriction where
  toJSON DownloadAccessRestriction {..} =
    Core.object
      ( Core.catMaybes
          [ ("deviceAllowed" Core..=) Core.<$> deviceAllowed,
            ("downloadsAcquired" Core..=) Core.<$> downloadsAcquired,
            ("justAcquired" Core..=) Core.<$> justAcquired,
            ("kind" Core..=) Core.<$> kind,
            ("maxDownloadDevices" Core..=) Core.<$> maxDownloadDevices,
            ("message" Core..=) Core.<$> message,
            ("nonce" Core..=) Core.<$> nonce,
            ("reasonCode" Core..=) Core.<$> reasonCode,
            ("restricted" Core..=) Core.<$> restricted,
            ("signature" Core..=) Core.<$> signature,
            ("source" Core..=) Core.<$> source,
            ("volumeId" Core..=) Core.<$> volumeId
          ]
      )

--
-- /See:/ 'newDownloadAccesses' smart constructor.
data DownloadAccesses = DownloadAccesses
  { -- | A list of download access responses.
    downloadAccessList :: (Core.Maybe [DownloadAccessRestriction]),
    -- | Resource type.
    kind :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DownloadAccesses' with the minimum fields required to make a request.
newDownloadAccesses ::
  DownloadAccesses
newDownloadAccesses =
  DownloadAccesses
    { downloadAccessList = Core.Nothing,
      kind = Core.Nothing
    }

instance Core.FromJSON DownloadAccesses where
  parseJSON =
    Core.withObject
      "DownloadAccesses"
      ( \o ->
          DownloadAccesses
            Core.<$> (o Core..:? "downloadAccessList")
            Core.<*> (o Core..:? "kind")
      )

instance Core.ToJSON DownloadAccesses where
  toJSON DownloadAccesses {..} =
    Core.object
      ( Core.catMaybes
          [ ("downloadAccessList" Core..=) Core.<$> downloadAccessList,
            ("kind" Core..=) Core.<$> kind
          ]
      )

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

--
-- /See:/ 'newFamilyInfo' smart constructor.
data FamilyInfo = FamilyInfo
  { -- | Resource type.
    kind :: (Core.Maybe Core.Text),
    -- | Family membership info of the user that made the request.
    membership :: (Core.Maybe FamilyInfo_Membership)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'FamilyInfo' with the minimum fields required to make a request.
newFamilyInfo ::
  FamilyInfo
newFamilyInfo =
  FamilyInfo {kind = Core.Nothing, membership = Core.Nothing}

instance Core.FromJSON FamilyInfo where
  parseJSON =
    Core.withObject
      "FamilyInfo"
      ( \o ->
          FamilyInfo
            Core.<$> (o Core..:? "kind")
            Core.<*> (o Core..:? "membership")
      )

instance Core.ToJSON FamilyInfo where
  toJSON FamilyInfo {..} =
    Core.object
      ( Core.catMaybes
          [ ("kind" Core..=) Core.<$> kind,
            ("membership" Core..=) Core.<$> membership
          ]
      )

-- | Family membership info of the user that made the request.
--
-- /See:/ 'newFamilyInfo_Membership' smart constructor.
data FamilyInfo_Membership = FamilyInfo_Membership
  { -- | Restrictions on user buying and acquiring content.
    acquirePermission :: (Core.Maybe Core.Text),
    -- | The age group of the user.
    ageGroup :: (Core.Maybe Core.Text),
    -- | The maximum allowed maturity rating for the user.
    allowedMaturityRating :: (Core.Maybe Core.Text),
    isInFamily :: (Core.Maybe Core.Bool),
    -- | The role of the user in the family.
    role' :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'FamilyInfo_Membership' with the minimum fields required to make a request.
newFamilyInfo_Membership ::
  FamilyInfo_Membership
newFamilyInfo_Membership =
  FamilyInfo_Membership
    { acquirePermission = Core.Nothing,
      ageGroup = Core.Nothing,
      allowedMaturityRating = Core.Nothing,
      isInFamily = Core.Nothing,
      role' = Core.Nothing
    }

instance Core.FromJSON FamilyInfo_Membership where
  parseJSON =
    Core.withObject
      "FamilyInfo_Membership"
      ( \o ->
          FamilyInfo_Membership
            Core.<$> (o Core..:? "acquirePermission")
            Core.<*> (o Core..:? "ageGroup")
            Core.<*> (o Core..:? "allowedMaturityRating")
            Core.<*> (o Core..:? "isInFamily")
            Core.<*> (o Core..:? "role")
      )

instance Core.ToJSON FamilyInfo_Membership where
  toJSON FamilyInfo_Membership {..} =
    Core.object
      ( Core.catMaybes
          [ ("acquirePermission" Core..=) Core.<$> acquirePermission,
            ("ageGroup" Core..=) Core.<$> ageGroup,
            ("allowedMaturityRating" Core..=) Core.<$> allowedMaturityRating,
            ("isInFamily" Core..=) Core.<$> isInFamily,
            ("role" Core..=) Core.<$> role'
          ]
      )

--
-- /See:/ 'newGeoAnnotationdata' smart constructor.
data GeoAnnotationdata = GeoAnnotationdata
  { -- | The type of annotation this data is for.
    annotationType :: (Core.Maybe Core.Text),
    -- | JSON encoded data for this geo annotation data. Emitted with name \'data\' in JSON output. Either this or dict_data will be populated.
    data' :: (Core.Maybe Geolayerdata),
    -- | Base64 encoded data for this annotation data.
    encodedData :: (Core.Maybe Core.Base64),
    -- | Unique id for this annotation data.
    id :: (Core.Maybe Core.Text),
    -- | Resource Type
    kind :: (Core.Maybe Core.Text),
    -- | The Layer id for this data. *
    layerId :: (Core.Maybe Core.Text),
    -- | URL for this resource. *
    selfLink :: (Core.Maybe Core.Text),
    -- | Timestamp for the last time this data was updated. (RFC 3339 UTC date-time format).
    updated :: (Core.Maybe Core.Text),
    -- | The volume id for this data. *
    volumeId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'GeoAnnotationdata' with the minimum fields required to make a request.
newGeoAnnotationdata ::
  GeoAnnotationdata
newGeoAnnotationdata =
  GeoAnnotationdata
    { annotationType = Core.Nothing,
      data' = Core.Nothing,
      encodedData = Core.Nothing,
      id = Core.Nothing,
      kind = Core.Nothing,
      layerId = Core.Nothing,
      selfLink = Core.Nothing,
      updated = Core.Nothing,
      volumeId = Core.Nothing
    }

instance Core.FromJSON GeoAnnotationdata where
  parseJSON =
    Core.withObject
      "GeoAnnotationdata"
      ( \o ->
          GeoAnnotationdata
            Core.<$> (o Core..:? "annotationType")
            Core.<*> (o Core..:? "data")
            Core.<*> (o Core..:? "encodedData")
            Core.<*> (o Core..:? "id")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "layerId")
            Core.<*> (o Core..:? "selfLink")
            Core.<*> (o Core..:? "updated")
            Core.<*> (o Core..:? "volumeId")
      )

instance Core.ToJSON GeoAnnotationdata where
  toJSON GeoAnnotationdata {..} =
    Core.object
      ( Core.catMaybes
          [ ("annotationType" Core..=) Core.<$> annotationType,
            ("data" Core..=) Core.<$> data',
            ("encodedData" Core..=) Core.<$> encodedData,
            ("id" Core..=) Core.<$> id,
            ("kind" Core..=) Core.<$> kind,
            ("layerId" Core..=) Core.<$> layerId,
            ("selfLink" Core..=) Core.<$> selfLink,
            ("updated" Core..=) Core.<$> updated,
            ("volumeId" Core..=) Core.<$> volumeId
          ]
      )

--
-- /See:/ 'newGeolayerdata' smart constructor.
data Geolayerdata = Geolayerdata
  { common :: (Core.Maybe Geolayerdata_Common),
    geo :: (Core.Maybe Geolayerdata_Geo),
    kind :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Geolayerdata' with the minimum fields required to make a request.
newGeolayerdata ::
  Geolayerdata
newGeolayerdata =
  Geolayerdata
    { common = Core.Nothing,
      geo = Core.Nothing,
      kind = Core.Nothing
    }

instance Core.FromJSON Geolayerdata where
  parseJSON =
    Core.withObject
      "Geolayerdata"
      ( \o ->
          Geolayerdata
            Core.<$> (o Core..:? "common")
            Core.<*> (o Core..:? "geo")
            Core.<*> (o Core..:? "kind")
      )

instance Core.ToJSON Geolayerdata where
  toJSON Geolayerdata {..} =
    Core.object
      ( Core.catMaybes
          [ ("common" Core..=) Core.<$> common,
            ("geo" Core..=) Core.<$> geo,
            ("kind" Core..=) Core.<$> kind
          ]
      )

--
-- /See:/ 'newGeolayerdata_Common' smart constructor.
data Geolayerdata_Common = Geolayerdata_Common
  { -- | The language of the information url and description.
    lang :: (Core.Maybe Core.Text),
    -- | The URL for the preview image information.
    previewImageUrl :: (Core.Maybe Core.Text),
    -- | The description for this location.
    snippet :: (Core.Maybe Core.Text),
    -- | The URL for information for this location. Ex: wikipedia link.
    snippetUrl :: (Core.Maybe Core.Text),
    -- | The display title and localized canonical name to use when searching for this entity on Google search.
    title :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Geolayerdata_Common' with the minimum fields required to make a request.
newGeolayerdata_Common ::
  Geolayerdata_Common
newGeolayerdata_Common =
  Geolayerdata_Common
    { lang = Core.Nothing,
      previewImageUrl = Core.Nothing,
      snippet = Core.Nothing,
      snippetUrl = Core.Nothing,
      title = Core.Nothing
    }

instance Core.FromJSON Geolayerdata_Common where
  parseJSON =
    Core.withObject
      "Geolayerdata_Common"
      ( \o ->
          Geolayerdata_Common
            Core.<$> (o Core..:? "lang")
            Core.<*> (o Core..:? "previewImageUrl")
            Core.<*> (o Core..:? "snippet")
            Core.<*> (o Core..:? "snippetUrl")
            Core.<*> (o Core..:? "title")
      )

instance Core.ToJSON Geolayerdata_Common where
  toJSON Geolayerdata_Common {..} =
    Core.object
      ( Core.catMaybes
          [ ("lang" Core..=) Core.<$> lang,
            ("previewImageUrl" Core..=) Core.<$> previewImageUrl,
            ("snippet" Core..=) Core.<$> snippet,
            ("snippetUrl" Core..=) Core.<$> snippetUrl,
            ("title" Core..=) Core.<$> title
          ]
      )

--
-- /See:/ 'newGeolayerdata_Geo' smart constructor.
data Geolayerdata_Geo = Geolayerdata_Geo
  { -- | The boundary of the location as a set of loops containing pairs of latitude, longitude coordinates.
    boundary :: (Core.Maybe [Core.Text]),
    -- | The cache policy active for this data. EX: UNRESTRICTED, RESTRICTED, NEVER
    cachePolicy :: (Core.Maybe Core.Text),
    -- | The country code of the location.
    countryCode :: (Core.Maybe Core.Text),
    -- | The latitude of the location.
    latitude :: (Core.Maybe Core.Double),
    -- | The longitude of the location.
    longitude :: (Core.Maybe Core.Double),
    -- | The type of map that should be used for this location. EX: HYBRID, ROADMAP, SATELLITE, TERRAIN
    mapType :: (Core.Maybe Core.Text),
    -- | The viewport for showing this location. This is a latitude, longitude rectangle.
    viewport :: (Core.Maybe Geolayerdata_Geo_Viewport),
    -- | The Zoom level to use for the map. Zoom levels between 0 (the lowest zoom level, in which the entire world can be seen on one map) to 21+ (down to individual buildings). See: https: \/\/developers.google.com\/maps\/documentation\/staticmaps\/#Zoomlevels
    zoom :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Geolayerdata_Geo' with the minimum fields required to make a request.
newGeolayerdata_Geo ::
  Geolayerdata_Geo
newGeolayerdata_Geo =
  Geolayerdata_Geo
    { boundary = Core.Nothing,
      cachePolicy = Core.Nothing,
      countryCode = Core.Nothing,
      latitude = Core.Nothing,
      longitude = Core.Nothing,
      mapType = Core.Nothing,
      viewport = Core.Nothing,
      zoom = Core.Nothing
    }

instance Core.FromJSON Geolayerdata_Geo where
  parseJSON =
    Core.withObject
      "Geolayerdata_Geo"
      ( \o ->
          Geolayerdata_Geo
            Core.<$> (o Core..:? "boundary")
            Core.<*> (o Core..:? "cachePolicy")
            Core.<*> (o Core..:? "countryCode")
            Core.<*> (o Core..:? "latitude")
            Core.<*> (o Core..:? "longitude")
            Core.<*> (o Core..:? "mapType")
            Core.<*> (o Core..:? "viewport")
            Core.<*> (o Core..:? "zoom")
      )

instance Core.ToJSON Geolayerdata_Geo where
  toJSON Geolayerdata_Geo {..} =
    Core.object
      ( Core.catMaybes
          [ ("boundary" Core..=) Core.<$> boundary,
            ("cachePolicy" Core..=) Core.<$> cachePolicy,
            ("countryCode" Core..=) Core.<$> countryCode,
            ("latitude" Core..=) Core.<$> latitude,
            ("longitude" Core..=) Core.<$> longitude,
            ("mapType" Core..=) Core.<$> mapType,
            ("viewport" Core..=) Core.<$> viewport,
            ("zoom" Core..=) Core.<$> zoom
          ]
      )

-- | The viewport for showing this location. This is a latitude, longitude rectangle.
--
-- /See:/ 'newGeolayerdata_Geo_Viewport' smart constructor.
data Geolayerdata_Geo_Viewport = Geolayerdata_Geo_Viewport
  { hi :: (Core.Maybe Geolayerdata_Geo_Viewport_Hi),
    lo :: (Core.Maybe Geolayerdata_Geo_Viewport_Lo)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Geolayerdata_Geo_Viewport' with the minimum fields required to make a request.
newGeolayerdata_Geo_Viewport ::
  Geolayerdata_Geo_Viewport
newGeolayerdata_Geo_Viewport =
  Geolayerdata_Geo_Viewport {hi = Core.Nothing, lo = Core.Nothing}

instance Core.FromJSON Geolayerdata_Geo_Viewport where
  parseJSON =
    Core.withObject
      "Geolayerdata_Geo_Viewport"
      ( \o ->
          Geolayerdata_Geo_Viewport
            Core.<$> (o Core..:? "hi")
            Core.<*> (o Core..:? "lo")
      )

instance Core.ToJSON Geolayerdata_Geo_Viewport where
  toJSON Geolayerdata_Geo_Viewport {..} =
    Core.object
      ( Core.catMaybes
          [("hi" Core..=) Core.<$> hi, ("lo" Core..=) Core.<$> lo]
      )

--
-- /See:/ 'newGeolayerdata_Geo_Viewport_Hi' smart constructor.
data Geolayerdata_Geo_Viewport_Hi = Geolayerdata_Geo_Viewport_Hi
  { latitude :: (Core.Maybe Core.Double),
    longitude :: (Core.Maybe Core.Double)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Geolayerdata_Geo_Viewport_Hi' with the minimum fields required to make a request.
newGeolayerdata_Geo_Viewport_Hi ::
  Geolayerdata_Geo_Viewport_Hi
newGeolayerdata_Geo_Viewport_Hi =
  Geolayerdata_Geo_Viewport_Hi
    { latitude = Core.Nothing,
      longitude = Core.Nothing
    }

instance Core.FromJSON Geolayerdata_Geo_Viewport_Hi where
  parseJSON =
    Core.withObject
      "Geolayerdata_Geo_Viewport_Hi"
      ( \o ->
          Geolayerdata_Geo_Viewport_Hi
            Core.<$> (o Core..:? "latitude")
            Core.<*> (o Core..:? "longitude")
      )

instance Core.ToJSON Geolayerdata_Geo_Viewport_Hi where
  toJSON Geolayerdata_Geo_Viewport_Hi {..} =
    Core.object
      ( Core.catMaybes
          [ ("latitude" Core..=) Core.<$> latitude,
            ("longitude" Core..=) Core.<$> longitude
          ]
      )

--
-- /See:/ 'newGeolayerdata_Geo_Viewport_Lo' smart constructor.
data Geolayerdata_Geo_Viewport_Lo = Geolayerdata_Geo_Viewport_Lo
  { latitude :: (Core.Maybe Core.Double),
    longitude :: (Core.Maybe Core.Double)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Geolayerdata_Geo_Viewport_Lo' with the minimum fields required to make a request.
newGeolayerdata_Geo_Viewport_Lo ::
  Geolayerdata_Geo_Viewport_Lo
newGeolayerdata_Geo_Viewport_Lo =
  Geolayerdata_Geo_Viewport_Lo
    { latitude = Core.Nothing,
      longitude = Core.Nothing
    }

instance Core.FromJSON Geolayerdata_Geo_Viewport_Lo where
  parseJSON =
    Core.withObject
      "Geolayerdata_Geo_Viewport_Lo"
      ( \o ->
          Geolayerdata_Geo_Viewport_Lo
            Core.<$> (o Core..:? "latitude")
            Core.<*> (o Core..:? "longitude")
      )

instance Core.ToJSON Geolayerdata_Geo_Viewport_Lo where
  toJSON Geolayerdata_Geo_Viewport_Lo {..} =
    Core.object
      ( Core.catMaybes
          [ ("latitude" Core..=) Core.<$> latitude,
            ("longitude" Core..=) Core.<$> longitude
          ]
      )

--
-- /See:/ 'newLayersummaries' smart constructor.
data Layersummaries = Layersummaries
  { -- | A list of layer summary items.
    items :: (Core.Maybe [Layersummary]),
    -- | Resource type.
    kind :: (Core.Maybe Core.Text),
    -- | The total number of layer summaries found.
    totalItems :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Layersummaries' with the minimum fields required to make a request.
newLayersummaries ::
  Layersummaries
newLayersummaries =
  Layersummaries
    { items = Core.Nothing,
      kind = Core.Nothing,
      totalItems = Core.Nothing
    }

instance Core.FromJSON Layersummaries where
  parseJSON =
    Core.withObject
      "Layersummaries"
      ( \o ->
          Layersummaries
            Core.<$> (o Core..:? "items")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "totalItems")
      )

instance Core.ToJSON Layersummaries where
  toJSON Layersummaries {..} =
    Core.object
      ( Core.catMaybes
          [ ("items" Core..=) Core.<$> items,
            ("kind" Core..=) Core.<$> kind,
            ("totalItems" Core..=) Core.<$> totalItems
          ]
      )

--
-- /See:/ 'newLayersummary' smart constructor.
data Layersummary = Layersummary
  { -- | The number of annotations for this layer.
    annotationCount :: (Core.Maybe Core.Int32),
    -- | The list of annotation types contained for this layer.
    annotationTypes :: (Core.Maybe [Core.Text]),
    -- | Link to get data for this annotation.
    annotationsDataLink :: (Core.Maybe Core.Text),
    -- | The link to get the annotations for this layer.
    annotationsLink :: (Core.Maybe Core.Text),
    -- | The content version this resource is for.
    contentVersion :: (Core.Maybe Core.Text),
    -- | The number of data items for this layer.
    dataCount :: (Core.Maybe Core.Int32),
    -- | Unique id of this layer summary.
    id :: (Core.Maybe Core.Text),
    -- | Resource Type
    kind :: (Core.Maybe Core.Text),
    -- | The layer id for this summary.
    layerId :: (Core.Maybe Core.Text),
    -- | URL to this resource.
    selfLink :: (Core.Maybe Core.Text),
    -- | Timestamp for the last time an item in this layer was updated. (RFC 3339 UTC date-time format).
    updated :: (Core.Maybe Core.Text),
    -- | The current version of this layer\'s volume annotations. Note that this version applies only to the data in the books.layers.volumeAnnotations.* responses. The actual annotation data is versioned separately.
    volumeAnnotationsVersion :: (Core.Maybe Core.Text),
    -- | The volume id this resource is for.
    volumeId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Layersummary' with the minimum fields required to make a request.
newLayersummary ::
  Layersummary
newLayersummary =
  Layersummary
    { annotationCount = Core.Nothing,
      annotationTypes = Core.Nothing,
      annotationsDataLink = Core.Nothing,
      annotationsLink = Core.Nothing,
      contentVersion = Core.Nothing,
      dataCount = Core.Nothing,
      id = Core.Nothing,
      kind = Core.Nothing,
      layerId = Core.Nothing,
      selfLink = Core.Nothing,
      updated = Core.Nothing,
      volumeAnnotationsVersion = Core.Nothing,
      volumeId = Core.Nothing
    }

instance Core.FromJSON Layersummary where
  parseJSON =
    Core.withObject
      "Layersummary"
      ( \o ->
          Layersummary
            Core.<$> (o Core..:? "annotationCount")
            Core.<*> (o Core..:? "annotationTypes")
            Core.<*> (o Core..:? "annotationsDataLink")
            Core.<*> (o Core..:? "annotationsLink")
            Core.<*> (o Core..:? "contentVersion")
            Core.<*> (o Core..:? "dataCount")
            Core.<*> (o Core..:? "id")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "layerId")
            Core.<*> (o Core..:? "selfLink")
            Core.<*> (o Core..:? "updated")
            Core.<*> (o Core..:? "volumeAnnotationsVersion")
            Core.<*> (o Core..:? "volumeId")
      )

instance Core.ToJSON Layersummary where
  toJSON Layersummary {..} =
    Core.object
      ( Core.catMaybes
          [ ("annotationCount" Core..=) Core.<$> annotationCount,
            ("annotationTypes" Core..=) Core.<$> annotationTypes,
            ("annotationsDataLink" Core..=) Core.<$> annotationsDataLink,
            ("annotationsLink" Core..=) Core.<$> annotationsLink,
            ("contentVersion" Core..=) Core.<$> contentVersion,
            ("dataCount" Core..=) Core.<$> dataCount,
            ("id" Core..=) Core.<$> id,
            ("kind" Core..=) Core.<$> kind,
            ("layerId" Core..=) Core.<$> layerId,
            ("selfLink" Core..=) Core.<$> selfLink,
            ("updated" Core..=) Core.<$> updated,
            ("volumeAnnotationsVersion" Core..=)
              Core.<$> volumeAnnotationsVersion,
            ("volumeId" Core..=) Core.<$> volumeId
          ]
      )

--
-- /See:/ 'newMetadata' smart constructor.
data Metadata = Metadata
  { -- | A list of offline dictionary metadata.
    items :: (Core.Maybe [Metadata_ItemsItem]),
    -- | Resource type.
    kind :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Metadata' with the minimum fields required to make a request.
newMetadata ::
  Metadata
newMetadata = Metadata {items = Core.Nothing, kind = Core.Nothing}

instance Core.FromJSON Metadata where
  parseJSON =
    Core.withObject
      "Metadata"
      ( \o ->
          Metadata
            Core.<$> (o Core..:? "items")
            Core.<*> (o Core..:? "kind")
      )

instance Core.ToJSON Metadata where
  toJSON Metadata {..} =
    Core.object
      ( Core.catMaybes
          [("items" Core..=) Core.<$> items, ("kind" Core..=) Core.<$> kind]
      )

--
-- /See:/ 'newMetadata_ItemsItem' smart constructor.
data Metadata_ItemsItem = Metadata_ItemsItem
  { downloadUrl :: (Core.Maybe Core.Text),
    encryptedKey :: (Core.Maybe Core.Text),
    language :: (Core.Maybe Core.Text),
    size :: (Core.Maybe Core.Int64),
    version :: (Core.Maybe Core.Int64)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Metadata_ItemsItem' with the minimum fields required to make a request.
newMetadata_ItemsItem ::
  Metadata_ItemsItem
newMetadata_ItemsItem =
  Metadata_ItemsItem
    { downloadUrl = Core.Nothing,
      encryptedKey = Core.Nothing,
      language = Core.Nothing,
      size = Core.Nothing,
      version = Core.Nothing
    }

instance Core.FromJSON Metadata_ItemsItem where
  parseJSON =
    Core.withObject
      "Metadata_ItemsItem"
      ( \o ->
          Metadata_ItemsItem
            Core.<$> (o Core..:? "download_url")
            Core.<*> (o Core..:? "encrypted_key")
            Core.<*> (o Core..:? "language")
            Core.<*> (o Core..:? "size" Core.<&> Core.fmap Core.fromAsText)
            Core.<*> (o Core..:? "version" Core.<&> Core.fmap Core.fromAsText)
      )

instance Core.ToJSON Metadata_ItemsItem where
  toJSON Metadata_ItemsItem {..} =
    Core.object
      ( Core.catMaybes
          [ ("download_url" Core..=) Core.<$> downloadUrl,
            ("encrypted_key" Core..=) Core.<$> encryptedKey,
            ("language" Core..=) Core.<$> language,
            ("size" Core..=) Core.. Core.AsText Core.<$> size,
            ("version" Core..=) Core.. Core.AsText Core.<$> version
          ]
      )

--
-- /See:/ 'newNotification' smart constructor.
data Notification = Notification
  { body :: (Core.Maybe Core.Text),
    -- | The list of crm experiment ids.
    crmExperimentIds :: (Core.Maybe [Core.Int64]),
    docId :: (Core.Maybe Core.Text),
    docType :: (Core.Maybe Core.Text),
    dontShowNotification :: (Core.Maybe Core.Bool),
    iconUrl :: (Core.Maybe Core.Text),
    isDocumentMature :: (Core.Maybe Core.Bool),
    -- | Resource type.
    kind :: (Core.Maybe Core.Text),
    notificationGroup :: (Core.Maybe Core.Text),
    notificationType :: (Core.Maybe Core.Text),
    pcampaignId :: (Core.Maybe Core.Text),
    reason :: (Core.Maybe Core.Text),
    showNotificationSettingsAction :: (Core.Maybe Core.Bool),
    targetUrl :: (Core.Maybe Core.Text),
    timeToExpireMs :: (Core.Maybe Core.Int64),
    title :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Notification' with the minimum fields required to make a request.
newNotification ::
  Notification
newNotification =
  Notification
    { body = Core.Nothing,
      crmExperimentIds = Core.Nothing,
      docId = Core.Nothing,
      docType = Core.Nothing,
      dontShowNotification = Core.Nothing,
      iconUrl = Core.Nothing,
      isDocumentMature = Core.Nothing,
      kind = Core.Nothing,
      notificationGroup = Core.Nothing,
      notificationType = Core.Nothing,
      pcampaignId = Core.Nothing,
      reason = Core.Nothing,
      showNotificationSettingsAction = Core.Nothing,
      targetUrl = Core.Nothing,
      timeToExpireMs = Core.Nothing,
      title = Core.Nothing
    }

instance Core.FromJSON Notification where
  parseJSON =
    Core.withObject
      "Notification"
      ( \o ->
          Notification
            Core.<$> (o Core..:? "body")
            Core.<*> ( o
                         Core..:? "crmExperimentIds"
                         Core.<&> Core.fmap (Core.fmap Core.fromAsText)
                     )
            Core.<*> (o Core..:? "doc_id")
            Core.<*> (o Core..:? "doc_type")
            Core.<*> (o Core..:? "dont_show_notification")
            Core.<*> (o Core..:? "iconUrl")
            Core.<*> (o Core..:? "is_document_mature")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "notificationGroup")
            Core.<*> (o Core..:? "notification_type")
            Core.<*> (o Core..:? "pcampaign_id")
            Core.<*> (o Core..:? "reason")
            Core.<*> (o Core..:? "show_notification_settings_action")
            Core.<*> (o Core..:? "targetUrl")
            Core.<*> (o Core..:? "timeToExpireMs" Core.<&> Core.fmap Core.fromAsText)
            Core.<*> (o Core..:? "title")
      )

instance Core.ToJSON Notification where
  toJSON Notification {..} =
    Core.object
      ( Core.catMaybes
          [ ("body" Core..=) Core.<$> body,
            ("crmExperimentIds" Core..=)
              Core.. Core.fmap Core.AsText
              Core.<$> crmExperimentIds,
            ("doc_id" Core..=) Core.<$> docId,
            ("doc_type" Core..=) Core.<$> docType,
            ("dont_show_notification" Core..=) Core.<$> dontShowNotification,
            ("iconUrl" Core..=) Core.<$> iconUrl,
            ("is_document_mature" Core..=) Core.<$> isDocumentMature,
            ("kind" Core..=) Core.<$> kind,
            ("notificationGroup" Core..=) Core.<$> notificationGroup,
            ("notification_type" Core..=) Core.<$> notificationType,
            ("pcampaign_id" Core..=) Core.<$> pcampaignId,
            ("reason" Core..=) Core.<$> reason,
            ("show_notification_settings_action" Core..=)
              Core.<$> showNotificationSettingsAction,
            ("targetUrl" Core..=) Core.<$> targetUrl,
            ("timeToExpireMs" Core..=)
              Core.. Core.AsText
              Core.<$> timeToExpireMs,
            ("title" Core..=) Core.<$> title
          ]
      )

--
-- /See:/ 'newOffers' smart constructor.
data Offers = Offers
  { -- | A list of offers.
    items :: (Core.Maybe [Offers_ItemsItem]),
    -- | Resource type.
    kind :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Offers' with the minimum fields required to make a request.
newOffers ::
  Offers
newOffers = Offers {items = Core.Nothing, kind = Core.Nothing}

instance Core.FromJSON Offers where
  parseJSON =
    Core.withObject
      "Offers"
      ( \o ->
          Offers Core.<$> (o Core..:? "items") Core.<*> (o Core..:? "kind")
      )

instance Core.ToJSON Offers where
  toJSON Offers {..} =
    Core.object
      ( Core.catMaybes
          [("items" Core..=) Core.<$> items, ("kind" Core..=) Core.<$> kind]
      )

--
-- /See:/ 'newOffers_ItemsItem' smart constructor.
data Offers_ItemsItem = Offers_ItemsItem
  { artUrl :: (Core.Maybe Core.Text),
    gservicesKey :: (Core.Maybe Core.Text),
    id :: (Core.Maybe Core.Text),
    items :: (Core.Maybe [Offers_ItemsItem_ItemsItem])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Offers_ItemsItem' with the minimum fields required to make a request.
newOffers_ItemsItem ::
  Offers_ItemsItem
newOffers_ItemsItem =
  Offers_ItemsItem
    { artUrl = Core.Nothing,
      gservicesKey = Core.Nothing,
      id = Core.Nothing,
      items = Core.Nothing
    }

instance Core.FromJSON Offers_ItemsItem where
  parseJSON =
    Core.withObject
      "Offers_ItemsItem"
      ( \o ->
          Offers_ItemsItem
            Core.<$> (o Core..:? "artUrl")
            Core.<*> (o Core..:? "gservicesKey")
            Core.<*> (o Core..:? "id")
            Core.<*> (o Core..:? "items")
      )

instance Core.ToJSON Offers_ItemsItem where
  toJSON Offers_ItemsItem {..} =
    Core.object
      ( Core.catMaybes
          [ ("artUrl" Core..=) Core.<$> artUrl,
            ("gservicesKey" Core..=) Core.<$> gservicesKey,
            ("id" Core..=) Core.<$> id,
            ("items" Core..=) Core.<$> items
          ]
      )

--
-- /See:/ 'newOffers_ItemsItem_ItemsItem' smart constructor.
data Offers_ItemsItem_ItemsItem = Offers_ItemsItem_ItemsItem
  { author :: (Core.Maybe Core.Text),
    canonicalVolumeLink :: (Core.Maybe Core.Text),
    coverUrl :: (Core.Maybe Core.Text),
    description :: (Core.Maybe Core.Text),
    title :: (Core.Maybe Core.Text),
    volumeId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Offers_ItemsItem_ItemsItem' with the minimum fields required to make a request.
newOffers_ItemsItem_ItemsItem ::
  Offers_ItemsItem_ItemsItem
newOffers_ItemsItem_ItemsItem =
  Offers_ItemsItem_ItemsItem
    { author = Core.Nothing,
      canonicalVolumeLink = Core.Nothing,
      coverUrl = Core.Nothing,
      description = Core.Nothing,
      title = Core.Nothing,
      volumeId = Core.Nothing
    }

instance Core.FromJSON Offers_ItemsItem_ItemsItem where
  parseJSON =
    Core.withObject
      "Offers_ItemsItem_ItemsItem"
      ( \o ->
          Offers_ItemsItem_ItemsItem
            Core.<$> (o Core..:? "author")
            Core.<*> (o Core..:? "canonicalVolumeLink")
            Core.<*> (o Core..:? "coverUrl")
            Core.<*> (o Core..:? "description")
            Core.<*> (o Core..:? "title")
            Core.<*> (o Core..:? "volumeId")
      )

instance Core.ToJSON Offers_ItemsItem_ItemsItem where
  toJSON Offers_ItemsItem_ItemsItem {..} =
    Core.object
      ( Core.catMaybes
          [ ("author" Core..=) Core.<$> author,
            ("canonicalVolumeLink" Core..=) Core.<$> canonicalVolumeLink,
            ("coverUrl" Core..=) Core.<$> coverUrl,
            ("description" Core..=) Core.<$> description,
            ("title" Core..=) Core.<$> title,
            ("volumeId" Core..=) Core.<$> volumeId
          ]
      )

--
-- /See:/ 'newReadingPosition' smart constructor.
data ReadingPosition = ReadingPosition
  { -- | Position in an EPUB as a CFI.
    epubCfiPosition :: (Core.Maybe Core.Text),
    -- | Position in a volume for image-based content.
    gbImagePosition :: (Core.Maybe Core.Text),
    -- | Position in a volume for text-based content.
    gbTextPosition :: (Core.Maybe Core.Text),
    -- | Resource type for a reading position.
    kind :: (Core.Maybe Core.Text),
    -- | Position in a PDF file.
    pdfPosition :: (Core.Maybe Core.Text),
    -- | Timestamp when this reading position was last updated (formatted UTC timestamp with millisecond resolution).
    updated :: (Core.Maybe Core.Text),
    -- | Volume id associated with this reading position.
    volumeId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ReadingPosition' with the minimum fields required to make a request.
newReadingPosition ::
  ReadingPosition
newReadingPosition =
  ReadingPosition
    { epubCfiPosition = Core.Nothing,
      gbImagePosition = Core.Nothing,
      gbTextPosition = Core.Nothing,
      kind = Core.Nothing,
      pdfPosition = Core.Nothing,
      updated = Core.Nothing,
      volumeId = Core.Nothing
    }

instance Core.FromJSON ReadingPosition where
  parseJSON =
    Core.withObject
      "ReadingPosition"
      ( \o ->
          ReadingPosition
            Core.<$> (o Core..:? "epubCfiPosition")
            Core.<*> (o Core..:? "gbImagePosition")
            Core.<*> (o Core..:? "gbTextPosition")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "pdfPosition")
            Core.<*> (o Core..:? "updated")
            Core.<*> (o Core..:? "volumeId")
      )

instance Core.ToJSON ReadingPosition where
  toJSON ReadingPosition {..} =
    Core.object
      ( Core.catMaybes
          [ ("epubCfiPosition" Core..=) Core.<$> epubCfiPosition,
            ("gbImagePosition" Core..=) Core.<$> gbImagePosition,
            ("gbTextPosition" Core..=) Core.<$> gbTextPosition,
            ("kind" Core..=) Core.<$> kind,
            ("pdfPosition" Core..=) Core.<$> pdfPosition,
            ("updated" Core..=) Core.<$> updated,
            ("volumeId" Core..=) Core.<$> volumeId
          ]
      )

--
-- /See:/ 'newRequestAccessData' smart constructor.
data RequestAccessData = RequestAccessData
  { -- | A concurrent access response.
    concurrentAccess :: (Core.Maybe ConcurrentAccessRestriction),
    -- | A download access response.
    downloadAccess :: (Core.Maybe DownloadAccessRestriction),
    -- | Resource type.
    kind :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'RequestAccessData' with the minimum fields required to make a request.
newRequestAccessData ::
  RequestAccessData
newRequestAccessData =
  RequestAccessData
    { concurrentAccess = Core.Nothing,
      downloadAccess = Core.Nothing,
      kind = Core.Nothing
    }

instance Core.FromJSON RequestAccessData where
  parseJSON =
    Core.withObject
      "RequestAccessData"
      ( \o ->
          RequestAccessData
            Core.<$> (o Core..:? "concurrentAccess")
            Core.<*> (o Core..:? "downloadAccess")
            Core.<*> (o Core..:? "kind")
      )

instance Core.ToJSON RequestAccessData where
  toJSON RequestAccessData {..} =
    Core.object
      ( Core.catMaybes
          [ ("concurrentAccess" Core..=) Core.<$> concurrentAccess,
            ("downloadAccess" Core..=) Core.<$> downloadAccess,
            ("kind" Core..=) Core.<$> kind
          ]
      )

--
-- /See:/ 'newReview' smart constructor.
data Review = Review
  { -- | Author of this review.
    author :: (Core.Maybe Review_Author),
    -- | Review text.
    content :: (Core.Maybe Core.Text),
    -- | Date of this review.
    date :: (Core.Maybe Core.Text),
    -- | URL for the full review text, for reviews gathered from the web.
    fullTextUrl :: (Core.Maybe Core.Text),
    -- | Resource type for a review.
    kind :: (Core.Maybe Core.Text),
    -- | Star rating for this review. Possible values are ONE, TWO, THREE, FOUR, FIVE or NOT_RATED.
    rating :: (Core.Maybe Core.Text),
    -- | Information regarding the source of this review, when the review is not from a Google Books user.
    source :: (Core.Maybe Review_Source),
    -- | Title for this review.
    title :: (Core.Maybe Core.Text),
    -- | Source type for this review. Possible values are EDITORIAL, WEB/USER or GOOGLE/USER.
    type' :: (Core.Maybe Core.Text),
    -- | Volume that this review is for.
    volumeId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Review' with the minimum fields required to make a request.
newReview ::
  Review
newReview =
  Review
    { author = Core.Nothing,
      content = Core.Nothing,
      date = Core.Nothing,
      fullTextUrl = Core.Nothing,
      kind = Core.Nothing,
      rating = Core.Nothing,
      source = Core.Nothing,
      title = Core.Nothing,
      type' = Core.Nothing,
      volumeId = Core.Nothing
    }

instance Core.FromJSON Review where
  parseJSON =
    Core.withObject
      "Review"
      ( \o ->
          Review
            Core.<$> (o Core..:? "author")
            Core.<*> (o Core..:? "content")
            Core.<*> (o Core..:? "date")
            Core.<*> (o Core..:? "fullTextUrl")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "rating")
            Core.<*> (o Core..:? "source")
            Core.<*> (o Core..:? "title")
            Core.<*> (o Core..:? "type")
            Core.<*> (o Core..:? "volumeId")
      )

instance Core.ToJSON Review where
  toJSON Review {..} =
    Core.object
      ( Core.catMaybes
          [ ("author" Core..=) Core.<$> author,
            ("content" Core..=) Core.<$> content,
            ("date" Core..=) Core.<$> date,
            ("fullTextUrl" Core..=) Core.<$> fullTextUrl,
            ("kind" Core..=) Core.<$> kind,
            ("rating" Core..=) Core.<$> rating,
            ("source" Core..=) Core.<$> source,
            ("title" Core..=) Core.<$> title,
            ("type" Core..=) Core.<$> type',
            ("volumeId" Core..=) Core.<$> volumeId
          ]
      )

-- | Author of this review.
--
-- /See:/ 'newReview_Author' smart constructor.
newtype Review_Author = Review_Author
  { -- | Name of this person.
    displayName :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Information regarding the source of this review, when the review is not from a Google Books user.
--
-- /See:/ 'newReview_Source' smart constructor.
data Review_Source = Review_Source
  { -- | Name of the source.
    description :: (Core.Maybe Core.Text),
    -- | Extra text about the source of the review.
    extraDescription :: (Core.Maybe Core.Text),
    -- | URL of the source of the review.
    url :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Review_Source' with the minimum fields required to make a request.
newReview_Source ::
  Review_Source
newReview_Source =
  Review_Source
    { description = Core.Nothing,
      extraDescription = Core.Nothing,
      url = Core.Nothing
    }

instance Core.FromJSON Review_Source where
  parseJSON =
    Core.withObject
      "Review_Source"
      ( \o ->
          Review_Source
            Core.<$> (o Core..:? "description")
            Core.<*> (o Core..:? "extraDescription")
            Core.<*> (o Core..:? "url")
      )

instance Core.ToJSON Review_Source where
  toJSON Review_Source {..} =
    Core.object
      ( Core.catMaybes
          [ ("description" Core..=) Core.<$> description,
            ("extraDescription" Core..=) Core.<$> extraDescription,
            ("url" Core..=) Core.<$> url
          ]
      )

--
-- /See:/ 'newSeries' smart constructor.
data Series = Series
  { -- | Resource type.
    kind :: (Core.Maybe Core.Text),
    series :: (Core.Maybe [Series_SeriesItem])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Series' with the minimum fields required to make a request.
newSeries ::
  Series
newSeries = Series {kind = Core.Nothing, series = Core.Nothing}

instance Core.FromJSON Series where
  parseJSON =
    Core.withObject
      "Series"
      ( \o ->
          Series Core.<$> (o Core..:? "kind") Core.<*> (o Core..:? "series")
      )

instance Core.ToJSON Series where
  toJSON Series {..} =
    Core.object
      ( Core.catMaybes
          [ ("kind" Core..=) Core.<$> kind,
            ("series" Core..=) Core.<$> series
          ]
      )

--
-- /See:/ 'newSeries_SeriesItem' smart constructor.
data Series_SeriesItem = Series_SeriesItem
  { bannerImageUrl :: (Core.Maybe Core.Text),
    eligibleForSubscription :: (Core.Maybe Core.Bool),
    imageUrl :: (Core.Maybe Core.Text),
    isComplete :: (Core.Maybe Core.Bool),
    seriesFormatType :: (Core.Maybe Core.Text),
    seriesId :: (Core.Maybe Core.Text),
    seriesSubscriptionReleaseInfo :: (Core.Maybe Series_SeriesItem_SeriesSubscriptionReleaseInfo),
    seriesType :: (Core.Maybe Core.Text),
    subscriptionId :: (Core.Maybe Core.Text),
    title :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Series_SeriesItem' with the minimum fields required to make a request.
newSeries_SeriesItem ::
  Series_SeriesItem
newSeries_SeriesItem =
  Series_SeriesItem
    { bannerImageUrl = Core.Nothing,
      eligibleForSubscription = Core.Nothing,
      imageUrl = Core.Nothing,
      isComplete = Core.Nothing,
      seriesFormatType = Core.Nothing,
      seriesId = Core.Nothing,
      seriesSubscriptionReleaseInfo = Core.Nothing,
      seriesType = Core.Nothing,
      subscriptionId = Core.Nothing,
      title = Core.Nothing
    }

instance Core.FromJSON Series_SeriesItem where
  parseJSON =
    Core.withObject
      "Series_SeriesItem"
      ( \o ->
          Series_SeriesItem
            Core.<$> (o Core..:? "bannerImageUrl")
            Core.<*> (o Core..:? "eligibleForSubscription")
            Core.<*> (o Core..:? "imageUrl")
            Core.<*> (o Core..:? "isComplete")
            Core.<*> (o Core..:? "seriesFormatType")
            Core.<*> (o Core..:? "seriesId")
            Core.<*> (o Core..:? "seriesSubscriptionReleaseInfo")
            Core.<*> (o Core..:? "seriesType")
            Core.<*> (o Core..:? "subscriptionId")
            Core.<*> (o Core..:? "title")
      )

instance Core.ToJSON Series_SeriesItem where
  toJSON Series_SeriesItem {..} =
    Core.object
      ( Core.catMaybes
          [ ("bannerImageUrl" Core..=) Core.<$> bannerImageUrl,
            ("eligibleForSubscription" Core..=)
              Core.<$> eligibleForSubscription,
            ("imageUrl" Core..=) Core.<$> imageUrl,
            ("isComplete" Core..=) Core.<$> isComplete,
            ("seriesFormatType" Core..=) Core.<$> seriesFormatType,
            ("seriesId" Core..=) Core.<$> seriesId,
            ("seriesSubscriptionReleaseInfo" Core..=)
              Core.<$> seriesSubscriptionReleaseInfo,
            ("seriesType" Core..=) Core.<$> seriesType,
            ("subscriptionId" Core..=) Core.<$> subscriptionId,
            ("title" Core..=) Core.<$> title
          ]
      )

--
-- /See:/ 'newSeries_SeriesItem_SeriesSubscriptionReleaseInfo' smart constructor.
data Series_SeriesItem_SeriesSubscriptionReleaseInfo = Series_SeriesItem_SeriesSubscriptionReleaseInfo
  { cancelTime :: (Core.Maybe Core.Text),
    currentReleaseInfo ::
      ( Core.Maybe
          Series_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo
      ),
    nextReleaseInfo ::
      ( Core.Maybe
          Series_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo
      ),
    seriesSubscriptionType :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Series_SeriesItem_SeriesSubscriptionReleaseInfo' with the minimum fields required to make a request.
newSeries_SeriesItem_SeriesSubscriptionReleaseInfo ::
  Series_SeriesItem_SeriesSubscriptionReleaseInfo
newSeries_SeriesItem_SeriesSubscriptionReleaseInfo =
  Series_SeriesItem_SeriesSubscriptionReleaseInfo
    { cancelTime =
        Core.Nothing,
      currentReleaseInfo = Core.Nothing,
      nextReleaseInfo = Core.Nothing,
      seriesSubscriptionType = Core.Nothing
    }

instance
  Core.FromJSON
    Series_SeriesItem_SeriesSubscriptionReleaseInfo
  where
  parseJSON =
    Core.withObject
      "Series_SeriesItem_SeriesSubscriptionReleaseInfo"
      ( \o ->
          Series_SeriesItem_SeriesSubscriptionReleaseInfo
            Core.<$> (o Core..:? "cancelTime")
            Core.<*> (o Core..:? "currentReleaseInfo")
            Core.<*> (o Core..:? "nextReleaseInfo")
            Core.<*> (o Core..:? "seriesSubscriptionType")
      )

instance
  Core.ToJSON
    Series_SeriesItem_SeriesSubscriptionReleaseInfo
  where
  toJSON Series_SeriesItem_SeriesSubscriptionReleaseInfo {..} =
    Core.object
      ( Core.catMaybes
          [ ("cancelTime" Core..=) Core.<$> cancelTime,
            ("currentReleaseInfo" Core..=) Core.<$> currentReleaseInfo,
            ("nextReleaseInfo" Core..=) Core.<$> nextReleaseInfo,
            ("seriesSubscriptionType" Core..=)
              Core.<$> seriesSubscriptionType
          ]
      )

--
-- /See:/ 'newSeries_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo' smart constructor.
data Series_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo = Series_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo
  { amountInMicros :: (Core.Maybe Core.Double),
    currencyCode :: (Core.Maybe Core.Text),
    releaseNumber :: (Core.Maybe Core.Text),
    releaseTime :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Series_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo' with the minimum fields required to make a request.
newSeries_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo ::
  Series_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo
newSeries_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo =
  Series_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo
    { amountInMicros =
        Core.Nothing,
      currencyCode = Core.Nothing,
      releaseNumber = Core.Nothing,
      releaseTime = Core.Nothing
    }

instance
  Core.FromJSON
    Series_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo
  where
  parseJSON =
    Core.withObject
      "Series_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo"
      ( \o ->
          Series_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo
            Core.<$> (o Core..:? "amountInMicros")
            Core.<*> (o Core..:? "currencyCode")
            Core.<*> (o Core..:? "releaseNumber")
            Core.<*> (o Core..:? "releaseTime")
      )

instance
  Core.ToJSON
    Series_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo
  where
  toJSON
    Series_SeriesItem_SeriesSubscriptionReleaseInfo_CurrentReleaseInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("amountInMicros" Core..=) Core.<$> amountInMicros,
              ("currencyCode" Core..=) Core.<$> currencyCode,
              ("releaseNumber" Core..=) Core.<$> releaseNumber,
              ("releaseTime" Core..=) Core.<$> releaseTime
            ]
        )

--
-- /See:/ 'newSeries_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo' smart constructor.
data Series_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo = Series_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo
  { amountInMicros :: (Core.Maybe Core.Double),
    currencyCode :: (Core.Maybe Core.Text),
    releaseNumber :: (Core.Maybe Core.Text),
    releaseTime :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Series_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo' with the minimum fields required to make a request.
newSeries_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo ::
  Series_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo
newSeries_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo =
  Series_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo
    { amountInMicros =
        Core.Nothing,
      currencyCode = Core.Nothing,
      releaseNumber = Core.Nothing,
      releaseTime = Core.Nothing
    }

instance
  Core.FromJSON
    Series_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo
  where
  parseJSON =
    Core.withObject
      "Series_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo"
      ( \o ->
          Series_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo
            Core.<$> (o Core..:? "amountInMicros")
            Core.<*> (o Core..:? "currencyCode")
            Core.<*> (o Core..:? "releaseNumber")
            Core.<*> (o Core..:? "releaseTime")
      )

instance
  Core.ToJSON
    Series_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo
  where
  toJSON
    Series_SeriesItem_SeriesSubscriptionReleaseInfo_NextReleaseInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("amountInMicros" Core..=) Core.<$> amountInMicros,
              ("currencyCode" Core..=) Core.<$> currencyCode,
              ("releaseNumber" Core..=) Core.<$> releaseNumber,
              ("releaseTime" Core..=) Core.<$> releaseTime
            ]
        )

--
-- /See:/ 'newSeriesmembership' smart constructor.
data Seriesmembership = Seriesmembership
  { -- | Resorce type.
    kind :: (Core.Maybe Core.Text),
    member :: (Core.Maybe [Volume]),
    nextPageToken :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Seriesmembership' with the minimum fields required to make a request.
newSeriesmembership ::
  Seriesmembership
newSeriesmembership =
  Seriesmembership
    { kind = Core.Nothing,
      member = Core.Nothing,
      nextPageToken = Core.Nothing
    }

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

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

--
-- /See:/ 'newUsersettings' smart constructor.
data Usersettings = Usersettings
  { -- | Resource type.
    kind :: (Core.Maybe Core.Text),
    -- | User settings in sub-objects, each for different purposes.
    notesExport :: (Core.Maybe Usersettings_NotesExport),
    notification :: (Core.Maybe Usersettings_Notification)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Usersettings' with the minimum fields required to make a request.
newUsersettings ::
  Usersettings
newUsersettings =
  Usersettings
    { kind = Core.Nothing,
      notesExport = Core.Nothing,
      notification = Core.Nothing
    }

instance Core.FromJSON Usersettings where
  parseJSON =
    Core.withObject
      "Usersettings"
      ( \o ->
          Usersettings
            Core.<$> (o Core..:? "kind")
            Core.<*> (o Core..:? "notesExport")
            Core.<*> (o Core..:? "notification")
      )

instance Core.ToJSON Usersettings where
  toJSON Usersettings {..} =
    Core.object
      ( Core.catMaybes
          [ ("kind" Core..=) Core.<$> kind,
            ("notesExport" Core..=) Core.<$> notesExport,
            ("notification" Core..=) Core.<$> notification
          ]
      )

-- | User settings in sub-objects, each for different purposes.
--
-- /See:/ 'newUsersettings_NotesExport' smart constructor.
data Usersettings_NotesExport = Usersettings_NotesExport
  { folderName :: (Core.Maybe Core.Text),
    isEnabled :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Usersettings_NotesExport' with the minimum fields required to make a request.
newUsersettings_NotesExport ::
  Usersettings_NotesExport
newUsersettings_NotesExport =
  Usersettings_NotesExport
    { folderName = Core.Nothing,
      isEnabled = Core.Nothing
    }

instance Core.FromJSON Usersettings_NotesExport where
  parseJSON =
    Core.withObject
      "Usersettings_NotesExport"
      ( \o ->
          Usersettings_NotesExport
            Core.<$> (o Core..:? "folderName")
            Core.<*> (o Core..:? "isEnabled")
      )

instance Core.ToJSON Usersettings_NotesExport where
  toJSON Usersettings_NotesExport {..} =
    Core.object
      ( Core.catMaybes
          [ ("folderName" Core..=) Core.<$> folderName,
            ("isEnabled" Core..=) Core.<$> isEnabled
          ]
      )

--
-- /See:/ 'newUsersettings_Notification' smart constructor.
data Usersettings_Notification = Usersettings_Notification
  { matchMyInterests :: (Core.Maybe Usersettings_Notification_MatchMyInterests),
    moreFromAuthors :: (Core.Maybe Usersettings_Notification_MoreFromAuthors),
    moreFromSeries :: (Core.Maybe Usersettings_Notification_MoreFromSeries),
    priceDrop :: (Core.Maybe Usersettings_Notification_PriceDrop),
    rewardExpirations :: (Core.Maybe Usersettings_Notification_RewardExpirations)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Usersettings_Notification' with the minimum fields required to make a request.
newUsersettings_Notification ::
  Usersettings_Notification
newUsersettings_Notification =
  Usersettings_Notification
    { matchMyInterests = Core.Nothing,
      moreFromAuthors = Core.Nothing,
      moreFromSeries = Core.Nothing,
      priceDrop = Core.Nothing,
      rewardExpirations = Core.Nothing
    }

instance Core.FromJSON Usersettings_Notification where
  parseJSON =
    Core.withObject
      "Usersettings_Notification"
      ( \o ->
          Usersettings_Notification
            Core.<$> (o Core..:? "matchMyInterests")
            Core.<*> (o Core..:? "moreFromAuthors")
            Core.<*> (o Core..:? "moreFromSeries")
            Core.<*> (o Core..:? "priceDrop")
            Core.<*> (o Core..:? "rewardExpirations")
      )

instance Core.ToJSON Usersettings_Notification where
  toJSON Usersettings_Notification {..} =
    Core.object
      ( Core.catMaybes
          [ ("matchMyInterests" Core..=) Core.<$> matchMyInterests,
            ("moreFromAuthors" Core..=) Core.<$> moreFromAuthors,
            ("moreFromSeries" Core..=) Core.<$> moreFromSeries,
            ("priceDrop" Core..=) Core.<$> priceDrop,
            ("rewardExpirations" Core..=) Core.<$> rewardExpirations
          ]
      )

--
-- /See:/ 'newUsersettings_Notification_MatchMyInterests' smart constructor.
newtype Usersettings_Notification_MatchMyInterests = Usersettings_Notification_MatchMyInterests
  { optedState :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

instance Core.ToJSON Usersettings_Notification_MatchMyInterests where
  toJSON Usersettings_Notification_MatchMyInterests {..} =
    Core.object
      (Core.catMaybes [("opted_state" Core..=) Core.<$> optedState])

--
-- /See:/ 'newUsersettings_Notification_MoreFromAuthors' smart constructor.
newtype Usersettings_Notification_MoreFromAuthors = Usersettings_Notification_MoreFromAuthors
  { optedState :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

instance Core.ToJSON Usersettings_Notification_MoreFromAuthors where
  toJSON Usersettings_Notification_MoreFromAuthors {..} =
    Core.object
      (Core.catMaybes [("opted_state" Core..=) Core.<$> optedState])

--
-- /See:/ 'newUsersettings_Notification_MoreFromSeries' smart constructor.
newtype Usersettings_Notification_MoreFromSeries = Usersettings_Notification_MoreFromSeries
  { optedState :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

instance Core.ToJSON Usersettings_Notification_MoreFromSeries where
  toJSON Usersettings_Notification_MoreFromSeries {..} =
    Core.object
      (Core.catMaybes [("opted_state" Core..=) Core.<$> optedState])

--
-- /See:/ 'newUsersettings_Notification_PriceDrop' smart constructor.
newtype Usersettings_Notification_PriceDrop = Usersettings_Notification_PriceDrop
  { optedState :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

instance Core.ToJSON Usersettings_Notification_PriceDrop where
  toJSON Usersettings_Notification_PriceDrop {..} =
    Core.object
      (Core.catMaybes [("opted_state" Core..=) Core.<$> optedState])

--
-- /See:/ 'newUsersettings_Notification_RewardExpirations' smart constructor.
newtype Usersettings_Notification_RewardExpirations = Usersettings_Notification_RewardExpirations
  { optedState :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

instance Core.ToJSON Usersettings_Notification_RewardExpirations where
  toJSON Usersettings_Notification_RewardExpirations {..} =
    Core.object
      (Core.catMaybes [("opted_state" Core..=) Core.<$> optedState])

--
-- /See:/ 'newVolume' smart constructor.
data Volume = Volume
  { -- | Any information about a volume related to reading or obtaining that volume text. This information can depend on country (books may be public domain in one country but not in another, e.g.).
    accessInfo :: (Core.Maybe Volume_AccessInfo),
    -- | Opaque identifier for a specific version of a volume resource. (In LITE projection)
    etag :: (Core.Maybe Core.Text),
    -- | Unique identifier for a volume. (In LITE projection.)
    id :: (Core.Maybe Core.Text),
    -- | Resource type for a volume. (In LITE projection.)
    kind :: (Core.Maybe Core.Text),
    -- | What layers exist in this volume and high level information about them.
    layerInfo :: (Core.Maybe Volume_LayerInfo),
    -- | Recommendation related information for this volume.
    recommendedInfo :: (Core.Maybe Volume_RecommendedInfo),
    -- | Any information about a volume related to the eBookstore and\/or purchaseability. This information can depend on the country where the request originates from (i.e. books may not be for sale in certain countries).
    saleInfo :: (Core.Maybe Volume_SaleInfo),
    -- | Search result information related to this volume.
    searchInfo :: (Core.Maybe Volume_SearchInfo),
    -- | URL to this resource. (In LITE projection.)
    selfLink :: (Core.Maybe Core.Text),
    -- | User specific information related to this volume. (e.g. page this user last read or whether they purchased this book)
    userInfo :: (Core.Maybe Volume_UserInfo),
    -- | General volume information.
    volumeInfo :: (Core.Maybe Volume_VolumeInfo)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume' with the minimum fields required to make a request.
newVolume ::
  Volume
newVolume =
  Volume
    { accessInfo = Core.Nothing,
      etag = Core.Nothing,
      id = Core.Nothing,
      kind = Core.Nothing,
      layerInfo = Core.Nothing,
      recommendedInfo = Core.Nothing,
      saleInfo = Core.Nothing,
      searchInfo = Core.Nothing,
      selfLink = Core.Nothing,
      userInfo = Core.Nothing,
      volumeInfo = Core.Nothing
    }

instance Core.FromJSON Volume where
  parseJSON =
    Core.withObject
      "Volume"
      ( \o ->
          Volume
            Core.<$> (o Core..:? "accessInfo")
            Core.<*> (o Core..:? "etag")
            Core.<*> (o Core..:? "id")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "layerInfo")
            Core.<*> (o Core..:? "recommendedInfo")
            Core.<*> (o Core..:? "saleInfo")
            Core.<*> (o Core..:? "searchInfo")
            Core.<*> (o Core..:? "selfLink")
            Core.<*> (o Core..:? "userInfo")
            Core.<*> (o Core..:? "volumeInfo")
      )

instance Core.ToJSON Volume where
  toJSON Volume {..} =
    Core.object
      ( Core.catMaybes
          [ ("accessInfo" Core..=) Core.<$> accessInfo,
            ("etag" Core..=) Core.<$> etag,
            ("id" Core..=) Core.<$> id,
            ("kind" Core..=) Core.<$> kind,
            ("layerInfo" Core..=) Core.<$> layerInfo,
            ("recommendedInfo" Core..=) Core.<$> recommendedInfo,
            ("saleInfo" Core..=) Core.<$> saleInfo,
            ("searchInfo" Core..=) Core.<$> searchInfo,
            ("selfLink" Core..=) Core.<$> selfLink,
            ("userInfo" Core..=) Core.<$> userInfo,
            ("volumeInfo" Core..=) Core.<$> volumeInfo
          ]
      )

-- | Any information about a volume related to reading or obtaining that volume text. This information can depend on country (books may be public domain in one country but not in another, e.g.).
--
-- /See:/ 'newVolume_AccessInfo' smart constructor.
data Volume_AccessInfo = Volume_AccessInfo
  { -- | Combines the access and viewability of this volume into a single status field for this user. Values can be FULL/PURCHASED, FULL/PUBLIC_DOMAIN, SAMPLE or NONE. (In LITE projection.)
    accessViewStatus :: (Core.Maybe Core.Text),
    -- | The two-letter ISO_3166-1 country code for which this access information is valid. (In LITE projection.)
    country :: (Core.Maybe Core.Text),
    -- | Information about a volume\'s download license access restrictions.
    downloadAccess :: (Core.Maybe DownloadAccessRestriction),
    -- | URL to the Google Drive viewer if this volume is uploaded by the user by selecting the file from Google Drive.
    driveImportedContentLink :: (Core.Maybe Core.Text),
    -- | Whether this volume can be embedded in a viewport using the Embedded Viewer API.
    embeddable :: (Core.Maybe Core.Bool),
    -- | Information about epub content. (In LITE projection.)
    epub :: (Core.Maybe Volume_AccessInfo_Epub),
    -- | Whether this volume requires that the client explicitly request offline download license rather than have it done automatically when loading the content, if the client supports it.
    explicitOfflineLicenseManagement :: (Core.Maybe Core.Bool),
    -- | Information about pdf content. (In LITE projection.)
    pdf :: (Core.Maybe Volume_AccessInfo_Pdf),
    -- | Whether or not this book is public domain in the country listed above.
    publicDomain :: (Core.Maybe Core.Bool),
    -- | Whether quote sharing is allowed for this volume.
    quoteSharingAllowed :: (Core.Maybe Core.Bool),
    -- | Whether text-to-speech is permitted for this volume. Values can be ALLOWED, ALLOWED/FOR/ACCESSIBILITY, or NOT_ALLOWED.
    textToSpeechPermission :: (Core.Maybe Core.Text),
    -- | For ordered but not yet processed orders, we give a URL that can be used to go to the appropriate Google Wallet page.
    viewOrderUrl :: (Core.Maybe Core.Text),
    -- | The read access of a volume. Possible values are PARTIAL, ALL/PAGES, NO/PAGES or UNKNOWN. This value depends on the country listed above. A value of PARTIAL means that the publisher has allowed some portion of the volume to be viewed publicly, without purchase. This can apply to eBooks as well as non-eBooks. Public domain books will always have a value of ALL_PAGES.
    viewability :: (Core.Maybe Core.Text),
    -- | URL to read this volume on the Google Books site. Link will not allow users to read non-viewable volumes.
    webReaderLink :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_AccessInfo' with the minimum fields required to make a request.
newVolume_AccessInfo ::
  Volume_AccessInfo
newVolume_AccessInfo =
  Volume_AccessInfo
    { accessViewStatus = Core.Nothing,
      country = Core.Nothing,
      downloadAccess = Core.Nothing,
      driveImportedContentLink = Core.Nothing,
      embeddable = Core.Nothing,
      epub = Core.Nothing,
      explicitOfflineLicenseManagement = Core.Nothing,
      pdf = Core.Nothing,
      publicDomain = Core.Nothing,
      quoteSharingAllowed = Core.Nothing,
      textToSpeechPermission = Core.Nothing,
      viewOrderUrl = Core.Nothing,
      viewability = Core.Nothing,
      webReaderLink = Core.Nothing
    }

instance Core.FromJSON Volume_AccessInfo where
  parseJSON =
    Core.withObject
      "Volume_AccessInfo"
      ( \o ->
          Volume_AccessInfo
            Core.<$> (o Core..:? "accessViewStatus")
            Core.<*> (o Core..:? "country")
            Core.<*> (o Core..:? "downloadAccess")
            Core.<*> (o Core..:? "driveImportedContentLink")
            Core.<*> (o Core..:? "embeddable")
            Core.<*> (o Core..:? "epub")
            Core.<*> (o Core..:? "explicitOfflineLicenseManagement")
            Core.<*> (o Core..:? "pdf")
            Core.<*> (o Core..:? "publicDomain")
            Core.<*> (o Core..:? "quoteSharingAllowed")
            Core.<*> (o Core..:? "textToSpeechPermission")
            Core.<*> (o Core..:? "viewOrderUrl")
            Core.<*> (o Core..:? "viewability")
            Core.<*> (o Core..:? "webReaderLink")
      )

instance Core.ToJSON Volume_AccessInfo where
  toJSON Volume_AccessInfo {..} =
    Core.object
      ( Core.catMaybes
          [ ("accessViewStatus" Core..=) Core.<$> accessViewStatus,
            ("country" Core..=) Core.<$> country,
            ("downloadAccess" Core..=) Core.<$> downloadAccess,
            ("driveImportedContentLink" Core..=)
              Core.<$> driveImportedContentLink,
            ("embeddable" Core..=) Core.<$> embeddable,
            ("epub" Core..=) Core.<$> epub,
            ("explicitOfflineLicenseManagement" Core..=)
              Core.<$> explicitOfflineLicenseManagement,
            ("pdf" Core..=) Core.<$> pdf,
            ("publicDomain" Core..=) Core.<$> publicDomain,
            ("quoteSharingAllowed" Core..=) Core.<$> quoteSharingAllowed,
            ("textToSpeechPermission" Core..=) Core.<$> textToSpeechPermission,
            ("viewOrderUrl" Core..=) Core.<$> viewOrderUrl,
            ("viewability" Core..=) Core.<$> viewability,
            ("webReaderLink" Core..=) Core.<$> webReaderLink
          ]
      )

-- | Information about epub content. (In LITE projection.)
--
-- /See:/ 'newVolume_AccessInfo_Epub' smart constructor.
data Volume_AccessInfo_Epub = Volume_AccessInfo_Epub
  { -- | URL to retrieve ACS token for epub download. (In LITE projection.)
    acsTokenLink :: (Core.Maybe Core.Text),
    -- | URL to download epub. (In LITE projection.)
    downloadLink :: (Core.Maybe Core.Text),
    -- | Is a flowing text epub available either as public domain or for purchase. (In LITE projection.)
    isAvailable :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_AccessInfo_Epub' with the minimum fields required to make a request.
newVolume_AccessInfo_Epub ::
  Volume_AccessInfo_Epub
newVolume_AccessInfo_Epub =
  Volume_AccessInfo_Epub
    { acsTokenLink = Core.Nothing,
      downloadLink = Core.Nothing,
      isAvailable = Core.Nothing
    }

instance Core.FromJSON Volume_AccessInfo_Epub where
  parseJSON =
    Core.withObject
      "Volume_AccessInfo_Epub"
      ( \o ->
          Volume_AccessInfo_Epub
            Core.<$> (o Core..:? "acsTokenLink")
            Core.<*> (o Core..:? "downloadLink")
            Core.<*> (o Core..:? "isAvailable")
      )

instance Core.ToJSON Volume_AccessInfo_Epub where
  toJSON Volume_AccessInfo_Epub {..} =
    Core.object
      ( Core.catMaybes
          [ ("acsTokenLink" Core..=) Core.<$> acsTokenLink,
            ("downloadLink" Core..=) Core.<$> downloadLink,
            ("isAvailable" Core..=) Core.<$> isAvailable
          ]
      )

-- | Information about pdf content. (In LITE projection.)
--
-- /See:/ 'newVolume_AccessInfo_Pdf' smart constructor.
data Volume_AccessInfo_Pdf = Volume_AccessInfo_Pdf
  { -- | URL to retrieve ACS token for pdf download. (In LITE projection.)
    acsTokenLink :: (Core.Maybe Core.Text),
    -- | URL to download pdf. (In LITE projection.)
    downloadLink :: (Core.Maybe Core.Text),
    -- | Is a scanned image pdf available either as public domain or for purchase. (In LITE projection.)
    isAvailable :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_AccessInfo_Pdf' with the minimum fields required to make a request.
newVolume_AccessInfo_Pdf ::
  Volume_AccessInfo_Pdf
newVolume_AccessInfo_Pdf =
  Volume_AccessInfo_Pdf
    { acsTokenLink = Core.Nothing,
      downloadLink = Core.Nothing,
      isAvailable = Core.Nothing
    }

instance Core.FromJSON Volume_AccessInfo_Pdf where
  parseJSON =
    Core.withObject
      "Volume_AccessInfo_Pdf"
      ( \o ->
          Volume_AccessInfo_Pdf
            Core.<$> (o Core..:? "acsTokenLink")
            Core.<*> (o Core..:? "downloadLink")
            Core.<*> (o Core..:? "isAvailable")
      )

instance Core.ToJSON Volume_AccessInfo_Pdf where
  toJSON Volume_AccessInfo_Pdf {..} =
    Core.object
      ( Core.catMaybes
          [ ("acsTokenLink" Core..=) Core.<$> acsTokenLink,
            ("downloadLink" Core..=) Core.<$> downloadLink,
            ("isAvailable" Core..=) Core.<$> isAvailable
          ]
      )

-- | What layers exist in this volume and high level information about them.
--
-- /See:/ 'newVolume_LayerInfo' smart constructor.
newtype Volume_LayerInfo = Volume_LayerInfo
  { -- | A layer should appear here if and only if the layer exists for this book.
    layers :: (Core.Maybe [Volume_LayerInfo_LayersItem])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

--
-- /See:/ 'newVolume_LayerInfo_LayersItem' smart constructor.
data Volume_LayerInfo_LayersItem = Volume_LayerInfo_LayersItem
  { -- | The layer id of this layer (e.g. \"geo\").
    layerId :: (Core.Maybe Core.Text),
    -- | The current version of this layer\'s volume annotations. Note that this version applies only to the data in the books.layers.volumeAnnotations.* responses. The actual annotation data is versioned separately.
    volumeAnnotationsVersion :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_LayerInfo_LayersItem' with the minimum fields required to make a request.
newVolume_LayerInfo_LayersItem ::
  Volume_LayerInfo_LayersItem
newVolume_LayerInfo_LayersItem =
  Volume_LayerInfo_LayersItem
    { layerId = Core.Nothing,
      volumeAnnotationsVersion = Core.Nothing
    }

instance Core.FromJSON Volume_LayerInfo_LayersItem where
  parseJSON =
    Core.withObject
      "Volume_LayerInfo_LayersItem"
      ( \o ->
          Volume_LayerInfo_LayersItem
            Core.<$> (o Core..:? "layerId")
            Core.<*> (o Core..:? "volumeAnnotationsVersion")
      )

instance Core.ToJSON Volume_LayerInfo_LayersItem where
  toJSON Volume_LayerInfo_LayersItem {..} =
    Core.object
      ( Core.catMaybes
          [ ("layerId" Core..=) Core.<$> layerId,
            ("volumeAnnotationsVersion" Core..=)
              Core.<$> volumeAnnotationsVersion
          ]
      )

-- | Recommendation related information for this volume.
--
-- /See:/ 'newVolume_RecommendedInfo' smart constructor.
newtype Volume_RecommendedInfo = Volume_RecommendedInfo
  { -- | A text explaining why this volume is recommended.
    explanation :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Any information about a volume related to the eBookstore and\/or purchaseability. This information can depend on the country where the request originates from (i.e. books may not be for sale in certain countries).
--
-- /See:/ 'newVolume_SaleInfo' smart constructor.
data Volume_SaleInfo = Volume_SaleInfo
  { -- | URL to purchase this volume on the Google Books site. (In LITE projection)
    buyLink :: (Core.Maybe Core.Text),
    -- | The two-letter ISO_3166-1 country code for which this sale information is valid. (In LITE projection.)
    country :: (Core.Maybe Core.Text),
    -- | Whether or not this volume is an eBook (can be added to the My eBooks shelf).
    isEbook :: (Core.Maybe Core.Bool),
    -- | Suggested retail price. (In LITE projection.)
    listPrice :: (Core.Maybe Volume_SaleInfo_ListPrice),
    -- | Offers available for this volume (sales and rentals).
    offers :: (Core.Maybe [Volume_SaleInfo_OffersItem]),
    -- | The date on which this book is available for sale.
    onSaleDate :: (Core.Maybe Core.Text),
    -- | The actual selling price of the book. This is the same as the suggested retail or list price unless there are offers or discounts on this volume. (In LITE projection.)
    retailPrice :: (Core.Maybe Volume_SaleInfo_RetailPrice),
    -- | Whether or not this book is available for sale or offered for free in the Google eBookstore for the country listed above. Possible values are FOR/SALE, FOR/RENTAL/ONLY, FOR/SALE/AND/RENTAL, FREE, NOT/FOR/SALE, or FOR_PREORDER.
    saleability :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_SaleInfo' with the minimum fields required to make a request.
newVolume_SaleInfo ::
  Volume_SaleInfo
newVolume_SaleInfo =
  Volume_SaleInfo
    { buyLink = Core.Nothing,
      country = Core.Nothing,
      isEbook = Core.Nothing,
      listPrice = Core.Nothing,
      offers = Core.Nothing,
      onSaleDate = Core.Nothing,
      retailPrice = Core.Nothing,
      saleability = Core.Nothing
    }

instance Core.FromJSON Volume_SaleInfo where
  parseJSON =
    Core.withObject
      "Volume_SaleInfo"
      ( \o ->
          Volume_SaleInfo
            Core.<$> (o Core..:? "buyLink")
            Core.<*> (o Core..:? "country")
            Core.<*> (o Core..:? "isEbook")
            Core.<*> (o Core..:? "listPrice")
            Core.<*> (o Core..:? "offers")
            Core.<*> (o Core..:? "onSaleDate")
            Core.<*> (o Core..:? "retailPrice")
            Core.<*> (o Core..:? "saleability")
      )

instance Core.ToJSON Volume_SaleInfo where
  toJSON Volume_SaleInfo {..} =
    Core.object
      ( Core.catMaybes
          [ ("buyLink" Core..=) Core.<$> buyLink,
            ("country" Core..=) Core.<$> country,
            ("isEbook" Core..=) Core.<$> isEbook,
            ("listPrice" Core..=) Core.<$> listPrice,
            ("offers" Core..=) Core.<$> offers,
            ("onSaleDate" Core..=) Core.<$> onSaleDate,
            ("retailPrice" Core..=) Core.<$> retailPrice,
            ("saleability" Core..=) Core.<$> saleability
          ]
      )

-- | Suggested retail price. (In LITE projection.)
--
-- /See:/ 'newVolume_SaleInfo_ListPrice' smart constructor.
data Volume_SaleInfo_ListPrice = Volume_SaleInfo_ListPrice
  { -- | Amount in the currency listed below. (In LITE projection.)
    amount :: (Core.Maybe Core.Double),
    -- | An ISO 4217, three-letter currency code. (In LITE projection.)
    currencyCode :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_SaleInfo_ListPrice' with the minimum fields required to make a request.
newVolume_SaleInfo_ListPrice ::
  Volume_SaleInfo_ListPrice
newVolume_SaleInfo_ListPrice =
  Volume_SaleInfo_ListPrice
    { amount = Core.Nothing,
      currencyCode = Core.Nothing
    }

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

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

--
-- /See:/ 'newVolume_SaleInfo_OffersItem' smart constructor.
data Volume_SaleInfo_OffersItem = Volume_SaleInfo_OffersItem
  { -- | The finsky offer type (e.g., PURCHASE=0 RENTAL=3)
    finskyOfferType :: (Core.Maybe Core.Int32),
    -- | Indicates whether the offer is giftable.
    giftable :: (Core.Maybe Core.Bool),
    -- | Offer list (=undiscounted) price in Micros.
    listPrice :: (Core.Maybe Volume_SaleInfo_OffersItem_ListPrice),
    -- | The rental duration (for rental offers only).
    rentalDuration :: (Core.Maybe Volume_SaleInfo_OffersItem_RentalDuration),
    -- | Offer retail (=discounted) price in Micros
    retailPrice :: (Core.Maybe Volume_SaleInfo_OffersItem_RetailPrice)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_SaleInfo_OffersItem' with the minimum fields required to make a request.
newVolume_SaleInfo_OffersItem ::
  Volume_SaleInfo_OffersItem
newVolume_SaleInfo_OffersItem =
  Volume_SaleInfo_OffersItem
    { finskyOfferType = Core.Nothing,
      giftable = Core.Nothing,
      listPrice = Core.Nothing,
      rentalDuration = Core.Nothing,
      retailPrice = Core.Nothing
    }

instance Core.FromJSON Volume_SaleInfo_OffersItem where
  parseJSON =
    Core.withObject
      "Volume_SaleInfo_OffersItem"
      ( \o ->
          Volume_SaleInfo_OffersItem
            Core.<$> (o Core..:? "finskyOfferType")
            Core.<*> (o Core..:? "giftable")
            Core.<*> (o Core..:? "listPrice")
            Core.<*> (o Core..:? "rentalDuration")
            Core.<*> (o Core..:? "retailPrice")
      )

instance Core.ToJSON Volume_SaleInfo_OffersItem where
  toJSON Volume_SaleInfo_OffersItem {..} =
    Core.object
      ( Core.catMaybes
          [ ("finskyOfferType" Core..=) Core.<$> finskyOfferType,
            ("giftable" Core..=) Core.<$> giftable,
            ("listPrice" Core..=) Core.<$> listPrice,
            ("rentalDuration" Core..=) Core.<$> rentalDuration,
            ("retailPrice" Core..=) Core.<$> retailPrice
          ]
      )

-- | Offer list (=undiscounted) price in Micros.
--
-- /See:/ 'newVolume_SaleInfo_OffersItem_ListPrice' smart constructor.
data Volume_SaleInfo_OffersItem_ListPrice = Volume_SaleInfo_OffersItem_ListPrice
  { amountInMicros :: (Core.Maybe Core.Double),
    currencyCode :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_SaleInfo_OffersItem_ListPrice' with the minimum fields required to make a request.
newVolume_SaleInfo_OffersItem_ListPrice ::
  Volume_SaleInfo_OffersItem_ListPrice
newVolume_SaleInfo_OffersItem_ListPrice =
  Volume_SaleInfo_OffersItem_ListPrice
    { amountInMicros =
        Core.Nothing,
      currencyCode = Core.Nothing
    }

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

instance Core.ToJSON Volume_SaleInfo_OffersItem_ListPrice where
  toJSON Volume_SaleInfo_OffersItem_ListPrice {..} =
    Core.object
      ( Core.catMaybes
          [ ("amountInMicros" Core..=) Core.<$> amountInMicros,
            ("currencyCode" Core..=) Core.<$> currencyCode
          ]
      )

-- | The rental duration (for rental offers only).
--
-- /See:/ 'newVolume_SaleInfo_OffersItem_RentalDuration' smart constructor.
data Volume_SaleInfo_OffersItem_RentalDuration = Volume_SaleInfo_OffersItem_RentalDuration
  { count :: (Core.Maybe Core.Double),
    unit :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_SaleInfo_OffersItem_RentalDuration' with the minimum fields required to make a request.
newVolume_SaleInfo_OffersItem_RentalDuration ::
  Volume_SaleInfo_OffersItem_RentalDuration
newVolume_SaleInfo_OffersItem_RentalDuration =
  Volume_SaleInfo_OffersItem_RentalDuration
    { count = Core.Nothing,
      unit = Core.Nothing
    }

instance Core.FromJSON Volume_SaleInfo_OffersItem_RentalDuration where
  parseJSON =
    Core.withObject
      "Volume_SaleInfo_OffersItem_RentalDuration"
      ( \o ->
          Volume_SaleInfo_OffersItem_RentalDuration
            Core.<$> (o Core..:? "count")
            Core.<*> (o Core..:? "unit")
      )

instance Core.ToJSON Volume_SaleInfo_OffersItem_RentalDuration where
  toJSON Volume_SaleInfo_OffersItem_RentalDuration {..} =
    Core.object
      ( Core.catMaybes
          [("count" Core..=) Core.<$> count, ("unit" Core..=) Core.<$> unit]
      )

-- | Offer retail (=discounted) price in Micros
--
-- /See:/ 'newVolume_SaleInfo_OffersItem_RetailPrice' smart constructor.
data Volume_SaleInfo_OffersItem_RetailPrice = Volume_SaleInfo_OffersItem_RetailPrice
  { amountInMicros :: (Core.Maybe Core.Double),
    currencyCode :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_SaleInfo_OffersItem_RetailPrice' with the minimum fields required to make a request.
newVolume_SaleInfo_OffersItem_RetailPrice ::
  Volume_SaleInfo_OffersItem_RetailPrice
newVolume_SaleInfo_OffersItem_RetailPrice =
  Volume_SaleInfo_OffersItem_RetailPrice
    { amountInMicros =
        Core.Nothing,
      currencyCode = Core.Nothing
    }

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

instance Core.ToJSON Volume_SaleInfo_OffersItem_RetailPrice where
  toJSON Volume_SaleInfo_OffersItem_RetailPrice {..} =
    Core.object
      ( Core.catMaybes
          [ ("amountInMicros" Core..=) Core.<$> amountInMicros,
            ("currencyCode" Core..=) Core.<$> currencyCode
          ]
      )

-- | The actual selling price of the book. This is the same as the suggested retail or list price unless there are offers or discounts on this volume. (In LITE projection.)
--
-- /See:/ 'newVolume_SaleInfo_RetailPrice' smart constructor.
data Volume_SaleInfo_RetailPrice = Volume_SaleInfo_RetailPrice
  { -- | Amount in the currency listed below. (In LITE projection.)
    amount :: (Core.Maybe Core.Double),
    -- | An ISO 4217, three-letter currency code. (In LITE projection.)
    currencyCode :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_SaleInfo_RetailPrice' with the minimum fields required to make a request.
newVolume_SaleInfo_RetailPrice ::
  Volume_SaleInfo_RetailPrice
newVolume_SaleInfo_RetailPrice =
  Volume_SaleInfo_RetailPrice
    { amount = Core.Nothing,
      currencyCode = Core.Nothing
    }

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

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

-- | Search result information related to this volume.
--
-- /See:/ 'newVolume_SearchInfo' smart constructor.
newtype Volume_SearchInfo = Volume_SearchInfo
  { -- | A text snippet containing the search query.
    textSnippet :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | User specific information related to this volume. (e.g. page this user last read or whether they purchased this book)
--
-- /See:/ 'newVolume_UserInfo' smart constructor.
data Volume_UserInfo = Volume_UserInfo
  { -- | Timestamp when this volume was acquired by the user. (RFC 3339 UTC date-time format) Acquiring includes purchase, user upload, receiving family sharing, etc.
    acquiredTime :: (Core.Maybe Core.Text),
    -- | How this volume was acquired.
    acquisitionType :: (Core.Maybe Core.Int32),
    -- | Copy\/Paste accounting information.
    copy :: (Core.Maybe Volume_UserInfo_Copy),
    -- | Whether this volume is purchased, sample, pd download etc.
    entitlementType :: (Core.Maybe Core.Int32),
    -- | Information on the ability to share with the family.
    familySharing :: (Core.Maybe Volume_UserInfo_FamilySharing),
    -- | Whether or not the user shared this volume with the family.
    isFamilySharedFromUser :: (Core.Maybe Core.Bool),
    -- | Whether or not the user received this volume through family sharing.
    isFamilySharedToUser :: (Core.Maybe Core.Bool),
    -- | Deprecated: Replaced by familySharing.
    isFamilySharingAllowed :: (Core.Maybe Core.Bool),
    -- | Deprecated: Replaced by familySharing.
    isFamilySharingDisabledByFop :: (Core.Maybe Core.Bool),
    -- | Whether or not this volume is currently in \"my books.\"
    isInMyBooks :: (Core.Maybe Core.Bool),
    -- | Whether or not this volume was pre-ordered by the authenticated user making the request. (In LITE projection.)
    isPreordered :: (Core.Maybe Core.Bool),
    -- | Whether or not this volume was purchased by the authenticated user making the request. (In LITE projection.)
    isPurchased :: (Core.Maybe Core.Bool),
    -- | Whether or not this volume was user uploaded.
    isUploaded :: (Core.Maybe Core.Bool),
    -- | The user\'s current reading position in the volume, if one is available. (In LITE projection.)
    readingPosition :: (Core.Maybe ReadingPosition),
    -- | Period during this book is\/was a valid rental.
    rentalPeriod :: (Core.Maybe Volume_UserInfo_RentalPeriod),
    -- | Whether this book is an active or an expired rental.
    rentalState :: (Core.Maybe Core.Text),
    -- | This user\'s review of this volume, if one exists.
    review :: (Core.Maybe Review),
    -- | Timestamp when this volume was last modified by a user action, such as a reading position update, volume purchase or writing a review. (RFC 3339 UTC date-time format).
    updated :: (Core.Maybe Core.Text),
    userUploadedVolumeInfo :: (Core.Maybe Volume_UserInfo_UserUploadedVolumeInfo)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_UserInfo' with the minimum fields required to make a request.
newVolume_UserInfo ::
  Volume_UserInfo
newVolume_UserInfo =
  Volume_UserInfo
    { acquiredTime = Core.Nothing,
      acquisitionType = Core.Nothing,
      copy = Core.Nothing,
      entitlementType = Core.Nothing,
      familySharing = Core.Nothing,
      isFamilySharedFromUser = Core.Nothing,
      isFamilySharedToUser = Core.Nothing,
      isFamilySharingAllowed = Core.Nothing,
      isFamilySharingDisabledByFop = Core.Nothing,
      isInMyBooks = Core.Nothing,
      isPreordered = Core.Nothing,
      isPurchased = Core.Nothing,
      isUploaded = Core.Nothing,
      readingPosition = Core.Nothing,
      rentalPeriod = Core.Nothing,
      rentalState = Core.Nothing,
      review = Core.Nothing,
      updated = Core.Nothing,
      userUploadedVolumeInfo = Core.Nothing
    }

instance Core.FromJSON Volume_UserInfo where
  parseJSON =
    Core.withObject
      "Volume_UserInfo"
      ( \o ->
          Volume_UserInfo
            Core.<$> (o Core..:? "acquiredTime")
            Core.<*> (o Core..:? "acquisitionType")
            Core.<*> (o Core..:? "copy")
            Core.<*> (o Core..:? "entitlementType")
            Core.<*> (o Core..:? "familySharing")
            Core.<*> (o Core..:? "isFamilySharedFromUser")
            Core.<*> (o Core..:? "isFamilySharedToUser")
            Core.<*> (o Core..:? "isFamilySharingAllowed")
            Core.<*> (o Core..:? "isFamilySharingDisabledByFop")
            Core.<*> (o Core..:? "isInMyBooks")
            Core.<*> (o Core..:? "isPreordered")
            Core.<*> (o Core..:? "isPurchased")
            Core.<*> (o Core..:? "isUploaded")
            Core.<*> (o Core..:? "readingPosition")
            Core.<*> (o Core..:? "rentalPeriod")
            Core.<*> (o Core..:? "rentalState")
            Core.<*> (o Core..:? "review")
            Core.<*> (o Core..:? "updated")
            Core.<*> (o Core..:? "userUploadedVolumeInfo")
      )

instance Core.ToJSON Volume_UserInfo where
  toJSON Volume_UserInfo {..} =
    Core.object
      ( Core.catMaybes
          [ ("acquiredTime" Core..=) Core.<$> acquiredTime,
            ("acquisitionType" Core..=) Core.<$> acquisitionType,
            ("copy" Core..=) Core.<$> copy,
            ("entitlementType" Core..=) Core.<$> entitlementType,
            ("familySharing" Core..=) Core.<$> familySharing,
            ("isFamilySharedFromUser" Core..=) Core.<$> isFamilySharedFromUser,
            ("isFamilySharedToUser" Core..=) Core.<$> isFamilySharedToUser,
            ("isFamilySharingAllowed" Core..=) Core.<$> isFamilySharingAllowed,
            ("isFamilySharingDisabledByFop" Core..=)
              Core.<$> isFamilySharingDisabledByFop,
            ("isInMyBooks" Core..=) Core.<$> isInMyBooks,
            ("isPreordered" Core..=) Core.<$> isPreordered,
            ("isPurchased" Core..=) Core.<$> isPurchased,
            ("isUploaded" Core..=) Core.<$> isUploaded,
            ("readingPosition" Core..=) Core.<$> readingPosition,
            ("rentalPeriod" Core..=) Core.<$> rentalPeriod,
            ("rentalState" Core..=) Core.<$> rentalState,
            ("review" Core..=) Core.<$> review,
            ("updated" Core..=) Core.<$> updated,
            ("userUploadedVolumeInfo" Core..=)
              Core.<$> userUploadedVolumeInfo
          ]
      )

-- | Copy\/Paste accounting information.
--
-- /See:/ 'newVolume_UserInfo_Copy' smart constructor.
data Volume_UserInfo_Copy = Volume_UserInfo_Copy
  { allowedCharacterCount :: (Core.Maybe Core.Int32),
    limitType :: (Core.Maybe Core.Text),
    remainingCharacterCount :: (Core.Maybe Core.Int32),
    updated :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_UserInfo_Copy' with the minimum fields required to make a request.
newVolume_UserInfo_Copy ::
  Volume_UserInfo_Copy
newVolume_UserInfo_Copy =
  Volume_UserInfo_Copy
    { allowedCharacterCount = Core.Nothing,
      limitType = Core.Nothing,
      remainingCharacterCount = Core.Nothing,
      updated = Core.Nothing
    }

instance Core.FromJSON Volume_UserInfo_Copy where
  parseJSON =
    Core.withObject
      "Volume_UserInfo_Copy"
      ( \o ->
          Volume_UserInfo_Copy
            Core.<$> (o Core..:? "allowedCharacterCount")
            Core.<*> (o Core..:? "limitType")
            Core.<*> (o Core..:? "remainingCharacterCount")
            Core.<*> (o Core..:? "updated")
      )

instance Core.ToJSON Volume_UserInfo_Copy where
  toJSON Volume_UserInfo_Copy {..} =
    Core.object
      ( Core.catMaybes
          [ ("allowedCharacterCount" Core..=) Core.<$> allowedCharacterCount,
            ("limitType" Core..=) Core.<$> limitType,
            ("remainingCharacterCount" Core..=)
              Core.<$> remainingCharacterCount,
            ("updated" Core..=) Core.<$> updated
          ]
      )

-- | Information on the ability to share with the family.
--
-- /See:/ 'newVolume_UserInfo_FamilySharing' smart constructor.
data Volume_UserInfo_FamilySharing = Volume_UserInfo_FamilySharing
  { -- | The role of the user in the family.
    familyRole :: (Core.Maybe Core.Text),
    -- | Whether or not this volume can be shared with the family by the user. This includes sharing eligibility of both the volume and the user. If the value is true, the user can initiate a family sharing action.
    isSharingAllowed :: (Core.Maybe Core.Bool),
    -- | Whether or not sharing this volume is temporarily disabled due to issues with the Family Wallet.
    isSharingDisabledByFop :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_UserInfo_FamilySharing' with the minimum fields required to make a request.
newVolume_UserInfo_FamilySharing ::
  Volume_UserInfo_FamilySharing
newVolume_UserInfo_FamilySharing =
  Volume_UserInfo_FamilySharing
    { familyRole = Core.Nothing,
      isSharingAllowed = Core.Nothing,
      isSharingDisabledByFop = Core.Nothing
    }

instance Core.FromJSON Volume_UserInfo_FamilySharing where
  parseJSON =
    Core.withObject
      "Volume_UserInfo_FamilySharing"
      ( \o ->
          Volume_UserInfo_FamilySharing
            Core.<$> (o Core..:? "familyRole")
            Core.<*> (o Core..:? "isSharingAllowed")
            Core.<*> (o Core..:? "isSharingDisabledByFop")
      )

instance Core.ToJSON Volume_UserInfo_FamilySharing where
  toJSON Volume_UserInfo_FamilySharing {..} =
    Core.object
      ( Core.catMaybes
          [ ("familyRole" Core..=) Core.<$> familyRole,
            ("isSharingAllowed" Core..=) Core.<$> isSharingAllowed,
            ("isSharingDisabledByFop" Core..=)
              Core.<$> isSharingDisabledByFop
          ]
      )

-- | Period during this book is\/was a valid rental.
--
-- /See:/ 'newVolume_UserInfo_RentalPeriod' smart constructor.
data Volume_UserInfo_RentalPeriod = Volume_UserInfo_RentalPeriod
  { endUtcSec :: (Core.Maybe Core.Int64),
    startUtcSec :: (Core.Maybe Core.Int64)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_UserInfo_RentalPeriod' with the minimum fields required to make a request.
newVolume_UserInfo_RentalPeriod ::
  Volume_UserInfo_RentalPeriod
newVolume_UserInfo_RentalPeriod =
  Volume_UserInfo_RentalPeriod
    { endUtcSec = Core.Nothing,
      startUtcSec = Core.Nothing
    }

instance Core.FromJSON Volume_UserInfo_RentalPeriod where
  parseJSON =
    Core.withObject
      "Volume_UserInfo_RentalPeriod"
      ( \o ->
          Volume_UserInfo_RentalPeriod
            Core.<$> (o Core..:? "endUtcSec" Core.<&> Core.fmap Core.fromAsText)
            Core.<*> (o Core..:? "startUtcSec" Core.<&> Core.fmap Core.fromAsText)
      )

instance Core.ToJSON Volume_UserInfo_RentalPeriod where
  toJSON Volume_UserInfo_RentalPeriod {..} =
    Core.object
      ( Core.catMaybes
          [ ("endUtcSec" Core..=) Core.. Core.AsText Core.<$> endUtcSec,
            ("startUtcSec" Core..=) Core.. Core.AsText Core.<$> startUtcSec
          ]
      )

--
-- /See:/ 'newVolume_UserInfo_UserUploadedVolumeInfo' smart constructor.
newtype Volume_UserInfo_UserUploadedVolumeInfo = Volume_UserInfo_UserUploadedVolumeInfo
  { processingState :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | General volume information.
--
-- /See:/ 'newVolume_VolumeInfo' smart constructor.
data Volume_VolumeInfo = Volume_VolumeInfo
  { -- | Whether anonymous logging should be allowed.
    allowAnonLogging :: (Core.Maybe Core.Bool),
    -- | The names of the authors and\/or editors for this volume. (In LITE projection)
    authors :: (Core.Maybe [Core.Text]),
    -- | The mean review rating for this volume. (min = 1.0, max = 5.0)
    averageRating :: (Core.Maybe Core.Double),
    -- | Canonical URL for a volume. (In LITE projection.)
    canonicalVolumeLink :: (Core.Maybe Core.Text),
    -- | A list of subject categories, such as \"Fiction\", \"Suspense\", etc.
    categories :: (Core.Maybe [Core.Text]),
    -- | Whether the volume has comics content.
    comicsContent :: (Core.Maybe Core.Bool),
    -- | An identifier for the version of the volume content (text & images). (In LITE projection)
    contentVersion :: (Core.Maybe Core.Text),
    -- | A synopsis of the volume. The text of the description is formatted in HTML and includes simple formatting elements, such as b, i, and br tags. (In LITE projection.)
    description :: (Core.Maybe Core.Text),
    -- | Physical dimensions of this volume.
    dimensions :: (Core.Maybe Volume_VolumeInfo_Dimensions),
    -- | A list of image links for all the sizes that are available. (In LITE projection.)
    imageLinks :: (Core.Maybe Volume_VolumeInfo_ImageLinks),
    -- | Industry standard identifiers for this volume.
    industryIdentifiers :: (Core.Maybe [Volume_VolumeInfo_IndustryIdentifiersItem]),
    -- | URL to view information about this volume on the Google Books site. (In LITE projection)
    infoLink :: (Core.Maybe Core.Text),
    -- | Best language for this volume (based on content). It is the two-letter ISO 639-1 code such as \'fr\', \'en\', etc.
    language :: (Core.Maybe Core.Text),
    -- | The main category to which this volume belongs. It will be the category from the categories list returned below that has the highest weight.
    mainCategory :: (Core.Maybe Core.Text),
    maturityRating :: (Core.Maybe Core.Text),
    -- | Total number of pages as per publisher metadata.
    pageCount :: (Core.Maybe Core.Int32),
    -- | A top-level summary of the panelization info in this volume.
    panelizationSummary :: (Core.Maybe Volume_VolumeInfo_PanelizationSummary),
    -- | URL to preview this volume on the Google Books site.
    previewLink :: (Core.Maybe Core.Text),
    -- | Type of publication of this volume. Possible values are BOOK or MAGAZINE.
    printType :: (Core.Maybe Core.Text),
    -- | Total number of printed pages in generated pdf representation.
    printedPageCount :: (Core.Maybe Core.Int32),
    -- | Date of publication. (In LITE projection.)
    publishedDate :: (Core.Maybe Core.Text),
    -- | Publisher of this volume. (In LITE projection.)
    publisher :: (Core.Maybe Core.Text),
    -- | The number of review ratings for this volume.
    ratingsCount :: (Core.Maybe Core.Int32),
    -- | The reading modes available for this volume.
    readingModes :: (Core.Maybe Volume_VolumeInfo_ReadingModes),
    -- | Total number of sample pages as per publisher metadata.
    samplePageCount :: (Core.Maybe Core.Int32),
    seriesInfo :: (Core.Maybe Volumeseriesinfo),
    -- | Volume subtitle. (In LITE projection.)
    subtitle :: (Core.Maybe Core.Text),
    -- | Volume title. (In LITE projection.)
    title :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_VolumeInfo' with the minimum fields required to make a request.
newVolume_VolumeInfo ::
  Volume_VolumeInfo
newVolume_VolumeInfo =
  Volume_VolumeInfo
    { allowAnonLogging = Core.Nothing,
      authors = Core.Nothing,
      averageRating = Core.Nothing,
      canonicalVolumeLink = Core.Nothing,
      categories = Core.Nothing,
      comicsContent = Core.Nothing,
      contentVersion = Core.Nothing,
      description = Core.Nothing,
      dimensions = Core.Nothing,
      imageLinks = Core.Nothing,
      industryIdentifiers = Core.Nothing,
      infoLink = Core.Nothing,
      language = Core.Nothing,
      mainCategory = Core.Nothing,
      maturityRating = Core.Nothing,
      pageCount = Core.Nothing,
      panelizationSummary = Core.Nothing,
      previewLink = Core.Nothing,
      printType = Core.Nothing,
      printedPageCount = Core.Nothing,
      publishedDate = Core.Nothing,
      publisher = Core.Nothing,
      ratingsCount = Core.Nothing,
      readingModes = Core.Nothing,
      samplePageCount = Core.Nothing,
      seriesInfo = Core.Nothing,
      subtitle = Core.Nothing,
      title = Core.Nothing
    }

instance Core.FromJSON Volume_VolumeInfo where
  parseJSON =
    Core.withObject
      "Volume_VolumeInfo"
      ( \o ->
          Volume_VolumeInfo
            Core.<$> (o Core..:? "allowAnonLogging")
            Core.<*> (o Core..:? "authors")
            Core.<*> (o Core..:? "averageRating")
            Core.<*> (o Core..:? "canonicalVolumeLink")
            Core.<*> (o Core..:? "categories")
            Core.<*> (o Core..:? "comicsContent")
            Core.<*> (o Core..:? "contentVersion")
            Core.<*> (o Core..:? "description")
            Core.<*> (o Core..:? "dimensions")
            Core.<*> (o Core..:? "imageLinks")
            Core.<*> (o Core..:? "industryIdentifiers")
            Core.<*> (o Core..:? "infoLink")
            Core.<*> (o Core..:? "language")
            Core.<*> (o Core..:? "mainCategory")
            Core.<*> (o Core..:? "maturityRating")
            Core.<*> (o Core..:? "pageCount")
            Core.<*> (o Core..:? "panelizationSummary")
            Core.<*> (o Core..:? "previewLink")
            Core.<*> (o Core..:? "printType")
            Core.<*> (o Core..:? "printedPageCount")
            Core.<*> (o Core..:? "publishedDate")
            Core.<*> (o Core..:? "publisher")
            Core.<*> (o Core..:? "ratingsCount")
            Core.<*> (o Core..:? "readingModes")
            Core.<*> (o Core..:? "samplePageCount")
            Core.<*> (o Core..:? "seriesInfo")
            Core.<*> (o Core..:? "subtitle")
            Core.<*> (o Core..:? "title")
      )

instance Core.ToJSON Volume_VolumeInfo where
  toJSON Volume_VolumeInfo {..} =
    Core.object
      ( Core.catMaybes
          [ ("allowAnonLogging" Core..=) Core.<$> allowAnonLogging,
            ("authors" Core..=) Core.<$> authors,
            ("averageRating" Core..=) Core.<$> averageRating,
            ("canonicalVolumeLink" Core..=) Core.<$> canonicalVolumeLink,
            ("categories" Core..=) Core.<$> categories,
            ("comicsContent" Core..=) Core.<$> comicsContent,
            ("contentVersion" Core..=) Core.<$> contentVersion,
            ("description" Core..=) Core.<$> description,
            ("dimensions" Core..=) Core.<$> dimensions,
            ("imageLinks" Core..=) Core.<$> imageLinks,
            ("industryIdentifiers" Core..=) Core.<$> industryIdentifiers,
            ("infoLink" Core..=) Core.<$> infoLink,
            ("language" Core..=) Core.<$> language,
            ("mainCategory" Core..=) Core.<$> mainCategory,
            ("maturityRating" Core..=) Core.<$> maturityRating,
            ("pageCount" Core..=) Core.<$> pageCount,
            ("panelizationSummary" Core..=) Core.<$> panelizationSummary,
            ("previewLink" Core..=) Core.<$> previewLink,
            ("printType" Core..=) Core.<$> printType,
            ("printedPageCount" Core..=) Core.<$> printedPageCount,
            ("publishedDate" Core..=) Core.<$> publishedDate,
            ("publisher" Core..=) Core.<$> publisher,
            ("ratingsCount" Core..=) Core.<$> ratingsCount,
            ("readingModes" Core..=) Core.<$> readingModes,
            ("samplePageCount" Core..=) Core.<$> samplePageCount,
            ("seriesInfo" Core..=) Core.<$> seriesInfo,
            ("subtitle" Core..=) Core.<$> subtitle,
            ("title" Core..=) Core.<$> title
          ]
      )

-- | Physical dimensions of this volume.
--
-- /See:/ 'newVolume_VolumeInfo_Dimensions' smart constructor.
data Volume_VolumeInfo_Dimensions = Volume_VolumeInfo_Dimensions
  { -- | Height or length of this volume (in cm).
    height :: (Core.Maybe Core.Text),
    -- | Thickness of this volume (in cm).
    thickness :: (Core.Maybe Core.Text),
    -- | Width of this volume (in cm).
    width :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_VolumeInfo_Dimensions' with the minimum fields required to make a request.
newVolume_VolumeInfo_Dimensions ::
  Volume_VolumeInfo_Dimensions
newVolume_VolumeInfo_Dimensions =
  Volume_VolumeInfo_Dimensions
    { height = Core.Nothing,
      thickness = Core.Nothing,
      width = Core.Nothing
    }

instance Core.FromJSON Volume_VolumeInfo_Dimensions where
  parseJSON =
    Core.withObject
      "Volume_VolumeInfo_Dimensions"
      ( \o ->
          Volume_VolumeInfo_Dimensions
            Core.<$> (o Core..:? "height")
            Core.<*> (o Core..:? "thickness")
            Core.<*> (o Core..:? "width")
      )

instance Core.ToJSON Volume_VolumeInfo_Dimensions where
  toJSON Volume_VolumeInfo_Dimensions {..} =
    Core.object
      ( Core.catMaybes
          [ ("height" Core..=) Core.<$> height,
            ("thickness" Core..=) Core.<$> thickness,
            ("width" Core..=) Core.<$> width
          ]
      )

-- | A list of image links for all the sizes that are available. (In LITE projection.)
--
-- /See:/ 'newVolume_VolumeInfo_ImageLinks' smart constructor.
data Volume_VolumeInfo_ImageLinks = Volume_VolumeInfo_ImageLinks
  { -- | Image link for extra large size (width of ~1280 pixels). (In LITE projection)
    extraLarge :: (Core.Maybe Core.Text),
    -- | Image link for large size (width of ~800 pixels). (In LITE projection)
    large :: (Core.Maybe Core.Text),
    -- | Image link for medium size (width of ~575 pixels). (In LITE projection)
    medium :: (Core.Maybe Core.Text),
    -- | Image link for small size (width of ~300 pixels). (In LITE projection)
    small :: (Core.Maybe Core.Text),
    -- | Image link for small thumbnail size (width of ~80 pixels). (In LITE projection)
    smallThumbnail :: (Core.Maybe Core.Text),
    -- | Image link for thumbnail size (width of ~128 pixels). (In LITE projection)
    thumbnail :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_VolumeInfo_ImageLinks' with the minimum fields required to make a request.
newVolume_VolumeInfo_ImageLinks ::
  Volume_VolumeInfo_ImageLinks
newVolume_VolumeInfo_ImageLinks =
  Volume_VolumeInfo_ImageLinks
    { extraLarge = Core.Nothing,
      large = Core.Nothing,
      medium = Core.Nothing,
      small = Core.Nothing,
      smallThumbnail = Core.Nothing,
      thumbnail = Core.Nothing
    }

instance Core.FromJSON Volume_VolumeInfo_ImageLinks where
  parseJSON =
    Core.withObject
      "Volume_VolumeInfo_ImageLinks"
      ( \o ->
          Volume_VolumeInfo_ImageLinks
            Core.<$> (o Core..:? "extraLarge")
            Core.<*> (o Core..:? "large")
            Core.<*> (o Core..:? "medium")
            Core.<*> (o Core..:? "small")
            Core.<*> (o Core..:? "smallThumbnail")
            Core.<*> (o Core..:? "thumbnail")
      )

instance Core.ToJSON Volume_VolumeInfo_ImageLinks where
  toJSON Volume_VolumeInfo_ImageLinks {..} =
    Core.object
      ( Core.catMaybes
          [ ("extraLarge" Core..=) Core.<$> extraLarge,
            ("large" Core..=) Core.<$> large,
            ("medium" Core..=) Core.<$> medium,
            ("small" Core..=) Core.<$> small,
            ("smallThumbnail" Core..=) Core.<$> smallThumbnail,
            ("thumbnail" Core..=) Core.<$> thumbnail
          ]
      )

--
-- /See:/ 'newVolume_VolumeInfo_IndustryIdentifiersItem' smart constructor.
data Volume_VolumeInfo_IndustryIdentifiersItem = Volume_VolumeInfo_IndustryIdentifiersItem
  { -- | Industry specific volume identifier.
    identifier :: (Core.Maybe Core.Text),
    -- | Identifier type. Possible values are ISBN/10, ISBN/13, ISSN and OTHER.
    type' :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A top-level summary of the panelization info in this volume.
--
-- /See:/ 'newVolume_VolumeInfo_PanelizationSummary' smart constructor.
data Volume_VolumeInfo_PanelizationSummary = Volume_VolumeInfo_PanelizationSummary
  { containsEpubBubbles :: (Core.Maybe Core.Bool),
    containsImageBubbles :: (Core.Maybe Core.Bool),
    epubBubbleVersion :: (Core.Maybe Core.Text),
    imageBubbleVersion :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_VolumeInfo_PanelizationSummary' with the minimum fields required to make a request.
newVolume_VolumeInfo_PanelizationSummary ::
  Volume_VolumeInfo_PanelizationSummary
newVolume_VolumeInfo_PanelizationSummary =
  Volume_VolumeInfo_PanelizationSummary
    { containsEpubBubbles =
        Core.Nothing,
      containsImageBubbles = Core.Nothing,
      epubBubbleVersion = Core.Nothing,
      imageBubbleVersion = Core.Nothing
    }

instance Core.FromJSON Volume_VolumeInfo_PanelizationSummary where
  parseJSON =
    Core.withObject
      "Volume_VolumeInfo_PanelizationSummary"
      ( \o ->
          Volume_VolumeInfo_PanelizationSummary
            Core.<$> (o Core..:? "containsEpubBubbles")
            Core.<*> (o Core..:? "containsImageBubbles")
            Core.<*> (o Core..:? "epubBubbleVersion")
            Core.<*> (o Core..:? "imageBubbleVersion")
      )

instance Core.ToJSON Volume_VolumeInfo_PanelizationSummary where
  toJSON Volume_VolumeInfo_PanelizationSummary {..} =
    Core.object
      ( Core.catMaybes
          [ ("containsEpubBubbles" Core..=) Core.<$> containsEpubBubbles,
            ("containsImageBubbles" Core..=) Core.<$> containsImageBubbles,
            ("epubBubbleVersion" Core..=) Core.<$> epubBubbleVersion,
            ("imageBubbleVersion" Core..=) Core.<$> imageBubbleVersion
          ]
      )

-- | The reading modes available for this volume.
--
-- /See:/ 'newVolume_VolumeInfo_ReadingModes' smart constructor.
data Volume_VolumeInfo_ReadingModes = Volume_VolumeInfo_ReadingModes
  { image :: (Core.Maybe Core.Bool),
    text :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume_VolumeInfo_ReadingModes' with the minimum fields required to make a request.
newVolume_VolumeInfo_ReadingModes ::
  Volume_VolumeInfo_ReadingModes
newVolume_VolumeInfo_ReadingModes =
  Volume_VolumeInfo_ReadingModes
    { image = Core.Nothing,
      text = Core.Nothing
    }

instance Core.FromJSON Volume_VolumeInfo_ReadingModes where
  parseJSON =
    Core.withObject
      "Volume_VolumeInfo_ReadingModes"
      ( \o ->
          Volume_VolumeInfo_ReadingModes
            Core.<$> (o Core..:? "image")
            Core.<*> (o Core..:? "text")
      )

instance Core.ToJSON Volume_VolumeInfo_ReadingModes where
  toJSON Volume_VolumeInfo_ReadingModes {..} =
    Core.object
      ( Core.catMaybes
          [("image" Core..=) Core.<$> image, ("text" Core..=) Core.<$> text]
      )

--
-- /See:/ 'newVolume2' smart constructor.
data Volume2 = Volume2
  { -- | A list of volumes.
    items :: (Core.Maybe [Volume]),
    -- | Resource type.
    kind :: (Core.Maybe Core.Text),
    nextPageToken :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volume2' with the minimum fields required to make a request.
newVolume2 ::
  Volume2
newVolume2 =
  Volume2
    { items = Core.Nothing,
      kind = Core.Nothing,
      nextPageToken = Core.Nothing
    }

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

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

--
-- /See:/ 'newVolumeannotation' smart constructor.
data Volumeannotation = Volumeannotation
  { -- | The annotation data id for this volume annotation.
    annotationDataId :: (Core.Maybe Core.Text),
    -- | Link to get data for this annotation.
    annotationDataLink :: (Core.Maybe Core.Text),
    -- | The type of annotation this is.
    annotationType :: (Core.Maybe Core.Text),
    -- | The content ranges to identify the selected text.
    contentRanges :: (Core.Maybe Volumeannotation_ContentRanges),
    -- | Data for this annotation.
    data' :: (Core.Maybe Core.Text),
    -- | Indicates that this annotation is deleted.
    deleted :: (Core.Maybe Core.Bool),
    -- | Unique id of this volume annotation.
    id :: (Core.Maybe Core.Text),
    -- | Resource Type
    kind :: (Core.Maybe Core.Text),
    -- | The Layer this annotation is for.
    layerId :: (Core.Maybe Core.Text),
    -- | Pages the annotation spans.
    pageIds :: (Core.Maybe [Core.Text]),
    -- | Excerpt from the volume.
    selectedText :: (Core.Maybe Core.Text),
    -- | URL to this resource.
    selfLink :: (Core.Maybe Core.Text),
    -- | Timestamp for the last time this anntoation was updated. (RFC 3339 UTC date-time format).
    updated :: (Core.Maybe Core.Text),
    -- | The Volume this annotation is for.
    volumeId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volumeannotation' with the minimum fields required to make a request.
newVolumeannotation ::
  Volumeannotation
newVolumeannotation =
  Volumeannotation
    { annotationDataId = Core.Nothing,
      annotationDataLink = Core.Nothing,
      annotationType = Core.Nothing,
      contentRanges = Core.Nothing,
      data' = Core.Nothing,
      deleted = Core.Nothing,
      id = Core.Nothing,
      kind = Core.Nothing,
      layerId = Core.Nothing,
      pageIds = Core.Nothing,
      selectedText = Core.Nothing,
      selfLink = Core.Nothing,
      updated = Core.Nothing,
      volumeId = Core.Nothing
    }

instance Core.FromJSON Volumeannotation where
  parseJSON =
    Core.withObject
      "Volumeannotation"
      ( \o ->
          Volumeannotation
            Core.<$> (o Core..:? "annotationDataId")
            Core.<*> (o Core..:? "annotationDataLink")
            Core.<*> (o Core..:? "annotationType")
            Core.<*> (o Core..:? "contentRanges")
            Core.<*> (o Core..:? "data")
            Core.<*> (o Core..:? "deleted")
            Core.<*> (o Core..:? "id")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "layerId")
            Core.<*> (o Core..:? "pageIds")
            Core.<*> (o Core..:? "selectedText")
            Core.<*> (o Core..:? "selfLink")
            Core.<*> (o Core..:? "updated")
            Core.<*> (o Core..:? "volumeId")
      )

instance Core.ToJSON Volumeannotation where
  toJSON Volumeannotation {..} =
    Core.object
      ( Core.catMaybes
          [ ("annotationDataId" Core..=) Core.<$> annotationDataId,
            ("annotationDataLink" Core..=) Core.<$> annotationDataLink,
            ("annotationType" Core..=) Core.<$> annotationType,
            ("contentRanges" Core..=) Core.<$> contentRanges,
            ("data" Core..=) Core.<$> data',
            ("deleted" Core..=) Core.<$> deleted,
            ("id" Core..=) Core.<$> id,
            ("kind" Core..=) Core.<$> kind,
            ("layerId" Core..=) Core.<$> layerId,
            ("pageIds" Core..=) Core.<$> pageIds,
            ("selectedText" Core..=) Core.<$> selectedText,
            ("selfLink" Core..=) Core.<$> selfLink,
            ("updated" Core..=) Core.<$> updated,
            ("volumeId" Core..=) Core.<$> volumeId
          ]
      )

-- | The content ranges to identify the selected text.
--
-- /See:/ 'newVolumeannotation_ContentRanges' smart constructor.
data Volumeannotation_ContentRanges = Volumeannotation_ContentRanges
  { -- | Range in CFI format for this annotation for version above.
    cfiRange :: (Core.Maybe BooksAnnotationsRange),
    -- | Content version applicable to ranges below.
    contentVersion :: (Core.Maybe Core.Text),
    -- | Range in GB image format for this annotation for version above.
    gbImageRange :: (Core.Maybe BooksAnnotationsRange),
    -- | Range in GB text format for this annotation for version above.
    gbTextRange :: (Core.Maybe BooksAnnotationsRange)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volumeannotation_ContentRanges' with the minimum fields required to make a request.
newVolumeannotation_ContentRanges ::
  Volumeannotation_ContentRanges
newVolumeannotation_ContentRanges =
  Volumeannotation_ContentRanges
    { cfiRange = Core.Nothing,
      contentVersion = Core.Nothing,
      gbImageRange = Core.Nothing,
      gbTextRange = Core.Nothing
    }

instance Core.FromJSON Volumeannotation_ContentRanges where
  parseJSON =
    Core.withObject
      "Volumeannotation_ContentRanges"
      ( \o ->
          Volumeannotation_ContentRanges
            Core.<$> (o Core..:? "cfiRange")
            Core.<*> (o Core..:? "contentVersion")
            Core.<*> (o Core..:? "gbImageRange")
            Core.<*> (o Core..:? "gbTextRange")
      )

instance Core.ToJSON Volumeannotation_ContentRanges where
  toJSON Volumeannotation_ContentRanges {..} =
    Core.object
      ( Core.catMaybes
          [ ("cfiRange" Core..=) Core.<$> cfiRange,
            ("contentVersion" Core..=) Core.<$> contentVersion,
            ("gbImageRange" Core..=) Core.<$> gbImageRange,
            ("gbTextRange" Core..=) Core.<$> gbTextRange
          ]
      )

--
-- /See:/ 'newVolumeannotations' smart constructor.
data Volumeannotations = Volumeannotations
  { -- | A list of volume annotations.
    items :: (Core.Maybe [Volumeannotation]),
    -- | Resource type
    kind :: (Core.Maybe Core.Text),
    -- | Token to pass in for pagination for the next page. This will not be present if this request does not have more results.
    nextPageToken :: (Core.Maybe Core.Text),
    -- | The total number of volume annotations found.
    totalItems :: (Core.Maybe Core.Int32),
    -- | The version string for all of the volume annotations in this layer (not just the ones in this response). Note: the version string doesn\'t apply to the annotation data, just the information in this response (e.g. the location of annotations in the book).
    version :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volumeannotations' with the minimum fields required to make a request.
newVolumeannotations ::
  Volumeannotations
newVolumeannotations =
  Volumeannotations
    { items = Core.Nothing,
      kind = Core.Nothing,
      nextPageToken = Core.Nothing,
      totalItems = Core.Nothing,
      version = Core.Nothing
    }

instance Core.FromJSON Volumeannotations where
  parseJSON =
    Core.withObject
      "Volumeannotations"
      ( \o ->
          Volumeannotations
            Core.<$> (o Core..:? "items")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "nextPageToken")
            Core.<*> (o Core..:? "totalItems")
            Core.<*> (o Core..:? "version")
      )

instance Core.ToJSON Volumeannotations where
  toJSON Volumeannotations {..} =
    Core.object
      ( Core.catMaybes
          [ ("items" Core..=) Core.<$> items,
            ("kind" Core..=) Core.<$> kind,
            ("nextPageToken" Core..=) Core.<$> nextPageToken,
            ("totalItems" Core..=) Core.<$> totalItems,
            ("version" Core..=) Core.<$> version
          ]
      )

--
-- /See:/ 'newVolumes' smart constructor.
data Volumes = Volumes
  { -- | A list of volumes.
    items :: (Core.Maybe [Volume]),
    -- | Resource type.
    kind :: (Core.Maybe Core.Text),
    -- | Total number of volumes found. This might be greater than the number of volumes returned in this response if results have been paginated.
    totalItems :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volumes' with the minimum fields required to make a request.
newVolumes ::
  Volumes
newVolumes =
  Volumes
    { items = Core.Nothing,
      kind = Core.Nothing,
      totalItems = Core.Nothing
    }

instance Core.FromJSON Volumes where
  parseJSON =
    Core.withObject
      "Volumes"
      ( \o ->
          Volumes
            Core.<$> (o Core..:? "items")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "totalItems")
      )

instance Core.ToJSON Volumes where
  toJSON Volumes {..} =
    Core.object
      ( Core.catMaybes
          [ ("items" Core..=) Core.<$> items,
            ("kind" Core..=) Core.<$> kind,
            ("totalItems" Core..=) Core.<$> totalItems
          ]
      )

--
-- /See:/ 'newVolumeseriesinfo' smart constructor.
data Volumeseriesinfo = Volumeseriesinfo
  { -- | The display number string. This should be used only for display purposes and the actual sequence should be inferred from the below orderNumber.
    bookDisplayNumber :: (Core.Maybe Core.Text),
    -- | Resource type.
    kind :: (Core.Maybe Core.Text),
    -- | Short book title in the context of the series.
    shortSeriesBookTitle :: (Core.Maybe Core.Text),
    volumeSeries :: (Core.Maybe [Volumeseriesinfo_VolumeSeriesItem])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volumeseriesinfo' with the minimum fields required to make a request.
newVolumeseriesinfo ::
  Volumeseriesinfo
newVolumeseriesinfo =
  Volumeseriesinfo
    { bookDisplayNumber = Core.Nothing,
      kind = Core.Nothing,
      shortSeriesBookTitle = Core.Nothing,
      volumeSeries = Core.Nothing
    }

instance Core.FromJSON Volumeseriesinfo where
  parseJSON =
    Core.withObject
      "Volumeseriesinfo"
      ( \o ->
          Volumeseriesinfo
            Core.<$> (o Core..:? "bookDisplayNumber")
            Core.<*> (o Core..:? "kind")
            Core.<*> (o Core..:? "shortSeriesBookTitle")
            Core.<*> (o Core..:? "volumeSeries")
      )

instance Core.ToJSON Volumeseriesinfo where
  toJSON Volumeseriesinfo {..} =
    Core.object
      ( Core.catMaybes
          [ ("bookDisplayNumber" Core..=) Core.<$> bookDisplayNumber,
            ("kind" Core..=) Core.<$> kind,
            ("shortSeriesBookTitle" Core..=) Core.<$> shortSeriesBookTitle,
            ("volumeSeries" Core..=) Core.<$> volumeSeries
          ]
      )

--
-- /See:/ 'newVolumeseriesinfo_VolumeSeriesItem' smart constructor.
data Volumeseriesinfo_VolumeSeriesItem = Volumeseriesinfo_VolumeSeriesItem
  { -- | List of issues. Applicable only for Collection Edition and Omnibus.
    issue :: (Core.Maybe [Volumeseriesinfo_VolumeSeriesItem_IssueItem]),
    -- | The book order number in the series.
    orderNumber :: (Core.Maybe Core.Int32),
    -- | The book type in the context of series. Examples - Single Issue, Collection Edition, etc.
    seriesBookType :: (Core.Maybe Core.Text),
    -- | The series id.
    seriesId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volumeseriesinfo_VolumeSeriesItem' with the minimum fields required to make a request.
newVolumeseriesinfo_VolumeSeriesItem ::
  Volumeseriesinfo_VolumeSeriesItem
newVolumeseriesinfo_VolumeSeriesItem =
  Volumeseriesinfo_VolumeSeriesItem
    { issue = Core.Nothing,
      orderNumber = Core.Nothing,
      seriesBookType = Core.Nothing,
      seriesId = Core.Nothing
    }

instance Core.FromJSON Volumeseriesinfo_VolumeSeriesItem where
  parseJSON =
    Core.withObject
      "Volumeseriesinfo_VolumeSeriesItem"
      ( \o ->
          Volumeseriesinfo_VolumeSeriesItem
            Core.<$> (o Core..:? "issue")
            Core.<*> (o Core..:? "orderNumber")
            Core.<*> (o Core..:? "seriesBookType")
            Core.<*> (o Core..:? "seriesId")
      )

instance Core.ToJSON Volumeseriesinfo_VolumeSeriesItem where
  toJSON Volumeseriesinfo_VolumeSeriesItem {..} =
    Core.object
      ( Core.catMaybes
          [ ("issue" Core..=) Core.<$> issue,
            ("orderNumber" Core..=) Core.<$> orderNumber,
            ("seriesBookType" Core..=) Core.<$> seriesBookType,
            ("seriesId" Core..=) Core.<$> seriesId
          ]
      )

--
-- /See:/ 'newVolumeseriesinfo_VolumeSeriesItem_IssueItem' smart constructor.
data Volumeseriesinfo_VolumeSeriesItem_IssueItem = Volumeseriesinfo_VolumeSeriesItem_IssueItem
  { issueDisplayNumber :: (Core.Maybe Core.Text),
    issueOrderNumber :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Volumeseriesinfo_VolumeSeriesItem_IssueItem' with the minimum fields required to make a request.
newVolumeseriesinfo_VolumeSeriesItem_IssueItem ::
  Volumeseriesinfo_VolumeSeriesItem_IssueItem
newVolumeseriesinfo_VolumeSeriesItem_IssueItem =
  Volumeseriesinfo_VolumeSeriesItem_IssueItem
    { issueDisplayNumber =
        Core.Nothing,
      issueOrderNumber = Core.Nothing
    }

instance Core.FromJSON Volumeseriesinfo_VolumeSeriesItem_IssueItem where
  parseJSON =
    Core.withObject
      "Volumeseriesinfo_VolumeSeriesItem_IssueItem"
      ( \o ->
          Volumeseriesinfo_VolumeSeriesItem_IssueItem
            Core.<$> (o Core..:? "issueDisplayNumber")
            Core.<*> (o Core..:? "issueOrderNumber")
      )

instance Core.ToJSON Volumeseriesinfo_VolumeSeriesItem_IssueItem where
  toJSON Volumeseriesinfo_VolumeSeriesItem_IssueItem {..} =
    Core.object
      ( Core.catMaybes
          [ ("issueDisplayNumber" Core..=) Core.<$> issueDisplayNumber,
            ("issueOrderNumber" Core..=) Core.<$> issueOrderNumber
          ]
      )