gogol-docs-1.0.0: gen/Gogol/Docs/Internal/Product.hs

{-# 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.Docs.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.Docs.Internal.Product
  ( -- * AutoText
    AutoText (..),
    newAutoText,

    -- * AutoText_SuggestedTextStyleChanges
    AutoText_SuggestedTextStyleChanges (..),
    newAutoText_SuggestedTextStyleChanges,

    -- * Background
    Background (..),
    newBackground,

    -- * BackgroundSuggestionState
    BackgroundSuggestionState (..),
    newBackgroundSuggestionState,

    -- * BatchUpdateDocumentRequest
    BatchUpdateDocumentRequest (..),
    newBatchUpdateDocumentRequest,

    -- * BatchUpdateDocumentResponse
    BatchUpdateDocumentResponse (..),
    newBatchUpdateDocumentResponse,

    -- * Body
    Body (..),
    newBody,

    -- * BookmarkLink
    BookmarkLink (..),
    newBookmarkLink,

    -- * Bullet
    Bullet (..),
    newBullet,

    -- * BulletSuggestionState
    BulletSuggestionState (..),
    newBulletSuggestionState,

    -- * Color
    Color (..),
    newColor,

    -- * ColumnBreak
    ColumnBreak (..),
    newColumnBreak,

    -- * ColumnBreak_SuggestedTextStyleChanges
    ColumnBreak_SuggestedTextStyleChanges (..),
    newColumnBreak_SuggestedTextStyleChanges,

    -- * CreateFooterRequest
    CreateFooterRequest (..),
    newCreateFooterRequest,

    -- * CreateFooterResponse
    CreateFooterResponse (..),
    newCreateFooterResponse,

    -- * CreateFootnoteRequest
    CreateFootnoteRequest (..),
    newCreateFootnoteRequest,

    -- * CreateFootnoteResponse
    CreateFootnoteResponse (..),
    newCreateFootnoteResponse,

    -- * CreateHeaderRequest
    CreateHeaderRequest (..),
    newCreateHeaderRequest,

    -- * CreateHeaderResponse
    CreateHeaderResponse (..),
    newCreateHeaderResponse,

    -- * CreateNamedRangeRequest
    CreateNamedRangeRequest (..),
    newCreateNamedRangeRequest,

    -- * CreateNamedRangeResponse
    CreateNamedRangeResponse (..),
    newCreateNamedRangeResponse,

    -- * CreateParagraphBulletsRequest
    CreateParagraphBulletsRequest (..),
    newCreateParagraphBulletsRequest,

    -- * CropProperties
    CropProperties (..),
    newCropProperties,

    -- * CropPropertiesSuggestionState
    CropPropertiesSuggestionState (..),
    newCropPropertiesSuggestionState,

    -- * DeleteContentRangeRequest
    DeleteContentRangeRequest (..),
    newDeleteContentRangeRequest,

    -- * DeleteFooterRequest
    DeleteFooterRequest (..),
    newDeleteFooterRequest,

    -- * DeleteHeaderRequest
    DeleteHeaderRequest (..),
    newDeleteHeaderRequest,

    -- * DeleteNamedRangeRequest
    DeleteNamedRangeRequest (..),
    newDeleteNamedRangeRequest,

    -- * DeleteParagraphBulletsRequest
    DeleteParagraphBulletsRequest (..),
    newDeleteParagraphBulletsRequest,

    -- * DeletePositionedObjectRequest
    DeletePositionedObjectRequest (..),
    newDeletePositionedObjectRequest,

    -- * DeleteTableColumnRequest
    DeleteTableColumnRequest (..),
    newDeleteTableColumnRequest,

    -- * DeleteTableRowRequest
    DeleteTableRowRequest (..),
    newDeleteTableRowRequest,

    -- * Dimension
    Dimension (..),
    newDimension,

    -- * Document
    Document (..),
    newDocument,

    -- * Document_Footers
    Document_Footers (..),
    newDocument_Footers,

    -- * Document_Footnotes
    Document_Footnotes (..),
    newDocument_Footnotes,

    -- * Document_Headers
    Document_Headers (..),
    newDocument_Headers,

    -- * Document_InlineObjects
    Document_InlineObjects (..),
    newDocument_InlineObjects,

    -- * Document_Lists
    Document_Lists (..),
    newDocument_Lists,

    -- * Document_NamedRanges
    Document_NamedRanges (..),
    newDocument_NamedRanges,

    -- * Document_PositionedObjects
    Document_PositionedObjects (..),
    newDocument_PositionedObjects,

    -- * Document_SuggestedDocumentStyleChanges
    Document_SuggestedDocumentStyleChanges (..),
    newDocument_SuggestedDocumentStyleChanges,

    -- * Document_SuggestedNamedStylesChanges
    Document_SuggestedNamedStylesChanges (..),
    newDocument_SuggestedNamedStylesChanges,

    -- * DocumentStyle
    DocumentStyle (..),
    newDocumentStyle,

    -- * DocumentStyleSuggestionState
    DocumentStyleSuggestionState (..),
    newDocumentStyleSuggestionState,

    -- * DocumentTab
    DocumentTab (..),
    newDocumentTab,

    -- * DocumentTab_Footers
    DocumentTab_Footers (..),
    newDocumentTab_Footers,

    -- * DocumentTab_Footnotes
    DocumentTab_Footnotes (..),
    newDocumentTab_Footnotes,

    -- * DocumentTab_Headers
    DocumentTab_Headers (..),
    newDocumentTab_Headers,

    -- * DocumentTab_InlineObjects
    DocumentTab_InlineObjects (..),
    newDocumentTab_InlineObjects,

    -- * DocumentTab_Lists
    DocumentTab_Lists (..),
    newDocumentTab_Lists,

    -- * DocumentTab_NamedRanges
    DocumentTab_NamedRanges (..),
    newDocumentTab_NamedRanges,

    -- * DocumentTab_PositionedObjects
    DocumentTab_PositionedObjects (..),
    newDocumentTab_PositionedObjects,

    -- * DocumentTab_SuggestedDocumentStyleChanges
    DocumentTab_SuggestedDocumentStyleChanges (..),
    newDocumentTab_SuggestedDocumentStyleChanges,

    -- * DocumentTab_SuggestedNamedStylesChanges
    DocumentTab_SuggestedNamedStylesChanges (..),
    newDocumentTab_SuggestedNamedStylesChanges,

    -- * EmbeddedDrawingProperties
    EmbeddedDrawingProperties (..),
    newEmbeddedDrawingProperties,

    -- * EmbeddedDrawingPropertiesSuggestionState
    EmbeddedDrawingPropertiesSuggestionState (..),
    newEmbeddedDrawingPropertiesSuggestionState,

    -- * EmbeddedObject
    EmbeddedObject (..),
    newEmbeddedObject,

    -- * EmbeddedObjectBorder
    EmbeddedObjectBorder (..),
    newEmbeddedObjectBorder,

    -- * EmbeddedObjectBorderSuggestionState
    EmbeddedObjectBorderSuggestionState (..),
    newEmbeddedObjectBorderSuggestionState,

    -- * EmbeddedObjectSuggestionState
    EmbeddedObjectSuggestionState (..),
    newEmbeddedObjectSuggestionState,

    -- * EndOfSegmentLocation
    EndOfSegmentLocation (..),
    newEndOfSegmentLocation,

    -- * Equation
    Equation (..),
    newEquation,

    -- * Footer
    Footer (..),
    newFooter,

    -- * Footnote
    Footnote (..),
    newFootnote,

    -- * FootnoteReference
    FootnoteReference (..),
    newFootnoteReference,

    -- * FootnoteReference_SuggestedTextStyleChanges
    FootnoteReference_SuggestedTextStyleChanges (..),
    newFootnoteReference_SuggestedTextStyleChanges,

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

    -- * HeadingLink
    HeadingLink (..),
    newHeadingLink,

    -- * HorizontalRule
    HorizontalRule (..),
    newHorizontalRule,

    -- * HorizontalRule_SuggestedTextStyleChanges
    HorizontalRule_SuggestedTextStyleChanges (..),
    newHorizontalRule_SuggestedTextStyleChanges,

    -- * ImageProperties
    ImageProperties (..),
    newImageProperties,

    -- * ImagePropertiesSuggestionState
    ImagePropertiesSuggestionState (..),
    newImagePropertiesSuggestionState,

    -- * InlineObject
    InlineObject (..),
    newInlineObject,

    -- * InlineObject_SuggestedInlineObjectPropertiesChanges
    InlineObject_SuggestedInlineObjectPropertiesChanges (..),
    newInlineObject_SuggestedInlineObjectPropertiesChanges,

    -- * InlineObjectElement
    InlineObjectElement (..),
    newInlineObjectElement,

    -- * InlineObjectElement_SuggestedTextStyleChanges
    InlineObjectElement_SuggestedTextStyleChanges (..),
    newInlineObjectElement_SuggestedTextStyleChanges,

    -- * InlineObjectProperties
    InlineObjectProperties (..),
    newInlineObjectProperties,

    -- * InlineObjectPropertiesSuggestionState
    InlineObjectPropertiesSuggestionState (..),
    newInlineObjectPropertiesSuggestionState,

    -- * InsertInlineImageRequest
    InsertInlineImageRequest (..),
    newInsertInlineImageRequest,

    -- * InsertInlineImageResponse
    InsertInlineImageResponse (..),
    newInsertInlineImageResponse,

    -- * InsertInlineSheetsChartResponse
    InsertInlineSheetsChartResponse (..),
    newInsertInlineSheetsChartResponse,

    -- * InsertPageBreakRequest
    InsertPageBreakRequest (..),
    newInsertPageBreakRequest,

    -- * InsertSectionBreakRequest
    InsertSectionBreakRequest (..),
    newInsertSectionBreakRequest,

    -- * InsertTableColumnRequest
    InsertTableColumnRequest (..),
    newInsertTableColumnRequest,

    -- * InsertTableRequest
    InsertTableRequest (..),
    newInsertTableRequest,

    -- * InsertTableRowRequest
    InsertTableRowRequest (..),
    newInsertTableRowRequest,

    -- * InsertTextRequest
    InsertTextRequest (..),
    newInsertTextRequest,

    -- * Link
    Link (..),
    newLink,

    -- * LinkedContentReference
    LinkedContentReference (..),
    newLinkedContentReference,

    -- * LinkedContentReferenceSuggestionState
    LinkedContentReferenceSuggestionState (..),
    newLinkedContentReferenceSuggestionState,

    -- * List
    List (..),
    newList,

    -- * List_SuggestedListPropertiesChanges
    List_SuggestedListPropertiesChanges (..),
    newList_SuggestedListPropertiesChanges,

    -- * ListProperties
    ListProperties (..),
    newListProperties,

    -- * ListPropertiesSuggestionState
    ListPropertiesSuggestionState (..),
    newListPropertiesSuggestionState,

    -- * Location
    Location (..),
    newLocation,

    -- * MergeTableCellsRequest
    MergeTableCellsRequest (..),
    newMergeTableCellsRequest,

    -- * NamedRange
    NamedRange (..),
    newNamedRange,

    -- * NamedRanges
    NamedRanges (..),
    newNamedRanges,

    -- * NamedStyle
    NamedStyle (..),
    newNamedStyle,

    -- * NamedStyleSuggestionState
    NamedStyleSuggestionState (..),
    newNamedStyleSuggestionState,

    -- * NamedStyles
    NamedStyles (..),
    newNamedStyles,

    -- * NamedStylesSuggestionState
    NamedStylesSuggestionState (..),
    newNamedStylesSuggestionState,

    -- * NestingLevel
    NestingLevel (..),
    newNestingLevel,

    -- * NestingLevelSuggestionState
    NestingLevelSuggestionState (..),
    newNestingLevelSuggestionState,

    -- * ObjectReferences
    ObjectReferences (..),
    newObjectReferences,

    -- * OptionalColor
    OptionalColor (..),
    newOptionalColor,

    -- * PageBreak
    PageBreak (..),
    newPageBreak,

    -- * PageBreak_SuggestedTextStyleChanges
    PageBreak_SuggestedTextStyleChanges (..),
    newPageBreak_SuggestedTextStyleChanges,

    -- * Paragraph
    Paragraph (..),
    newParagraph,

    -- * Paragraph_SuggestedBulletChanges
    Paragraph_SuggestedBulletChanges (..),
    newParagraph_SuggestedBulletChanges,

    -- * Paragraph_SuggestedParagraphStyleChanges
    Paragraph_SuggestedParagraphStyleChanges (..),
    newParagraph_SuggestedParagraphStyleChanges,

    -- * Paragraph_SuggestedPositionedObjectIds
    Paragraph_SuggestedPositionedObjectIds (..),
    newParagraph_SuggestedPositionedObjectIds,

    -- * ParagraphBorder
    ParagraphBorder (..),
    newParagraphBorder,

    -- * ParagraphElement
    ParagraphElement (..),
    newParagraphElement,

    -- * ParagraphStyle
    ParagraphStyle (..),
    newParagraphStyle,

    -- * ParagraphStyleSuggestionState
    ParagraphStyleSuggestionState (..),
    newParagraphStyleSuggestionState,

    -- * Person
    Person (..),
    newPerson,

    -- * Person_SuggestedTextStyleChanges
    Person_SuggestedTextStyleChanges (..),
    newPerson_SuggestedTextStyleChanges,

    -- * PersonProperties
    PersonProperties (..),
    newPersonProperties,

    -- * PinTableHeaderRowsRequest
    PinTableHeaderRowsRequest (..),
    newPinTableHeaderRowsRequest,

    -- * PositionedObject
    PositionedObject (..),
    newPositionedObject,

    -- * PositionedObject_SuggestedPositionedObjectPropertiesChanges
    PositionedObject_SuggestedPositionedObjectPropertiesChanges (..),
    newPositionedObject_SuggestedPositionedObjectPropertiesChanges,

    -- * PositionedObjectPositioning
    PositionedObjectPositioning (..),
    newPositionedObjectPositioning,

    -- * PositionedObjectPositioningSuggestionState
    PositionedObjectPositioningSuggestionState (..),
    newPositionedObjectPositioningSuggestionState,

    -- * PositionedObjectProperties
    PositionedObjectProperties (..),
    newPositionedObjectProperties,

    -- * PositionedObjectPropertiesSuggestionState
    PositionedObjectPropertiesSuggestionState (..),
    newPositionedObjectPropertiesSuggestionState,

    -- * Range
    Range (..),
    newRange,

    -- * ReplaceAllTextRequest
    ReplaceAllTextRequest (..),
    newReplaceAllTextRequest,

    -- * ReplaceAllTextResponse
    ReplaceAllTextResponse (..),
    newReplaceAllTextResponse,

    -- * ReplaceImageRequest
    ReplaceImageRequest (..),
    newReplaceImageRequest,

    -- * ReplaceNamedRangeContentRequest
    ReplaceNamedRangeContentRequest (..),
    newReplaceNamedRangeContentRequest,

    -- * Request'
    Request' (..),
    newRequest,

    -- * Response
    Response (..),
    newResponse,

    -- * RgbColor
    RgbColor (..),
    newRgbColor,

    -- * RichLink
    RichLink (..),
    newRichLink,

    -- * RichLink_SuggestedTextStyleChanges
    RichLink_SuggestedTextStyleChanges (..),
    newRichLink_SuggestedTextStyleChanges,

    -- * RichLinkProperties
    RichLinkProperties (..),
    newRichLinkProperties,

    -- * SectionBreak
    SectionBreak (..),
    newSectionBreak,

    -- * SectionColumnProperties
    SectionColumnProperties (..),
    newSectionColumnProperties,

    -- * SectionStyle
    SectionStyle (..),
    newSectionStyle,

    -- * Shading
    Shading (..),
    newShading,

    -- * ShadingSuggestionState
    ShadingSuggestionState (..),
    newShadingSuggestionState,

    -- * SheetsChartReference
    SheetsChartReference (..),
    newSheetsChartReference,

    -- * SheetsChartReferenceSuggestionState
    SheetsChartReferenceSuggestionState (..),
    newSheetsChartReferenceSuggestionState,

    -- * Size
    Size (..),
    newSize,

    -- * SizeSuggestionState
    SizeSuggestionState (..),
    newSizeSuggestionState,

    -- * StructuralElement
    StructuralElement (..),
    newStructuralElement,

    -- * SubstringMatchCriteria
    SubstringMatchCriteria (..),
    newSubstringMatchCriteria,

    -- * SuggestedBullet
    SuggestedBullet (..),
    newSuggestedBullet,

    -- * SuggestedDocumentStyle
    SuggestedDocumentStyle (..),
    newSuggestedDocumentStyle,

    -- * SuggestedInlineObjectProperties
    SuggestedInlineObjectProperties (..),
    newSuggestedInlineObjectProperties,

    -- * SuggestedListProperties
    SuggestedListProperties (..),
    newSuggestedListProperties,

    -- * SuggestedNamedStyles
    SuggestedNamedStyles (..),
    newSuggestedNamedStyles,

    -- * SuggestedParagraphStyle
    SuggestedParagraphStyle (..),
    newSuggestedParagraphStyle,

    -- * SuggestedPositionedObjectProperties
    SuggestedPositionedObjectProperties (..),
    newSuggestedPositionedObjectProperties,

    -- * SuggestedTableCellStyle
    SuggestedTableCellStyle (..),
    newSuggestedTableCellStyle,

    -- * SuggestedTableRowStyle
    SuggestedTableRowStyle (..),
    newSuggestedTableRowStyle,

    -- * SuggestedTextStyle
    SuggestedTextStyle (..),
    newSuggestedTextStyle,

    -- * Tab
    Tab (..),
    newTab,

    -- * TabProperties
    TabProperties (..),
    newTabProperties,

    -- * TabStop
    TabStop (..),
    newTabStop,

    -- * Table
    Table (..),
    newTable,

    -- * TableCell
    TableCell (..),
    newTableCell,

    -- * TableCell_SuggestedTableCellStyleChanges
    TableCell_SuggestedTableCellStyleChanges (..),
    newTableCell_SuggestedTableCellStyleChanges,

    -- * TableCellBorder
    TableCellBorder (..),
    newTableCellBorder,

    -- * TableCellLocation
    TableCellLocation (..),
    newTableCellLocation,

    -- * TableCellStyle
    TableCellStyle (..),
    newTableCellStyle,

    -- * TableCellStyleSuggestionState
    TableCellStyleSuggestionState (..),
    newTableCellStyleSuggestionState,

    -- * TableColumnProperties
    TableColumnProperties (..),
    newTableColumnProperties,

    -- * TableOfContents
    TableOfContents (..),
    newTableOfContents,

    -- * TableRange
    TableRange (..),
    newTableRange,

    -- * TableRow
    TableRow (..),
    newTableRow,

    -- * TableRow_SuggestedTableRowStyleChanges
    TableRow_SuggestedTableRowStyleChanges (..),
    newTableRow_SuggestedTableRowStyleChanges,

    -- * TableRowStyle
    TableRowStyle (..),
    newTableRowStyle,

    -- * TableRowStyleSuggestionState
    TableRowStyleSuggestionState (..),
    newTableRowStyleSuggestionState,

    -- * TableStyle
    TableStyle (..),
    newTableStyle,

    -- * TabsCriteria
    TabsCriteria (..),
    newTabsCriteria,

    -- * TextRun
    TextRun (..),
    newTextRun,

    -- * TextRun_SuggestedTextStyleChanges
    TextRun_SuggestedTextStyleChanges (..),
    newTextRun_SuggestedTextStyleChanges,

    -- * TextStyle
    TextStyle (..),
    newTextStyle,

    -- * TextStyleSuggestionState
    TextStyleSuggestionState (..),
    newTextStyleSuggestionState,

    -- * UnmergeTableCellsRequest
    UnmergeTableCellsRequest (..),
    newUnmergeTableCellsRequest,

    -- * UpdateDocumentStyleRequest
    UpdateDocumentStyleRequest (..),
    newUpdateDocumentStyleRequest,

    -- * UpdateParagraphStyleRequest
    UpdateParagraphStyleRequest (..),
    newUpdateParagraphStyleRequest,

    -- * UpdateSectionStyleRequest
    UpdateSectionStyleRequest (..),
    newUpdateSectionStyleRequest,

    -- * UpdateTableCellStyleRequest
    UpdateTableCellStyleRequest (..),
    newUpdateTableCellStyleRequest,

    -- * UpdateTableColumnPropertiesRequest
    UpdateTableColumnPropertiesRequest (..),
    newUpdateTableColumnPropertiesRequest,

    -- * UpdateTableRowStyleRequest
    UpdateTableRowStyleRequest (..),
    newUpdateTableRowStyleRequest,

    -- * UpdateTextStyleRequest
    UpdateTextStyleRequest (..),
    newUpdateTextStyleRequest,

    -- * WeightedFontFamily
    WeightedFontFamily (..),
    newWeightedFontFamily,

    -- * WriteControl
    WriteControl (..),
    newWriteControl,
  )
where

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

-- | A ParagraphElement representing a spot in the text that\'s dynamically replaced with content that can change over time, like a page number.
--
-- /See:/ 'newAutoText' smart constructor.
data AutoText = AutoText
  { -- | The suggested deletion IDs. If empty, then there are no suggested deletions of this content.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested insertion IDs. An AutoText may have multiple insertion IDs if it\'s a nested suggested change. If empty, then this is not a suggested insertion.
    suggestedInsertionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested text style changes to this AutoText, keyed by suggestion ID.
    suggestedTextStyleChanges :: (Core.Maybe AutoText_SuggestedTextStyleChanges),
    -- | The text style of this AutoText.
    textStyle :: (Core.Maybe TextStyle),
    -- | The type of this auto text.
    type' :: (Core.Maybe AutoText_Type)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'AutoText' with the minimum fields required to make a request.
newAutoText ::
  AutoText
newAutoText =
  AutoText
    { suggestedDeletionIds = Core.Nothing,
      suggestedInsertionIds = Core.Nothing,
      suggestedTextStyleChanges = Core.Nothing,
      textStyle = Core.Nothing,
      type' = Core.Nothing
    }

instance Core.FromJSON AutoText where
  parseJSON =
    Core.withObject
      "AutoText"
      ( \o ->
          AutoText
            Core.<$> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionIds")
            Core.<*> (o Core..:? "suggestedTextStyleChanges")
            Core.<*> (o Core..:? "textStyle")
            Core.<*> (o Core..:? "type")
      )

instance Core.ToJSON AutoText where
  toJSON AutoText {..} =
    Core.object
      ( Core.catMaybes
          [ ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionIds" Core..=) Core.<$> suggestedInsertionIds,
            ("suggestedTextStyleChanges" Core..=)
              Core.<$> suggestedTextStyleChanges,
            ("textStyle" Core..=) Core.<$> textStyle,
            ("type" Core..=) Core.<$> type'
          ]
      )

-- | The suggested text style changes to this AutoText, keyed by suggestion ID.
--
-- /See:/ 'newAutoText_SuggestedTextStyleChanges' smart constructor.
newtype AutoText_SuggestedTextStyleChanges = AutoText_SuggestedTextStyleChanges
  { additional :: (Core.HashMap Core.Text SuggestedTextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'AutoText_SuggestedTextStyleChanges' with the minimum fields required to make a request.
newAutoText_SuggestedTextStyleChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedTextStyle ->
  AutoText_SuggestedTextStyleChanges
newAutoText_SuggestedTextStyleChanges additional =
  AutoText_SuggestedTextStyleChanges {additional = additional}

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

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

-- | Represents the background of a document.
--
-- /See:/ 'newBackground' smart constructor.
newtype Background = Background
  { -- | The background color.
    color :: (Core.Maybe OptionalColor)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A mask that indicates which of the fields on the base Background have been changed in this suggestion. For any field set to true, the Backgound has a new suggested value.
--
-- /See:/ 'newBackgroundSuggestionState' smart constructor.
newtype BackgroundSuggestionState = BackgroundSuggestionState
  { -- | Indicates whether the current background color has been modified in this suggestion.
    backgroundColorSuggested :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Request message for BatchUpdateDocument.
--
-- /See:/ 'newBatchUpdateDocumentRequest' smart constructor.
data BatchUpdateDocumentRequest = BatchUpdateDocumentRequest
  { -- | A list of updates to apply to the document.
    requests :: (Core.Maybe [Request']),
    -- | Provides control over how write requests are executed.
    writeControl :: (Core.Maybe WriteControl)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'BatchUpdateDocumentRequest' with the minimum fields required to make a request.
newBatchUpdateDocumentRequest ::
  BatchUpdateDocumentRequest
newBatchUpdateDocumentRequest =
  BatchUpdateDocumentRequest
    { requests = Core.Nothing,
      writeControl = Core.Nothing
    }

instance Core.FromJSON BatchUpdateDocumentRequest where
  parseJSON =
    Core.withObject
      "BatchUpdateDocumentRequest"
      ( \o ->
          BatchUpdateDocumentRequest
            Core.<$> (o Core..:? "requests")
            Core.<*> (o Core..:? "writeControl")
      )

instance Core.ToJSON BatchUpdateDocumentRequest where
  toJSON BatchUpdateDocumentRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("requests" Core..=) Core.<$> requests,
            ("writeControl" Core..=) Core.<$> writeControl
          ]
      )

-- | Response message from a BatchUpdateDocument request.
--
-- /See:/ 'newBatchUpdateDocumentResponse' smart constructor.
data BatchUpdateDocumentResponse = BatchUpdateDocumentResponse
  { -- | The ID of the document to which the updates were applied to.
    documentId :: (Core.Maybe Core.Text),
    -- | The reply of the updates. This maps 1:1 with the updates, although replies to some requests may be empty.
    replies :: (Core.Maybe [Response]),
    -- | The updated write control after applying the request.
    writeControl :: (Core.Maybe WriteControl)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'BatchUpdateDocumentResponse' with the minimum fields required to make a request.
newBatchUpdateDocumentResponse ::
  BatchUpdateDocumentResponse
newBatchUpdateDocumentResponse =
  BatchUpdateDocumentResponse
    { documentId = Core.Nothing,
      replies = Core.Nothing,
      writeControl = Core.Nothing
    }

instance Core.FromJSON BatchUpdateDocumentResponse where
  parseJSON =
    Core.withObject
      "BatchUpdateDocumentResponse"
      ( \o ->
          BatchUpdateDocumentResponse
            Core.<$> (o Core..:? "documentId")
            Core.<*> (o Core..:? "replies")
            Core.<*> (o Core..:? "writeControl")
      )

instance Core.ToJSON BatchUpdateDocumentResponse where
  toJSON BatchUpdateDocumentResponse {..} =
    Core.object
      ( Core.catMaybes
          [ ("documentId" Core..=) Core.<$> documentId,
            ("replies" Core..=) Core.<$> replies,
            ("writeControl" Core..=) Core.<$> writeControl
          ]
      )

-- | The document body. The body typically contains the full document contents except for headers, footers, and footnotes.
--
-- /See:/ 'newBody' smart constructor.
newtype Body = Body
  { -- | The contents of the body. The indexes for the body\'s content begin at zero.
    content :: (Core.Maybe [StructuralElement])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A reference to a bookmark in this document.
--
-- /See:/ 'newBookmarkLink' smart constructor.
data BookmarkLink = BookmarkLink
  { -- | The ID of a bookmark in this document.
    id :: (Core.Maybe Core.Text),
    -- | The ID of the tab containing this bookmark.
    tabId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Describes the bullet of a paragraph.
--
-- /See:/ 'newBullet' smart constructor.
data Bullet = Bullet
  { -- | The ID of the list this paragraph belongs to.
    listId :: (Core.Maybe Core.Text),
    -- | The nesting level of this paragraph in the list.
    nestingLevel :: (Core.Maybe Core.Int32),
    -- | The paragraph-specific text style applied to this bullet.
    textStyle :: (Core.Maybe TextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Bullet' with the minimum fields required to make a request.
newBullet ::
  Bullet
newBullet =
  Bullet
    { listId = Core.Nothing,
      nestingLevel = Core.Nothing,
      textStyle = Core.Nothing
    }

instance Core.FromJSON Bullet where
  parseJSON =
    Core.withObject
      "Bullet"
      ( \o ->
          Bullet
            Core.<$> (o Core..:? "listId")
            Core.<*> (o Core..:? "nestingLevel")
            Core.<*> (o Core..:? "textStyle")
      )

instance Core.ToJSON Bullet where
  toJSON Bullet {..} =
    Core.object
      ( Core.catMaybes
          [ ("listId" Core..=) Core.<$> listId,
            ("nestingLevel" Core..=) Core.<$> nestingLevel,
            ("textStyle" Core..=) Core.<$> textStyle
          ]
      )

-- | A mask that indicates which of the fields on the base Bullet have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newBulletSuggestionState' smart constructor.
data BulletSuggestionState = BulletSuggestionState
  { -- | Indicates if there was a suggested change to the list_id.
    listIdSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to the nesting_level.
    nestingLevelSuggested :: (Core.Maybe Core.Bool),
    -- | A mask that indicates which of the fields in text style have been changed in this suggestion.
    textStyleSuggestionState :: (Core.Maybe TextStyleSuggestionState)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'BulletSuggestionState' with the minimum fields required to make a request.
newBulletSuggestionState ::
  BulletSuggestionState
newBulletSuggestionState =
  BulletSuggestionState
    { listIdSuggested = Core.Nothing,
      nestingLevelSuggested = Core.Nothing,
      textStyleSuggestionState = Core.Nothing
    }

instance Core.FromJSON BulletSuggestionState where
  parseJSON =
    Core.withObject
      "BulletSuggestionState"
      ( \o ->
          BulletSuggestionState
            Core.<$> (o Core..:? "listIdSuggested")
            Core.<*> (o Core..:? "nestingLevelSuggested")
            Core.<*> (o Core..:? "textStyleSuggestionState")
      )

instance Core.ToJSON BulletSuggestionState where
  toJSON BulletSuggestionState {..} =
    Core.object
      ( Core.catMaybes
          [ ("listIdSuggested" Core..=) Core.<$> listIdSuggested,
            ("nestingLevelSuggested" Core..=) Core.<$> nestingLevelSuggested,
            ("textStyleSuggestionState" Core..=)
              Core.<$> textStyleSuggestionState
          ]
      )

-- | A solid color.
--
-- /See:/ 'newColor' smart constructor.
newtype Color = Color
  { -- | The RGB color value.
    rgbColor :: (Core.Maybe RgbColor)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A ParagraphElement representing a column break. A column break makes the subsequent text start at the top of the next column.
--
-- /See:/ 'newColumnBreak' smart constructor.
data ColumnBreak = ColumnBreak
  { -- | The suggested deletion IDs. If empty, then there are no suggested deletions of this content.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested insertion IDs. A ColumnBreak may have multiple insertion IDs if it\'s a nested suggested change. If empty, then this is not a suggested insertion.
    suggestedInsertionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested text style changes to this ColumnBreak, keyed by suggestion ID.
    suggestedTextStyleChanges :: (Core.Maybe ColumnBreak_SuggestedTextStyleChanges),
    -- | The text style of this ColumnBreak. Similar to text content, like text runs and footnote references, the text style of a column break can affect content layout as well as the styling of text inserted next to it.
    textStyle :: (Core.Maybe TextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ColumnBreak' with the minimum fields required to make a request.
newColumnBreak ::
  ColumnBreak
newColumnBreak =
  ColumnBreak
    { suggestedDeletionIds = Core.Nothing,
      suggestedInsertionIds = Core.Nothing,
      suggestedTextStyleChanges = Core.Nothing,
      textStyle = Core.Nothing
    }

instance Core.FromJSON ColumnBreak where
  parseJSON =
    Core.withObject
      "ColumnBreak"
      ( \o ->
          ColumnBreak
            Core.<$> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionIds")
            Core.<*> (o Core..:? "suggestedTextStyleChanges")
            Core.<*> (o Core..:? "textStyle")
      )

instance Core.ToJSON ColumnBreak where
  toJSON ColumnBreak {..} =
    Core.object
      ( Core.catMaybes
          [ ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionIds" Core..=) Core.<$> suggestedInsertionIds,
            ("suggestedTextStyleChanges" Core..=)
              Core.<$> suggestedTextStyleChanges,
            ("textStyle" Core..=) Core.<$> textStyle
          ]
      )

-- | The suggested text style changes to this ColumnBreak, keyed by suggestion ID.
--
-- /See:/ 'newColumnBreak_SuggestedTextStyleChanges' smart constructor.
newtype ColumnBreak_SuggestedTextStyleChanges = ColumnBreak_SuggestedTextStyleChanges
  { additional :: (Core.HashMap Core.Text SuggestedTextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ColumnBreak_SuggestedTextStyleChanges' with the minimum fields required to make a request.
newColumnBreak_SuggestedTextStyleChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedTextStyle ->
  ColumnBreak_SuggestedTextStyleChanges
newColumnBreak_SuggestedTextStyleChanges additional =
  ColumnBreak_SuggestedTextStyleChanges {additional = additional}

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

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

-- | Creates a Footer. The new footer is applied to the SectionStyle at the location of the SectionBreak if specified, otherwise it is applied to the DocumentStyle. If a footer of the specified type already exists, a 400 bad request error is returned.
--
-- /See:/ 'newCreateFooterRequest' smart constructor.
data CreateFooterRequest = CreateFooterRequest
  { -- | The location of the SectionBreak immediately preceding the section whose SectionStyle this footer should belong to. If this is unset or refers to the first section break in the document, the footer applies to the document style.
    sectionBreakLocation :: (Core.Maybe Location),
    -- | The type of footer to create.
    type' :: (Core.Maybe CreateFooterRequest_Type)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | The result of creating a footer.
--
-- /See:/ 'newCreateFooterResponse' smart constructor.
newtype CreateFooterResponse = CreateFooterResponse
  { -- | The ID of the created footer.
    footerId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Creates a Footnote segment and inserts a new FootnoteReference to it at the given location. The new Footnote segment will contain a space followed by a newline character.
--
-- /See:/ 'newCreateFootnoteRequest' smart constructor.
data CreateFootnoteRequest = CreateFootnoteRequest
  { -- | Inserts the footnote reference at the end of the document body. Footnote references cannot be inserted inside a header, footer or footnote. Since footnote references can only be inserted in the body, the segment ID field must be empty.
    endOfSegmentLocation :: (Core.Maybe EndOfSegmentLocation),
    -- | Inserts the footnote reference at a specific index in the document. The footnote reference must be inserted inside the bounds of an existing Paragraph. For instance, it cannot be inserted at a table\'s start index (i.e. between the table and its preceding paragraph). Footnote references cannot be inserted inside an equation, header, footer or footnote. Since footnote references can only be inserted in the body, the segment ID field must be empty.
    location :: (Core.Maybe Location)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'CreateFootnoteRequest' with the minimum fields required to make a request.
newCreateFootnoteRequest ::
  CreateFootnoteRequest
newCreateFootnoteRequest =
  CreateFootnoteRequest
    { endOfSegmentLocation = Core.Nothing,
      location = Core.Nothing
    }

instance Core.FromJSON CreateFootnoteRequest where
  parseJSON =
    Core.withObject
      "CreateFootnoteRequest"
      ( \o ->
          CreateFootnoteRequest
            Core.<$> (o Core..:? "endOfSegmentLocation")
            Core.<*> (o Core..:? "location")
      )

instance Core.ToJSON CreateFootnoteRequest where
  toJSON CreateFootnoteRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("endOfSegmentLocation" Core..=) Core.<$> endOfSegmentLocation,
            ("location" Core..=) Core.<$> location
          ]
      )

-- | The result of creating a footnote.
--
-- /See:/ 'newCreateFootnoteResponse' smart constructor.
newtype CreateFootnoteResponse = CreateFootnoteResponse
  { -- | The ID of the created footnote.
    footnoteId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Creates a Header. The new header is applied to the SectionStyle at the location of the SectionBreak if specified, otherwise it is applied to the DocumentStyle. If a header of the specified type already exists, a 400 bad request error is returned.
--
-- /See:/ 'newCreateHeaderRequest' smart constructor.
data CreateHeaderRequest = CreateHeaderRequest
  { -- | The location of the SectionBreak which begins the section this header should belong to. If \`section/break/location\' is unset or if it refers to the first section break in the document body, the header applies to the DocumentStyle
    sectionBreakLocation :: (Core.Maybe Location),
    -- | The type of header to create.
    type' :: (Core.Maybe CreateHeaderRequest_Type)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | The result of creating a header.
--
-- /See:/ 'newCreateHeaderResponse' smart constructor.
newtype CreateHeaderResponse = CreateHeaderResponse
  { -- | The ID of the created header.
    headerId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Creates a NamedRange referencing the given range.
--
-- /See:/ 'newCreateNamedRangeRequest' smart constructor.
data CreateNamedRangeRequest = CreateNamedRangeRequest
  { -- | The name of the NamedRange. Names do not need to be unique. Names must be at least 1 character and no more than 256 characters, measured in UTF-16 code units.
    name :: (Core.Maybe Core.Text),
    -- | The range to apply the name to.
    range :: (Core.Maybe Range)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | The result of creating a named range.
--
-- /See:/ 'newCreateNamedRangeResponse' smart constructor.
newtype CreateNamedRangeResponse = CreateNamedRangeResponse
  { -- | The ID of the created named range.
    namedRangeId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Creates bullets for all of the paragraphs that overlap with the given range. The nesting level of each paragraph will be determined by counting leading tabs in front of each paragraph. To avoid excess space between the bullet and the corresponding paragraph, these leading tabs are removed by this request. This may change the indices of parts of the text. If the paragraph immediately before paragraphs being updated is in a list with a matching preset, the paragraphs being updated are added to that preceding list.
--
-- /See:/ 'newCreateParagraphBulletsRequest' smart constructor.
data CreateParagraphBulletsRequest = CreateParagraphBulletsRequest
  { -- | The kinds of bullet glyphs to be used.
    bulletPreset :: (Core.Maybe CreateParagraphBulletsRequest_BulletPreset),
    -- | The range to apply the bullet preset to.
    range :: (Core.Maybe Range)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'CreateParagraphBulletsRequest' with the minimum fields required to make a request.
newCreateParagraphBulletsRequest ::
  CreateParagraphBulletsRequest
newCreateParagraphBulletsRequest =
  CreateParagraphBulletsRequest
    { bulletPreset = Core.Nothing,
      range = Core.Nothing
    }

instance Core.FromJSON CreateParagraphBulletsRequest where
  parseJSON =
    Core.withObject
      "CreateParagraphBulletsRequest"
      ( \o ->
          CreateParagraphBulletsRequest
            Core.<$> (o Core..:? "bulletPreset")
            Core.<*> (o Core..:? "range")
      )

instance Core.ToJSON CreateParagraphBulletsRequest where
  toJSON CreateParagraphBulletsRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("bulletPreset" Core..=) Core.<$> bulletPreset,
            ("range" Core..=) Core.<$> range
          ]
      )

-- | The crop properties of an image. The crop rectangle is represented using fractional offsets from the original content\'s 4 edges. - If the offset is in the interval (0, 1), the corresponding edge of crop rectangle is positioned inside of the image\'s original bounding rectangle. - If the offset is negative or greater than 1, the corresponding edge of crop rectangle is positioned outside of the image\'s original bounding rectangle. - If all offsets and rotation angles are 0, the image is not cropped.
--
-- /See:/ 'newCropProperties' smart constructor.
data CropProperties = CropProperties
  { -- | The clockwise rotation angle of the crop rectangle around its center, in radians. Rotation is applied after the offsets.
    angle :: (Core.Maybe Core.Double),
    -- | The offset specifies how far inwards the bottom edge of the crop rectangle is from the bottom edge of the original content as a fraction of the original content\'s height.
    offsetBottom :: (Core.Maybe Core.Double),
    -- | The offset specifies how far inwards the left edge of the crop rectangle is from the left edge of the original content as a fraction of the original content\'s width.
    offsetLeft :: (Core.Maybe Core.Double),
    -- | The offset specifies how far inwards the right edge of the crop rectangle is from the right edge of the original content as a fraction of the original content\'s width.
    offsetRight :: (Core.Maybe Core.Double),
    -- | The offset specifies how far inwards the top edge of the crop rectangle is from the top edge of the original content as a fraction of the original content\'s height.
    offsetTop :: (Core.Maybe Core.Double)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'CropProperties' with the minimum fields required to make a request.
newCropProperties ::
  CropProperties
newCropProperties =
  CropProperties
    { angle = Core.Nothing,
      offsetBottom = Core.Nothing,
      offsetLeft = Core.Nothing,
      offsetRight = Core.Nothing,
      offsetTop = Core.Nothing
    }

instance Core.FromJSON CropProperties where
  parseJSON =
    Core.withObject
      "CropProperties"
      ( \o ->
          CropProperties
            Core.<$> (o Core..:? "angle")
            Core.<*> (o Core..:? "offsetBottom")
            Core.<*> (o Core..:? "offsetLeft")
            Core.<*> (o Core..:? "offsetRight")
            Core.<*> (o Core..:? "offsetTop")
      )

instance Core.ToJSON CropProperties where
  toJSON CropProperties {..} =
    Core.object
      ( Core.catMaybes
          [ ("angle" Core..=) Core.<$> angle,
            ("offsetBottom" Core..=) Core.<$> offsetBottom,
            ("offsetLeft" Core..=) Core.<$> offsetLeft,
            ("offsetRight" Core..=) Core.<$> offsetRight,
            ("offsetTop" Core..=) Core.<$> offsetTop
          ]
      )

-- | A mask that indicates which of the fields on the base CropProperties have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newCropPropertiesSuggestionState' smart constructor.
data CropPropertiesSuggestionState = CropPropertiesSuggestionState
  { -- | Indicates if there was a suggested change to angle.
    angleSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to offset_bottom.
    offsetBottomSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to offset_left.
    offsetLeftSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to offset_right.
    offsetRightSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to offset_top.
    offsetTopSuggested :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'CropPropertiesSuggestionState' with the minimum fields required to make a request.
newCropPropertiesSuggestionState ::
  CropPropertiesSuggestionState
newCropPropertiesSuggestionState =
  CropPropertiesSuggestionState
    { angleSuggested = Core.Nothing,
      offsetBottomSuggested = Core.Nothing,
      offsetLeftSuggested = Core.Nothing,
      offsetRightSuggested = Core.Nothing,
      offsetTopSuggested = Core.Nothing
    }

instance Core.FromJSON CropPropertiesSuggestionState where
  parseJSON =
    Core.withObject
      "CropPropertiesSuggestionState"
      ( \o ->
          CropPropertiesSuggestionState
            Core.<$> (o Core..:? "angleSuggested")
            Core.<*> (o Core..:? "offsetBottomSuggested")
            Core.<*> (o Core..:? "offsetLeftSuggested")
            Core.<*> (o Core..:? "offsetRightSuggested")
            Core.<*> (o Core..:? "offsetTopSuggested")
      )

instance Core.ToJSON CropPropertiesSuggestionState where
  toJSON CropPropertiesSuggestionState {..} =
    Core.object
      ( Core.catMaybes
          [ ("angleSuggested" Core..=) Core.<$> angleSuggested,
            ("offsetBottomSuggested" Core..=) Core.<$> offsetBottomSuggested,
            ("offsetLeftSuggested" Core..=) Core.<$> offsetLeftSuggested,
            ("offsetRightSuggested" Core..=) Core.<$> offsetRightSuggested,
            ("offsetTopSuggested" Core..=) Core.<$> offsetTopSuggested
          ]
      )

-- | Deletes content from the document.
--
-- /See:/ 'newDeleteContentRangeRequest' smart constructor.
newtype DeleteContentRangeRequest = DeleteContentRangeRequest
  { -- | The range of content to delete. Deleting text that crosses a paragraph boundary may result in changes to paragraph styles, lists, positioned objects and bookmarks as the two paragraphs are merged. Attempting to delete certain ranges can result in an invalid document structure in which case a 400 bad request error is returned. Some examples of invalid delete requests include: * Deleting one code unit of a surrogate pair. * Deleting the last newline character of a Body, Header, Footer, Footnote, TableCell or TableOfContents. * Deleting the start or end of a Table, TableOfContents or Equation without deleting the entire element. * Deleting the newline character before a Table, TableOfContents or SectionBreak without deleting the element. * Deleting individual rows or cells of a table. Deleting the content within a table cell is allowed.
    range :: (Core.Maybe Range)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Deletes a Footer from the document.
--
-- /See:/ 'newDeleteFooterRequest' smart constructor.
data DeleteFooterRequest = DeleteFooterRequest
  { -- | The id of the footer to delete. If this footer is defined on DocumentStyle, the reference to this footer is removed, resulting in no footer of that type for the first section of the document. If this footer is defined on a SectionStyle, the reference to this footer is removed and the footer of that type is now continued from the previous section.
    footerId :: (Core.Maybe Core.Text),
    -- | The tab that contains the footer to delete. When omitted, the request is applied to the first tab. In a document containing a single tab: - If provided, must match the singular tab\'s ID. - If omitted, the request applies to the singular tab. In a document containing multiple tabs: - If provided, the request applies to the specified tab. - If omitted, the request applies to the first tab in the document.
    tabId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DeleteFooterRequest' with the minimum fields required to make a request.
newDeleteFooterRequest ::
  DeleteFooterRequest
newDeleteFooterRequest =
  DeleteFooterRequest
    { footerId = Core.Nothing,
      tabId = Core.Nothing
    }

instance Core.FromJSON DeleteFooterRequest where
  parseJSON =
    Core.withObject
      "DeleteFooterRequest"
      ( \o ->
          DeleteFooterRequest
            Core.<$> (o Core..:? "footerId")
            Core.<*> (o Core..:? "tabId")
      )

instance Core.ToJSON DeleteFooterRequest where
  toJSON DeleteFooterRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("footerId" Core..=) Core.<$> footerId,
            ("tabId" Core..=) Core.<$> tabId
          ]
      )

-- | Deletes a Header from the document.
--
-- /See:/ 'newDeleteHeaderRequest' smart constructor.
data DeleteHeaderRequest = DeleteHeaderRequest
  { -- | The id of the header to delete. If this header is defined on DocumentStyle, the reference to this header is removed, resulting in no header of that type for the first section of the document. If this header is defined on a SectionStyle, the reference to this header is removed and the header of that type is now continued from the previous section.
    headerId :: (Core.Maybe Core.Text),
    -- | The tab containing the header to delete. When omitted, the request is applied to the first tab. In a document containing a single tab: - If provided, must match the singular tab\'s ID. - If omitted, the request applies to the singular tab. In a document containing multiple tabs: - If provided, the request applies to the specified tab. - If omitted, the request applies to the first tab in the document.
    tabId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DeleteHeaderRequest' with the minimum fields required to make a request.
newDeleteHeaderRequest ::
  DeleteHeaderRequest
newDeleteHeaderRequest =
  DeleteHeaderRequest
    { headerId = Core.Nothing,
      tabId = Core.Nothing
    }

instance Core.FromJSON DeleteHeaderRequest where
  parseJSON =
    Core.withObject
      "DeleteHeaderRequest"
      ( \o ->
          DeleteHeaderRequest
            Core.<$> (o Core..:? "headerId")
            Core.<*> (o Core..:? "tabId")
      )

instance Core.ToJSON DeleteHeaderRequest where
  toJSON DeleteHeaderRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("headerId" Core..=) Core.<$> headerId,
            ("tabId" Core..=) Core.<$> tabId
          ]
      )

-- | Deletes a NamedRange.
--
-- /See:/ 'newDeleteNamedRangeRequest' smart constructor.
data DeleteNamedRangeRequest = DeleteNamedRangeRequest
  { -- | The name of the range(s) to delete. All named ranges with the given name will be deleted.
    name :: (Core.Maybe Core.Text),
    -- | The ID of the named range to delete.
    namedRangeId :: (Core.Maybe Core.Text),
    -- | Optional. The criteria used to specify which tab(s) the range deletion should occur in. When omitted, the range deletion is applied to all tabs. In a document containing a single tab: - If provided, must match the singular tab\'s ID. - If omitted, the range deletion applies to the singular tab. In a document containing multiple tabs: - If provided, the range deletion applies to the specified tabs. - If not provided, the range deletion applies to all tabs.
    tabsCriteria :: (Core.Maybe TabsCriteria)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DeleteNamedRangeRequest' with the minimum fields required to make a request.
newDeleteNamedRangeRequest ::
  DeleteNamedRangeRequest
newDeleteNamedRangeRequest =
  DeleteNamedRangeRequest
    { name = Core.Nothing,
      namedRangeId = Core.Nothing,
      tabsCriteria = Core.Nothing
    }

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

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

-- | Deletes bullets from all of the paragraphs that overlap with the given range. The nesting level of each paragraph will be visually preserved by adding indent to the start of the corresponding paragraph.
--
-- /See:/ 'newDeleteParagraphBulletsRequest' smart constructor.
newtype DeleteParagraphBulletsRequest = DeleteParagraphBulletsRequest
  { -- | The range to delete bullets from.
    range :: (Core.Maybe Range)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Deletes a PositionedObject from the document.
--
-- /See:/ 'newDeletePositionedObjectRequest' smart constructor.
data DeletePositionedObjectRequest = DeletePositionedObjectRequest
  { -- | The ID of the positioned object to delete.
    objectId :: (Core.Maybe Core.Text),
    -- | The tab that the positioned object to delete is in. When omitted, the request is applied to the first tab. In a document containing a single tab: - If provided, must match the singular tab\'s ID. - If omitted, the request applies to the singular tab. In a document containing multiple tabs: - If provided, the request applies to the specified tab. - If omitted, the request applies to the first tab in the document.
    tabId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DeletePositionedObjectRequest' with the minimum fields required to make a request.
newDeletePositionedObjectRequest ::
  DeletePositionedObjectRequest
newDeletePositionedObjectRequest =
  DeletePositionedObjectRequest
    { objectId = Core.Nothing,
      tabId = Core.Nothing
    }

instance Core.FromJSON DeletePositionedObjectRequest where
  parseJSON =
    Core.withObject
      "DeletePositionedObjectRequest"
      ( \o ->
          DeletePositionedObjectRequest
            Core.<$> (o Core..:? "objectId")
            Core.<*> (o Core..:? "tabId")
      )

instance Core.ToJSON DeletePositionedObjectRequest where
  toJSON DeletePositionedObjectRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("objectId" Core..=) Core.<$> objectId,
            ("tabId" Core..=) Core.<$> tabId
          ]
      )

-- | Deletes a column from a table.
--
-- /See:/ 'newDeleteTableColumnRequest' smart constructor.
newtype DeleteTableColumnRequest = DeleteTableColumnRequest
  { -- | The reference table cell location from which the column will be deleted. The column this cell spans will be deleted. If this is a merged cell that spans multiple columns, all columns that the cell spans will be deleted. If no columns remain in the table after this deletion, the whole table is deleted.
    tableCellLocation :: (Core.Maybe TableCellLocation)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Deletes a row from a table.
--
-- /See:/ 'newDeleteTableRowRequest' smart constructor.
newtype DeleteTableRowRequest = DeleteTableRowRequest
  { -- | The reference table cell location from which the row will be deleted. The row this cell spans will be deleted. If this is a merged cell that spans multiple rows, all rows that the cell spans will be deleted. If no rows remain in the table after this deletion, the whole table is deleted.
    tableCellLocation :: (Core.Maybe TableCellLocation)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A magnitude in a single direction in the specified units.
--
-- /See:/ 'newDimension' smart constructor.
data Dimension = Dimension
  { -- | The magnitude.
    magnitude :: (Core.Maybe Core.Double),
    -- | The units for magnitude.
    unit :: (Core.Maybe Dimension_Unit)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A Google Docs document.
--
-- /See:/ 'newDocument' smart constructor.
data Document = Document
  { -- | Output only. The main body of the document. Legacy field: Instead, use Document.tabs.documentTab.body, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
    body :: (Core.Maybe Body),
    -- | Output only. The ID of the document.
    documentId :: (Core.Maybe Core.Text),
    -- | Output only. The style of the document. Legacy field: Instead, use Document.tabs.documentTab.documentStyle, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
    documentStyle :: (Core.Maybe DocumentStyle),
    -- | Output only. The footers in the document, keyed by footer ID. Legacy field: Instead, use Document.tabs.documentTab.footers, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
    footers :: (Core.Maybe Document_Footers),
    -- | Output only. The footnotes in the document, keyed by footnote ID. Legacy field: Instead, use Document.tabs.documentTab.footnotes, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
    footnotes :: (Core.Maybe Document_Footnotes),
    -- | Output only. The headers in the document, keyed by header ID. Legacy field: Instead, use Document.tabs.documentTab.headers, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
    headers :: (Core.Maybe Document_Headers),
    -- | Output only. The inline objects in the document, keyed by object ID. Legacy field: Instead, use Document.tabs.documentTab.inlineObjects, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
    inlineObjects :: (Core.Maybe Document_InlineObjects),
    -- | Output only. The lists in the document, keyed by list ID. Legacy field: Instead, use Document.tabs.documentTab.lists, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
    lists :: (Core.Maybe Document_Lists),
    -- | Output only. The named ranges in the document, keyed by name. Legacy field: Instead, use Document.tabs.documentTab.namedRanges, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
    namedRanges :: (Core.Maybe Document_NamedRanges),
    -- | Output only. The named styles of the document. Legacy field: Instead, use Document.tabs.documentTab.namedStyles, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
    namedStyles :: (Core.Maybe NamedStyles),
    -- | Output only. The positioned objects in the document, keyed by object ID. Legacy field: Instead, use Document.tabs.documentTab.positionedObjects, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
    positionedObjects :: (Core.Maybe Document_PositionedObjects),
    -- | Output only. The revision ID of the document. Can be used in update requests to specify which revision of a document to apply updates to and how the request should behave if the document has been edited since that revision. Only populated if the user has edit access to the document. The revision ID is not a sequential number but an opaque string. The format of the revision ID might change over time. A returned revision ID is only guaranteed to be valid for 24 hours after it has been returned and cannot be shared across users. If the revision ID is unchanged between calls, then the document has not changed. Conversely, a changed ID (for the same document and user) usually means the document has been updated. However, a changed ID can also be due to internal factors such as ID format changes.
    revisionId :: (Core.Maybe Core.Text),
    -- | Output only. The suggested changes to the style of the document, keyed by suggestion ID. Legacy field: Instead, use Document.tabs.documentTab.suggestedDocumentStyleChanges, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
    suggestedDocumentStyleChanges :: (Core.Maybe Document_SuggestedDocumentStyleChanges),
    -- | Output only. The suggested changes to the named styles of the document, keyed by suggestion ID. Legacy field: Instead, use Document.tabs.documentTab.suggestedNamedStylesChanges, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
    suggestedNamedStylesChanges :: (Core.Maybe Document_SuggestedNamedStylesChanges),
    -- | Output only. The suggestions view mode applied to the document. Note: When editing a document, changes must be based on a document with SUGGESTIONS_INLINE.
    suggestionsViewMode :: (Core.Maybe Document_SuggestionsViewMode),
    -- | Tabs that are part of a document. Tabs can contain child tabs, a tab nested within another tab. Child tabs are represented by the Tab.childTabs field.
    tabs :: (Core.Maybe [Tab]),
    -- | The title of the document.
    title :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Document' with the minimum fields required to make a request.
newDocument ::
  Document
newDocument =
  Document
    { body = Core.Nothing,
      documentId = Core.Nothing,
      documentStyle = Core.Nothing,
      footers = Core.Nothing,
      footnotes = Core.Nothing,
      headers = Core.Nothing,
      inlineObjects = Core.Nothing,
      lists = Core.Nothing,
      namedRanges = Core.Nothing,
      namedStyles = Core.Nothing,
      positionedObjects = Core.Nothing,
      revisionId = Core.Nothing,
      suggestedDocumentStyleChanges = Core.Nothing,
      suggestedNamedStylesChanges = Core.Nothing,
      suggestionsViewMode = Core.Nothing,
      tabs = Core.Nothing,
      title = Core.Nothing
    }

instance Core.FromJSON Document where
  parseJSON =
    Core.withObject
      "Document"
      ( \o ->
          Document
            Core.<$> (o Core..:? "body")
            Core.<*> (o Core..:? "documentId")
            Core.<*> (o Core..:? "documentStyle")
            Core.<*> (o Core..:? "footers")
            Core.<*> (o Core..:? "footnotes")
            Core.<*> (o Core..:? "headers")
            Core.<*> (o Core..:? "inlineObjects")
            Core.<*> (o Core..:? "lists")
            Core.<*> (o Core..:? "namedRanges")
            Core.<*> (o Core..:? "namedStyles")
            Core.<*> (o Core..:? "positionedObjects")
            Core.<*> (o Core..:? "revisionId")
            Core.<*> (o Core..:? "suggestedDocumentStyleChanges")
            Core.<*> (o Core..:? "suggestedNamedStylesChanges")
            Core.<*> (o Core..:? "suggestionsViewMode")
            Core.<*> (o Core..:? "tabs")
            Core.<*> (o Core..:? "title")
      )

instance Core.ToJSON Document where
  toJSON Document {..} =
    Core.object
      ( Core.catMaybes
          [ ("body" Core..=) Core.<$> body,
            ("documentId" Core..=) Core.<$> documentId,
            ("documentStyle" Core..=) Core.<$> documentStyle,
            ("footers" Core..=) Core.<$> footers,
            ("footnotes" Core..=) Core.<$> footnotes,
            ("headers" Core..=) Core.<$> headers,
            ("inlineObjects" Core..=) Core.<$> inlineObjects,
            ("lists" Core..=) Core.<$> lists,
            ("namedRanges" Core..=) Core.<$> namedRanges,
            ("namedStyles" Core..=) Core.<$> namedStyles,
            ("positionedObjects" Core..=) Core.<$> positionedObjects,
            ("revisionId" Core..=) Core.<$> revisionId,
            ("suggestedDocumentStyleChanges" Core..=)
              Core.<$> suggestedDocumentStyleChanges,
            ("suggestedNamedStylesChanges" Core..=)
              Core.<$> suggestedNamedStylesChanges,
            ("suggestionsViewMode" Core..=) Core.<$> suggestionsViewMode,
            ("tabs" Core..=) Core.<$> tabs,
            ("title" Core..=) Core.<$> title
          ]
      )

-- | Output only. The footers in the document, keyed by footer ID. Legacy field: Instead, use Document.tabs.documentTab.footers, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
--
-- /See:/ 'newDocument_Footers' smart constructor.
newtype Document_Footers = Document_Footers
  { additional :: (Core.HashMap Core.Text Footer)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Document_Footers' with the minimum fields required to make a request.
newDocument_Footers ::
  -- |  See 'additional'.
  Core.HashMap Core.Text Footer ->
  Document_Footers
newDocument_Footers additional =
  Document_Footers {additional = additional}

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

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

-- | Output only. The footnotes in the document, keyed by footnote ID. Legacy field: Instead, use Document.tabs.documentTab.footnotes, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
--
-- /See:/ 'newDocument_Footnotes' smart constructor.
newtype Document_Footnotes = Document_Footnotes
  { additional :: (Core.HashMap Core.Text Footnote)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Document_Footnotes' with the minimum fields required to make a request.
newDocument_Footnotes ::
  -- |  See 'additional'.
  Core.HashMap Core.Text Footnote ->
  Document_Footnotes
newDocument_Footnotes additional =
  Document_Footnotes {additional = additional}

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

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

-- | Output only. The headers in the document, keyed by header ID. Legacy field: Instead, use Document.tabs.documentTab.headers, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
--
-- /See:/ 'newDocument_Headers' smart constructor.
newtype Document_Headers = Document_Headers
  { additional :: (Core.HashMap Core.Text Header)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Document_Headers' with the minimum fields required to make a request.
newDocument_Headers ::
  -- |  See 'additional'.
  Core.HashMap Core.Text Header ->
  Document_Headers
newDocument_Headers additional =
  Document_Headers {additional = additional}

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

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

-- | Output only. The inline objects in the document, keyed by object ID. Legacy field: Instead, use Document.tabs.documentTab.inlineObjects, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
--
-- /See:/ 'newDocument_InlineObjects' smart constructor.
newtype Document_InlineObjects = Document_InlineObjects
  { additional :: (Core.HashMap Core.Text InlineObject)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Document_InlineObjects' with the minimum fields required to make a request.
newDocument_InlineObjects ::
  -- |  See 'additional'.
  Core.HashMap Core.Text InlineObject ->
  Document_InlineObjects
newDocument_InlineObjects additional =
  Document_InlineObjects {additional = additional}

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

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

-- | Output only. The lists in the document, keyed by list ID. Legacy field: Instead, use Document.tabs.documentTab.lists, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
--
-- /See:/ 'newDocument_Lists' smart constructor.
newtype Document_Lists = Document_Lists
  { additional :: (Core.HashMap Core.Text List)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Document_Lists' with the minimum fields required to make a request.
newDocument_Lists ::
  -- |  See 'additional'.
  Core.HashMap Core.Text List ->
  Document_Lists
newDocument_Lists additional =
  Document_Lists {additional = additional}

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

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

-- | Output only. The named ranges in the document, keyed by name. Legacy field: Instead, use Document.tabs.documentTab.namedRanges, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
--
-- /See:/ 'newDocument_NamedRanges' smart constructor.
newtype Document_NamedRanges = Document_NamedRanges
  { additional :: (Core.HashMap Core.Text NamedRanges)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Document_NamedRanges' with the minimum fields required to make a request.
newDocument_NamedRanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text NamedRanges ->
  Document_NamedRanges
newDocument_NamedRanges additional =
  Document_NamedRanges {additional = additional}

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

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

-- | Output only. The positioned objects in the document, keyed by object ID. Legacy field: Instead, use Document.tabs.documentTab.positionedObjects, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
--
-- /See:/ 'newDocument_PositionedObjects' smart constructor.
newtype Document_PositionedObjects = Document_PositionedObjects
  { additional :: (Core.HashMap Core.Text PositionedObject)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Document_PositionedObjects' with the minimum fields required to make a request.
newDocument_PositionedObjects ::
  -- |  See 'additional'.
  Core.HashMap Core.Text PositionedObject ->
  Document_PositionedObjects
newDocument_PositionedObjects additional =
  Document_PositionedObjects {additional = additional}

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

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

-- | Output only. The suggested changes to the style of the document, keyed by suggestion ID. Legacy field: Instead, use Document.tabs.documentTab.suggestedDocumentStyleChanges, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
--
-- /See:/ 'newDocument_SuggestedDocumentStyleChanges' smart constructor.
newtype Document_SuggestedDocumentStyleChanges = Document_SuggestedDocumentStyleChanges
  { additional :: (Core.HashMap Core.Text SuggestedDocumentStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Document_SuggestedDocumentStyleChanges' with the minimum fields required to make a request.
newDocument_SuggestedDocumentStyleChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedDocumentStyle ->
  Document_SuggestedDocumentStyleChanges
newDocument_SuggestedDocumentStyleChanges additional =
  Document_SuggestedDocumentStyleChanges {additional = additional}

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

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

-- | Output only. The suggested changes to the named styles of the document, keyed by suggestion ID. Legacy field: Instead, use Document.tabs.documentTab.suggestedNamedStylesChanges, which exposes the actual document content from all tabs when the includeTabsContent parameter is set to @true@. If @false@ or unset, this field contains information about the first tab in the document.
--
-- /See:/ 'newDocument_SuggestedNamedStylesChanges' smart constructor.
newtype Document_SuggestedNamedStylesChanges = Document_SuggestedNamedStylesChanges
  { additional :: (Core.HashMap Core.Text SuggestedNamedStyles)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Document_SuggestedNamedStylesChanges' with the minimum fields required to make a request.
newDocument_SuggestedNamedStylesChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedNamedStyles ->
  Document_SuggestedNamedStylesChanges
newDocument_SuggestedNamedStylesChanges additional =
  Document_SuggestedNamedStylesChanges {additional = additional}

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

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

-- | The style of the document.
--
-- /See:/ 'newDocumentStyle' smart constructor.
data DocumentStyle = DocumentStyle
  { -- | The background of the document. Documents cannot have a transparent background color.
    background :: (Core.Maybe Background),
    -- | The ID of the default footer. If not set, there\'s no default footer. This property is read-only.
    defaultFooterId :: (Core.Maybe Core.Text),
    -- | The ID of the default header. If not set, there\'s no default header. This property is read-only.
    defaultHeaderId :: (Core.Maybe Core.Text),
    -- | The ID of the footer used only for even pages. The value of use/even/page/header/footer determines whether to use the default/footer/id or this value for the footer on even pages. If not set, there\'s no even page footer. This property is read-only.
    evenPageFooterId :: (Core.Maybe Core.Text),
    -- | The ID of the header used only for even pages. The value of use/even/page/header/footer determines whether to use the default/header/id or this value for the header on even pages. If not set, there\'s no even page header. This property is read-only.
    evenPageHeaderId :: (Core.Maybe Core.Text),
    -- | The ID of the footer used only for the first page. If not set then a unique footer for the first page does not exist. The value of use/first/page/header/footer determines whether to use the default/footer/id or this value for the footer on the first page. If not set, there\'s no first page footer. This property is read-only.
    firstPageFooterId :: (Core.Maybe Core.Text),
    -- | The ID of the header used only for the first page. If not set then a unique header for the first page does not exist. The value of use/first/page/header/footer determines whether to use the default/header/id or this value for the header on the first page. If not set, there\'s no first page header. This property is read-only.
    firstPageHeaderId :: (Core.Maybe Core.Text),
    -- | Optional. Indicates whether to flip the dimensions of the page_size, which allows changing the page orientation between portrait and landscape.
    flipPageOrientation :: (Core.Maybe Core.Bool),
    -- | The bottom page margin. Updating the bottom page margin on the document style clears the bottom page margin on all section styles.
    marginBottom :: (Core.Maybe Dimension),
    -- | The amount of space between the bottom of the page and the contents of the footer.
    marginFooter :: (Core.Maybe Dimension),
    -- | The amount of space between the top of the page and the contents of the header.
    marginHeader :: (Core.Maybe Dimension),
    -- | The left page margin. Updating the left page margin on the document style clears the left page margin on all section styles. It may also cause columns to resize in all sections.
    marginLeft :: (Core.Maybe Dimension),
    -- | The right page margin. Updating the right page margin on the document style clears the right page margin on all section styles. It may also cause columns to resize in all sections.
    marginRight :: (Core.Maybe Dimension),
    -- | The top page margin. Updating the top page margin on the document style clears the top page margin on all section styles.
    marginTop :: (Core.Maybe Dimension),
    -- | The page number from which to start counting the number of pages.
    pageNumberStart :: (Core.Maybe Core.Int32),
    -- | The size of a page in the document.
    pageSize :: (Core.Maybe Size),
    -- | Indicates whether DocumentStyle margin/header, SectionStyle margin/header and DocumentStyle margin/footer, SectionStyle margin/footer are respected. When false, the default values in the Docs editor for header and footer margin is used. This property is read-only.
    useCustomHeaderFooterMargins :: (Core.Maybe Core.Bool),
    -- | Indicates whether to use the even page header \/ footer IDs for the even pages.
    useEvenPageHeaderFooter :: (Core.Maybe Core.Bool),
    -- | Indicates whether to use the first page header \/ footer IDs for the first page.
    useFirstPageHeaderFooter :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DocumentStyle' with the minimum fields required to make a request.
newDocumentStyle ::
  DocumentStyle
newDocumentStyle =
  DocumentStyle
    { background = Core.Nothing,
      defaultFooterId = Core.Nothing,
      defaultHeaderId = Core.Nothing,
      evenPageFooterId = Core.Nothing,
      evenPageHeaderId = Core.Nothing,
      firstPageFooterId = Core.Nothing,
      firstPageHeaderId = Core.Nothing,
      flipPageOrientation = Core.Nothing,
      marginBottom = Core.Nothing,
      marginFooter = Core.Nothing,
      marginHeader = Core.Nothing,
      marginLeft = Core.Nothing,
      marginRight = Core.Nothing,
      marginTop = Core.Nothing,
      pageNumberStart = Core.Nothing,
      pageSize = Core.Nothing,
      useCustomHeaderFooterMargins = Core.Nothing,
      useEvenPageHeaderFooter = Core.Nothing,
      useFirstPageHeaderFooter = Core.Nothing
    }

instance Core.FromJSON DocumentStyle where
  parseJSON =
    Core.withObject
      "DocumentStyle"
      ( \o ->
          DocumentStyle
            Core.<$> (o Core..:? "background")
            Core.<*> (o Core..:? "defaultFooterId")
            Core.<*> (o Core..:? "defaultHeaderId")
            Core.<*> (o Core..:? "evenPageFooterId")
            Core.<*> (o Core..:? "evenPageHeaderId")
            Core.<*> (o Core..:? "firstPageFooterId")
            Core.<*> (o Core..:? "firstPageHeaderId")
            Core.<*> (o Core..:? "flipPageOrientation")
            Core.<*> (o Core..:? "marginBottom")
            Core.<*> (o Core..:? "marginFooter")
            Core.<*> (o Core..:? "marginHeader")
            Core.<*> (o Core..:? "marginLeft")
            Core.<*> (o Core..:? "marginRight")
            Core.<*> (o Core..:? "marginTop")
            Core.<*> (o Core..:? "pageNumberStart")
            Core.<*> (o Core..:? "pageSize")
            Core.<*> (o Core..:? "useCustomHeaderFooterMargins")
            Core.<*> (o Core..:? "useEvenPageHeaderFooter")
            Core.<*> (o Core..:? "useFirstPageHeaderFooter")
      )

instance Core.ToJSON DocumentStyle where
  toJSON DocumentStyle {..} =
    Core.object
      ( Core.catMaybes
          [ ("background" Core..=) Core.<$> background,
            ("defaultFooterId" Core..=) Core.<$> defaultFooterId,
            ("defaultHeaderId" Core..=) Core.<$> defaultHeaderId,
            ("evenPageFooterId" Core..=) Core.<$> evenPageFooterId,
            ("evenPageHeaderId" Core..=) Core.<$> evenPageHeaderId,
            ("firstPageFooterId" Core..=) Core.<$> firstPageFooterId,
            ("firstPageHeaderId" Core..=) Core.<$> firstPageHeaderId,
            ("flipPageOrientation" Core..=) Core.<$> flipPageOrientation,
            ("marginBottom" Core..=) Core.<$> marginBottom,
            ("marginFooter" Core..=) Core.<$> marginFooter,
            ("marginHeader" Core..=) Core.<$> marginHeader,
            ("marginLeft" Core..=) Core.<$> marginLeft,
            ("marginRight" Core..=) Core.<$> marginRight,
            ("marginTop" Core..=) Core.<$> marginTop,
            ("pageNumberStart" Core..=) Core.<$> pageNumberStart,
            ("pageSize" Core..=) Core.<$> pageSize,
            ("useCustomHeaderFooterMargins" Core..=)
              Core.<$> useCustomHeaderFooterMargins,
            ("useEvenPageHeaderFooter" Core..=)
              Core.<$> useEvenPageHeaderFooter,
            ("useFirstPageHeaderFooter" Core..=)
              Core.<$> useFirstPageHeaderFooter
          ]
      )

-- | A mask that indicates which of the fields on the base DocumentStyle have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newDocumentStyleSuggestionState' smart constructor.
data DocumentStyleSuggestionState = DocumentStyleSuggestionState
  { -- | A mask that indicates which of the fields in background have been changed in this suggestion.
    backgroundSuggestionState :: (Core.Maybe BackgroundSuggestionState),
    -- | Indicates if there was a suggested change to default/footer/id.
    defaultFooterIdSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to default/header/id.
    defaultHeaderIdSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to even/page/footer_id.
    evenPageFooterIdSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to even/page/header_id.
    evenPageHeaderIdSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to first/page/footer_id.
    firstPageFooterIdSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to first/page/header_id.
    firstPageHeaderIdSuggested :: (Core.Maybe Core.Bool),
    -- | Optional. Indicates if there was a suggested change to flip/page/orientation.
    flipPageOrientationSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to margin_bottom.
    marginBottomSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to margin_footer.
    marginFooterSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to margin_header.
    marginHeaderSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to margin_left.
    marginLeftSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to margin_right.
    marginRightSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to margin_top.
    marginTopSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to page/number/start.
    pageNumberStartSuggested :: (Core.Maybe Core.Bool),
    -- | A mask that indicates which of the fields in size have been changed in this suggestion.
    pageSizeSuggestionState :: (Core.Maybe SizeSuggestionState),
    -- | Indicates if there was a suggested change to use/custom/header/footer/margins.
    useCustomHeaderFooterMarginsSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to use/even/page/header/footer.
    useEvenPageHeaderFooterSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to use/first/page/header/footer.
    useFirstPageHeaderFooterSuggested :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DocumentStyleSuggestionState' with the minimum fields required to make a request.
newDocumentStyleSuggestionState ::
  DocumentStyleSuggestionState
newDocumentStyleSuggestionState =
  DocumentStyleSuggestionState
    { backgroundSuggestionState =
        Core.Nothing,
      defaultFooterIdSuggested = Core.Nothing,
      defaultHeaderIdSuggested = Core.Nothing,
      evenPageFooterIdSuggested = Core.Nothing,
      evenPageHeaderIdSuggested = Core.Nothing,
      firstPageFooterIdSuggested = Core.Nothing,
      firstPageHeaderIdSuggested = Core.Nothing,
      flipPageOrientationSuggested = Core.Nothing,
      marginBottomSuggested = Core.Nothing,
      marginFooterSuggested = Core.Nothing,
      marginHeaderSuggested = Core.Nothing,
      marginLeftSuggested = Core.Nothing,
      marginRightSuggested = Core.Nothing,
      marginTopSuggested = Core.Nothing,
      pageNumberStartSuggested = Core.Nothing,
      pageSizeSuggestionState = Core.Nothing,
      useCustomHeaderFooterMarginsSuggested = Core.Nothing,
      useEvenPageHeaderFooterSuggested = Core.Nothing,
      useFirstPageHeaderFooterSuggested = Core.Nothing
    }

instance Core.FromJSON DocumentStyleSuggestionState where
  parseJSON =
    Core.withObject
      "DocumentStyleSuggestionState"
      ( \o ->
          DocumentStyleSuggestionState
            Core.<$> (o Core..:? "backgroundSuggestionState")
            Core.<*> (o Core..:? "defaultFooterIdSuggested")
            Core.<*> (o Core..:? "defaultHeaderIdSuggested")
            Core.<*> (o Core..:? "evenPageFooterIdSuggested")
            Core.<*> (o Core..:? "evenPageHeaderIdSuggested")
            Core.<*> (o Core..:? "firstPageFooterIdSuggested")
            Core.<*> (o Core..:? "firstPageHeaderIdSuggested")
            Core.<*> (o Core..:? "flipPageOrientationSuggested")
            Core.<*> (o Core..:? "marginBottomSuggested")
            Core.<*> (o Core..:? "marginFooterSuggested")
            Core.<*> (o Core..:? "marginHeaderSuggested")
            Core.<*> (o Core..:? "marginLeftSuggested")
            Core.<*> (o Core..:? "marginRightSuggested")
            Core.<*> (o Core..:? "marginTopSuggested")
            Core.<*> (o Core..:? "pageNumberStartSuggested")
            Core.<*> (o Core..:? "pageSizeSuggestionState")
            Core.<*> (o Core..:? "useCustomHeaderFooterMarginsSuggested")
            Core.<*> (o Core..:? "useEvenPageHeaderFooterSuggested")
            Core.<*> (o Core..:? "useFirstPageHeaderFooterSuggested")
      )

instance Core.ToJSON DocumentStyleSuggestionState where
  toJSON DocumentStyleSuggestionState {..} =
    Core.object
      ( Core.catMaybes
          [ ("backgroundSuggestionState" Core..=)
              Core.<$> backgroundSuggestionState,
            ("defaultFooterIdSuggested" Core..=)
              Core.<$> defaultFooterIdSuggested,
            ("defaultHeaderIdSuggested" Core..=)
              Core.<$> defaultHeaderIdSuggested,
            ("evenPageFooterIdSuggested" Core..=)
              Core.<$> evenPageFooterIdSuggested,
            ("evenPageHeaderIdSuggested" Core..=)
              Core.<$> evenPageHeaderIdSuggested,
            ("firstPageFooterIdSuggested" Core..=)
              Core.<$> firstPageFooterIdSuggested,
            ("firstPageHeaderIdSuggested" Core..=)
              Core.<$> firstPageHeaderIdSuggested,
            ("flipPageOrientationSuggested" Core..=)
              Core.<$> flipPageOrientationSuggested,
            ("marginBottomSuggested" Core..=) Core.<$> marginBottomSuggested,
            ("marginFooterSuggested" Core..=) Core.<$> marginFooterSuggested,
            ("marginHeaderSuggested" Core..=) Core.<$> marginHeaderSuggested,
            ("marginLeftSuggested" Core..=) Core.<$> marginLeftSuggested,
            ("marginRightSuggested" Core..=) Core.<$> marginRightSuggested,
            ("marginTopSuggested" Core..=) Core.<$> marginTopSuggested,
            ("pageNumberStartSuggested" Core..=)
              Core.<$> pageNumberStartSuggested,
            ("pageSizeSuggestionState" Core..=)
              Core.<$> pageSizeSuggestionState,
            ("useCustomHeaderFooterMarginsSuggested" Core..=)
              Core.<$> useCustomHeaderFooterMarginsSuggested,
            ("useEvenPageHeaderFooterSuggested" Core..=)
              Core.<$> useEvenPageHeaderFooterSuggested,
            ("useFirstPageHeaderFooterSuggested" Core..=)
              Core.<$> useFirstPageHeaderFooterSuggested
          ]
      )

-- | A tab with document contents.
--
-- /See:/ 'newDocumentTab' smart constructor.
data DocumentTab = DocumentTab
  { -- | The main body of the document tab.
    body :: (Core.Maybe Body),
    -- | The style of the document tab.
    documentStyle :: (Core.Maybe DocumentStyle),
    -- | The footers in the document tab, keyed by footer ID.
    footers :: (Core.Maybe DocumentTab_Footers),
    -- | The footnotes in the document tab, keyed by footnote ID.
    footnotes :: (Core.Maybe DocumentTab_Footnotes),
    -- | The headers in the document tab, keyed by header ID.
    headers :: (Core.Maybe DocumentTab_Headers),
    -- | The inline objects in the document tab, keyed by object ID.
    inlineObjects :: (Core.Maybe DocumentTab_InlineObjects),
    -- | The lists in the document tab, keyed by list ID.
    lists :: (Core.Maybe DocumentTab_Lists),
    -- | The named ranges in the document tab, keyed by name.
    namedRanges :: (Core.Maybe DocumentTab_NamedRanges),
    -- | The named styles of the document tab.
    namedStyles :: (Core.Maybe NamedStyles),
    -- | The positioned objects in the document tab, keyed by object ID.
    positionedObjects :: (Core.Maybe DocumentTab_PositionedObjects),
    -- | The suggested changes to the style of the document tab, keyed by suggestion ID.
    suggestedDocumentStyleChanges :: (Core.Maybe DocumentTab_SuggestedDocumentStyleChanges),
    -- | The suggested changes to the named styles of the document tab, keyed by suggestion ID.
    suggestedNamedStylesChanges :: (Core.Maybe DocumentTab_SuggestedNamedStylesChanges)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DocumentTab' with the minimum fields required to make a request.
newDocumentTab ::
  DocumentTab
newDocumentTab =
  DocumentTab
    { body = Core.Nothing,
      documentStyle = Core.Nothing,
      footers = Core.Nothing,
      footnotes = Core.Nothing,
      headers = Core.Nothing,
      inlineObjects = Core.Nothing,
      lists = Core.Nothing,
      namedRanges = Core.Nothing,
      namedStyles = Core.Nothing,
      positionedObjects = Core.Nothing,
      suggestedDocumentStyleChanges = Core.Nothing,
      suggestedNamedStylesChanges = Core.Nothing
    }

instance Core.FromJSON DocumentTab where
  parseJSON =
    Core.withObject
      "DocumentTab"
      ( \o ->
          DocumentTab
            Core.<$> (o Core..:? "body")
            Core.<*> (o Core..:? "documentStyle")
            Core.<*> (o Core..:? "footers")
            Core.<*> (o Core..:? "footnotes")
            Core.<*> (o Core..:? "headers")
            Core.<*> (o Core..:? "inlineObjects")
            Core.<*> (o Core..:? "lists")
            Core.<*> (o Core..:? "namedRanges")
            Core.<*> (o Core..:? "namedStyles")
            Core.<*> (o Core..:? "positionedObjects")
            Core.<*> (o Core..:? "suggestedDocumentStyleChanges")
            Core.<*> (o Core..:? "suggestedNamedStylesChanges")
      )

instance Core.ToJSON DocumentTab where
  toJSON DocumentTab {..} =
    Core.object
      ( Core.catMaybes
          [ ("body" Core..=) Core.<$> body,
            ("documentStyle" Core..=) Core.<$> documentStyle,
            ("footers" Core..=) Core.<$> footers,
            ("footnotes" Core..=) Core.<$> footnotes,
            ("headers" Core..=) Core.<$> headers,
            ("inlineObjects" Core..=) Core.<$> inlineObjects,
            ("lists" Core..=) Core.<$> lists,
            ("namedRanges" Core..=) Core.<$> namedRanges,
            ("namedStyles" Core..=) Core.<$> namedStyles,
            ("positionedObjects" Core..=) Core.<$> positionedObjects,
            ("suggestedDocumentStyleChanges" Core..=)
              Core.<$> suggestedDocumentStyleChanges,
            ("suggestedNamedStylesChanges" Core..=)
              Core.<$> suggestedNamedStylesChanges
          ]
      )

-- | The footers in the document tab, keyed by footer ID.
--
-- /See:/ 'newDocumentTab_Footers' smart constructor.
newtype DocumentTab_Footers = DocumentTab_Footers
  { additional :: (Core.HashMap Core.Text Footer)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DocumentTab_Footers' with the minimum fields required to make a request.
newDocumentTab_Footers ::
  -- |  See 'additional'.
  Core.HashMap Core.Text Footer ->
  DocumentTab_Footers
newDocumentTab_Footers additional =
  DocumentTab_Footers {additional = additional}

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

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

-- | The footnotes in the document tab, keyed by footnote ID.
--
-- /See:/ 'newDocumentTab_Footnotes' smart constructor.
newtype DocumentTab_Footnotes = DocumentTab_Footnotes
  { additional :: (Core.HashMap Core.Text Footnote)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DocumentTab_Footnotes' with the minimum fields required to make a request.
newDocumentTab_Footnotes ::
  -- |  See 'additional'.
  Core.HashMap Core.Text Footnote ->
  DocumentTab_Footnotes
newDocumentTab_Footnotes additional =
  DocumentTab_Footnotes {additional = additional}

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

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

-- | The headers in the document tab, keyed by header ID.
--
-- /See:/ 'newDocumentTab_Headers' smart constructor.
newtype DocumentTab_Headers = DocumentTab_Headers
  { additional :: (Core.HashMap Core.Text Header)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DocumentTab_Headers' with the minimum fields required to make a request.
newDocumentTab_Headers ::
  -- |  See 'additional'.
  Core.HashMap Core.Text Header ->
  DocumentTab_Headers
newDocumentTab_Headers additional =
  DocumentTab_Headers {additional = additional}

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

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

-- | The inline objects in the document tab, keyed by object ID.
--
-- /See:/ 'newDocumentTab_InlineObjects' smart constructor.
newtype DocumentTab_InlineObjects = DocumentTab_InlineObjects
  { additional :: (Core.HashMap Core.Text InlineObject)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DocumentTab_InlineObjects' with the minimum fields required to make a request.
newDocumentTab_InlineObjects ::
  -- |  See 'additional'.
  Core.HashMap Core.Text InlineObject ->
  DocumentTab_InlineObjects
newDocumentTab_InlineObjects additional =
  DocumentTab_InlineObjects {additional = additional}

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

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

-- | The lists in the document tab, keyed by list ID.
--
-- /See:/ 'newDocumentTab_Lists' smart constructor.
newtype DocumentTab_Lists = DocumentTab_Lists
  { additional :: (Core.HashMap Core.Text List)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DocumentTab_Lists' with the minimum fields required to make a request.
newDocumentTab_Lists ::
  -- |  See 'additional'.
  Core.HashMap Core.Text List ->
  DocumentTab_Lists
newDocumentTab_Lists additional =
  DocumentTab_Lists {additional = additional}

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

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

-- | The named ranges in the document tab, keyed by name.
--
-- /See:/ 'newDocumentTab_NamedRanges' smart constructor.
newtype DocumentTab_NamedRanges = DocumentTab_NamedRanges
  { additional :: (Core.HashMap Core.Text NamedRanges)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DocumentTab_NamedRanges' with the minimum fields required to make a request.
newDocumentTab_NamedRanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text NamedRanges ->
  DocumentTab_NamedRanges
newDocumentTab_NamedRanges additional =
  DocumentTab_NamedRanges {additional = additional}

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

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

-- | The positioned objects in the document tab, keyed by object ID.
--
-- /See:/ 'newDocumentTab_PositionedObjects' smart constructor.
newtype DocumentTab_PositionedObjects = DocumentTab_PositionedObjects
  { additional :: (Core.HashMap Core.Text PositionedObject)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DocumentTab_PositionedObjects' with the minimum fields required to make a request.
newDocumentTab_PositionedObjects ::
  -- |  See 'additional'.
  Core.HashMap Core.Text PositionedObject ->
  DocumentTab_PositionedObjects
newDocumentTab_PositionedObjects additional =
  DocumentTab_PositionedObjects {additional = additional}

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

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

-- | The suggested changes to the style of the document tab, keyed by suggestion ID.
--
-- /See:/ 'newDocumentTab_SuggestedDocumentStyleChanges' smart constructor.
newtype DocumentTab_SuggestedDocumentStyleChanges = DocumentTab_SuggestedDocumentStyleChanges
  { additional :: (Core.HashMap Core.Text SuggestedDocumentStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DocumentTab_SuggestedDocumentStyleChanges' with the minimum fields required to make a request.
newDocumentTab_SuggestedDocumentStyleChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedDocumentStyle ->
  DocumentTab_SuggestedDocumentStyleChanges
newDocumentTab_SuggestedDocumentStyleChanges additional =
  DocumentTab_SuggestedDocumentStyleChanges
    { additional =
        additional
    }

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

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

-- | The suggested changes to the named styles of the document tab, keyed by suggestion ID.
--
-- /See:/ 'newDocumentTab_SuggestedNamedStylesChanges' smart constructor.
newtype DocumentTab_SuggestedNamedStylesChanges = DocumentTab_SuggestedNamedStylesChanges
  { additional :: (Core.HashMap Core.Text SuggestedNamedStyles)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'DocumentTab_SuggestedNamedStylesChanges' with the minimum fields required to make a request.
newDocumentTab_SuggestedNamedStylesChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedNamedStyles ->
  DocumentTab_SuggestedNamedStylesChanges
newDocumentTab_SuggestedNamedStylesChanges additional =
  DocumentTab_SuggestedNamedStylesChanges {additional = additional}

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

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

-- | The properties of an embedded drawing and used to differentiate the object type. An embedded drawing is one that\'s created and edited within a document. Note that extensive details are not supported.
--
-- /See:/ 'newEmbeddedDrawingProperties' smart constructor.
data EmbeddedDrawingProperties = EmbeddedDrawingProperties
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'EmbeddedDrawingProperties' with the minimum fields required to make a request.
newEmbeddedDrawingProperties ::
  EmbeddedDrawingProperties
newEmbeddedDrawingProperties = EmbeddedDrawingProperties

instance Core.FromJSON EmbeddedDrawingProperties where
  parseJSON =
    Core.withObject
      "EmbeddedDrawingProperties"
      (\o -> Core.pure EmbeddedDrawingProperties)

instance Core.ToJSON EmbeddedDrawingProperties where
  toJSON = Core.const Core.emptyObject

-- | A mask that indicates which of the fields on the base EmbeddedDrawingProperties have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newEmbeddedDrawingPropertiesSuggestionState' smart constructor.
data EmbeddedDrawingPropertiesSuggestionState = EmbeddedDrawingPropertiesSuggestionState
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'EmbeddedDrawingPropertiesSuggestionState' with the minimum fields required to make a request.
newEmbeddedDrawingPropertiesSuggestionState ::
  EmbeddedDrawingPropertiesSuggestionState
newEmbeddedDrawingPropertiesSuggestionState =
  EmbeddedDrawingPropertiesSuggestionState

instance Core.FromJSON EmbeddedDrawingPropertiesSuggestionState where
  parseJSON =
    Core.withObject
      "EmbeddedDrawingPropertiesSuggestionState"
      (\o -> Core.pure EmbeddedDrawingPropertiesSuggestionState)

instance Core.ToJSON EmbeddedDrawingPropertiesSuggestionState where
  toJSON = Core.const Core.emptyObject

-- | An embedded object in the document.
--
-- /See:/ 'newEmbeddedObject' smart constructor.
data EmbeddedObject = EmbeddedObject
  { -- | The description of the embedded object. The @title@ and @description@ are both combined to display alt text.
    description :: (Core.Maybe Core.Text),
    -- | The properties of an embedded drawing.
    embeddedDrawingProperties :: (Core.Maybe EmbeddedDrawingProperties),
    -- | The border of the embedded object.
    embeddedObjectBorder :: (Core.Maybe EmbeddedObjectBorder),
    -- | The properties of an image.
    imageProperties :: (Core.Maybe ImageProperties),
    -- | A reference to the external linked source content. For example, it contains a reference to the source Google Sheets chart when the embedded object is a linked chart. If unset, then the embedded object is not linked.
    linkedContentReference :: (Core.Maybe LinkedContentReference),
    -- | The bottom margin of the embedded object.
    marginBottom :: (Core.Maybe Dimension),
    -- | The left margin of the embedded object.
    marginLeft :: (Core.Maybe Dimension),
    -- | The right margin of the embedded object.
    marginRight :: (Core.Maybe Dimension),
    -- | The top margin of the embedded object.
    marginTop :: (Core.Maybe Dimension),
    -- | The visible size of the image after cropping.
    size :: (Core.Maybe Size),
    -- | The title of the embedded object. The @title@ and @description@ are both combined to display alt text.
    title :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'EmbeddedObject' with the minimum fields required to make a request.
newEmbeddedObject ::
  EmbeddedObject
newEmbeddedObject =
  EmbeddedObject
    { description = Core.Nothing,
      embeddedDrawingProperties = Core.Nothing,
      embeddedObjectBorder = Core.Nothing,
      imageProperties = Core.Nothing,
      linkedContentReference = Core.Nothing,
      marginBottom = Core.Nothing,
      marginLeft = Core.Nothing,
      marginRight = Core.Nothing,
      marginTop = Core.Nothing,
      size = Core.Nothing,
      title = Core.Nothing
    }

instance Core.FromJSON EmbeddedObject where
  parseJSON =
    Core.withObject
      "EmbeddedObject"
      ( \o ->
          EmbeddedObject
            Core.<$> (o Core..:? "description")
            Core.<*> (o Core..:? "embeddedDrawingProperties")
            Core.<*> (o Core..:? "embeddedObjectBorder")
            Core.<*> (o Core..:? "imageProperties")
            Core.<*> (o Core..:? "linkedContentReference")
            Core.<*> (o Core..:? "marginBottom")
            Core.<*> (o Core..:? "marginLeft")
            Core.<*> (o Core..:? "marginRight")
            Core.<*> (o Core..:? "marginTop")
            Core.<*> (o Core..:? "size")
            Core.<*> (o Core..:? "title")
      )

instance Core.ToJSON EmbeddedObject where
  toJSON EmbeddedObject {..} =
    Core.object
      ( Core.catMaybes
          [ ("description" Core..=) Core.<$> description,
            ("embeddedDrawingProperties" Core..=)
              Core.<$> embeddedDrawingProperties,
            ("embeddedObjectBorder" Core..=) Core.<$> embeddedObjectBorder,
            ("imageProperties" Core..=) Core.<$> imageProperties,
            ("linkedContentReference" Core..=) Core.<$> linkedContentReference,
            ("marginBottom" Core..=) Core.<$> marginBottom,
            ("marginLeft" Core..=) Core.<$> marginLeft,
            ("marginRight" Core..=) Core.<$> marginRight,
            ("marginTop" Core..=) Core.<$> marginTop,
            ("size" Core..=) Core.<$> size,
            ("title" Core..=) Core.<$> title
          ]
      )

-- | A border around an EmbeddedObject.
--
-- /See:/ 'newEmbeddedObjectBorder' smart constructor.
data EmbeddedObjectBorder = EmbeddedObjectBorder
  { -- | The color of the border.
    color :: (Core.Maybe OptionalColor),
    -- | The dash style of the border.
    dashStyle :: (Core.Maybe EmbeddedObjectBorder_DashStyle),
    -- | The property state of the border property.
    propertyState :: (Core.Maybe EmbeddedObjectBorder_PropertyState),
    -- | The width of the border.
    width :: (Core.Maybe Dimension)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'EmbeddedObjectBorder' with the minimum fields required to make a request.
newEmbeddedObjectBorder ::
  EmbeddedObjectBorder
newEmbeddedObjectBorder =
  EmbeddedObjectBorder
    { color = Core.Nothing,
      dashStyle = Core.Nothing,
      propertyState = Core.Nothing,
      width = Core.Nothing
    }

instance Core.FromJSON EmbeddedObjectBorder where
  parseJSON =
    Core.withObject
      "EmbeddedObjectBorder"
      ( \o ->
          EmbeddedObjectBorder
            Core.<$> (o Core..:? "color")
            Core.<*> (o Core..:? "dashStyle")
            Core.<*> (o Core..:? "propertyState")
            Core.<*> (o Core..:? "width")
      )

instance Core.ToJSON EmbeddedObjectBorder where
  toJSON EmbeddedObjectBorder {..} =
    Core.object
      ( Core.catMaybes
          [ ("color" Core..=) Core.<$> color,
            ("dashStyle" Core..=) Core.<$> dashStyle,
            ("propertyState" Core..=) Core.<$> propertyState,
            ("width" Core..=) Core.<$> width
          ]
      )

-- | A mask that indicates which of the fields on the base EmbeddedObjectBorder have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newEmbeddedObjectBorderSuggestionState' smart constructor.
data EmbeddedObjectBorderSuggestionState = EmbeddedObjectBorderSuggestionState
  { -- | Indicates if there was a suggested change to color.
    colorSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to dash_style.
    dashStyleSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to property_state.
    propertyStateSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to width.
    widthSuggested :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'EmbeddedObjectBorderSuggestionState' with the minimum fields required to make a request.
newEmbeddedObjectBorderSuggestionState ::
  EmbeddedObjectBorderSuggestionState
newEmbeddedObjectBorderSuggestionState =
  EmbeddedObjectBorderSuggestionState
    { colorSuggested =
        Core.Nothing,
      dashStyleSuggested = Core.Nothing,
      propertyStateSuggested = Core.Nothing,
      widthSuggested = Core.Nothing
    }

instance Core.FromJSON EmbeddedObjectBorderSuggestionState where
  parseJSON =
    Core.withObject
      "EmbeddedObjectBorderSuggestionState"
      ( \o ->
          EmbeddedObjectBorderSuggestionState
            Core.<$> (o Core..:? "colorSuggested")
            Core.<*> (o Core..:? "dashStyleSuggested")
            Core.<*> (o Core..:? "propertyStateSuggested")
            Core.<*> (o Core..:? "widthSuggested")
      )

instance Core.ToJSON EmbeddedObjectBorderSuggestionState where
  toJSON EmbeddedObjectBorderSuggestionState {..} =
    Core.object
      ( Core.catMaybes
          [ ("colorSuggested" Core..=) Core.<$> colorSuggested,
            ("dashStyleSuggested" Core..=) Core.<$> dashStyleSuggested,
            ("propertyStateSuggested" Core..=) Core.<$> propertyStateSuggested,
            ("widthSuggested" Core..=) Core.<$> widthSuggested
          ]
      )

-- | A mask that indicates which of the fields on the base EmbeddedObject have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newEmbeddedObjectSuggestionState' smart constructor.
data EmbeddedObjectSuggestionState = EmbeddedObjectSuggestionState
  { -- | Indicates if there was a suggested change to description.
    descriptionSuggested :: (Core.Maybe Core.Bool),
    -- | A mask that indicates which of the fields in embedded/drawing/properties have been changed in this suggestion.
    embeddedDrawingPropertiesSuggestionState :: (Core.Maybe EmbeddedDrawingPropertiesSuggestionState),
    -- | A mask that indicates which of the fields in embedded/object/border have been changed in this suggestion.
    embeddedObjectBorderSuggestionState :: (Core.Maybe EmbeddedObjectBorderSuggestionState),
    -- | A mask that indicates which of the fields in image_properties have been changed in this suggestion.
    imagePropertiesSuggestionState :: (Core.Maybe ImagePropertiesSuggestionState),
    -- | A mask that indicates which of the fields in linked/content/reference have been changed in this suggestion.
    linkedContentReferenceSuggestionState :: (Core.Maybe LinkedContentReferenceSuggestionState),
    -- | Indicates if there was a suggested change to margin_bottom.
    marginBottomSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to margin_left.
    marginLeftSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to margin_right.
    marginRightSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to margin_top.
    marginTopSuggested :: (Core.Maybe Core.Bool),
    -- | A mask that indicates which of the fields in size have been changed in this suggestion.
    sizeSuggestionState :: (Core.Maybe SizeSuggestionState),
    -- | Indicates if there was a suggested change to title.
    titleSuggested :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'EmbeddedObjectSuggestionState' with the minimum fields required to make a request.
newEmbeddedObjectSuggestionState ::
  EmbeddedObjectSuggestionState
newEmbeddedObjectSuggestionState =
  EmbeddedObjectSuggestionState
    { descriptionSuggested =
        Core.Nothing,
      embeddedDrawingPropertiesSuggestionState = Core.Nothing,
      embeddedObjectBorderSuggestionState = Core.Nothing,
      imagePropertiesSuggestionState = Core.Nothing,
      linkedContentReferenceSuggestionState = Core.Nothing,
      marginBottomSuggested = Core.Nothing,
      marginLeftSuggested = Core.Nothing,
      marginRightSuggested = Core.Nothing,
      marginTopSuggested = Core.Nothing,
      sizeSuggestionState = Core.Nothing,
      titleSuggested = Core.Nothing
    }

instance Core.FromJSON EmbeddedObjectSuggestionState where
  parseJSON =
    Core.withObject
      "EmbeddedObjectSuggestionState"
      ( \o ->
          EmbeddedObjectSuggestionState
            Core.<$> (o Core..:? "descriptionSuggested")
            Core.<*> (o Core..:? "embeddedDrawingPropertiesSuggestionState")
            Core.<*> (o Core..:? "embeddedObjectBorderSuggestionState")
            Core.<*> (o Core..:? "imagePropertiesSuggestionState")
            Core.<*> (o Core..:? "linkedContentReferenceSuggestionState")
            Core.<*> (o Core..:? "marginBottomSuggested")
            Core.<*> (o Core..:? "marginLeftSuggested")
            Core.<*> (o Core..:? "marginRightSuggested")
            Core.<*> (o Core..:? "marginTopSuggested")
            Core.<*> (o Core..:? "sizeSuggestionState")
            Core.<*> (o Core..:? "titleSuggested")
      )

instance Core.ToJSON EmbeddedObjectSuggestionState where
  toJSON EmbeddedObjectSuggestionState {..} =
    Core.object
      ( Core.catMaybes
          [ ("descriptionSuggested" Core..=) Core.<$> descriptionSuggested,
            ("embeddedDrawingPropertiesSuggestionState" Core..=)
              Core.<$> embeddedDrawingPropertiesSuggestionState,
            ("embeddedObjectBorderSuggestionState" Core..=)
              Core.<$> embeddedObjectBorderSuggestionState,
            ("imagePropertiesSuggestionState" Core..=)
              Core.<$> imagePropertiesSuggestionState,
            ("linkedContentReferenceSuggestionState" Core..=)
              Core.<$> linkedContentReferenceSuggestionState,
            ("marginBottomSuggested" Core..=) Core.<$> marginBottomSuggested,
            ("marginLeftSuggested" Core..=) Core.<$> marginLeftSuggested,
            ("marginRightSuggested" Core..=) Core.<$> marginRightSuggested,
            ("marginTopSuggested" Core..=) Core.<$> marginTopSuggested,
            ("sizeSuggestionState" Core..=) Core.<$> sizeSuggestionState,
            ("titleSuggested" Core..=) Core.<$> titleSuggested
          ]
      )

-- | Location at the end of a body, header, footer or footnote. The location is immediately before the last newline in the document segment.
--
-- /See:/ 'newEndOfSegmentLocation' smart constructor.
data EndOfSegmentLocation = EndOfSegmentLocation
  { -- | The ID of the header, footer or footnote the location is in. An empty segment ID signifies the document\'s body.
    segmentId :: (Core.Maybe Core.Text),
    -- | The tab that the location is in. When omitted, the request is applied to the first tab. In a document containing a single tab: - If provided, must match the singular tab\'s ID. - If omitted, the request applies to the singular tab. In a document containing multiple tabs: - If provided, the request applies to the specified tab. - If omitted, the request applies to the first tab in the document.
    tabId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'EndOfSegmentLocation' with the minimum fields required to make a request.
newEndOfSegmentLocation ::
  EndOfSegmentLocation
newEndOfSegmentLocation =
  EndOfSegmentLocation
    { segmentId = Core.Nothing,
      tabId = Core.Nothing
    }

instance Core.FromJSON EndOfSegmentLocation where
  parseJSON =
    Core.withObject
      "EndOfSegmentLocation"
      ( \o ->
          EndOfSegmentLocation
            Core.<$> (o Core..:? "segmentId")
            Core.<*> (o Core..:? "tabId")
      )

instance Core.ToJSON EndOfSegmentLocation where
  toJSON EndOfSegmentLocation {..} =
    Core.object
      ( Core.catMaybes
          [ ("segmentId" Core..=) Core.<$> segmentId,
            ("tabId" Core..=) Core.<$> tabId
          ]
      )

-- | A ParagraphElement representing an equation.
--
-- /See:/ 'newEquation' smart constructor.
data Equation = Equation
  { -- | The suggested deletion IDs. If empty, then there are no suggested deletions of this content.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested insertion IDs. An Equation may have multiple insertion IDs if it\'s a nested suggested change. If empty, then this is not a suggested insertion.
    suggestedInsertionIds :: (Core.Maybe [Core.Text])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Equation' with the minimum fields required to make a request.
newEquation ::
  Equation
newEquation =
  Equation
    { suggestedDeletionIds = Core.Nothing,
      suggestedInsertionIds = Core.Nothing
    }

instance Core.FromJSON Equation where
  parseJSON =
    Core.withObject
      "Equation"
      ( \o ->
          Equation
            Core.<$> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionIds")
      )

instance Core.ToJSON Equation where
  toJSON Equation {..} =
    Core.object
      ( Core.catMaybes
          [ ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionIds" Core..=) Core.<$> suggestedInsertionIds
          ]
      )

-- | A document footer.
--
-- /See:/ 'newFooter' smart constructor.
data Footer = Footer
  { -- | The contents of the footer. The indexes for a footer\'s content begin at zero.
    content :: (Core.Maybe [StructuralElement]),
    -- | The ID of the footer.
    footerId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Footer' with the minimum fields required to make a request.
newFooter ::
  Footer
newFooter = Footer {content = Core.Nothing, footerId = Core.Nothing}

instance Core.FromJSON Footer where
  parseJSON =
    Core.withObject
      "Footer"
      ( \o ->
          Footer
            Core.<$> (o Core..:? "content")
            Core.<*> (o Core..:? "footerId")
      )

instance Core.ToJSON Footer where
  toJSON Footer {..} =
    Core.object
      ( Core.catMaybes
          [ ("content" Core..=) Core.<$> content,
            ("footerId" Core..=) Core.<$> footerId
          ]
      )

-- | A document footnote.
--
-- /See:/ 'newFootnote' smart constructor.
data Footnote = Footnote
  { -- | The contents of the footnote. The indexes for a footnote\'s content begin at zero.
    content :: (Core.Maybe [StructuralElement]),
    -- | The ID of the footnote.
    footnoteId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Footnote' with the minimum fields required to make a request.
newFootnote ::
  Footnote
newFootnote =
  Footnote {content = Core.Nothing, footnoteId = Core.Nothing}

instance Core.FromJSON Footnote where
  parseJSON =
    Core.withObject
      "Footnote"
      ( \o ->
          Footnote
            Core.<$> (o Core..:? "content")
            Core.<*> (o Core..:? "footnoteId")
      )

instance Core.ToJSON Footnote where
  toJSON Footnote {..} =
    Core.object
      ( Core.catMaybes
          [ ("content" Core..=) Core.<$> content,
            ("footnoteId" Core..=) Core.<$> footnoteId
          ]
      )

-- | A ParagraphElement representing a footnote reference. A footnote reference is the inline content rendered with a number and is used to identify the footnote.
--
-- /See:/ 'newFootnoteReference' smart constructor.
data FootnoteReference = FootnoteReference
  { -- | The ID of the footnote that contains the content of this footnote reference.
    footnoteId :: (Core.Maybe Core.Text),
    -- | The rendered number of this footnote.
    footnoteNumber :: (Core.Maybe Core.Text),
    -- | The suggested deletion IDs. If empty, then there are no suggested deletions of this content.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested insertion IDs. A FootnoteReference may have multiple insertion IDs if it\'s a nested suggested change. If empty, then this is not a suggested insertion.
    suggestedInsertionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested text style changes to this FootnoteReference, keyed by suggestion ID.
    suggestedTextStyleChanges :: (Core.Maybe FootnoteReference_SuggestedTextStyleChanges),
    -- | The text style of this FootnoteReference.
    textStyle :: (Core.Maybe TextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'FootnoteReference' with the minimum fields required to make a request.
newFootnoteReference ::
  FootnoteReference
newFootnoteReference =
  FootnoteReference
    { footnoteId = Core.Nothing,
      footnoteNumber = Core.Nothing,
      suggestedDeletionIds = Core.Nothing,
      suggestedInsertionIds = Core.Nothing,
      suggestedTextStyleChanges = Core.Nothing,
      textStyle = Core.Nothing
    }

instance Core.FromJSON FootnoteReference where
  parseJSON =
    Core.withObject
      "FootnoteReference"
      ( \o ->
          FootnoteReference
            Core.<$> (o Core..:? "footnoteId")
            Core.<*> (o Core..:? "footnoteNumber")
            Core.<*> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionIds")
            Core.<*> (o Core..:? "suggestedTextStyleChanges")
            Core.<*> (o Core..:? "textStyle")
      )

instance Core.ToJSON FootnoteReference where
  toJSON FootnoteReference {..} =
    Core.object
      ( Core.catMaybes
          [ ("footnoteId" Core..=) Core.<$> footnoteId,
            ("footnoteNumber" Core..=) Core.<$> footnoteNumber,
            ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionIds" Core..=) Core.<$> suggestedInsertionIds,
            ("suggestedTextStyleChanges" Core..=)
              Core.<$> suggestedTextStyleChanges,
            ("textStyle" Core..=) Core.<$> textStyle
          ]
      )

-- | The suggested text style changes to this FootnoteReference, keyed by suggestion ID.
--
-- /See:/ 'newFootnoteReference_SuggestedTextStyleChanges' smart constructor.
newtype FootnoteReference_SuggestedTextStyleChanges = FootnoteReference_SuggestedTextStyleChanges
  { additional :: (Core.HashMap Core.Text SuggestedTextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'FootnoteReference_SuggestedTextStyleChanges' with the minimum fields required to make a request.
newFootnoteReference_SuggestedTextStyleChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedTextStyle ->
  FootnoteReference_SuggestedTextStyleChanges
newFootnoteReference_SuggestedTextStyleChanges additional =
  FootnoteReference_SuggestedTextStyleChanges
    { additional =
        additional
    }

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

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

-- | A document header.
--
-- /See:/ 'newHeader' smart constructor.
data Header = Header
  { -- | The contents of the header. The indexes for a header\'s content begin at zero.
    content :: (Core.Maybe [StructuralElement]),
    -- | The ID of the header.
    headerId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Header' with the minimum fields required to make a request.
newHeader ::
  Header
newHeader = Header {content = Core.Nothing, headerId = Core.Nothing}

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

instance Core.ToJSON Header where
  toJSON Header {..} =
    Core.object
      ( Core.catMaybes
          [ ("content" Core..=) Core.<$> content,
            ("headerId" Core..=) Core.<$> headerId
          ]
      )

-- | A reference to a heading in this document.
--
-- /See:/ 'newHeadingLink' smart constructor.
data HeadingLink = HeadingLink
  { -- | The ID of a heading in this document.
    id :: (Core.Maybe Core.Text),
    -- | The ID of the tab containing this heading.
    tabId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A ParagraphElement representing a horizontal line.
--
-- /See:/ 'newHorizontalRule' smart constructor.
data HorizontalRule = HorizontalRule
  { -- | The suggested deletion IDs. If empty, then there are no suggested deletions of this content.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested insertion IDs. A HorizontalRule may have multiple insertion IDs if it is a nested suggested change. If empty, then this is not a suggested insertion.
    suggestedInsertionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested text style changes to this HorizontalRule, keyed by suggestion ID.
    suggestedTextStyleChanges :: (Core.Maybe HorizontalRule_SuggestedTextStyleChanges),
    -- | The text style of this HorizontalRule. Similar to text content, like text runs and footnote references, the text style of a horizontal rule can affect content layout as well as the styling of text inserted next to it.
    textStyle :: (Core.Maybe TextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'HorizontalRule' with the minimum fields required to make a request.
newHorizontalRule ::
  HorizontalRule
newHorizontalRule =
  HorizontalRule
    { suggestedDeletionIds = Core.Nothing,
      suggestedInsertionIds = Core.Nothing,
      suggestedTextStyleChanges = Core.Nothing,
      textStyle = Core.Nothing
    }

instance Core.FromJSON HorizontalRule where
  parseJSON =
    Core.withObject
      "HorizontalRule"
      ( \o ->
          HorizontalRule
            Core.<$> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionIds")
            Core.<*> (o Core..:? "suggestedTextStyleChanges")
            Core.<*> (o Core..:? "textStyle")
      )

instance Core.ToJSON HorizontalRule where
  toJSON HorizontalRule {..} =
    Core.object
      ( Core.catMaybes
          [ ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionIds" Core..=) Core.<$> suggestedInsertionIds,
            ("suggestedTextStyleChanges" Core..=)
              Core.<$> suggestedTextStyleChanges,
            ("textStyle" Core..=) Core.<$> textStyle
          ]
      )

-- | The suggested text style changes to this HorizontalRule, keyed by suggestion ID.
--
-- /See:/ 'newHorizontalRule_SuggestedTextStyleChanges' smart constructor.
newtype HorizontalRule_SuggestedTextStyleChanges = HorizontalRule_SuggestedTextStyleChanges
  { additional :: (Core.HashMap Core.Text SuggestedTextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'HorizontalRule_SuggestedTextStyleChanges' with the minimum fields required to make a request.
newHorizontalRule_SuggestedTextStyleChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedTextStyle ->
  HorizontalRule_SuggestedTextStyleChanges
newHorizontalRule_SuggestedTextStyleChanges additional =
  HorizontalRule_SuggestedTextStyleChanges {additional = additional}

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

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

-- | The properties of an image.
--
-- /See:/ 'newImageProperties' smart constructor.
data ImageProperties = ImageProperties
  { -- | The clockwise rotation angle of the image, in radians.
    angle :: (Core.Maybe Core.Double),
    -- | The brightness effect of the image. The value should be in the interval [-1.0, 1.0], where 0 means no effect.
    brightness :: (Core.Maybe Core.Double),
    -- | A URI to the image with a default lifetime of 30 minutes. This URI is tagged with the account of the requester. Anyone with the URI effectively accesses the image as the original requester. Access to the image may be lost if the document\'s sharing settings change.
    contentUri :: (Core.Maybe Core.Text),
    -- | The contrast effect of the image. The value should be in the interval [-1.0, 1.0], where 0 means no effect.
    contrast :: (Core.Maybe Core.Double),
    -- | The crop properties of the image.
    cropProperties :: (Core.Maybe CropProperties),
    -- | The source URI is the URI used to insert the image. The source URI can be empty.
    sourceUri :: (Core.Maybe Core.Text),
    -- | The transparency effect of the image. The value should be in the interval [0.0, 1.0], where 0 means no effect and 1 means transparent.
    transparency :: (Core.Maybe Core.Double)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ImageProperties' with the minimum fields required to make a request.
newImageProperties ::
  ImageProperties
newImageProperties =
  ImageProperties
    { angle = Core.Nothing,
      brightness = Core.Nothing,
      contentUri = Core.Nothing,
      contrast = Core.Nothing,
      cropProperties = Core.Nothing,
      sourceUri = Core.Nothing,
      transparency = Core.Nothing
    }

instance Core.FromJSON ImageProperties where
  parseJSON =
    Core.withObject
      "ImageProperties"
      ( \o ->
          ImageProperties
            Core.<$> (o Core..:? "angle")
            Core.<*> (o Core..:? "brightness")
            Core.<*> (o Core..:? "contentUri")
            Core.<*> (o Core..:? "contrast")
            Core.<*> (o Core..:? "cropProperties")
            Core.<*> (o Core..:? "sourceUri")
            Core.<*> (o Core..:? "transparency")
      )

instance Core.ToJSON ImageProperties where
  toJSON ImageProperties {..} =
    Core.object
      ( Core.catMaybes
          [ ("angle" Core..=) Core.<$> angle,
            ("brightness" Core..=) Core.<$> brightness,
            ("contentUri" Core..=) Core.<$> contentUri,
            ("contrast" Core..=) Core.<$> contrast,
            ("cropProperties" Core..=) Core.<$> cropProperties,
            ("sourceUri" Core..=) Core.<$> sourceUri,
            ("transparency" Core..=) Core.<$> transparency
          ]
      )

-- | A mask that indicates which of the fields on the base ImageProperties have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newImagePropertiesSuggestionState' smart constructor.
data ImagePropertiesSuggestionState = ImagePropertiesSuggestionState
  { -- | Indicates if there was a suggested change to angle.
    angleSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to brightness.
    brightnessSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to content_uri.
    contentUriSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to contrast.
    contrastSuggested :: (Core.Maybe Core.Bool),
    -- | A mask that indicates which of the fields in crop_properties have been changed in this suggestion.
    cropPropertiesSuggestionState :: (Core.Maybe CropPropertiesSuggestionState),
    -- | Indicates if there was a suggested change to source_uri.
    sourceUriSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to transparency.
    transparencySuggested :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ImagePropertiesSuggestionState' with the minimum fields required to make a request.
newImagePropertiesSuggestionState ::
  ImagePropertiesSuggestionState
newImagePropertiesSuggestionState =
  ImagePropertiesSuggestionState
    { angleSuggested = Core.Nothing,
      brightnessSuggested = Core.Nothing,
      contentUriSuggested = Core.Nothing,
      contrastSuggested = Core.Nothing,
      cropPropertiesSuggestionState = Core.Nothing,
      sourceUriSuggested = Core.Nothing,
      transparencySuggested = Core.Nothing
    }

instance Core.FromJSON ImagePropertiesSuggestionState where
  parseJSON =
    Core.withObject
      "ImagePropertiesSuggestionState"
      ( \o ->
          ImagePropertiesSuggestionState
            Core.<$> (o Core..:? "angleSuggested")
            Core.<*> (o Core..:? "brightnessSuggested")
            Core.<*> (o Core..:? "contentUriSuggested")
            Core.<*> (o Core..:? "contrastSuggested")
            Core.<*> (o Core..:? "cropPropertiesSuggestionState")
            Core.<*> (o Core..:? "sourceUriSuggested")
            Core.<*> (o Core..:? "transparencySuggested")
      )

instance Core.ToJSON ImagePropertiesSuggestionState where
  toJSON ImagePropertiesSuggestionState {..} =
    Core.object
      ( Core.catMaybes
          [ ("angleSuggested" Core..=) Core.<$> angleSuggested,
            ("brightnessSuggested" Core..=) Core.<$> brightnessSuggested,
            ("contentUriSuggested" Core..=) Core.<$> contentUriSuggested,
            ("contrastSuggested" Core..=) Core.<$> contrastSuggested,
            ("cropPropertiesSuggestionState" Core..=)
              Core.<$> cropPropertiesSuggestionState,
            ("sourceUriSuggested" Core..=) Core.<$> sourceUriSuggested,
            ("transparencySuggested" Core..=) Core.<$> transparencySuggested
          ]
      )

-- | An object that appears inline with text. An InlineObject contains an EmbeddedObject such as an image.
--
-- /See:/ 'newInlineObject' smart constructor.
data InlineObject = InlineObject
  { -- | The properties of this inline object.
    inlineObjectProperties :: (Core.Maybe InlineObjectProperties),
    -- | The ID of this inline object. Can be used to update an object’s properties.
    objectId :: (Core.Maybe Core.Text),
    -- | The suggested deletion IDs. If empty, then there are no suggested deletions of this content.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested changes to the inline object properties, keyed by suggestion ID.
    suggestedInlineObjectPropertiesChanges :: (Core.Maybe InlineObject_SuggestedInlineObjectPropertiesChanges),
    -- | The suggested insertion ID. If empty, then this is not a suggested insertion.
    suggestedInsertionId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'InlineObject' with the minimum fields required to make a request.
newInlineObject ::
  InlineObject
newInlineObject =
  InlineObject
    { inlineObjectProperties = Core.Nothing,
      objectId = Core.Nothing,
      suggestedDeletionIds = Core.Nothing,
      suggestedInlineObjectPropertiesChanges = Core.Nothing,
      suggestedInsertionId = Core.Nothing
    }

instance Core.FromJSON InlineObject where
  parseJSON =
    Core.withObject
      "InlineObject"
      ( \o ->
          InlineObject
            Core.<$> (o Core..:? "inlineObjectProperties")
            Core.<*> (o Core..:? "objectId")
            Core.<*> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInlineObjectPropertiesChanges")
            Core.<*> (o Core..:? "suggestedInsertionId")
      )

instance Core.ToJSON InlineObject where
  toJSON InlineObject {..} =
    Core.object
      ( Core.catMaybes
          [ ("inlineObjectProperties" Core..=)
              Core.<$> inlineObjectProperties,
            ("objectId" Core..=) Core.<$> objectId,
            ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInlineObjectPropertiesChanges" Core..=)
              Core.<$> suggestedInlineObjectPropertiesChanges,
            ("suggestedInsertionId" Core..=) Core.<$> suggestedInsertionId
          ]
      )

-- | The suggested changes to the inline object properties, keyed by suggestion ID.
--
-- /See:/ 'newInlineObject_SuggestedInlineObjectPropertiesChanges' smart constructor.
newtype InlineObject_SuggestedInlineObjectPropertiesChanges = InlineObject_SuggestedInlineObjectPropertiesChanges
  { additional :: (Core.HashMap Core.Text SuggestedInlineObjectProperties)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'InlineObject_SuggestedInlineObjectPropertiesChanges' with the minimum fields required to make a request.
newInlineObject_SuggestedInlineObjectPropertiesChanges ::
  -- |  See 'additional'.
  Core.HashMap
    Core.Text
    SuggestedInlineObjectProperties ->
  InlineObject_SuggestedInlineObjectPropertiesChanges
newInlineObject_SuggestedInlineObjectPropertiesChanges additional =
  InlineObject_SuggestedInlineObjectPropertiesChanges
    { additional =
        additional
    }

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

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

-- | A ParagraphElement that contains an InlineObject.
--
-- /See:/ 'newInlineObjectElement' smart constructor.
data InlineObjectElement = InlineObjectElement
  { -- | The ID of the InlineObject this element contains.
    inlineObjectId :: (Core.Maybe Core.Text),
    -- | The suggested deletion IDs. If empty, then there are no suggested deletions of this content.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested insertion IDs. An InlineObjectElement may have multiple insertion IDs if it\'s a nested suggested change. If empty, then this is not a suggested insertion.
    suggestedInsertionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested text style changes to this InlineObject, keyed by suggestion ID.
    suggestedTextStyleChanges :: (Core.Maybe InlineObjectElement_SuggestedTextStyleChanges),
    -- | The text style of this InlineObjectElement. Similar to text content, like text runs and footnote references, the text style of an inline object element can affect content layout as well as the styling of text inserted next to it.
    textStyle :: (Core.Maybe TextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'InlineObjectElement' with the minimum fields required to make a request.
newInlineObjectElement ::
  InlineObjectElement
newInlineObjectElement =
  InlineObjectElement
    { inlineObjectId = Core.Nothing,
      suggestedDeletionIds = Core.Nothing,
      suggestedInsertionIds = Core.Nothing,
      suggestedTextStyleChanges = Core.Nothing,
      textStyle = Core.Nothing
    }

instance Core.FromJSON InlineObjectElement where
  parseJSON =
    Core.withObject
      "InlineObjectElement"
      ( \o ->
          InlineObjectElement
            Core.<$> (o Core..:? "inlineObjectId")
            Core.<*> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionIds")
            Core.<*> (o Core..:? "suggestedTextStyleChanges")
            Core.<*> (o Core..:? "textStyle")
      )

instance Core.ToJSON InlineObjectElement where
  toJSON InlineObjectElement {..} =
    Core.object
      ( Core.catMaybes
          [ ("inlineObjectId" Core..=) Core.<$> inlineObjectId,
            ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionIds" Core..=) Core.<$> suggestedInsertionIds,
            ("suggestedTextStyleChanges" Core..=)
              Core.<$> suggestedTextStyleChanges,
            ("textStyle" Core..=) Core.<$> textStyle
          ]
      )

-- | The suggested text style changes to this InlineObject, keyed by suggestion ID.
--
-- /See:/ 'newInlineObjectElement_SuggestedTextStyleChanges' smart constructor.
newtype InlineObjectElement_SuggestedTextStyleChanges = InlineObjectElement_SuggestedTextStyleChanges
  { additional :: (Core.HashMap Core.Text SuggestedTextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'InlineObjectElement_SuggestedTextStyleChanges' with the minimum fields required to make a request.
newInlineObjectElement_SuggestedTextStyleChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedTextStyle ->
  InlineObjectElement_SuggestedTextStyleChanges
newInlineObjectElement_SuggestedTextStyleChanges additional =
  InlineObjectElement_SuggestedTextStyleChanges
    { additional =
        additional
    }

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

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

-- | Properties of an InlineObject.
--
-- /See:/ 'newInlineObjectProperties' smart constructor.
newtype InlineObjectProperties = InlineObjectProperties
  { -- | The embedded object of this inline object.
    embeddedObject :: (Core.Maybe EmbeddedObject)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A mask that indicates which of the fields on the base InlineObjectProperties have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newInlineObjectPropertiesSuggestionState' smart constructor.
newtype InlineObjectPropertiesSuggestionState = InlineObjectPropertiesSuggestionState
  { -- | A mask that indicates which of the fields in embedded_object have been changed in this suggestion.
    embeddedObjectSuggestionState :: (Core.Maybe EmbeddedObjectSuggestionState)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Inserts an InlineObject containing an image at the given location.
--
-- /See:/ 'newInsertInlineImageRequest' smart constructor.
data InsertInlineImageRequest = InsertInlineImageRequest
  { -- | Inserts the text at the end of a header, footer or the document body. Inline images cannot be inserted inside a footnote.
    endOfSegmentLocation :: (Core.Maybe EndOfSegmentLocation),
    -- | Inserts the image at a specific index in the document. The image must be inserted inside the bounds of an existing Paragraph. For instance, it cannot be inserted at a table\'s start index (i.e. between the table and its preceding paragraph). Inline images cannot be inserted inside a footnote or equation.
    location :: (Core.Maybe Location),
    -- | The size that the image should appear as in the document. This property is optional and the final size of the image in the document is determined by the following rules: * If neither width nor height is specified, then a default size of the image is calculated based on its resolution. * If one dimension is specified then the other dimension is calculated to preserve the aspect ratio of the image. * If both width and height are specified, the image is scaled to fit within the provided dimensions while maintaining its aspect ratio.
    objectSize :: (Core.Maybe Size),
    -- | The image URI. The image is fetched once at insertion time and a copy is stored for display inside the document. Images must be less than 50MB in size, cannot exceed 25 megapixels, and must be in one of PNG, JPEG, or GIF format. The provided URI must be publicly accessible and at most 2 kB in length. The URI itself is saved with the image, and exposed via the ImageProperties.content_uri field.
    uri :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'InsertInlineImageRequest' with the minimum fields required to make a request.
newInsertInlineImageRequest ::
  InsertInlineImageRequest
newInsertInlineImageRequest =
  InsertInlineImageRequest
    { endOfSegmentLocation = Core.Nothing,
      location = Core.Nothing,
      objectSize = Core.Nothing,
      uri = Core.Nothing
    }

instance Core.FromJSON InsertInlineImageRequest where
  parseJSON =
    Core.withObject
      "InsertInlineImageRequest"
      ( \o ->
          InsertInlineImageRequest
            Core.<$> (o Core..:? "endOfSegmentLocation")
            Core.<*> (o Core..:? "location")
            Core.<*> (o Core..:? "objectSize")
            Core.<*> (o Core..:? "uri")
      )

instance Core.ToJSON InsertInlineImageRequest where
  toJSON InsertInlineImageRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("endOfSegmentLocation" Core..=) Core.<$> endOfSegmentLocation,
            ("location" Core..=) Core.<$> location,
            ("objectSize" Core..=) Core.<$> objectSize,
            ("uri" Core..=) Core.<$> uri
          ]
      )

-- | The result of inserting an inline image.
--
-- /See:/ 'newInsertInlineImageResponse' smart constructor.
newtype InsertInlineImageResponse = InsertInlineImageResponse
  { -- | The ID of the created InlineObject.
    objectId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | The result of inserting an embedded Google Sheets chart.
--
-- /See:/ 'newInsertInlineSheetsChartResponse' smart constructor.
newtype InsertInlineSheetsChartResponse = InsertInlineSheetsChartResponse
  { -- | The object ID of the inserted chart.
    objectId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Inserts a page break followed by a newline at the specified location.
--
-- /See:/ 'newInsertPageBreakRequest' smart constructor.
data InsertPageBreakRequest = InsertPageBreakRequest
  { -- | Inserts the page break at the end of the document body. Page breaks cannot be inserted inside a footnote, header or footer. Since page breaks can only be inserted inside the body, the segment ID field must be empty.
    endOfSegmentLocation :: (Core.Maybe EndOfSegmentLocation),
    -- | Inserts the page break at a specific index in the document. The page break must be inserted inside the bounds of an existing Paragraph. For instance, it cannot be inserted at a table\'s start index (i.e. between the table and its preceding paragraph). Page breaks cannot be inserted inside a table, equation, footnote, header or footer. Since page breaks can only be inserted inside the body, the segment ID field must be empty.
    location :: (Core.Maybe Location)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'InsertPageBreakRequest' with the minimum fields required to make a request.
newInsertPageBreakRequest ::
  InsertPageBreakRequest
newInsertPageBreakRequest =
  InsertPageBreakRequest
    { endOfSegmentLocation = Core.Nothing,
      location = Core.Nothing
    }

instance Core.FromJSON InsertPageBreakRequest where
  parseJSON =
    Core.withObject
      "InsertPageBreakRequest"
      ( \o ->
          InsertPageBreakRequest
            Core.<$> (o Core..:? "endOfSegmentLocation")
            Core.<*> (o Core..:? "location")
      )

instance Core.ToJSON InsertPageBreakRequest where
  toJSON InsertPageBreakRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("endOfSegmentLocation" Core..=) Core.<$> endOfSegmentLocation,
            ("location" Core..=) Core.<$> location
          ]
      )

-- | Inserts a section break at the given location. A newline character will be inserted before the section break.
--
-- /See:/ 'newInsertSectionBreakRequest' smart constructor.
data InsertSectionBreakRequest = InsertSectionBreakRequest
  { -- | Inserts a newline and a section break at the end of the document body. Section breaks cannot be inserted inside a footnote, header or footer. Because section breaks can only be inserted inside the body, the segment ID field must be empty.
    endOfSegmentLocation :: (Core.Maybe EndOfSegmentLocation),
    -- | Inserts a newline and a section break at a specific index in the document. The section break must be inserted inside the bounds of an existing Paragraph. For instance, it cannot be inserted at a table\'s start index (i.e. between the table and its preceding paragraph). Section breaks cannot be inserted inside a table, equation, footnote, header, or footer. Since section breaks can only be inserted inside the body, the segment ID field must be empty.
    location :: (Core.Maybe Location),
    -- | The type of section to insert.
    sectionType :: (Core.Maybe InsertSectionBreakRequest_SectionType)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'InsertSectionBreakRequest' with the minimum fields required to make a request.
newInsertSectionBreakRequest ::
  InsertSectionBreakRequest
newInsertSectionBreakRequest =
  InsertSectionBreakRequest
    { endOfSegmentLocation = Core.Nothing,
      location = Core.Nothing,
      sectionType = Core.Nothing
    }

instance Core.FromJSON InsertSectionBreakRequest where
  parseJSON =
    Core.withObject
      "InsertSectionBreakRequest"
      ( \o ->
          InsertSectionBreakRequest
            Core.<$> (o Core..:? "endOfSegmentLocation")
            Core.<*> (o Core..:? "location")
            Core.<*> (o Core..:? "sectionType")
      )

instance Core.ToJSON InsertSectionBreakRequest where
  toJSON InsertSectionBreakRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("endOfSegmentLocation" Core..=) Core.<$> endOfSegmentLocation,
            ("location" Core..=) Core.<$> location,
            ("sectionType" Core..=) Core.<$> sectionType
          ]
      )

-- | Inserts an empty column into a table.
--
-- /See:/ 'newInsertTableColumnRequest' smart constructor.
data InsertTableColumnRequest = InsertTableColumnRequest
  { -- | Whether to insert new column to the right of the reference cell location. - @True@: insert to the right. - @False@: insert to the left.
    insertRight :: (Core.Maybe Core.Bool),
    -- | The reference table cell location from which columns will be inserted. A new column will be inserted to the left (or right) of the column where the reference cell is. If the reference cell is a merged cell, a new column will be inserted to the left (or right) of the merged cell.
    tableCellLocation :: (Core.Maybe TableCellLocation)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'InsertTableColumnRequest' with the minimum fields required to make a request.
newInsertTableColumnRequest ::
  InsertTableColumnRequest
newInsertTableColumnRequest =
  InsertTableColumnRequest
    { insertRight = Core.Nothing,
      tableCellLocation = Core.Nothing
    }

instance Core.FromJSON InsertTableColumnRequest where
  parseJSON =
    Core.withObject
      "InsertTableColumnRequest"
      ( \o ->
          InsertTableColumnRequest
            Core.<$> (o Core..:? "insertRight")
            Core.<*> (o Core..:? "tableCellLocation")
      )

instance Core.ToJSON InsertTableColumnRequest where
  toJSON InsertTableColumnRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("insertRight" Core..=) Core.<$> insertRight,
            ("tableCellLocation" Core..=) Core.<$> tableCellLocation
          ]
      )

-- | Inserts a table at the specified location. A newline character will be inserted before the inserted table.
--
-- /See:/ 'newInsertTableRequest' smart constructor.
data InsertTableRequest = InsertTableRequest
  { -- | The number of columns in the table.
    columns :: (Core.Maybe Core.Int32),
    -- | Inserts the table at the end of the given header, footer or document body. A newline character will be inserted before the inserted table. Tables cannot be inserted inside a footnote.
    endOfSegmentLocation :: (Core.Maybe EndOfSegmentLocation),
    -- | Inserts the table at a specific model index. A newline character will be inserted before the inserted table, therefore the table start index will be at the specified location index + 1. The table must be inserted inside the bounds of an existing Paragraph. For instance, it cannot be inserted at a table\'s start index (i.e. between an existing table and its preceding paragraph). Tables cannot be inserted inside a footnote or equation.
    location :: (Core.Maybe Location),
    -- | The number of rows in the table.
    rows :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'InsertTableRequest' with the minimum fields required to make a request.
newInsertTableRequest ::
  InsertTableRequest
newInsertTableRequest =
  InsertTableRequest
    { columns = Core.Nothing,
      endOfSegmentLocation = Core.Nothing,
      location = Core.Nothing,
      rows = Core.Nothing
    }

instance Core.FromJSON InsertTableRequest where
  parseJSON =
    Core.withObject
      "InsertTableRequest"
      ( \o ->
          InsertTableRequest
            Core.<$> (o Core..:? "columns")
            Core.<*> (o Core..:? "endOfSegmentLocation")
            Core.<*> (o Core..:? "location")
            Core.<*> (o Core..:? "rows")
      )

instance Core.ToJSON InsertTableRequest where
  toJSON InsertTableRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("columns" Core..=) Core.<$> columns,
            ("endOfSegmentLocation" Core..=) Core.<$> endOfSegmentLocation,
            ("location" Core..=) Core.<$> location,
            ("rows" Core..=) Core.<$> rows
          ]
      )

-- | Inserts an empty row into a table.
--
-- /See:/ 'newInsertTableRowRequest' smart constructor.
data InsertTableRowRequest = InsertTableRowRequest
  { -- | Whether to insert new row below the reference cell location. - @True@: insert below the cell. - @False@: insert above the cell.
    insertBelow :: (Core.Maybe Core.Bool),
    -- | The reference table cell location from which rows will be inserted. A new row will be inserted above (or below) the row where the reference cell is. If the reference cell is a merged cell, a new row will be inserted above (or below) the merged cell.
    tableCellLocation :: (Core.Maybe TableCellLocation)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'InsertTableRowRequest' with the minimum fields required to make a request.
newInsertTableRowRequest ::
  InsertTableRowRequest
newInsertTableRowRequest =
  InsertTableRowRequest
    { insertBelow = Core.Nothing,
      tableCellLocation = Core.Nothing
    }

instance Core.FromJSON InsertTableRowRequest where
  parseJSON =
    Core.withObject
      "InsertTableRowRequest"
      ( \o ->
          InsertTableRowRequest
            Core.<$> (o Core..:? "insertBelow")
            Core.<*> (o Core..:? "tableCellLocation")
      )

instance Core.ToJSON InsertTableRowRequest where
  toJSON InsertTableRowRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("insertBelow" Core..=) Core.<$> insertBelow,
            ("tableCellLocation" Core..=) Core.<$> tableCellLocation
          ]
      )

-- | Inserts text at the specified location.
--
-- /See:/ 'newInsertTextRequest' smart constructor.
data InsertTextRequest = InsertTextRequest
  { -- | Inserts the text at the end of a header, footer, footnote or the document body.
    endOfSegmentLocation :: (Core.Maybe EndOfSegmentLocation),
    -- | Inserts the text at a specific index in the document. Text must be inserted inside the bounds of an existing Paragraph. For instance, text cannot be inserted at a table\'s start index (i.e. between the table and its preceding paragraph). The text must be inserted in the preceding paragraph.
    location :: (Core.Maybe Location),
    -- | The text to be inserted. Inserting a newline character will implicitly create a new Paragraph at that index. The paragraph style of the new paragraph will be copied from the paragraph at the current insertion index, including lists and bullets. Text styles for inserted text will be determined automatically, generally preserving the styling of neighboring text. In most cases, the text style for the inserted text will match the text immediately before the insertion index. Some control characters (U+0000-U+0008, U+000C-U+001F) and characters from the Unicode Basic Multilingual Plane Private Use Area (U+E000-U+F8FF) will be stripped out of the inserted text.
    text :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'InsertTextRequest' with the minimum fields required to make a request.
newInsertTextRequest ::
  InsertTextRequest
newInsertTextRequest =
  InsertTextRequest
    { endOfSegmentLocation = Core.Nothing,
      location = Core.Nothing,
      text = Core.Nothing
    }

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

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

-- | A reference to another portion of a document or an external URL resource.
--
-- /See:/ 'newLink' smart constructor.
data Link = Link
  { -- | A bookmark in this document. In documents containing a single tab, links to bookmarks within the singular tab continue to return Link.bookmarkId when the includeTabsContent parameter is set to @false@ or unset. Otherwise, this field is returned.
    bookmark :: (Core.Maybe BookmarkLink),
    -- | The ID of a bookmark in this document. Legacy field: Instead, set includeTabsContent to @true@ and use Link.bookmark for read and write operations. This field is only returned when includeTabsContent is set to @false@ in documents containing a single tab and links to a bookmark within the singular tab. Otherwise, Link.bookmark is returned. If this field is used in a write request, the bookmark is considered to be from the tab ID specified in the request. If a tab ID is not specified in the request, it is considered to be from the first tab in the document.
    bookmarkId :: (Core.Maybe Core.Text),
    -- | A heading in this document. In documents containing a single tab, links to headings within the singular tab continue to return Link.headingId when the includeTabsContent parameter is set to @false@ or unset. Otherwise, this field is returned.
    heading :: (Core.Maybe HeadingLink),
    -- | The ID of a heading in this document. Legacy field: Instead, set includeTabsContent to @true@ and use Link.heading for read and write operations. This field is only returned when includeTabsContent is set to @false@ in documents containing a single tab and links to a heading within the singular tab. Otherwise, Link.heading is returned. If this field is used in a write request, the heading is considered to be from the tab ID specified in the request. If a tab ID is not specified in the request, it is considered to be from the first tab in the document.
    headingId :: (Core.Maybe Core.Text),
    -- | The ID of a tab in this document.
    tabId :: (Core.Maybe Core.Text),
    -- | An external URL.
    url :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Link' with the minimum fields required to make a request.
newLink ::
  Link
newLink =
  Link
    { bookmark = Core.Nothing,
      bookmarkId = Core.Nothing,
      heading = Core.Nothing,
      headingId = Core.Nothing,
      tabId = Core.Nothing,
      url = Core.Nothing
    }

instance Core.FromJSON Link where
  parseJSON =
    Core.withObject
      "Link"
      ( \o ->
          Link
            Core.<$> (o Core..:? "bookmark")
            Core.<*> (o Core..:? "bookmarkId")
            Core.<*> (o Core..:? "heading")
            Core.<*> (o Core..:? "headingId")
            Core.<*> (o Core..:? "tabId")
            Core.<*> (o Core..:? "url")
      )

instance Core.ToJSON Link where
  toJSON Link {..} =
    Core.object
      ( Core.catMaybes
          [ ("bookmark" Core..=) Core.<$> bookmark,
            ("bookmarkId" Core..=) Core.<$> bookmarkId,
            ("heading" Core..=) Core.<$> heading,
            ("headingId" Core..=) Core.<$> headingId,
            ("tabId" Core..=) Core.<$> tabId,
            ("url" Core..=) Core.<$> url
          ]
      )

-- | A reference to the external linked source content.
--
-- /See:/ 'newLinkedContentReference' smart constructor.
newtype LinkedContentReference = LinkedContentReference
  { -- | A reference to the linked chart.
    sheetsChartReference :: (Core.Maybe SheetsChartReference)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A mask that indicates which of the fields on the base LinkedContentReference have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newLinkedContentReferenceSuggestionState' smart constructor.
newtype LinkedContentReferenceSuggestionState = LinkedContentReferenceSuggestionState
  { -- | A mask that indicates which of the fields in sheets/chart/reference have been changed in this suggestion.
    sheetsChartReferenceSuggestionState :: (Core.Maybe SheetsChartReferenceSuggestionState)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A List represents the list attributes for a group of paragraphs that all belong to the same list. A paragraph that\'s part of a list has a reference to the list\'s ID in its bullet.
--
-- /See:/ 'newList' smart constructor.
data List = List
  { -- | The properties of the list.
    listProperties :: (Core.Maybe ListProperties),
    -- | The suggested deletion IDs. If empty, then there are no suggested deletions of this list.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested insertion ID. If empty, then this is not a suggested insertion.
    suggestedInsertionId :: (Core.Maybe Core.Text),
    -- | The suggested changes to the list properties, keyed by suggestion ID.
    suggestedListPropertiesChanges :: (Core.Maybe List_SuggestedListPropertiesChanges)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'List' with the minimum fields required to make a request.
newList ::
  List
newList =
  List
    { listProperties = Core.Nothing,
      suggestedDeletionIds = Core.Nothing,
      suggestedInsertionId = Core.Nothing,
      suggestedListPropertiesChanges = Core.Nothing
    }

instance Core.FromJSON List where
  parseJSON =
    Core.withObject
      "List"
      ( \o ->
          List
            Core.<$> (o Core..:? "listProperties")
            Core.<*> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionId")
            Core.<*> (o Core..:? "suggestedListPropertiesChanges")
      )

instance Core.ToJSON List where
  toJSON List {..} =
    Core.object
      ( Core.catMaybes
          [ ("listProperties" Core..=) Core.<$> listProperties,
            ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionId" Core..=) Core.<$> suggestedInsertionId,
            ("suggestedListPropertiesChanges" Core..=)
              Core.<$> suggestedListPropertiesChanges
          ]
      )

-- | The suggested changes to the list properties, keyed by suggestion ID.
--
-- /See:/ 'newList_SuggestedListPropertiesChanges' smart constructor.
newtype List_SuggestedListPropertiesChanges = List_SuggestedListPropertiesChanges
  { additional :: (Core.HashMap Core.Text SuggestedListProperties)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'List_SuggestedListPropertiesChanges' with the minimum fields required to make a request.
newList_SuggestedListPropertiesChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedListProperties ->
  List_SuggestedListPropertiesChanges
newList_SuggestedListPropertiesChanges additional =
  List_SuggestedListPropertiesChanges {additional = additional}

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

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

-- | The properties of a list that describe the look and feel of bullets belonging to paragraphs associated with a list.
--
-- /See:/ 'newListProperties' smart constructor.
newtype ListProperties = ListProperties
  { -- | Describes the properties of the bullets at the associated level. A list has at most 9 levels of nesting with nesting level 0 corresponding to the top-most level and nesting level 8 corresponding to the most nested level. The nesting levels are returned in ascending order with the least nested returned first.
    nestingLevels :: (Core.Maybe [NestingLevel])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A mask that indicates which of the fields on the base ListProperties have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newListPropertiesSuggestionState' smart constructor.
newtype ListPropertiesSuggestionState = ListPropertiesSuggestionState
  { -- | A mask that indicates which of the fields on the corresponding NestingLevel in nesting_levels have been changed in this suggestion. The nesting level suggestion states are returned in ascending order of the nesting level with the least nested returned first.
    nestingLevelsSuggestionStates :: (Core.Maybe [NestingLevelSuggestionState])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A particular location in the document.
--
-- /See:/ 'newLocation' smart constructor.
data Location = Location
  { -- | The zero-based index, in UTF-16 code units. The index is relative to the beginning of the segment specified by segment_id.
    index :: (Core.Maybe Core.Int32),
    -- | The ID of the header, footer or footnote the location is in. An empty segment ID signifies the document\'s body.
    segmentId :: (Core.Maybe Core.Text),
    -- | The tab that the location is in. When omitted, the request is applied to the first tab. In a document containing a single tab: - If provided, must match the singular tab\'s ID. - If omitted, the request applies to the singular tab. In a document containing multiple tabs: - If provided, the request applies to the specified tab. - If omitted, the request applies to the first tab in the document.
    tabId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Location' with the minimum fields required to make a request.
newLocation ::
  Location
newLocation =
  Location
    { index = Core.Nothing,
      segmentId = Core.Nothing,
      tabId = Core.Nothing
    }

instance Core.FromJSON Location where
  parseJSON =
    Core.withObject
      "Location"
      ( \o ->
          Location
            Core.<$> (o Core..:? "index")
            Core.<*> (o Core..:? "segmentId")
            Core.<*> (o Core..:? "tabId")
      )

instance Core.ToJSON Location where
  toJSON Location {..} =
    Core.object
      ( Core.catMaybes
          [ ("index" Core..=) Core.<$> index,
            ("segmentId" Core..=) Core.<$> segmentId,
            ("tabId" Core..=) Core.<$> tabId
          ]
      )

-- | Merges cells in a Table.
--
-- /See:/ 'newMergeTableCellsRequest' smart constructor.
newtype MergeTableCellsRequest = MergeTableCellsRequest
  { -- | The table range specifying which cells of the table to merge. Any text in the cells being merged will be concatenated and stored in the \"head\" cell of the range. This is the upper-left cell of the range when the content direction is left to right, and the upper-right cell of the range otherwise. If the range is non-rectangular (which can occur in some cases where the range covers cells that are already merged or where the table is non-rectangular), a 400 bad request error is returned.
    tableRange :: (Core.Maybe TableRange)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A collection of Ranges with the same named range ID. Named ranges allow developers to associate parts of a document with an arbitrary user-defined label so their contents can be programmatically read or edited later. A document can contain multiple named ranges with the same name, but every named range has a unique ID. A named range is created with a single Range, and content inserted inside a named range generally expands that range. However, certain document changes can cause the range to be split into multiple ranges. Named ranges are not private. All applications and collaborators that have access to the document can see its named ranges.
--
-- /See:/ 'newNamedRange' smart constructor.
data NamedRange = NamedRange
  { -- | The name of the named range.
    name :: (Core.Maybe Core.Text),
    -- | The ID of the named range.
    namedRangeId :: (Core.Maybe Core.Text),
    -- | The ranges that belong to this named range.
    ranges :: (Core.Maybe [Range])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'NamedRange' with the minimum fields required to make a request.
newNamedRange ::
  NamedRange
newNamedRange =
  NamedRange
    { name = Core.Nothing,
      namedRangeId = Core.Nothing,
      ranges = Core.Nothing
    }

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

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

-- | A collection of all the NamedRanges in the document that share a given name.
--
-- /See:/ 'newNamedRanges' smart constructor.
data NamedRanges = NamedRanges
  { -- | The name that all the named ranges share.
    name :: (Core.Maybe Core.Text),
    -- | The NamedRanges that share the same name.
    namedRanges :: (Core.Maybe [NamedRange])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A named style. Paragraphs in the document can inherit their TextStyle and ParagraphStyle from this named style when they have the same named style type.
--
-- /See:/ 'newNamedStyle' smart constructor.
data NamedStyle = NamedStyle
  { -- | The type of this named style.
    namedStyleType :: (Core.Maybe NamedStyle_NamedStyleType),
    -- | The paragraph style of this named style.
    paragraphStyle :: (Core.Maybe ParagraphStyle),
    -- | The text style of this named style.
    textStyle :: (Core.Maybe TextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'NamedStyle' with the minimum fields required to make a request.
newNamedStyle ::
  NamedStyle
newNamedStyle =
  NamedStyle
    { namedStyleType = Core.Nothing,
      paragraphStyle = Core.Nothing,
      textStyle = Core.Nothing
    }

instance Core.FromJSON NamedStyle where
  parseJSON =
    Core.withObject
      "NamedStyle"
      ( \o ->
          NamedStyle
            Core.<$> (o Core..:? "namedStyleType")
            Core.<*> (o Core..:? "paragraphStyle")
            Core.<*> (o Core..:? "textStyle")
      )

instance Core.ToJSON NamedStyle where
  toJSON NamedStyle {..} =
    Core.object
      ( Core.catMaybes
          [ ("namedStyleType" Core..=) Core.<$> namedStyleType,
            ("paragraphStyle" Core..=) Core.<$> paragraphStyle,
            ("textStyle" Core..=) Core.<$> textStyle
          ]
      )

-- | A suggestion state of a NamedStyle message.
--
-- /See:/ 'newNamedStyleSuggestionState' smart constructor.
data NamedStyleSuggestionState = NamedStyleSuggestionState
  { -- | The named style type that this suggestion state corresponds to. This field is provided as a convenience for matching the NamedStyleSuggestionState with its corresponding NamedStyle.
    namedStyleType :: (Core.Maybe NamedStyleSuggestionState_NamedStyleType),
    -- | A mask that indicates which of the fields in paragraph style have been changed in this suggestion.
    paragraphStyleSuggestionState :: (Core.Maybe ParagraphStyleSuggestionState),
    -- | A mask that indicates which of the fields in text style have been changed in this suggestion.
    textStyleSuggestionState :: (Core.Maybe TextStyleSuggestionState)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'NamedStyleSuggestionState' with the minimum fields required to make a request.
newNamedStyleSuggestionState ::
  NamedStyleSuggestionState
newNamedStyleSuggestionState =
  NamedStyleSuggestionState
    { namedStyleType = Core.Nothing,
      paragraphStyleSuggestionState = Core.Nothing,
      textStyleSuggestionState = Core.Nothing
    }

instance Core.FromJSON NamedStyleSuggestionState where
  parseJSON =
    Core.withObject
      "NamedStyleSuggestionState"
      ( \o ->
          NamedStyleSuggestionState
            Core.<$> (o Core..:? "namedStyleType")
            Core.<*> (o Core..:? "paragraphStyleSuggestionState")
            Core.<*> (o Core..:? "textStyleSuggestionState")
      )

instance Core.ToJSON NamedStyleSuggestionState where
  toJSON NamedStyleSuggestionState {..} =
    Core.object
      ( Core.catMaybes
          [ ("namedStyleType" Core..=) Core.<$> namedStyleType,
            ("paragraphStyleSuggestionState" Core..=)
              Core.<$> paragraphStyleSuggestionState,
            ("textStyleSuggestionState" Core..=)
              Core.<$> textStyleSuggestionState
          ]
      )

-- | The named styles. Paragraphs in the document can inherit their TextStyle and ParagraphStyle from these named styles.
--
-- /See:/ 'newNamedStyles' smart constructor.
newtype NamedStyles = NamedStyles
  { -- | The named styles. There\'s an entry for each of the possible named style types.
    styles :: (Core.Maybe [NamedStyle])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | The suggestion state of a NamedStyles message.
--
-- /See:/ 'newNamedStylesSuggestionState' smart constructor.
newtype NamedStylesSuggestionState = NamedStylesSuggestionState
  { -- | A mask that indicates which of the fields on the corresponding NamedStyle in styles have been changed in this suggestion. The order of these named style suggestion states matches the order of the corresponding named style within the named styles suggestion.
    stylesSuggestionStates :: (Core.Maybe [NamedStyleSuggestionState])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Contains properties describing the look and feel of a list bullet at a given level of nesting.
--
-- /See:/ 'newNestingLevel' smart constructor.
data NestingLevel = NestingLevel
  { -- | The alignment of the bullet within the space allotted for rendering the bullet.
    bulletAlignment :: (Core.Maybe NestingLevel_BulletAlignment),
    -- | The format string used by bullets at this level of nesting. The glyph format contains one or more placeholders, and these placeholders are replaced with the appropriate values depending on the glyph/type or glyph/symbol. The placeholders follow the pattern @%[nesting_level]@. Furthermore, placeholders can have prefixes and suffixes. Thus, the glyph format follows the pattern @%[nesting_level]@. Note that the prefix and suffix are optional and can be arbitrary strings. For example, the glyph format @%0.@ indicates that the rendered glyph will replace the placeholder with the corresponding glyph for nesting level 0 followed by a period as the suffix. So a list with a glyph type of UPPER_ALPHA and glyph format @%0.@ at nesting level 0 will result in a list with rendered glyphs @A.@ @B.@ @C.@ The glyph format can contain placeholders for the current nesting level as well as placeholders for parent nesting levels. For example, a list can have a glyph format of @%0.@ at nesting level 0 and a glyph format of
    -- @%0.%1.@ at nesting level 1. Assuming both nesting levels have DECIMAL glyph types, this would result in a list with rendered glyphs @1.@ @2.@ @2.1.@ @2.2.@ @3.@ For nesting levels that are ordered, the string that replaces a placeholder in the glyph format for a particular paragraph depends on the paragraph\'s order within the list.
    glyphFormat :: (Core.Maybe Core.Text),
    -- | A custom glyph symbol used by bullets when paragraphs at this level of nesting is unordered. The glyph symbol replaces placeholders within the glyph/format. For example, if the glyph/symbol is the solid circle corresponding to Unicode U+25cf code point and the glyph_format is @%0@, the rendered glyph would be the solid circle.
    glyphSymbol :: (Core.Maybe Core.Text),
    -- | The type of glyph used by bullets when paragraphs at this level of nesting is ordered. The glyph type determines the type of glyph used to replace placeholders within the glyph/format when paragraphs at this level of nesting are ordered. For example, if the nesting level is 0, the glyph/format is @%0.@ and the glyph type is DECIMAL, then the rendered glyph would replace the placeholder @%0@ in the glyph format with a number corresponding to the list item\'s order within the list.
    glyphType :: (Core.Maybe NestingLevel_GlyphType),
    -- | The amount of indentation for the first line of paragraphs at this level of nesting.
    indentFirstLine :: (Core.Maybe Dimension),
    -- | The amount of indentation for paragraphs at this level of nesting. Applied to the side that corresponds to the start of the text, based on the paragraph\'s content direction.
    indentStart :: (Core.Maybe Dimension),
    -- | The number of the first list item at this nesting level. A value of 0 is treated as a value of 1 for lettered lists and Roman numeral lists. For values of both 0 and 1, lettered and Roman numeral lists will begin at @a@ and @i@ respectively. This value is ignored for nesting levels with unordered glyphs.
    startNumber :: (Core.Maybe Core.Int32),
    -- | The text style of bullets at this level of nesting.
    textStyle :: (Core.Maybe TextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'NestingLevel' with the minimum fields required to make a request.
newNestingLevel ::
  NestingLevel
newNestingLevel =
  NestingLevel
    { bulletAlignment = Core.Nothing,
      glyphFormat = Core.Nothing,
      glyphSymbol = Core.Nothing,
      glyphType = Core.Nothing,
      indentFirstLine = Core.Nothing,
      indentStart = Core.Nothing,
      startNumber = Core.Nothing,
      textStyle = Core.Nothing
    }

instance Core.FromJSON NestingLevel where
  parseJSON =
    Core.withObject
      "NestingLevel"
      ( \o ->
          NestingLevel
            Core.<$> (o Core..:? "bulletAlignment")
            Core.<*> (o Core..:? "glyphFormat")
            Core.<*> (o Core..:? "glyphSymbol")
            Core.<*> (o Core..:? "glyphType")
            Core.<*> (o Core..:? "indentFirstLine")
            Core.<*> (o Core..:? "indentStart")
            Core.<*> (o Core..:? "startNumber")
            Core.<*> (o Core..:? "textStyle")
      )

instance Core.ToJSON NestingLevel where
  toJSON NestingLevel {..} =
    Core.object
      ( Core.catMaybes
          [ ("bulletAlignment" Core..=) Core.<$> bulletAlignment,
            ("glyphFormat" Core..=) Core.<$> glyphFormat,
            ("glyphSymbol" Core..=) Core.<$> glyphSymbol,
            ("glyphType" Core..=) Core.<$> glyphType,
            ("indentFirstLine" Core..=) Core.<$> indentFirstLine,
            ("indentStart" Core..=) Core.<$> indentStart,
            ("startNumber" Core..=) Core.<$> startNumber,
            ("textStyle" Core..=) Core.<$> textStyle
          ]
      )

-- | A mask that indicates which of the fields on the base NestingLevel have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newNestingLevelSuggestionState' smart constructor.
data NestingLevelSuggestionState = NestingLevelSuggestionState
  { -- | Indicates if there was a suggested change to bullet_alignment.
    bulletAlignmentSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to glyph_format.
    glyphFormatSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to glyph_symbol.
    glyphSymbolSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to glyph_type.
    glyphTypeSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to indent/first/line.
    indentFirstLineSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to indent_start.
    indentStartSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to start_number.
    startNumberSuggested :: (Core.Maybe Core.Bool),
    -- | A mask that indicates which of the fields in text style have been changed in this suggestion.
    textStyleSuggestionState :: (Core.Maybe TextStyleSuggestionState)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'NestingLevelSuggestionState' with the minimum fields required to make a request.
newNestingLevelSuggestionState ::
  NestingLevelSuggestionState
newNestingLevelSuggestionState =
  NestingLevelSuggestionState
    { bulletAlignmentSuggested =
        Core.Nothing,
      glyphFormatSuggested = Core.Nothing,
      glyphSymbolSuggested = Core.Nothing,
      glyphTypeSuggested = Core.Nothing,
      indentFirstLineSuggested = Core.Nothing,
      indentStartSuggested = Core.Nothing,
      startNumberSuggested = Core.Nothing,
      textStyleSuggestionState = Core.Nothing
    }

instance Core.FromJSON NestingLevelSuggestionState where
  parseJSON =
    Core.withObject
      "NestingLevelSuggestionState"
      ( \o ->
          NestingLevelSuggestionState
            Core.<$> (o Core..:? "bulletAlignmentSuggested")
            Core.<*> (o Core..:? "glyphFormatSuggested")
            Core.<*> (o Core..:? "glyphSymbolSuggested")
            Core.<*> (o Core..:? "glyphTypeSuggested")
            Core.<*> (o Core..:? "indentFirstLineSuggested")
            Core.<*> (o Core..:? "indentStartSuggested")
            Core.<*> (o Core..:? "startNumberSuggested")
            Core.<*> (o Core..:? "textStyleSuggestionState")
      )

instance Core.ToJSON NestingLevelSuggestionState where
  toJSON NestingLevelSuggestionState {..} =
    Core.object
      ( Core.catMaybes
          [ ("bulletAlignmentSuggested" Core..=)
              Core.<$> bulletAlignmentSuggested,
            ("glyphFormatSuggested" Core..=) Core.<$> glyphFormatSuggested,
            ("glyphSymbolSuggested" Core..=) Core.<$> glyphSymbolSuggested,
            ("glyphTypeSuggested" Core..=) Core.<$> glyphTypeSuggested,
            ("indentFirstLineSuggested" Core..=)
              Core.<$> indentFirstLineSuggested,
            ("indentStartSuggested" Core..=) Core.<$> indentStartSuggested,
            ("startNumberSuggested" Core..=) Core.<$> startNumberSuggested,
            ("textStyleSuggestionState" Core..=)
              Core.<$> textStyleSuggestionState
          ]
      )

-- | A collection of object IDs.
--
-- /See:/ 'newObjectReferences' smart constructor.
newtype ObjectReferences = ObjectReferences
  { -- | The object IDs.
    objectIds :: (Core.Maybe [Core.Text])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A color that can either be fully opaque or fully transparent.
--
-- /See:/ 'newOptionalColor' smart constructor.
newtype OptionalColor = OptionalColor
  { -- | If set, this will be used as an opaque color. If unset, this represents a transparent color.
    color :: (Core.Maybe Color)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A ParagraphElement representing a page break. A page break makes the subsequent text start at the top of the next page.
--
-- /See:/ 'newPageBreak' smart constructor.
data PageBreak = PageBreak
  { -- | The suggested deletion IDs. If empty, then there are no suggested deletions of this content.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested insertion IDs. A PageBreak may have multiple insertion IDs if it\'s a nested suggested change. If empty, then this is not a suggested insertion.
    suggestedInsertionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested text style changes to this PageBreak, keyed by suggestion ID.
    suggestedTextStyleChanges :: (Core.Maybe PageBreak_SuggestedTextStyleChanges),
    -- | The text style of this PageBreak. Similar to text content, like text runs and footnote references, the text style of a page break can affect content layout as well as the styling of text inserted next to it.
    textStyle :: (Core.Maybe TextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'PageBreak' with the minimum fields required to make a request.
newPageBreak ::
  PageBreak
newPageBreak =
  PageBreak
    { suggestedDeletionIds = Core.Nothing,
      suggestedInsertionIds = Core.Nothing,
      suggestedTextStyleChanges = Core.Nothing,
      textStyle = Core.Nothing
    }

instance Core.FromJSON PageBreak where
  parseJSON =
    Core.withObject
      "PageBreak"
      ( \o ->
          PageBreak
            Core.<$> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionIds")
            Core.<*> (o Core..:? "suggestedTextStyleChanges")
            Core.<*> (o Core..:? "textStyle")
      )

instance Core.ToJSON PageBreak where
  toJSON PageBreak {..} =
    Core.object
      ( Core.catMaybes
          [ ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionIds" Core..=) Core.<$> suggestedInsertionIds,
            ("suggestedTextStyleChanges" Core..=)
              Core.<$> suggestedTextStyleChanges,
            ("textStyle" Core..=) Core.<$> textStyle
          ]
      )

-- | The suggested text style changes to this PageBreak, keyed by suggestion ID.
--
-- /See:/ 'newPageBreak_SuggestedTextStyleChanges' smart constructor.
newtype PageBreak_SuggestedTextStyleChanges = PageBreak_SuggestedTextStyleChanges
  { additional :: (Core.HashMap Core.Text SuggestedTextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'PageBreak_SuggestedTextStyleChanges' with the minimum fields required to make a request.
newPageBreak_SuggestedTextStyleChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedTextStyle ->
  PageBreak_SuggestedTextStyleChanges
newPageBreak_SuggestedTextStyleChanges additional =
  PageBreak_SuggestedTextStyleChanges {additional = additional}

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

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

-- | A StructuralElement representing a paragraph. A paragraph is a range of content that\'s terminated with a newline character.
--
-- /See:/ 'newParagraph' smart constructor.
data Paragraph = Paragraph
  { -- | The bullet for this paragraph. If not present, the paragraph does not belong to a list.
    bullet :: (Core.Maybe Bullet),
    -- | The content of the paragraph, broken down into its component parts.
    elements :: (Core.Maybe [ParagraphElement]),
    -- | The style of this paragraph.
    paragraphStyle :: (Core.Maybe ParagraphStyle),
    -- | The IDs of the positioned objects tethered to this paragraph.
    positionedObjectIds :: (Core.Maybe [Core.Text]),
    -- | The suggested changes to this paragraph\'s bullet.
    suggestedBulletChanges :: (Core.Maybe Paragraph_SuggestedBulletChanges),
    -- | The suggested paragraph style changes to this paragraph, keyed by suggestion ID.
    suggestedParagraphStyleChanges :: (Core.Maybe Paragraph_SuggestedParagraphStyleChanges),
    -- | The IDs of the positioned objects suggested to be attached to this paragraph, keyed by suggestion ID.
    suggestedPositionedObjectIds :: (Core.Maybe Paragraph_SuggestedPositionedObjectIds)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Paragraph' with the minimum fields required to make a request.
newParagraph ::
  Paragraph
newParagraph =
  Paragraph
    { bullet = Core.Nothing,
      elements = Core.Nothing,
      paragraphStyle = Core.Nothing,
      positionedObjectIds = Core.Nothing,
      suggestedBulletChanges = Core.Nothing,
      suggestedParagraphStyleChanges = Core.Nothing,
      suggestedPositionedObjectIds = Core.Nothing
    }

instance Core.FromJSON Paragraph where
  parseJSON =
    Core.withObject
      "Paragraph"
      ( \o ->
          Paragraph
            Core.<$> (o Core..:? "bullet")
            Core.<*> (o Core..:? "elements")
            Core.<*> (o Core..:? "paragraphStyle")
            Core.<*> (o Core..:? "positionedObjectIds")
            Core.<*> (o Core..:? "suggestedBulletChanges")
            Core.<*> (o Core..:? "suggestedParagraphStyleChanges")
            Core.<*> (o Core..:? "suggestedPositionedObjectIds")
      )

instance Core.ToJSON Paragraph where
  toJSON Paragraph {..} =
    Core.object
      ( Core.catMaybes
          [ ("bullet" Core..=) Core.<$> bullet,
            ("elements" Core..=) Core.<$> elements,
            ("paragraphStyle" Core..=) Core.<$> paragraphStyle,
            ("positionedObjectIds" Core..=) Core.<$> positionedObjectIds,
            ("suggestedBulletChanges" Core..=) Core.<$> suggestedBulletChanges,
            ("suggestedParagraphStyleChanges" Core..=)
              Core.<$> suggestedParagraphStyleChanges,
            ("suggestedPositionedObjectIds" Core..=)
              Core.<$> suggestedPositionedObjectIds
          ]
      )

-- | The suggested changes to this paragraph\'s bullet.
--
-- /See:/ 'newParagraph_SuggestedBulletChanges' smart constructor.
newtype Paragraph_SuggestedBulletChanges = Paragraph_SuggestedBulletChanges
  { additional :: (Core.HashMap Core.Text SuggestedBullet)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Paragraph_SuggestedBulletChanges' with the minimum fields required to make a request.
newParagraph_SuggestedBulletChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedBullet ->
  Paragraph_SuggestedBulletChanges
newParagraph_SuggestedBulletChanges additional =
  Paragraph_SuggestedBulletChanges {additional = additional}

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

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

-- | The suggested paragraph style changes to this paragraph, keyed by suggestion ID.
--
-- /See:/ 'newParagraph_SuggestedParagraphStyleChanges' smart constructor.
newtype Paragraph_SuggestedParagraphStyleChanges = Paragraph_SuggestedParagraphStyleChanges
  { additional :: (Core.HashMap Core.Text SuggestedParagraphStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Paragraph_SuggestedParagraphStyleChanges' with the minimum fields required to make a request.
newParagraph_SuggestedParagraphStyleChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedParagraphStyle ->
  Paragraph_SuggestedParagraphStyleChanges
newParagraph_SuggestedParagraphStyleChanges additional =
  Paragraph_SuggestedParagraphStyleChanges {additional = additional}

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

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

-- | The IDs of the positioned objects suggested to be attached to this paragraph, keyed by suggestion ID.
--
-- /See:/ 'newParagraph_SuggestedPositionedObjectIds' smart constructor.
newtype Paragraph_SuggestedPositionedObjectIds = Paragraph_SuggestedPositionedObjectIds
  { additional :: (Core.HashMap Core.Text ObjectReferences)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Paragraph_SuggestedPositionedObjectIds' with the minimum fields required to make a request.
newParagraph_SuggestedPositionedObjectIds ::
  -- |  See 'additional'.
  Core.HashMap Core.Text ObjectReferences ->
  Paragraph_SuggestedPositionedObjectIds
newParagraph_SuggestedPositionedObjectIds additional =
  Paragraph_SuggestedPositionedObjectIds {additional = additional}

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

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

-- | A border around a paragraph.
--
-- /See:/ 'newParagraphBorder' smart constructor.
data ParagraphBorder = ParagraphBorder
  { -- | The color of the border.
    color :: (Core.Maybe OptionalColor),
    -- | The dash style of the border.
    dashStyle :: (Core.Maybe ParagraphBorder_DashStyle),
    -- | The padding of the border.
    padding :: (Core.Maybe Dimension),
    -- | The width of the border.
    width :: (Core.Maybe Dimension)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ParagraphBorder' with the minimum fields required to make a request.
newParagraphBorder ::
  ParagraphBorder
newParagraphBorder =
  ParagraphBorder
    { color = Core.Nothing,
      dashStyle = Core.Nothing,
      padding = Core.Nothing,
      width = Core.Nothing
    }

instance Core.FromJSON ParagraphBorder where
  parseJSON =
    Core.withObject
      "ParagraphBorder"
      ( \o ->
          ParagraphBorder
            Core.<$> (o Core..:? "color")
            Core.<*> (o Core..:? "dashStyle")
            Core.<*> (o Core..:? "padding")
            Core.<*> (o Core..:? "width")
      )

instance Core.ToJSON ParagraphBorder where
  toJSON ParagraphBorder {..} =
    Core.object
      ( Core.catMaybes
          [ ("color" Core..=) Core.<$> color,
            ("dashStyle" Core..=) Core.<$> dashStyle,
            ("padding" Core..=) Core.<$> padding,
            ("width" Core..=) Core.<$> width
          ]
      )

-- | A ParagraphElement describes content within a Paragraph.
--
-- /See:/ 'newParagraphElement' smart constructor.
data ParagraphElement = ParagraphElement
  { -- | An auto text paragraph element.
    autoText :: (Core.Maybe AutoText),
    -- | A column break paragraph element.
    columnBreak :: (Core.Maybe ColumnBreak),
    -- | The zero-base end index of this paragraph element, exclusive, in UTF-16 code units.
    endIndex :: (Core.Maybe Core.Int32),
    -- | An equation paragraph element.
    equation :: (Core.Maybe Equation),
    -- | A footnote reference paragraph element.
    footnoteReference :: (Core.Maybe FootnoteReference),
    -- | A horizontal rule paragraph element.
    horizontalRule :: (Core.Maybe HorizontalRule),
    -- | An inline object paragraph element.
    inlineObjectElement :: (Core.Maybe InlineObjectElement),
    -- | A page break paragraph element.
    pageBreak :: (Core.Maybe PageBreak),
    -- | A paragraph element that links to a person or email address.
    person :: (Core.Maybe Person),
    -- | A paragraph element that links to a Google resource (such as a file in Google Drive, a YouTube video, or a Calendar event.)
    richLink :: (Core.Maybe RichLink),
    -- | The zero-based start index of this paragraph element, in UTF-16 code units.
    startIndex :: (Core.Maybe Core.Int32),
    -- | A text run paragraph element.
    textRun :: (Core.Maybe TextRun)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ParagraphElement' with the minimum fields required to make a request.
newParagraphElement ::
  ParagraphElement
newParagraphElement =
  ParagraphElement
    { autoText = Core.Nothing,
      columnBreak = Core.Nothing,
      endIndex = Core.Nothing,
      equation = Core.Nothing,
      footnoteReference = Core.Nothing,
      horizontalRule = Core.Nothing,
      inlineObjectElement = Core.Nothing,
      pageBreak = Core.Nothing,
      person = Core.Nothing,
      richLink = Core.Nothing,
      startIndex = Core.Nothing,
      textRun = Core.Nothing
    }

instance Core.FromJSON ParagraphElement where
  parseJSON =
    Core.withObject
      "ParagraphElement"
      ( \o ->
          ParagraphElement
            Core.<$> (o Core..:? "autoText")
            Core.<*> (o Core..:? "columnBreak")
            Core.<*> (o Core..:? "endIndex")
            Core.<*> (o Core..:? "equation")
            Core.<*> (o Core..:? "footnoteReference")
            Core.<*> (o Core..:? "horizontalRule")
            Core.<*> (o Core..:? "inlineObjectElement")
            Core.<*> (o Core..:? "pageBreak")
            Core.<*> (o Core..:? "person")
            Core.<*> (o Core..:? "richLink")
            Core.<*> (o Core..:? "startIndex")
            Core.<*> (o Core..:? "textRun")
      )

instance Core.ToJSON ParagraphElement where
  toJSON ParagraphElement {..} =
    Core.object
      ( Core.catMaybes
          [ ("autoText" Core..=) Core.<$> autoText,
            ("columnBreak" Core..=) Core.<$> columnBreak,
            ("endIndex" Core..=) Core.<$> endIndex,
            ("equation" Core..=) Core.<$> equation,
            ("footnoteReference" Core..=) Core.<$> footnoteReference,
            ("horizontalRule" Core..=) Core.<$> horizontalRule,
            ("inlineObjectElement" Core..=) Core.<$> inlineObjectElement,
            ("pageBreak" Core..=) Core.<$> pageBreak,
            ("person" Core..=) Core.<$> person,
            ("richLink" Core..=) Core.<$> richLink,
            ("startIndex" Core..=) Core.<$> startIndex,
            ("textRun" Core..=) Core.<$> textRun
          ]
      )

-- | Styles that apply to a whole paragraph. Inherited paragraph styles are represented as unset fields in this message. A paragraph style\'s parent depends on where the paragraph style is defined: * The ParagraphStyle on a Paragraph inherits from the paragraph\'s corresponding named style type. * The ParagraphStyle on a named style inherits from the normal text named style. * The ParagraphStyle of the normal text named style inherits from the default paragraph style in the Docs editor. * The ParagraphStyle on a Paragraph element that\'s contained in a table may inherit its paragraph style from the table style. If the paragraph style does not inherit from a parent, unsetting fields will revert the style to a value matching the defaults in the Docs editor.
--
-- /See:/ 'newParagraphStyle' smart constructor.
data ParagraphStyle = ParagraphStyle
  { -- | The text alignment for this paragraph.
    alignment :: (Core.Maybe ParagraphStyle_Alignment),
    -- | Whether to avoid widows and orphans for the paragraph. If unset, the value is inherited from the parent.
    avoidWidowAndOrphan :: (Core.Maybe Core.Bool),
    -- | The border between this paragraph and the next and previous paragraphs. If unset, the value is inherited from the parent. The between border is rendered when the adjacent paragraph has the same border and indent properties. Paragraph borders cannot be partially updated. When changing a paragraph border, the new border must be specified in its entirety.
    borderBetween :: (Core.Maybe ParagraphBorder),
    -- | The border at the bottom of this paragraph. If unset, the value is inherited from the parent. The bottom border is rendered when the paragraph below has different border and indent properties. Paragraph borders cannot be partially updated. When changing a paragraph border, the new border must be specified in its entirety.
    borderBottom :: (Core.Maybe ParagraphBorder),
    -- | The border to the left of this paragraph. If unset, the value is inherited from the parent. Paragraph borders cannot be partially updated. When changing a paragraph border, the new border must be specified in its entirety.
    borderLeft :: (Core.Maybe ParagraphBorder),
    -- | The border to the right of this paragraph. If unset, the value is inherited from the parent. Paragraph borders cannot be partially updated. When changing a paragraph border, the new border must be specified in its entirety.
    borderRight :: (Core.Maybe ParagraphBorder),
    -- | The border at the top of this paragraph. If unset, the value is inherited from the parent. The top border is rendered when the paragraph above has different border and indent properties. Paragraph borders cannot be partially updated. When changing a paragraph border, the new border must be specified in its entirety.
    borderTop :: (Core.Maybe ParagraphBorder),
    -- | The text direction of this paragraph. If unset, the value defaults to LEFT/TO/RIGHT since paragraph direction is not inherited.
    direction :: (Core.Maybe ParagraphStyle_Direction),
    -- | The heading ID of the paragraph. If empty, then this paragraph is not a heading. This property is read-only.
    headingId :: (Core.Maybe Core.Text),
    -- | The amount of indentation for the paragraph on the side that corresponds to the end of the text, based on the current paragraph direction. If unset, the value is inherited from the parent.
    indentEnd :: (Core.Maybe Dimension),
    -- | The amount of indentation for the first line of the paragraph. If unset, the value is inherited from the parent.
    indentFirstLine :: (Core.Maybe Dimension),
    -- | The amount of indentation for the paragraph on the side that corresponds to the start of the text, based on the current paragraph direction. If unset, the value is inherited from the parent.
    indentStart :: (Core.Maybe Dimension),
    -- | Whether all lines of the paragraph should be laid out on the same page or column if possible. If unset, the value is inherited from the parent.
    keepLinesTogether :: (Core.Maybe Core.Bool),
    -- | Whether at least a part of this paragraph should be laid out on the same page or column as the next paragraph if possible. If unset, the value is inherited from the parent.
    keepWithNext :: (Core.Maybe Core.Bool),
    -- | The amount of space between lines, as a percentage of normal, where normal is represented as 100.0. If unset, the value is inherited from the parent.
    lineSpacing :: (Core.Maybe Core.Double),
    -- | The named style type of the paragraph. Since updating the named style type affects other properties within ParagraphStyle, the named style type is applied before the other properties are updated.
    namedStyleType :: (Core.Maybe ParagraphStyle_NamedStyleType),
    -- | Whether the current paragraph should always start at the beginning of a page. If unset, the value is inherited from the parent. Attempting to update page/break/before for paragraphs in unsupported regions, including Table, Header, Footer and Footnote, can result in an invalid document state that returns a 400 bad request error.
    pageBreakBefore :: (Core.Maybe Core.Bool),
    -- | The shading of the paragraph. If unset, the value is inherited from the parent.
    shading :: (Core.Maybe Shading),
    -- | The amount of extra space above the paragraph. If unset, the value is inherited from the parent.
    spaceAbove :: (Core.Maybe Dimension),
    -- | The amount of extra space below the paragraph. If unset, the value is inherited from the parent.
    spaceBelow :: (Core.Maybe Dimension),
    -- | The spacing mode for the paragraph.
    spacingMode :: (Core.Maybe ParagraphStyle_SpacingMode),
    -- | A list of the tab stops for this paragraph. The list of tab stops is not inherited. This property is read-only.
    tabStops :: (Core.Maybe [TabStop])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ParagraphStyle' with the minimum fields required to make a request.
newParagraphStyle ::
  ParagraphStyle
newParagraphStyle =
  ParagraphStyle
    { alignment = Core.Nothing,
      avoidWidowAndOrphan = Core.Nothing,
      borderBetween = Core.Nothing,
      borderBottom = Core.Nothing,
      borderLeft = Core.Nothing,
      borderRight = Core.Nothing,
      borderTop = Core.Nothing,
      direction = Core.Nothing,
      headingId = Core.Nothing,
      indentEnd = Core.Nothing,
      indentFirstLine = Core.Nothing,
      indentStart = Core.Nothing,
      keepLinesTogether = Core.Nothing,
      keepWithNext = Core.Nothing,
      lineSpacing = Core.Nothing,
      namedStyleType = Core.Nothing,
      pageBreakBefore = Core.Nothing,
      shading = Core.Nothing,
      spaceAbove = Core.Nothing,
      spaceBelow = Core.Nothing,
      spacingMode = Core.Nothing,
      tabStops = Core.Nothing
    }

instance Core.FromJSON ParagraphStyle where
  parseJSON =
    Core.withObject
      "ParagraphStyle"
      ( \o ->
          ParagraphStyle
            Core.<$> (o Core..:? "alignment")
            Core.<*> (o Core..:? "avoidWidowAndOrphan")
            Core.<*> (o Core..:? "borderBetween")
            Core.<*> (o Core..:? "borderBottom")
            Core.<*> (o Core..:? "borderLeft")
            Core.<*> (o Core..:? "borderRight")
            Core.<*> (o Core..:? "borderTop")
            Core.<*> (o Core..:? "direction")
            Core.<*> (o Core..:? "headingId")
            Core.<*> (o Core..:? "indentEnd")
            Core.<*> (o Core..:? "indentFirstLine")
            Core.<*> (o Core..:? "indentStart")
            Core.<*> (o Core..:? "keepLinesTogether")
            Core.<*> (o Core..:? "keepWithNext")
            Core.<*> (o Core..:? "lineSpacing")
            Core.<*> (o Core..:? "namedStyleType")
            Core.<*> (o Core..:? "pageBreakBefore")
            Core.<*> (o Core..:? "shading")
            Core.<*> (o Core..:? "spaceAbove")
            Core.<*> (o Core..:? "spaceBelow")
            Core.<*> (o Core..:? "spacingMode")
            Core.<*> (o Core..:? "tabStops")
      )

instance Core.ToJSON ParagraphStyle where
  toJSON ParagraphStyle {..} =
    Core.object
      ( Core.catMaybes
          [ ("alignment" Core..=) Core.<$> alignment,
            ("avoidWidowAndOrphan" Core..=) Core.<$> avoidWidowAndOrphan,
            ("borderBetween" Core..=) Core.<$> borderBetween,
            ("borderBottom" Core..=) Core.<$> borderBottom,
            ("borderLeft" Core..=) Core.<$> borderLeft,
            ("borderRight" Core..=) Core.<$> borderRight,
            ("borderTop" Core..=) Core.<$> borderTop,
            ("direction" Core..=) Core.<$> direction,
            ("headingId" Core..=) Core.<$> headingId,
            ("indentEnd" Core..=) Core.<$> indentEnd,
            ("indentFirstLine" Core..=) Core.<$> indentFirstLine,
            ("indentStart" Core..=) Core.<$> indentStart,
            ("keepLinesTogether" Core..=) Core.<$> keepLinesTogether,
            ("keepWithNext" Core..=) Core.<$> keepWithNext,
            ("lineSpacing" Core..=) Core.<$> lineSpacing,
            ("namedStyleType" Core..=) Core.<$> namedStyleType,
            ("pageBreakBefore" Core..=) Core.<$> pageBreakBefore,
            ("shading" Core..=) Core.<$> shading,
            ("spaceAbove" Core..=) Core.<$> spaceAbove,
            ("spaceBelow" Core..=) Core.<$> spaceBelow,
            ("spacingMode" Core..=) Core.<$> spacingMode,
            ("tabStops" Core..=) Core.<$> tabStops
          ]
      )

-- | A mask that indicates which of the fields on the base ParagraphStyle have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newParagraphStyleSuggestionState' smart constructor.
data ParagraphStyleSuggestionState = ParagraphStyleSuggestionState
  { -- | Indicates if there was a suggested change to alignment.
    alignmentSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to avoid/widow/and_orphan.
    avoidWidowAndOrphanSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to border_between.
    borderBetweenSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to border_bottom.
    borderBottomSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to border_left.
    borderLeftSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to border_right.
    borderRightSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to border_top.
    borderTopSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to direction.
    directionSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to heading_id.
    headingIdSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to indent_end.
    indentEndSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to indent/first/line.
    indentFirstLineSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to indent_start.
    indentStartSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to keep/lines/together.
    keepLinesTogetherSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to keep/with/next.
    keepWithNextSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to line_spacing.
    lineSpacingSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to named/style/type.
    namedStyleTypeSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to page/break/before.
    pageBreakBeforeSuggested :: (Core.Maybe Core.Bool),
    -- | A mask that indicates which of the fields in shading have been changed in this suggestion.
    shadingSuggestionState :: (Core.Maybe ShadingSuggestionState),
    -- | Indicates if there was a suggested change to space_above.
    spaceAboveSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to space_below.
    spaceBelowSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to spacing_mode.
    spacingModeSuggested :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ParagraphStyleSuggestionState' with the minimum fields required to make a request.
newParagraphStyleSuggestionState ::
  ParagraphStyleSuggestionState
newParagraphStyleSuggestionState =
  ParagraphStyleSuggestionState
    { alignmentSuggested = Core.Nothing,
      avoidWidowAndOrphanSuggested = Core.Nothing,
      borderBetweenSuggested = Core.Nothing,
      borderBottomSuggested = Core.Nothing,
      borderLeftSuggested = Core.Nothing,
      borderRightSuggested = Core.Nothing,
      borderTopSuggested = Core.Nothing,
      directionSuggested = Core.Nothing,
      headingIdSuggested = Core.Nothing,
      indentEndSuggested = Core.Nothing,
      indentFirstLineSuggested = Core.Nothing,
      indentStartSuggested = Core.Nothing,
      keepLinesTogetherSuggested = Core.Nothing,
      keepWithNextSuggested = Core.Nothing,
      lineSpacingSuggested = Core.Nothing,
      namedStyleTypeSuggested = Core.Nothing,
      pageBreakBeforeSuggested = Core.Nothing,
      shadingSuggestionState = Core.Nothing,
      spaceAboveSuggested = Core.Nothing,
      spaceBelowSuggested = Core.Nothing,
      spacingModeSuggested = Core.Nothing
    }

instance Core.FromJSON ParagraphStyleSuggestionState where
  parseJSON =
    Core.withObject
      "ParagraphStyleSuggestionState"
      ( \o ->
          ParagraphStyleSuggestionState
            Core.<$> (o Core..:? "alignmentSuggested")
            Core.<*> (o Core..:? "avoidWidowAndOrphanSuggested")
            Core.<*> (o Core..:? "borderBetweenSuggested")
            Core.<*> (o Core..:? "borderBottomSuggested")
            Core.<*> (o Core..:? "borderLeftSuggested")
            Core.<*> (o Core..:? "borderRightSuggested")
            Core.<*> (o Core..:? "borderTopSuggested")
            Core.<*> (o Core..:? "directionSuggested")
            Core.<*> (o Core..:? "headingIdSuggested")
            Core.<*> (o Core..:? "indentEndSuggested")
            Core.<*> (o Core..:? "indentFirstLineSuggested")
            Core.<*> (o Core..:? "indentStartSuggested")
            Core.<*> (o Core..:? "keepLinesTogetherSuggested")
            Core.<*> (o Core..:? "keepWithNextSuggested")
            Core.<*> (o Core..:? "lineSpacingSuggested")
            Core.<*> (o Core..:? "namedStyleTypeSuggested")
            Core.<*> (o Core..:? "pageBreakBeforeSuggested")
            Core.<*> (o Core..:? "shadingSuggestionState")
            Core.<*> (o Core..:? "spaceAboveSuggested")
            Core.<*> (o Core..:? "spaceBelowSuggested")
            Core.<*> (o Core..:? "spacingModeSuggested")
      )

instance Core.ToJSON ParagraphStyleSuggestionState where
  toJSON ParagraphStyleSuggestionState {..} =
    Core.object
      ( Core.catMaybes
          [ ("alignmentSuggested" Core..=) Core.<$> alignmentSuggested,
            ("avoidWidowAndOrphanSuggested" Core..=)
              Core.<$> avoidWidowAndOrphanSuggested,
            ("borderBetweenSuggested" Core..=) Core.<$> borderBetweenSuggested,
            ("borderBottomSuggested" Core..=) Core.<$> borderBottomSuggested,
            ("borderLeftSuggested" Core..=) Core.<$> borderLeftSuggested,
            ("borderRightSuggested" Core..=) Core.<$> borderRightSuggested,
            ("borderTopSuggested" Core..=) Core.<$> borderTopSuggested,
            ("directionSuggested" Core..=) Core.<$> directionSuggested,
            ("headingIdSuggested" Core..=) Core.<$> headingIdSuggested,
            ("indentEndSuggested" Core..=) Core.<$> indentEndSuggested,
            ("indentFirstLineSuggested" Core..=)
              Core.<$> indentFirstLineSuggested,
            ("indentStartSuggested" Core..=) Core.<$> indentStartSuggested,
            ("keepLinesTogetherSuggested" Core..=)
              Core.<$> keepLinesTogetherSuggested,
            ("keepWithNextSuggested" Core..=) Core.<$> keepWithNextSuggested,
            ("lineSpacingSuggested" Core..=) Core.<$> lineSpacingSuggested,
            ("namedStyleTypeSuggested" Core..=)
              Core.<$> namedStyleTypeSuggested,
            ("pageBreakBeforeSuggested" Core..=)
              Core.<$> pageBreakBeforeSuggested,
            ("shadingSuggestionState" Core..=) Core.<$> shadingSuggestionState,
            ("spaceAboveSuggested" Core..=) Core.<$> spaceAboveSuggested,
            ("spaceBelowSuggested" Core..=) Core.<$> spaceBelowSuggested,
            ("spacingModeSuggested" Core..=) Core.<$> spacingModeSuggested
          ]
      )

-- | A person or email address mentioned in a document. These mentions behave as a single, immutable element containing the person\'s name or email address.
--
-- /See:/ 'newPerson' smart constructor.
data Person = Person
  { -- | Output only. The unique ID of this link.
    personId :: (Core.Maybe Core.Text),
    -- | Output only. The properties of this Person. This field is always present.
    personProperties :: (Core.Maybe PersonProperties),
    -- | IDs for suggestions that remove this person link from the document. A Person might have multiple deletion IDs if, for example, multiple users suggest deleting it. If empty, then this person link isn\'t suggested for deletion.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | IDs for suggestions that insert this person link into the document. A Person might have multiple insertion IDs if it\'s a nested suggested change (a suggestion within a suggestion made by a different user, for example). If empty, then this person link isn\'t a suggested insertion.
    suggestedInsertionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested text style changes to this Person, keyed by suggestion ID.
    suggestedTextStyleChanges :: (Core.Maybe Person_SuggestedTextStyleChanges),
    -- | The text style of this Person.
    textStyle :: (Core.Maybe TextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Person' with the minimum fields required to make a request.
newPerson ::
  Person
newPerson =
  Person
    { personId = Core.Nothing,
      personProperties = Core.Nothing,
      suggestedDeletionIds = Core.Nothing,
      suggestedInsertionIds = Core.Nothing,
      suggestedTextStyleChanges = Core.Nothing,
      textStyle = Core.Nothing
    }

instance Core.FromJSON Person where
  parseJSON =
    Core.withObject
      "Person"
      ( \o ->
          Person
            Core.<$> (o Core..:? "personId")
            Core.<*> (o Core..:? "personProperties")
            Core.<*> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionIds")
            Core.<*> (o Core..:? "suggestedTextStyleChanges")
            Core.<*> (o Core..:? "textStyle")
      )

instance Core.ToJSON Person where
  toJSON Person {..} =
    Core.object
      ( Core.catMaybes
          [ ("personId" Core..=) Core.<$> personId,
            ("personProperties" Core..=) Core.<$> personProperties,
            ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionIds" Core..=) Core.<$> suggestedInsertionIds,
            ("suggestedTextStyleChanges" Core..=)
              Core.<$> suggestedTextStyleChanges,
            ("textStyle" Core..=) Core.<$> textStyle
          ]
      )

-- | The suggested text style changes to this Person, keyed by suggestion ID.
--
-- /See:/ 'newPerson_SuggestedTextStyleChanges' smart constructor.
newtype Person_SuggestedTextStyleChanges = Person_SuggestedTextStyleChanges
  { additional :: (Core.HashMap Core.Text SuggestedTextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Person_SuggestedTextStyleChanges' with the minimum fields required to make a request.
newPerson_SuggestedTextStyleChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedTextStyle ->
  Person_SuggestedTextStyleChanges
newPerson_SuggestedTextStyleChanges additional =
  Person_SuggestedTextStyleChanges {additional = additional}

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

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

-- | Properties specific to a linked Person.
--
-- /See:/ 'newPersonProperties' smart constructor.
data PersonProperties = PersonProperties
  { -- | Output only. The email address linked to this Person. This field is always present.
    email :: (Core.Maybe Core.Text),
    -- | Output only. The name of the person if it\'s displayed in the link text instead of the person\'s email address.
    name :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Updates the number of pinned table header rows in a table.
--
-- /See:/ 'newPinTableHeaderRowsRequest' smart constructor.
data PinTableHeaderRowsRequest = PinTableHeaderRowsRequest
  { -- | The number of table rows to pin, where 0 implies that all rows are unpinned.
    pinnedHeaderRowsCount :: (Core.Maybe Core.Int32),
    -- | The location where the table starts in the document.
    tableStartLocation :: (Core.Maybe Location)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'PinTableHeaderRowsRequest' with the minimum fields required to make a request.
newPinTableHeaderRowsRequest ::
  PinTableHeaderRowsRequest
newPinTableHeaderRowsRequest =
  PinTableHeaderRowsRequest
    { pinnedHeaderRowsCount = Core.Nothing,
      tableStartLocation = Core.Nothing
    }

instance Core.FromJSON PinTableHeaderRowsRequest where
  parseJSON =
    Core.withObject
      "PinTableHeaderRowsRequest"
      ( \o ->
          PinTableHeaderRowsRequest
            Core.<$> (o Core..:? "pinnedHeaderRowsCount")
            Core.<*> (o Core..:? "tableStartLocation")
      )

instance Core.ToJSON PinTableHeaderRowsRequest where
  toJSON PinTableHeaderRowsRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("pinnedHeaderRowsCount" Core..=) Core.<$> pinnedHeaderRowsCount,
            ("tableStartLocation" Core..=) Core.<$> tableStartLocation
          ]
      )

-- | An object that\'s tethered to a Paragraph and positioned relative to the beginning of the paragraph. A PositionedObject contains an EmbeddedObject such as an image.
--
-- /See:/ 'newPositionedObject' smart constructor.
data PositionedObject = PositionedObject
  { -- | The ID of this positioned object.
    objectId :: (Core.Maybe Core.Text),
    -- | The properties of this positioned object.
    positionedObjectProperties :: (Core.Maybe PositionedObjectProperties),
    -- | The suggested deletion IDs. If empty, then there are no suggested deletions of this content.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested insertion ID. If empty, then this is not a suggested insertion.
    suggestedInsertionId :: (Core.Maybe Core.Text),
    -- | The suggested changes to the positioned object properties, keyed by suggestion ID.
    suggestedPositionedObjectPropertiesChanges ::
      ( Core.Maybe
          PositionedObject_SuggestedPositionedObjectPropertiesChanges
      )
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'PositionedObject' with the minimum fields required to make a request.
newPositionedObject ::
  PositionedObject
newPositionedObject =
  PositionedObject
    { objectId = Core.Nothing,
      positionedObjectProperties = Core.Nothing,
      suggestedDeletionIds = Core.Nothing,
      suggestedInsertionId = Core.Nothing,
      suggestedPositionedObjectPropertiesChanges = Core.Nothing
    }

instance Core.FromJSON PositionedObject where
  parseJSON =
    Core.withObject
      "PositionedObject"
      ( \o ->
          PositionedObject
            Core.<$> (o Core..:? "objectId")
            Core.<*> (o Core..:? "positionedObjectProperties")
            Core.<*> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionId")
            Core.<*> (o Core..:? "suggestedPositionedObjectPropertiesChanges")
      )

instance Core.ToJSON PositionedObject where
  toJSON PositionedObject {..} =
    Core.object
      ( Core.catMaybes
          [ ("objectId" Core..=) Core.<$> objectId,
            ("positionedObjectProperties" Core..=)
              Core.<$> positionedObjectProperties,
            ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionId" Core..=) Core.<$> suggestedInsertionId,
            ("suggestedPositionedObjectPropertiesChanges" Core..=)
              Core.<$> suggestedPositionedObjectPropertiesChanges
          ]
      )

-- | The suggested changes to the positioned object properties, keyed by suggestion ID.
--
-- /See:/ 'newPositionedObject_SuggestedPositionedObjectPropertiesChanges' smart constructor.
newtype PositionedObject_SuggestedPositionedObjectPropertiesChanges = PositionedObject_SuggestedPositionedObjectPropertiesChanges
  { additional :: (Core.HashMap Core.Text SuggestedPositionedObjectProperties)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'PositionedObject_SuggestedPositionedObjectPropertiesChanges' with the minimum fields required to make a request.
newPositionedObject_SuggestedPositionedObjectPropertiesChanges ::
  -- |  See 'additional'.
  Core.HashMap
    Core.Text
    SuggestedPositionedObjectProperties ->
  PositionedObject_SuggestedPositionedObjectPropertiesChanges
newPositionedObject_SuggestedPositionedObjectPropertiesChanges
  additional =
    PositionedObject_SuggestedPositionedObjectPropertiesChanges
      { additional =
          additional
      }

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

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

-- | The positioning of a PositionedObject. The positioned object is positioned relative to the beginning of the Paragraph it\'s tethered to.
--
-- /See:/ 'newPositionedObjectPositioning' smart constructor.
data PositionedObjectPositioning = PositionedObjectPositioning
  { -- | The layout of this positioned object.
    layout :: (Core.Maybe PositionedObjectPositioning_Layout),
    -- | The offset of the left edge of the positioned object relative to the beginning of the Paragraph it\'s tethered to. The exact positioning of the object can depend on other content in the document and the document\'s styling.
    leftOffset :: (Core.Maybe Dimension),
    -- | The offset of the top edge of the positioned object relative to the beginning of the Paragraph it\'s tethered to. The exact positioning of the object can depend on other content in the document and the document\'s styling.
    topOffset :: (Core.Maybe Dimension)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'PositionedObjectPositioning' with the minimum fields required to make a request.
newPositionedObjectPositioning ::
  PositionedObjectPositioning
newPositionedObjectPositioning =
  PositionedObjectPositioning
    { layout = Core.Nothing,
      leftOffset = Core.Nothing,
      topOffset = Core.Nothing
    }

instance Core.FromJSON PositionedObjectPositioning where
  parseJSON =
    Core.withObject
      "PositionedObjectPositioning"
      ( \o ->
          PositionedObjectPositioning
            Core.<$> (o Core..:? "layout")
            Core.<*> (o Core..:? "leftOffset")
            Core.<*> (o Core..:? "topOffset")
      )

instance Core.ToJSON PositionedObjectPositioning where
  toJSON PositionedObjectPositioning {..} =
    Core.object
      ( Core.catMaybes
          [ ("layout" Core..=) Core.<$> layout,
            ("leftOffset" Core..=) Core.<$> leftOffset,
            ("topOffset" Core..=) Core.<$> topOffset
          ]
      )

-- | A mask that indicates which of the fields on the base PositionedObjectPositioning have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newPositionedObjectPositioningSuggestionState' smart constructor.
data PositionedObjectPositioningSuggestionState = PositionedObjectPositioningSuggestionState
  { -- | Indicates if there was a suggested change to layout.
    layoutSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to left_offset.
    leftOffsetSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to top_offset.
    topOffsetSuggested :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'PositionedObjectPositioningSuggestionState' with the minimum fields required to make a request.
newPositionedObjectPositioningSuggestionState ::
  PositionedObjectPositioningSuggestionState
newPositionedObjectPositioningSuggestionState =
  PositionedObjectPositioningSuggestionState
    { layoutSuggested =
        Core.Nothing,
      leftOffsetSuggested = Core.Nothing,
      topOffsetSuggested = Core.Nothing
    }

instance Core.FromJSON PositionedObjectPositioningSuggestionState where
  parseJSON =
    Core.withObject
      "PositionedObjectPositioningSuggestionState"
      ( \o ->
          PositionedObjectPositioningSuggestionState
            Core.<$> (o Core..:? "layoutSuggested")
            Core.<*> (o Core..:? "leftOffsetSuggested")
            Core.<*> (o Core..:? "topOffsetSuggested")
      )

instance Core.ToJSON PositionedObjectPositioningSuggestionState where
  toJSON PositionedObjectPositioningSuggestionState {..} =
    Core.object
      ( Core.catMaybes
          [ ("layoutSuggested" Core..=) Core.<$> layoutSuggested,
            ("leftOffsetSuggested" Core..=) Core.<$> leftOffsetSuggested,
            ("topOffsetSuggested" Core..=) Core.<$> topOffsetSuggested
          ]
      )

-- | Properties of a PositionedObject.
--
-- /See:/ 'newPositionedObjectProperties' smart constructor.
data PositionedObjectProperties = PositionedObjectProperties
  { -- | The embedded object of this positioned object.
    embeddedObject :: (Core.Maybe EmbeddedObject),
    -- | The positioning of this positioned object relative to the newline of the Paragraph that references this positioned object.
    positioning :: (Core.Maybe PositionedObjectPositioning)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'PositionedObjectProperties' with the minimum fields required to make a request.
newPositionedObjectProperties ::
  PositionedObjectProperties
newPositionedObjectProperties =
  PositionedObjectProperties
    { embeddedObject = Core.Nothing,
      positioning = Core.Nothing
    }

instance Core.FromJSON PositionedObjectProperties where
  parseJSON =
    Core.withObject
      "PositionedObjectProperties"
      ( \o ->
          PositionedObjectProperties
            Core.<$> (o Core..:? "embeddedObject")
            Core.<*> (o Core..:? "positioning")
      )

instance Core.ToJSON PositionedObjectProperties where
  toJSON PositionedObjectProperties {..} =
    Core.object
      ( Core.catMaybes
          [ ("embeddedObject" Core..=) Core.<$> embeddedObject,
            ("positioning" Core..=) Core.<$> positioning
          ]
      )

-- | A mask that indicates which of the fields on the base PositionedObjectProperties have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newPositionedObjectPropertiesSuggestionState' smart constructor.
data PositionedObjectPropertiesSuggestionState = PositionedObjectPropertiesSuggestionState
  { -- | A mask that indicates which of the fields in embedded_object have been changed in this suggestion.
    embeddedObjectSuggestionState :: (Core.Maybe EmbeddedObjectSuggestionState),
    -- | A mask that indicates which of the fields in positioning have been changed in this suggestion.
    positioningSuggestionState :: (Core.Maybe PositionedObjectPositioningSuggestionState)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'PositionedObjectPropertiesSuggestionState' with the minimum fields required to make a request.
newPositionedObjectPropertiesSuggestionState ::
  PositionedObjectPropertiesSuggestionState
newPositionedObjectPropertiesSuggestionState =
  PositionedObjectPropertiesSuggestionState
    { embeddedObjectSuggestionState =
        Core.Nothing,
      positioningSuggestionState = Core.Nothing
    }

instance Core.FromJSON PositionedObjectPropertiesSuggestionState where
  parseJSON =
    Core.withObject
      "PositionedObjectPropertiesSuggestionState"
      ( \o ->
          PositionedObjectPropertiesSuggestionState
            Core.<$> (o Core..:? "embeddedObjectSuggestionState")
            Core.<*> (o Core..:? "positioningSuggestionState")
      )

instance Core.ToJSON PositionedObjectPropertiesSuggestionState where
  toJSON PositionedObjectPropertiesSuggestionState {..} =
    Core.object
      ( Core.catMaybes
          [ ("embeddedObjectSuggestionState" Core..=)
              Core.<$> embeddedObjectSuggestionState,
            ("positioningSuggestionState" Core..=)
              Core.<$> positioningSuggestionState
          ]
      )

-- | Specifies a contiguous range of text.
--
-- /See:/ 'newRange' smart constructor.
data Range = Range
  { -- | The zero-based end index of this range, exclusive, in UTF-16 code units. In all current uses, an end index must be provided. This field is an Int32Value in order to accommodate future use cases with open-ended ranges.
    endIndex :: (Core.Maybe Core.Int32),
    -- | The ID of the header, footer, or footnote that this range is contained in. An empty segment ID signifies the document\'s body.
    segmentId :: (Core.Maybe Core.Text),
    -- | The zero-based start index of this range, in UTF-16 code units. In all current uses, a start index must be provided. This field is an Int32Value in order to accommodate future use cases with open-ended ranges.
    startIndex :: (Core.Maybe Core.Int32),
    -- | The tab that contains this range. When omitted, the request applies to the first tab. In a document containing a single tab: - If provided, must match the singular tab\'s ID. - If omitted, the request applies to the singular tab. In a document containing multiple tabs: - If provided, the request applies to the specified tab. - If omitted, the request applies to the first tab in the document.
    tabId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Range' with the minimum fields required to make a request.
newRange ::
  Range
newRange =
  Range
    { endIndex = Core.Nothing,
      segmentId = Core.Nothing,
      startIndex = Core.Nothing,
      tabId = Core.Nothing
    }

instance Core.FromJSON Range where
  parseJSON =
    Core.withObject
      "Range"
      ( \o ->
          Range
            Core.<$> (o Core..:? "endIndex")
            Core.<*> (o Core..:? "segmentId")
            Core.<*> (o Core..:? "startIndex")
            Core.<*> (o Core..:? "tabId")
      )

instance Core.ToJSON Range where
  toJSON Range {..} =
    Core.object
      ( Core.catMaybes
          [ ("endIndex" Core..=) Core.<$> endIndex,
            ("segmentId" Core..=) Core.<$> segmentId,
            ("startIndex" Core..=) Core.<$> startIndex,
            ("tabId" Core..=) Core.<$> tabId
          ]
      )

-- | Replaces all instances of text matching a criteria with replace text.
--
-- /See:/ 'newReplaceAllTextRequest' smart constructor.
data ReplaceAllTextRequest = ReplaceAllTextRequest
  { -- | Finds text in the document matching this substring.
    containsText :: (Core.Maybe SubstringMatchCriteria),
    -- | The text that will replace the matched text.
    replaceText :: (Core.Maybe Core.Text),
    -- | Optional. The criteria used to specify in which tabs the replacement occurs. When omitted, the replacement applies to all tabs. In a document containing a single tab: - If provided, must match the singular tab\'s ID. - If omitted, the replacement applies to the singular tab. In a document containing multiple tabs: - If provided, the replacement applies to the specified tabs. - If omitted, the replacement applies to all tabs.
    tabsCriteria :: (Core.Maybe TabsCriteria)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ReplaceAllTextRequest' with the minimum fields required to make a request.
newReplaceAllTextRequest ::
  ReplaceAllTextRequest
newReplaceAllTextRequest =
  ReplaceAllTextRequest
    { containsText = Core.Nothing,
      replaceText = Core.Nothing,
      tabsCriteria = Core.Nothing
    }

instance Core.FromJSON ReplaceAllTextRequest where
  parseJSON =
    Core.withObject
      "ReplaceAllTextRequest"
      ( \o ->
          ReplaceAllTextRequest
            Core.<$> (o Core..:? "containsText")
            Core.<*> (o Core..:? "replaceText")
            Core.<*> (o Core..:? "tabsCriteria")
      )

instance Core.ToJSON ReplaceAllTextRequest where
  toJSON ReplaceAllTextRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("containsText" Core..=) Core.<$> containsText,
            ("replaceText" Core..=) Core.<$> replaceText,
            ("tabsCriteria" Core..=) Core.<$> tabsCriteria
          ]
      )

-- | The result of replacing text.
--
-- /See:/ 'newReplaceAllTextResponse' smart constructor.
newtype ReplaceAllTextResponse = ReplaceAllTextResponse
  { -- | The number of occurrences changed by replacing all text.
    occurrencesChanged :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Replaces an existing image with a new image. Replacing an image removes some image effects from the existing image in order to mirror the behavior of the Docs editor.
--
-- /See:/ 'newReplaceImageRequest' smart constructor.
data ReplaceImageRequest = ReplaceImageRequest
  { -- | The ID of the existing image that will be replaced. The ID can be retrieved from the response of a get request.
    imageObjectId :: (Core.Maybe Core.Text),
    -- | The replacement method.
    imageReplaceMethod :: (Core.Maybe ReplaceImageRequest_ImageReplaceMethod),
    -- | The tab that the image to be replaced is in. When omitted, the request is applied to the first tab. In a document containing a single tab: - If provided, must match the singular tab\'s ID. - If omitted, the request applies to the singular tab. In a document containing multiple tabs: - If provided, the request applies to the specified tab. - If omitted, the request applies to the first tab in the document.
    tabId :: (Core.Maybe Core.Text),
    -- | The URI of the new image. The image is fetched once at insertion time and a copy is stored for display inside the document. Images must be less than 50MB, cannot exceed 25 megapixels, and must be in PNG, JPEG, or GIF format. The provided URI can\'t surpass 2 KB in length. The URI is saved with the image, and exposed through the ImageProperties.source_uri field.
    uri :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ReplaceImageRequest' with the minimum fields required to make a request.
newReplaceImageRequest ::
  ReplaceImageRequest
newReplaceImageRequest =
  ReplaceImageRequest
    { imageObjectId = Core.Nothing,
      imageReplaceMethod = Core.Nothing,
      tabId = Core.Nothing,
      uri = Core.Nothing
    }

instance Core.FromJSON ReplaceImageRequest where
  parseJSON =
    Core.withObject
      "ReplaceImageRequest"
      ( \o ->
          ReplaceImageRequest
            Core.<$> (o Core..:? "imageObjectId")
            Core.<*> (o Core..:? "imageReplaceMethod")
            Core.<*> (o Core..:? "tabId")
            Core.<*> (o Core..:? "uri")
      )

instance Core.ToJSON ReplaceImageRequest where
  toJSON ReplaceImageRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("imageObjectId" Core..=) Core.<$> imageObjectId,
            ("imageReplaceMethod" Core..=) Core.<$> imageReplaceMethod,
            ("tabId" Core..=) Core.<$> tabId,
            ("uri" Core..=) Core.<$> uri
          ]
      )

-- | Replaces the contents of the specified NamedRange or NamedRanges with the given replacement content. Note that an individual NamedRange may consist of multiple discontinuous ranges. In this case, only the content in the first range will be replaced. The other ranges and their content will be deleted. In cases where replacing or deleting any ranges would result in an invalid document structure, a 400 bad request error is returned.
--
-- /See:/ 'newReplaceNamedRangeContentRequest' smart constructor.
data ReplaceNamedRangeContentRequest = ReplaceNamedRangeContentRequest
  { -- | The ID of the named range whose content will be replaced. If there is no named range with the given ID a 400 bad request error is returned.
    namedRangeId :: (Core.Maybe Core.Text),
    -- | The name of the NamedRanges whose content will be replaced. If there are multiple named ranges with the given name, then the content of each one will be replaced. If there are no named ranges with the given name, then the request will be a no-op.
    namedRangeName :: (Core.Maybe Core.Text),
    -- | Optional. The criteria used to specify in which tabs the replacement occurs. When omitted, the replacement applies to all tabs. In a document containing a single tab: - If provided, must match the singular tab\'s ID. - If omitted, the replacement applies to the singular tab. In a document containing multiple tabs: - If provided, the replacement applies to the specified tabs. - If omitted, the replacement applies to all tabs.
    tabsCriteria :: (Core.Maybe TabsCriteria),
    -- | Replaces the content of the specified named range(s) with the given text.
    text :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ReplaceNamedRangeContentRequest' with the minimum fields required to make a request.
newReplaceNamedRangeContentRequest ::
  ReplaceNamedRangeContentRequest
newReplaceNamedRangeContentRequest =
  ReplaceNamedRangeContentRequest
    { namedRangeId = Core.Nothing,
      namedRangeName = Core.Nothing,
      tabsCriteria = Core.Nothing,
      text = Core.Nothing
    }

instance Core.FromJSON ReplaceNamedRangeContentRequest where
  parseJSON =
    Core.withObject
      "ReplaceNamedRangeContentRequest"
      ( \o ->
          ReplaceNamedRangeContentRequest
            Core.<$> (o Core..:? "namedRangeId")
            Core.<*> (o Core..:? "namedRangeName")
            Core.<*> (o Core..:? "tabsCriteria")
            Core.<*> (o Core..:? "text")
      )

instance Core.ToJSON ReplaceNamedRangeContentRequest where
  toJSON ReplaceNamedRangeContentRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("namedRangeId" Core..=) Core.<$> namedRangeId,
            ("namedRangeName" Core..=) Core.<$> namedRangeName,
            ("tabsCriteria" Core..=) Core.<$> tabsCriteria,
            ("text" Core..=) Core.<$> text
          ]
      )

-- | A single update to apply to a document.
--
-- /See:/ 'newRequest' smart constructor.
data Request' = Request'
  { -- | Creates a footer.
    createFooter :: (Core.Maybe CreateFooterRequest),
    -- | Creates a footnote.
    createFootnote :: (Core.Maybe CreateFootnoteRequest),
    -- | Creates a header.
    createHeader :: (Core.Maybe CreateHeaderRequest),
    -- | Creates a named range.
    createNamedRange :: (Core.Maybe CreateNamedRangeRequest),
    -- | Creates bullets for paragraphs.
    createParagraphBullets :: (Core.Maybe CreateParagraphBulletsRequest),
    -- | Deletes content from the document.
    deleteContentRange :: (Core.Maybe DeleteContentRangeRequest),
    -- | Deletes a footer from the document.
    deleteFooter :: (Core.Maybe DeleteFooterRequest),
    -- | Deletes a header from the document.
    deleteHeader :: (Core.Maybe DeleteHeaderRequest),
    -- | Deletes a named range.
    deleteNamedRange :: (Core.Maybe DeleteNamedRangeRequest),
    -- | Deletes bullets from paragraphs.
    deleteParagraphBullets :: (Core.Maybe DeleteParagraphBulletsRequest),
    -- | Deletes a positioned object from the document.
    deletePositionedObject :: (Core.Maybe DeletePositionedObjectRequest),
    -- | Deletes a column from a table.
    deleteTableColumn :: (Core.Maybe DeleteTableColumnRequest),
    -- | Deletes a row from a table.
    deleteTableRow :: (Core.Maybe DeleteTableRowRequest),
    -- | Inserts an inline image at the specified location.
    insertInlineImage :: (Core.Maybe InsertInlineImageRequest),
    -- | Inserts a page break at the specified location.
    insertPageBreak :: (Core.Maybe InsertPageBreakRequest),
    -- | Inserts a section break at the specified location.
    insertSectionBreak :: (Core.Maybe InsertSectionBreakRequest),
    -- | Inserts a table at the specified location.
    insertTable :: (Core.Maybe InsertTableRequest),
    -- | Inserts an empty column into a table.
    insertTableColumn :: (Core.Maybe InsertTableColumnRequest),
    -- | Inserts an empty row into a table.
    insertTableRow :: (Core.Maybe InsertTableRowRequest),
    -- | Inserts text at the specified location.
    insertText :: (Core.Maybe InsertTextRequest),
    -- | Merges cells in a table.
    mergeTableCells :: (Core.Maybe MergeTableCellsRequest),
    -- | Updates the number of pinned header rows in a table.
    pinTableHeaderRows :: (Core.Maybe PinTableHeaderRowsRequest),
    -- | Replaces all instances of the specified text.
    replaceAllText :: (Core.Maybe ReplaceAllTextRequest),
    -- | Replaces an image in the document.
    replaceImage :: (Core.Maybe ReplaceImageRequest),
    -- | Replaces the content in a named range.
    replaceNamedRangeContent :: (Core.Maybe ReplaceNamedRangeContentRequest),
    -- | Unmerges cells in a table.
    unmergeTableCells :: (Core.Maybe UnmergeTableCellsRequest),
    -- | Updates the style of the document.
    updateDocumentStyle :: (Core.Maybe UpdateDocumentStyleRequest),
    -- | Updates the paragraph style at the specified range.
    updateParagraphStyle :: (Core.Maybe UpdateParagraphStyleRequest),
    -- | Updates the section style of the specified range.
    updateSectionStyle :: (Core.Maybe UpdateSectionStyleRequest),
    -- | Updates the style of table cells.
    updateTableCellStyle :: (Core.Maybe UpdateTableCellStyleRequest),
    -- | Updates the properties of columns in a table.
    updateTableColumnProperties :: (Core.Maybe UpdateTableColumnPropertiesRequest),
    -- | Updates the row style in a table.
    updateTableRowStyle :: (Core.Maybe UpdateTableRowStyleRequest),
    -- | Updates the text style at the specified range.
    updateTextStyle :: (Core.Maybe UpdateTextStyleRequest)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Request' with the minimum fields required to make a request.
newRequest ::
  Request'
newRequest =
  Request'
    { createFooter = Core.Nothing,
      createFootnote = Core.Nothing,
      createHeader = Core.Nothing,
      createNamedRange = Core.Nothing,
      createParagraphBullets = Core.Nothing,
      deleteContentRange = Core.Nothing,
      deleteFooter = Core.Nothing,
      deleteHeader = Core.Nothing,
      deleteNamedRange = Core.Nothing,
      deleteParagraphBullets = Core.Nothing,
      deletePositionedObject = Core.Nothing,
      deleteTableColumn = Core.Nothing,
      deleteTableRow = Core.Nothing,
      insertInlineImage = Core.Nothing,
      insertPageBreak = Core.Nothing,
      insertSectionBreak = Core.Nothing,
      insertTable = Core.Nothing,
      insertTableColumn = Core.Nothing,
      insertTableRow = Core.Nothing,
      insertText = Core.Nothing,
      mergeTableCells = Core.Nothing,
      pinTableHeaderRows = Core.Nothing,
      replaceAllText = Core.Nothing,
      replaceImage = Core.Nothing,
      replaceNamedRangeContent = Core.Nothing,
      unmergeTableCells = Core.Nothing,
      updateDocumentStyle = Core.Nothing,
      updateParagraphStyle = Core.Nothing,
      updateSectionStyle = Core.Nothing,
      updateTableCellStyle = Core.Nothing,
      updateTableColumnProperties = Core.Nothing,
      updateTableRowStyle = Core.Nothing,
      updateTextStyle = Core.Nothing
    }

instance Core.FromJSON Request' where
  parseJSON =
    Core.withObject
      "Request'"
      ( \o ->
          Request'
            Core.<$> (o Core..:? "createFooter")
            Core.<*> (o Core..:? "createFootnote")
            Core.<*> (o Core..:? "createHeader")
            Core.<*> (o Core..:? "createNamedRange")
            Core.<*> (o Core..:? "createParagraphBullets")
            Core.<*> (o Core..:? "deleteContentRange")
            Core.<*> (o Core..:? "deleteFooter")
            Core.<*> (o Core..:? "deleteHeader")
            Core.<*> (o Core..:? "deleteNamedRange")
            Core.<*> (o Core..:? "deleteParagraphBullets")
            Core.<*> (o Core..:? "deletePositionedObject")
            Core.<*> (o Core..:? "deleteTableColumn")
            Core.<*> (o Core..:? "deleteTableRow")
            Core.<*> (o Core..:? "insertInlineImage")
            Core.<*> (o Core..:? "insertPageBreak")
            Core.<*> (o Core..:? "insertSectionBreak")
            Core.<*> (o Core..:? "insertTable")
            Core.<*> (o Core..:? "insertTableColumn")
            Core.<*> (o Core..:? "insertTableRow")
            Core.<*> (o Core..:? "insertText")
            Core.<*> (o Core..:? "mergeTableCells")
            Core.<*> (o Core..:? "pinTableHeaderRows")
            Core.<*> (o Core..:? "replaceAllText")
            Core.<*> (o Core..:? "replaceImage")
            Core.<*> (o Core..:? "replaceNamedRangeContent")
            Core.<*> (o Core..:? "unmergeTableCells")
            Core.<*> (o Core..:? "updateDocumentStyle")
            Core.<*> (o Core..:? "updateParagraphStyle")
            Core.<*> (o Core..:? "updateSectionStyle")
            Core.<*> (o Core..:? "updateTableCellStyle")
            Core.<*> (o Core..:? "updateTableColumnProperties")
            Core.<*> (o Core..:? "updateTableRowStyle")
            Core.<*> (o Core..:? "updateTextStyle")
      )

instance Core.ToJSON Request' where
  toJSON Request' {..} =
    Core.object
      ( Core.catMaybes
          [ ("createFooter" Core..=) Core.<$> createFooter,
            ("createFootnote" Core..=) Core.<$> createFootnote,
            ("createHeader" Core..=) Core.<$> createHeader,
            ("createNamedRange" Core..=) Core.<$> createNamedRange,
            ("createParagraphBullets" Core..=) Core.<$> createParagraphBullets,
            ("deleteContentRange" Core..=) Core.<$> deleteContentRange,
            ("deleteFooter" Core..=) Core.<$> deleteFooter,
            ("deleteHeader" Core..=) Core.<$> deleteHeader,
            ("deleteNamedRange" Core..=) Core.<$> deleteNamedRange,
            ("deleteParagraphBullets" Core..=) Core.<$> deleteParagraphBullets,
            ("deletePositionedObject" Core..=) Core.<$> deletePositionedObject,
            ("deleteTableColumn" Core..=) Core.<$> deleteTableColumn,
            ("deleteTableRow" Core..=) Core.<$> deleteTableRow,
            ("insertInlineImage" Core..=) Core.<$> insertInlineImage,
            ("insertPageBreak" Core..=) Core.<$> insertPageBreak,
            ("insertSectionBreak" Core..=) Core.<$> insertSectionBreak,
            ("insertTable" Core..=) Core.<$> insertTable,
            ("insertTableColumn" Core..=) Core.<$> insertTableColumn,
            ("insertTableRow" Core..=) Core.<$> insertTableRow,
            ("insertText" Core..=) Core.<$> insertText,
            ("mergeTableCells" Core..=) Core.<$> mergeTableCells,
            ("pinTableHeaderRows" Core..=) Core.<$> pinTableHeaderRows,
            ("replaceAllText" Core..=) Core.<$> replaceAllText,
            ("replaceImage" Core..=) Core.<$> replaceImage,
            ("replaceNamedRangeContent" Core..=)
              Core.<$> replaceNamedRangeContent,
            ("unmergeTableCells" Core..=) Core.<$> unmergeTableCells,
            ("updateDocumentStyle" Core..=) Core.<$> updateDocumentStyle,
            ("updateParagraphStyle" Core..=) Core.<$> updateParagraphStyle,
            ("updateSectionStyle" Core..=) Core.<$> updateSectionStyle,
            ("updateTableCellStyle" Core..=) Core.<$> updateTableCellStyle,
            ("updateTableColumnProperties" Core..=)
              Core.<$> updateTableColumnProperties,
            ("updateTableRowStyle" Core..=) Core.<$> updateTableRowStyle,
            ("updateTextStyle" Core..=) Core.<$> updateTextStyle
          ]
      )

-- | A single response from an update.
--
-- /See:/ 'newResponse' smart constructor.
data Response = Response
  { -- | The result of creating a footer.
    createFooter :: (Core.Maybe CreateFooterResponse),
    -- | The result of creating a footnote.
    createFootnote :: (Core.Maybe CreateFootnoteResponse),
    -- | The result of creating a header.
    createHeader :: (Core.Maybe CreateHeaderResponse),
    -- | The result of creating a named range.
    createNamedRange :: (Core.Maybe CreateNamedRangeResponse),
    -- | The result of inserting an inline image.
    insertInlineImage :: (Core.Maybe InsertInlineImageResponse),
    -- | The result of inserting an inline Google Sheets chart.
    insertInlineSheetsChart :: (Core.Maybe InsertInlineSheetsChartResponse),
    -- | The result of replacing text.
    replaceAllText :: (Core.Maybe ReplaceAllTextResponse)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Response' with the minimum fields required to make a request.
newResponse ::
  Response
newResponse =
  Response
    { createFooter = Core.Nothing,
      createFootnote = Core.Nothing,
      createHeader = Core.Nothing,
      createNamedRange = Core.Nothing,
      insertInlineImage = Core.Nothing,
      insertInlineSheetsChart = Core.Nothing,
      replaceAllText = Core.Nothing
    }

instance Core.FromJSON Response where
  parseJSON =
    Core.withObject
      "Response"
      ( \o ->
          Response
            Core.<$> (o Core..:? "createFooter")
            Core.<*> (o Core..:? "createFootnote")
            Core.<*> (o Core..:? "createHeader")
            Core.<*> (o Core..:? "createNamedRange")
            Core.<*> (o Core..:? "insertInlineImage")
            Core.<*> (o Core..:? "insertInlineSheetsChart")
            Core.<*> (o Core..:? "replaceAllText")
      )

instance Core.ToJSON Response where
  toJSON Response {..} =
    Core.object
      ( Core.catMaybes
          [ ("createFooter" Core..=) Core.<$> createFooter,
            ("createFootnote" Core..=) Core.<$> createFootnote,
            ("createHeader" Core..=) Core.<$> createHeader,
            ("createNamedRange" Core..=) Core.<$> createNamedRange,
            ("insertInlineImage" Core..=) Core.<$> insertInlineImage,
            ("insertInlineSheetsChart" Core..=)
              Core.<$> insertInlineSheetsChart,
            ("replaceAllText" Core..=) Core.<$> replaceAllText
          ]
      )

-- | An RGB color.
--
-- /See:/ 'newRgbColor' smart constructor.
data RgbColor = RgbColor
  { -- | The blue component of the color, from 0.0 to 1.0.
    blue :: (Core.Maybe Core.Double),
    -- | The green component of the color, from 0.0 to 1.0.
    green :: (Core.Maybe Core.Double),
    -- | The red component of the color, from 0.0 to 1.0.
    red :: (Core.Maybe Core.Double)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'RgbColor' with the minimum fields required to make a request.
newRgbColor ::
  RgbColor
newRgbColor =
  RgbColor
    { blue = Core.Nothing,
      green = Core.Nothing,
      red = Core.Nothing
    }

instance Core.FromJSON RgbColor where
  parseJSON =
    Core.withObject
      "RgbColor"
      ( \o ->
          RgbColor
            Core.<$> (o Core..:? "blue")
            Core.<*> (o Core..:? "green")
            Core.<*> (o Core..:? "red")
      )

instance Core.ToJSON RgbColor where
  toJSON RgbColor {..} =
    Core.object
      ( Core.catMaybes
          [ ("blue" Core..=) Core.<$> blue,
            ("green" Core..=) Core.<$> green,
            ("red" Core..=) Core.<$> red
          ]
      )

-- | A link to a Google resource (such as a file in Drive, a YouTube video, or a Calendar event).
--
-- /See:/ 'newRichLink' smart constructor.
data RichLink = RichLink
  { -- | Output only. The ID of this link.
    richLinkId :: (Core.Maybe Core.Text),
    -- | Output only. The properties of this RichLink. This field is always present.
    richLinkProperties :: (Core.Maybe RichLinkProperties),
    -- | IDs for suggestions that remove this link from the document. A RichLink might have multiple deletion IDs if, for example, multiple users suggest deleting it. If empty, then this person link isn\'t suggested for deletion.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | IDs for suggestions that insert this link into the document. A RichLink might have multiple insertion IDs if it\'s a nested suggested change (a suggestion within a suggestion made by a different user, for example). If empty, then this person link isn\'t a suggested insertion.
    suggestedInsertionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested text style changes to this RichLink, keyed by suggestion ID.
    suggestedTextStyleChanges :: (Core.Maybe RichLink_SuggestedTextStyleChanges),
    -- | The text style of this RichLink.
    textStyle :: (Core.Maybe TextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'RichLink' with the minimum fields required to make a request.
newRichLink ::
  RichLink
newRichLink =
  RichLink
    { richLinkId = Core.Nothing,
      richLinkProperties = Core.Nothing,
      suggestedDeletionIds = Core.Nothing,
      suggestedInsertionIds = Core.Nothing,
      suggestedTextStyleChanges = Core.Nothing,
      textStyle = Core.Nothing
    }

instance Core.FromJSON RichLink where
  parseJSON =
    Core.withObject
      "RichLink"
      ( \o ->
          RichLink
            Core.<$> (o Core..:? "richLinkId")
            Core.<*> (o Core..:? "richLinkProperties")
            Core.<*> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionIds")
            Core.<*> (o Core..:? "suggestedTextStyleChanges")
            Core.<*> (o Core..:? "textStyle")
      )

instance Core.ToJSON RichLink where
  toJSON RichLink {..} =
    Core.object
      ( Core.catMaybes
          [ ("richLinkId" Core..=) Core.<$> richLinkId,
            ("richLinkProperties" Core..=) Core.<$> richLinkProperties,
            ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionIds" Core..=) Core.<$> suggestedInsertionIds,
            ("suggestedTextStyleChanges" Core..=)
              Core.<$> suggestedTextStyleChanges,
            ("textStyle" Core..=) Core.<$> textStyle
          ]
      )

-- | The suggested text style changes to this RichLink, keyed by suggestion ID.
--
-- /See:/ 'newRichLink_SuggestedTextStyleChanges' smart constructor.
newtype RichLink_SuggestedTextStyleChanges = RichLink_SuggestedTextStyleChanges
  { additional :: (Core.HashMap Core.Text SuggestedTextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'RichLink_SuggestedTextStyleChanges' with the minimum fields required to make a request.
newRichLink_SuggestedTextStyleChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedTextStyle ->
  RichLink_SuggestedTextStyleChanges
newRichLink_SuggestedTextStyleChanges additional =
  RichLink_SuggestedTextStyleChanges {additional = additional}

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

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

-- | Properties specific to a RichLink.
--
-- /See:/ 'newRichLinkProperties' smart constructor.
data RichLinkProperties = RichLinkProperties
  { -- | Output only. The <https://developers.google.com/drive/api/v3/mime-types MIME type> of the RichLink, if there\'s one (for example, when it\'s a file in Drive).
    mimeType :: (Core.Maybe Core.Text),
    -- | Output only. The title of the RichLink as displayed in the link. This title matches the title of the linked resource at the time of the insertion or last update of the link. This field is always present.
    title :: (Core.Maybe Core.Text),
    -- | Output only. The URI to the RichLink. This is always present.
    uri :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'RichLinkProperties' with the minimum fields required to make a request.
newRichLinkProperties ::
  RichLinkProperties
newRichLinkProperties =
  RichLinkProperties
    { mimeType = Core.Nothing,
      title = Core.Nothing,
      uri = Core.Nothing
    }

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

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

-- | A StructuralElement representing a section break. A section is a range of content that has the same SectionStyle. A section break represents the start of a new section, and the section style applies to the section after the section break. The document body always begins with a section break.
--
-- /See:/ 'newSectionBreak' smart constructor.
data SectionBreak = SectionBreak
  { -- | The style of the section after this section break.
    sectionStyle :: (Core.Maybe SectionStyle),
    -- | The suggested deletion IDs. If empty, then there are no suggested deletions of this content.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested insertion IDs. A SectionBreak may have multiple insertion IDs if it\'s a nested suggested change. If empty, then this is not a suggested insertion.
    suggestedInsertionIds :: (Core.Maybe [Core.Text])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SectionBreak' with the minimum fields required to make a request.
newSectionBreak ::
  SectionBreak
newSectionBreak =
  SectionBreak
    { sectionStyle = Core.Nothing,
      suggestedDeletionIds = Core.Nothing,
      suggestedInsertionIds = Core.Nothing
    }

instance Core.FromJSON SectionBreak where
  parseJSON =
    Core.withObject
      "SectionBreak"
      ( \o ->
          SectionBreak
            Core.<$> (o Core..:? "sectionStyle")
            Core.<*> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionIds")
      )

instance Core.ToJSON SectionBreak where
  toJSON SectionBreak {..} =
    Core.object
      ( Core.catMaybes
          [ ("sectionStyle" Core..=) Core.<$> sectionStyle,
            ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionIds" Core..=) Core.<$> suggestedInsertionIds
          ]
      )

-- | Properties that apply to a section\'s column.
--
-- /See:/ 'newSectionColumnProperties' smart constructor.
data SectionColumnProperties = SectionColumnProperties
  { -- | The padding at the end of the column.
    paddingEnd :: (Core.Maybe Dimension),
    -- | Output only. The width of the column.
    width :: (Core.Maybe Dimension)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SectionColumnProperties' with the minimum fields required to make a request.
newSectionColumnProperties ::
  SectionColumnProperties
newSectionColumnProperties =
  SectionColumnProperties
    { paddingEnd = Core.Nothing,
      width = Core.Nothing
    }

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

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

-- | The styling that applies to a section.
--
-- /See:/ 'newSectionStyle' smart constructor.
data SectionStyle = SectionStyle
  { -- | The section\'s columns properties. If empty, the section contains one column with the default properties in the Docs editor. A section can be updated to have no more than 3 columns. When updating this property, setting a concrete value is required. Unsetting this property will result in a 400 bad request error.
    columnProperties :: (Core.Maybe [SectionColumnProperties]),
    -- | The style of column separators. This style can be set even when there\'s one column in the section. When updating this property, setting a concrete value is required. Unsetting this property results in a 400 bad request error.
    columnSeparatorStyle :: (Core.Maybe SectionStyle_ColumnSeparatorStyle),
    -- | The content direction of this section. If unset, the value defaults to LEFT/TO/RIGHT. When updating this property, setting a concrete value is required. Unsetting this property results in a 400 bad request error.
    contentDirection :: (Core.Maybe SectionStyle_ContentDirection),
    -- | The ID of the default footer. If unset, the value inherits from the previous SectionBreak\'s SectionStyle. If the value is unset in the first SectionBreak, it inherits from DocumentStyle\'s default/footer/id. This property is read-only.
    defaultFooterId :: (Core.Maybe Core.Text),
    -- | The ID of the default header. If unset, the value inherits from the previous SectionBreak\'s SectionStyle. If the value is unset in the first SectionBreak, it inherits from DocumentStyle\'s default/header/id. This property is read-only.
    defaultHeaderId :: (Core.Maybe Core.Text),
    -- | The ID of the footer used only for even pages. If the value of DocumentStyle\'s use/even/page/header/footer is true, this value is used for the footers on even pages in the section. If it is false, the footers on even pages use the default/footer/id. If unset, the value inherits from the previous SectionBreak\'s SectionStyle. If the value is unset in the first SectionBreak, it inherits from DocumentStyle\'s even/page/footer_id. This property is read-only.
    evenPageFooterId :: (Core.Maybe Core.Text),
    -- | The ID of the header used only for even pages. If the value of DocumentStyle\'s use/even/page/header/footer is true, this value is used for the headers on even pages in the section. If it is false, the headers on even pages use the default/header/id. If unset, the value inherits from the previous SectionBreak\'s SectionStyle. If the value is unset in the first SectionBreak, it inherits from DocumentStyle\'s even/page/header_id. This property is read-only.
    evenPageHeaderId :: (Core.Maybe Core.Text),
    -- | The ID of the footer used only for the first page of the section. If use/first/page/header/footer is true, this value is used for the footer on the first page of the section. If it\'s false, the footer on the first page of the section uses the default/footer/id. If unset, the value inherits from the previous SectionBreak\'s SectionStyle. If the value is unset in the first SectionBreak, it inherits from DocumentStyle\'s first/page/footer_id. This property is read-only.
    firstPageFooterId :: (Core.Maybe Core.Text),
    -- | The ID of the header used only for the first page of the section. If use/first/page/header/footer is true, this value is used for the header on the first page of the section. If it\'s false, the header on the first page of the section uses the default/header/id. If unset, the value inherits from the previous SectionBreak\'s SectionStyle. If the value is unset in the first SectionBreak, it inherits from DocumentStyle\'s first/page/header_id. This property is read-only.
    firstPageHeaderId :: (Core.Maybe Core.Text),
    -- | Optional. Indicates whether to flip the dimensions of DocumentStyle\'s page/size for this section, which allows changing the page orientation between portrait and landscape. If unset, the value inherits from DocumentStyle\'s flip/page_orientation. When updating this property, setting a concrete value is required. Unsetting this property results in a 400 bad request error.
    flipPageOrientation :: (Core.Maybe Core.Bool),
    -- | The bottom page margin of the section. If unset, the value defaults to margin_bottom from DocumentStyle. When updating this property, setting a concrete value is required. Unsetting this property results in a 400 bad request error.
    marginBottom :: (Core.Maybe Dimension),
    -- | The footer margin of the section. If unset, the value defaults to margin/footer from DocumentStyle. If updated, use/custom/header/footer/margins is set to true on DocumentStyle. The value of use/custom/header/footer_margins on DocumentStyle indicates if a footer margin is being respected for this section When updating this property, setting a concrete value is required. Unsetting this property results in a 400 bad request error.
    marginFooter :: (Core.Maybe Dimension),
    -- | The header margin of the section. If unset, the value defaults to margin/header from DocumentStyle. If updated, use/custom/header/footer/margins is set to true on DocumentStyle. The value of use/custom/header/footer_margins on DocumentStyle indicates if a header margin is being respected for this section. When updating this property, setting a concrete value is required. Unsetting this property results in a 400 bad request error.
    marginHeader :: (Core.Maybe Dimension),
    -- | The left page margin of the section. If unset, the value defaults to margin_left from DocumentStyle. Updating the left margin causes columns in this section to resize. Since the margin affects column width, it\'s applied before column properties. When updating this property, setting a concrete value is required. Unsetting this property results in a 400 bad request error.
    marginLeft :: (Core.Maybe Dimension),
    -- | The right page margin of the section. If unset, the value defaults to margin_right from DocumentStyle. Updating the right margin causes columns in this section to resize. Since the margin affects column width, it\'s applied before column properties. When updating this property, setting a concrete value is required. Unsetting this property results in a 400 bad request error.
    marginRight :: (Core.Maybe Dimension),
    -- | The top page margin of the section. If unset, the value defaults to margin_top from DocumentStyle. When updating this property, setting a concrete value is required. Unsetting this property results in a 400 bad request error.
    marginTop :: (Core.Maybe Dimension),
    -- | The page number from which to start counting the number of pages for this section. If unset, page numbering continues from the previous section. If the value is unset in the first SectionBreak, refer to DocumentStyle\'s page/number/start. When updating this property, setting a concrete value is required. Unsetting this property results in a 400 bad request error.
    pageNumberStart :: (Core.Maybe Core.Int32),
    -- | Output only. The type of section.
    sectionType :: (Core.Maybe SectionStyle_SectionType),
    -- | Indicates whether to use the first page header \/ footer IDs for the first page of the section. If unset, it inherits from DocumentStyle\'s use/first/page/header/footer for the first section. If the value is unset for subsequent sectors, it should be interpreted as false. When updating this property, setting a concrete value is required. Unsetting this property results in a 400 bad request error.
    useFirstPageHeaderFooter :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SectionStyle' with the minimum fields required to make a request.
newSectionStyle ::
  SectionStyle
newSectionStyle =
  SectionStyle
    { columnProperties = Core.Nothing,
      columnSeparatorStyle = Core.Nothing,
      contentDirection = Core.Nothing,
      defaultFooterId = Core.Nothing,
      defaultHeaderId = Core.Nothing,
      evenPageFooterId = Core.Nothing,
      evenPageHeaderId = Core.Nothing,
      firstPageFooterId = Core.Nothing,
      firstPageHeaderId = Core.Nothing,
      flipPageOrientation = Core.Nothing,
      marginBottom = Core.Nothing,
      marginFooter = Core.Nothing,
      marginHeader = Core.Nothing,
      marginLeft = Core.Nothing,
      marginRight = Core.Nothing,
      marginTop = Core.Nothing,
      pageNumberStart = Core.Nothing,
      sectionType = Core.Nothing,
      useFirstPageHeaderFooter = Core.Nothing
    }

instance Core.FromJSON SectionStyle where
  parseJSON =
    Core.withObject
      "SectionStyle"
      ( \o ->
          SectionStyle
            Core.<$> (o Core..:? "columnProperties")
            Core.<*> (o Core..:? "columnSeparatorStyle")
            Core.<*> (o Core..:? "contentDirection")
            Core.<*> (o Core..:? "defaultFooterId")
            Core.<*> (o Core..:? "defaultHeaderId")
            Core.<*> (o Core..:? "evenPageFooterId")
            Core.<*> (o Core..:? "evenPageHeaderId")
            Core.<*> (o Core..:? "firstPageFooterId")
            Core.<*> (o Core..:? "firstPageHeaderId")
            Core.<*> (o Core..:? "flipPageOrientation")
            Core.<*> (o Core..:? "marginBottom")
            Core.<*> (o Core..:? "marginFooter")
            Core.<*> (o Core..:? "marginHeader")
            Core.<*> (o Core..:? "marginLeft")
            Core.<*> (o Core..:? "marginRight")
            Core.<*> (o Core..:? "marginTop")
            Core.<*> (o Core..:? "pageNumberStart")
            Core.<*> (o Core..:? "sectionType")
            Core.<*> (o Core..:? "useFirstPageHeaderFooter")
      )

instance Core.ToJSON SectionStyle where
  toJSON SectionStyle {..} =
    Core.object
      ( Core.catMaybes
          [ ("columnProperties" Core..=) Core.<$> columnProperties,
            ("columnSeparatorStyle" Core..=) Core.<$> columnSeparatorStyle,
            ("contentDirection" Core..=) Core.<$> contentDirection,
            ("defaultFooterId" Core..=) Core.<$> defaultFooterId,
            ("defaultHeaderId" Core..=) Core.<$> defaultHeaderId,
            ("evenPageFooterId" Core..=) Core.<$> evenPageFooterId,
            ("evenPageHeaderId" Core..=) Core.<$> evenPageHeaderId,
            ("firstPageFooterId" Core..=) Core.<$> firstPageFooterId,
            ("firstPageHeaderId" Core..=) Core.<$> firstPageHeaderId,
            ("flipPageOrientation" Core..=) Core.<$> flipPageOrientation,
            ("marginBottom" Core..=) Core.<$> marginBottom,
            ("marginFooter" Core..=) Core.<$> marginFooter,
            ("marginHeader" Core..=) Core.<$> marginHeader,
            ("marginLeft" Core..=) Core.<$> marginLeft,
            ("marginRight" Core..=) Core.<$> marginRight,
            ("marginTop" Core..=) Core.<$> marginTop,
            ("pageNumberStart" Core..=) Core.<$> pageNumberStart,
            ("sectionType" Core..=) Core.<$> sectionType,
            ("useFirstPageHeaderFooter" Core..=)
              Core.<$> useFirstPageHeaderFooter
          ]
      )

-- | The shading of a paragraph.
--
-- /See:/ 'newShading' smart constructor.
newtype Shading = Shading
  { -- | The background color of this paragraph shading.
    backgroundColor :: (Core.Maybe OptionalColor)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A mask that indicates which of the fields on the base Shading have been changed in this suggested change. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newShadingSuggestionState' smart constructor.
newtype ShadingSuggestionState = ShadingSuggestionState
  { -- | Indicates if there was a suggested change to the Shading.
    backgroundColorSuggested :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A reference to a linked chart embedded from Google Sheets.
--
-- /See:/ 'newSheetsChartReference' smart constructor.
data SheetsChartReference = SheetsChartReference
  { -- | The ID of the specific chart in the Google Sheets spreadsheet that\'s embedded.
    chartId :: (Core.Maybe Core.Int32),
    -- | The ID of the Google Sheets spreadsheet that contains the source chart.
    spreadsheetId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SheetsChartReference' with the minimum fields required to make a request.
newSheetsChartReference ::
  SheetsChartReference
newSheetsChartReference =
  SheetsChartReference
    { chartId = Core.Nothing,
      spreadsheetId = Core.Nothing
    }

instance Core.FromJSON SheetsChartReference where
  parseJSON =
    Core.withObject
      "SheetsChartReference"
      ( \o ->
          SheetsChartReference
            Core.<$> (o Core..:? "chartId")
            Core.<*> (o Core..:? "spreadsheetId")
      )

instance Core.ToJSON SheetsChartReference where
  toJSON SheetsChartReference {..} =
    Core.object
      ( Core.catMaybes
          [ ("chartId" Core..=) Core.<$> chartId,
            ("spreadsheetId" Core..=) Core.<$> spreadsheetId
          ]
      )

-- | A mask that indicates which of the fields on the base SheetsChartReference have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newSheetsChartReferenceSuggestionState' smart constructor.
data SheetsChartReferenceSuggestionState = SheetsChartReferenceSuggestionState
  { -- | Indicates if there was a suggested change to chart_id.
    chartIdSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to spreadsheet_id.
    spreadsheetIdSuggested :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SheetsChartReferenceSuggestionState' with the minimum fields required to make a request.
newSheetsChartReferenceSuggestionState ::
  SheetsChartReferenceSuggestionState
newSheetsChartReferenceSuggestionState =
  SheetsChartReferenceSuggestionState
    { chartIdSuggested =
        Core.Nothing,
      spreadsheetIdSuggested = Core.Nothing
    }

instance Core.FromJSON SheetsChartReferenceSuggestionState where
  parseJSON =
    Core.withObject
      "SheetsChartReferenceSuggestionState"
      ( \o ->
          SheetsChartReferenceSuggestionState
            Core.<$> (o Core..:? "chartIdSuggested")
            Core.<*> (o Core..:? "spreadsheetIdSuggested")
      )

instance Core.ToJSON SheetsChartReferenceSuggestionState where
  toJSON SheetsChartReferenceSuggestionState {..} =
    Core.object
      ( Core.catMaybes
          [ ("chartIdSuggested" Core..=) Core.<$> chartIdSuggested,
            ("spreadsheetIdSuggested" Core..=)
              Core.<$> spreadsheetIdSuggested
          ]
      )

-- | A width and height.
--
-- /See:/ 'newSize' smart constructor.
data Size = Size
  { -- | The height of the object.
    height :: (Core.Maybe Dimension),
    -- | The width of the object.
    width :: (Core.Maybe Dimension)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A mask that indicates which of the fields on the base Size have been changed in this suggestion. For any field set to true, the Size has a new suggested value.
--
-- /See:/ 'newSizeSuggestionState' smart constructor.
data SizeSuggestionState = SizeSuggestionState
  { -- | Indicates if there was a suggested change to height.
    heightSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to width.
    widthSuggested :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SizeSuggestionState' with the minimum fields required to make a request.
newSizeSuggestionState ::
  SizeSuggestionState
newSizeSuggestionState =
  SizeSuggestionState
    { heightSuggested = Core.Nothing,
      widthSuggested = Core.Nothing
    }

instance Core.FromJSON SizeSuggestionState where
  parseJSON =
    Core.withObject
      "SizeSuggestionState"
      ( \o ->
          SizeSuggestionState
            Core.<$> (o Core..:? "heightSuggested")
            Core.<*> (o Core..:? "widthSuggested")
      )

instance Core.ToJSON SizeSuggestionState where
  toJSON SizeSuggestionState {..} =
    Core.object
      ( Core.catMaybes
          [ ("heightSuggested" Core..=) Core.<$> heightSuggested,
            ("widthSuggested" Core..=) Core.<$> widthSuggested
          ]
      )

-- | A StructuralElement describes content that provides structure to the document.
--
-- /See:/ 'newStructuralElement' smart constructor.
data StructuralElement = StructuralElement
  { -- | The zero-based end index of this structural element, exclusive, in UTF-16 code units.
    endIndex :: (Core.Maybe Core.Int32),
    -- | A paragraph type of structural element.
    paragraph :: (Core.Maybe Paragraph),
    -- | A section break type of structural element.
    sectionBreak :: (Core.Maybe SectionBreak),
    -- | The zero-based start index of this structural element, in UTF-16 code units.
    startIndex :: (Core.Maybe Core.Int32),
    -- | A table type of structural element.
    table :: (Core.Maybe Table),
    -- | A table of contents type of structural element.
    tableOfContents :: (Core.Maybe TableOfContents)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'StructuralElement' with the minimum fields required to make a request.
newStructuralElement ::
  StructuralElement
newStructuralElement =
  StructuralElement
    { endIndex = Core.Nothing,
      paragraph = Core.Nothing,
      sectionBreak = Core.Nothing,
      startIndex = Core.Nothing,
      table = Core.Nothing,
      tableOfContents = Core.Nothing
    }

instance Core.FromJSON StructuralElement where
  parseJSON =
    Core.withObject
      "StructuralElement"
      ( \o ->
          StructuralElement
            Core.<$> (o Core..:? "endIndex")
            Core.<*> (o Core..:? "paragraph")
            Core.<*> (o Core..:? "sectionBreak")
            Core.<*> (o Core..:? "startIndex")
            Core.<*> (o Core..:? "table")
            Core.<*> (o Core..:? "tableOfContents")
      )

instance Core.ToJSON StructuralElement where
  toJSON StructuralElement {..} =
    Core.object
      ( Core.catMaybes
          [ ("endIndex" Core..=) Core.<$> endIndex,
            ("paragraph" Core..=) Core.<$> paragraph,
            ("sectionBreak" Core..=) Core.<$> sectionBreak,
            ("startIndex" Core..=) Core.<$> startIndex,
            ("table" Core..=) Core.<$> table,
            ("tableOfContents" Core..=) Core.<$> tableOfContents
          ]
      )

-- | A criteria that matches a specific string of text in the document.
--
-- /See:/ 'newSubstringMatchCriteria' smart constructor.
data SubstringMatchCriteria = SubstringMatchCriteria
  { -- | Indicates whether the search should respect case: - @True@: the search is case sensitive. - @False@: the search is case insensitive.
    matchCase :: (Core.Maybe Core.Bool),
    -- | The text to search for in the document.
    text :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A suggested change to a Bullet.
--
-- /See:/ 'newSuggestedBullet' smart constructor.
data SuggestedBullet = SuggestedBullet
  { -- | A Bullet that only includes the changes made in this suggestion. This can be used along with the bullet/suggestion/state to see which fields have changed and their new values.
    bullet :: (Core.Maybe Bullet),
    -- | A mask that indicates which of the fields on the base Bullet have been changed in this suggestion.
    bulletSuggestionState :: (Core.Maybe BulletSuggestionState)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SuggestedBullet' with the minimum fields required to make a request.
newSuggestedBullet ::
  SuggestedBullet
newSuggestedBullet =
  SuggestedBullet
    { bullet = Core.Nothing,
      bulletSuggestionState = Core.Nothing
    }

instance Core.FromJSON SuggestedBullet where
  parseJSON =
    Core.withObject
      "SuggestedBullet"
      ( \o ->
          SuggestedBullet
            Core.<$> (o Core..:? "bullet")
            Core.<*> (o Core..:? "bulletSuggestionState")
      )

instance Core.ToJSON SuggestedBullet where
  toJSON SuggestedBullet {..} =
    Core.object
      ( Core.catMaybes
          [ ("bullet" Core..=) Core.<$> bullet,
            ("bulletSuggestionState" Core..=) Core.<$> bulletSuggestionState
          ]
      )

-- | A suggested change to the DocumentStyle.
--
-- /See:/ 'newSuggestedDocumentStyle' smart constructor.
data SuggestedDocumentStyle = SuggestedDocumentStyle
  { -- | A DocumentStyle that only includes the changes made in this suggestion. This can be used along with the document/style/suggestion_state to see which fields have changed and their new values.
    documentStyle :: (Core.Maybe DocumentStyle),
    -- | A mask that indicates which of the fields on the base DocumentStyle have been changed in this suggestion.
    documentStyleSuggestionState :: (Core.Maybe DocumentStyleSuggestionState)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SuggestedDocumentStyle' with the minimum fields required to make a request.
newSuggestedDocumentStyle ::
  SuggestedDocumentStyle
newSuggestedDocumentStyle =
  SuggestedDocumentStyle
    { documentStyle = Core.Nothing,
      documentStyleSuggestionState = Core.Nothing
    }

instance Core.FromJSON SuggestedDocumentStyle where
  parseJSON =
    Core.withObject
      "SuggestedDocumentStyle"
      ( \o ->
          SuggestedDocumentStyle
            Core.<$> (o Core..:? "documentStyle")
            Core.<*> (o Core..:? "documentStyleSuggestionState")
      )

instance Core.ToJSON SuggestedDocumentStyle where
  toJSON SuggestedDocumentStyle {..} =
    Core.object
      ( Core.catMaybes
          [ ("documentStyle" Core..=) Core.<$> documentStyle,
            ("documentStyleSuggestionState" Core..=)
              Core.<$> documentStyleSuggestionState
          ]
      )

-- | A suggested change to InlineObjectProperties.
--
-- /See:/ 'newSuggestedInlineObjectProperties' smart constructor.
data SuggestedInlineObjectProperties = SuggestedInlineObjectProperties
  { -- | An InlineObjectProperties that only includes the changes made in this suggestion. This can be used along with the inline/object/properties/suggestion/state to see which fields have changed and their new values.
    inlineObjectProperties :: (Core.Maybe InlineObjectProperties),
    -- | A mask that indicates which of the fields on the base InlineObjectProperties have been changed in this suggestion.
    inlineObjectPropertiesSuggestionState :: (Core.Maybe InlineObjectPropertiesSuggestionState)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SuggestedInlineObjectProperties' with the minimum fields required to make a request.
newSuggestedInlineObjectProperties ::
  SuggestedInlineObjectProperties
newSuggestedInlineObjectProperties =
  SuggestedInlineObjectProperties
    { inlineObjectProperties =
        Core.Nothing,
      inlineObjectPropertiesSuggestionState = Core.Nothing
    }

instance Core.FromJSON SuggestedInlineObjectProperties where
  parseJSON =
    Core.withObject
      "SuggestedInlineObjectProperties"
      ( \o ->
          SuggestedInlineObjectProperties
            Core.<$> (o Core..:? "inlineObjectProperties")
            Core.<*> (o Core..:? "inlineObjectPropertiesSuggestionState")
      )

instance Core.ToJSON SuggestedInlineObjectProperties where
  toJSON SuggestedInlineObjectProperties {..} =
    Core.object
      ( Core.catMaybes
          [ ("inlineObjectProperties" Core..=)
              Core.<$> inlineObjectProperties,
            ("inlineObjectPropertiesSuggestionState" Core..=)
              Core.<$> inlineObjectPropertiesSuggestionState
          ]
      )

-- | A suggested change to ListProperties.
--
-- /See:/ 'newSuggestedListProperties' smart constructor.
data SuggestedListProperties = SuggestedListProperties
  { -- | A ListProperties that only includes the changes made in this suggestion. This can be used along with the list/properties/suggestion_state to see which fields have changed and their new values.
    listProperties :: (Core.Maybe ListProperties),
    -- | A mask that indicates which of the fields on the base ListProperties have been changed in this suggestion.
    listPropertiesSuggestionState :: (Core.Maybe ListPropertiesSuggestionState)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SuggestedListProperties' with the minimum fields required to make a request.
newSuggestedListProperties ::
  SuggestedListProperties
newSuggestedListProperties =
  SuggestedListProperties
    { listProperties = Core.Nothing,
      listPropertiesSuggestionState = Core.Nothing
    }

instance Core.FromJSON SuggestedListProperties where
  parseJSON =
    Core.withObject
      "SuggestedListProperties"
      ( \o ->
          SuggestedListProperties
            Core.<$> (o Core..:? "listProperties")
            Core.<*> (o Core..:? "listPropertiesSuggestionState")
      )

instance Core.ToJSON SuggestedListProperties where
  toJSON SuggestedListProperties {..} =
    Core.object
      ( Core.catMaybes
          [ ("listProperties" Core..=) Core.<$> listProperties,
            ("listPropertiesSuggestionState" Core..=)
              Core.<$> listPropertiesSuggestionState
          ]
      )

-- | A suggested change to the NamedStyles.
--
-- /See:/ 'newSuggestedNamedStyles' smart constructor.
data SuggestedNamedStyles = SuggestedNamedStyles
  { -- | A NamedStyles that only includes the changes made in this suggestion. This can be used along with the named/styles/suggestion_state to see which fields have changed and their new values.
    namedStyles :: (Core.Maybe NamedStyles),
    -- | A mask that indicates which of the fields on the base NamedStyles have been changed in this suggestion.
    namedStylesSuggestionState :: (Core.Maybe NamedStylesSuggestionState)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SuggestedNamedStyles' with the minimum fields required to make a request.
newSuggestedNamedStyles ::
  SuggestedNamedStyles
newSuggestedNamedStyles =
  SuggestedNamedStyles
    { namedStyles = Core.Nothing,
      namedStylesSuggestionState = Core.Nothing
    }

instance Core.FromJSON SuggestedNamedStyles where
  parseJSON =
    Core.withObject
      "SuggestedNamedStyles"
      ( \o ->
          SuggestedNamedStyles
            Core.<$> (o Core..:? "namedStyles")
            Core.<*> (o Core..:? "namedStylesSuggestionState")
      )

instance Core.ToJSON SuggestedNamedStyles where
  toJSON SuggestedNamedStyles {..} =
    Core.object
      ( Core.catMaybes
          [ ("namedStyles" Core..=) Core.<$> namedStyles,
            ("namedStylesSuggestionState" Core..=)
              Core.<$> namedStylesSuggestionState
          ]
      )

-- | A suggested change to a ParagraphStyle.
--
-- /See:/ 'newSuggestedParagraphStyle' smart constructor.
data SuggestedParagraphStyle = SuggestedParagraphStyle
  { -- | A ParagraphStyle that only includes the changes made in this suggestion. This can be used along with the paragraph/style/suggestion_state to see which fields have changed and their new values.
    paragraphStyle :: (Core.Maybe ParagraphStyle),
    -- | A mask that indicates which of the fields on the base ParagraphStyle have been changed in this suggestion.
    paragraphStyleSuggestionState :: (Core.Maybe ParagraphStyleSuggestionState)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SuggestedParagraphStyle' with the minimum fields required to make a request.
newSuggestedParagraphStyle ::
  SuggestedParagraphStyle
newSuggestedParagraphStyle =
  SuggestedParagraphStyle
    { paragraphStyle = Core.Nothing,
      paragraphStyleSuggestionState = Core.Nothing
    }

instance Core.FromJSON SuggestedParagraphStyle where
  parseJSON =
    Core.withObject
      "SuggestedParagraphStyle"
      ( \o ->
          SuggestedParagraphStyle
            Core.<$> (o Core..:? "paragraphStyle")
            Core.<*> (o Core..:? "paragraphStyleSuggestionState")
      )

instance Core.ToJSON SuggestedParagraphStyle where
  toJSON SuggestedParagraphStyle {..} =
    Core.object
      ( Core.catMaybes
          [ ("paragraphStyle" Core..=) Core.<$> paragraphStyle,
            ("paragraphStyleSuggestionState" Core..=)
              Core.<$> paragraphStyleSuggestionState
          ]
      )

-- | A suggested change to PositionedObjectProperties.
--
-- /See:/ 'newSuggestedPositionedObjectProperties' smart constructor.
data SuggestedPositionedObjectProperties = SuggestedPositionedObjectProperties
  { -- | A PositionedObjectProperties that only includes the changes made in this suggestion. This can be used along with the positioned/object/properties/suggestion/state to see which fields have changed and their new values.
    positionedObjectProperties :: (Core.Maybe PositionedObjectProperties),
    -- | A mask that indicates which of the fields on the base PositionedObjectProperties have been changed in this suggestion.
    positionedObjectPropertiesSuggestionState :: (Core.Maybe PositionedObjectPropertiesSuggestionState)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SuggestedPositionedObjectProperties' with the minimum fields required to make a request.
newSuggestedPositionedObjectProperties ::
  SuggestedPositionedObjectProperties
newSuggestedPositionedObjectProperties =
  SuggestedPositionedObjectProperties
    { positionedObjectProperties =
        Core.Nothing,
      positionedObjectPropertiesSuggestionState = Core.Nothing
    }

instance Core.FromJSON SuggestedPositionedObjectProperties where
  parseJSON =
    Core.withObject
      "SuggestedPositionedObjectProperties"
      ( \o ->
          SuggestedPositionedObjectProperties
            Core.<$> (o Core..:? "positionedObjectProperties")
            Core.<*> (o Core..:? "positionedObjectPropertiesSuggestionState")
      )

instance Core.ToJSON SuggestedPositionedObjectProperties where
  toJSON SuggestedPositionedObjectProperties {..} =
    Core.object
      ( Core.catMaybes
          [ ("positionedObjectProperties" Core..=)
              Core.<$> positionedObjectProperties,
            ("positionedObjectPropertiesSuggestionState" Core..=)
              Core.<$> positionedObjectPropertiesSuggestionState
          ]
      )

-- | A suggested change to a TableCellStyle.
--
-- /See:/ 'newSuggestedTableCellStyle' smart constructor.
data SuggestedTableCellStyle = SuggestedTableCellStyle
  { -- | A TableCellStyle that only includes the changes made in this suggestion. This can be used along with the table/cell/style/suggestion/state to see which fields have changed and their new values.
    tableCellStyle :: (Core.Maybe TableCellStyle),
    -- | A mask that indicates which of the fields on the base TableCellStyle have been changed in this suggestion.
    tableCellStyleSuggestionState :: (Core.Maybe TableCellStyleSuggestionState)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SuggestedTableCellStyle' with the minimum fields required to make a request.
newSuggestedTableCellStyle ::
  SuggestedTableCellStyle
newSuggestedTableCellStyle =
  SuggestedTableCellStyle
    { tableCellStyle = Core.Nothing,
      tableCellStyleSuggestionState = Core.Nothing
    }

instance Core.FromJSON SuggestedTableCellStyle where
  parseJSON =
    Core.withObject
      "SuggestedTableCellStyle"
      ( \o ->
          SuggestedTableCellStyle
            Core.<$> (o Core..:? "tableCellStyle")
            Core.<*> (o Core..:? "tableCellStyleSuggestionState")
      )

instance Core.ToJSON SuggestedTableCellStyle where
  toJSON SuggestedTableCellStyle {..} =
    Core.object
      ( Core.catMaybes
          [ ("tableCellStyle" Core..=) Core.<$> tableCellStyle,
            ("tableCellStyleSuggestionState" Core..=)
              Core.<$> tableCellStyleSuggestionState
          ]
      )

-- | A suggested change to a TableRowStyle.
--
-- /See:/ 'newSuggestedTableRowStyle' smart constructor.
data SuggestedTableRowStyle = SuggestedTableRowStyle
  { -- | A TableRowStyle that only includes the changes made in this suggestion. This can be used along with the table/row/style/suggestion/state to see which fields have changed and their new values.
    tableRowStyle :: (Core.Maybe TableRowStyle),
    -- | A mask that indicates which of the fields on the base TableRowStyle have been changed in this suggestion.
    tableRowStyleSuggestionState :: (Core.Maybe TableRowStyleSuggestionState)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SuggestedTableRowStyle' with the minimum fields required to make a request.
newSuggestedTableRowStyle ::
  SuggestedTableRowStyle
newSuggestedTableRowStyle =
  SuggestedTableRowStyle
    { tableRowStyle = Core.Nothing,
      tableRowStyleSuggestionState = Core.Nothing
    }

instance Core.FromJSON SuggestedTableRowStyle where
  parseJSON =
    Core.withObject
      "SuggestedTableRowStyle"
      ( \o ->
          SuggestedTableRowStyle
            Core.<$> (o Core..:? "tableRowStyle")
            Core.<*> (o Core..:? "tableRowStyleSuggestionState")
      )

instance Core.ToJSON SuggestedTableRowStyle where
  toJSON SuggestedTableRowStyle {..} =
    Core.object
      ( Core.catMaybes
          [ ("tableRowStyle" Core..=) Core.<$> tableRowStyle,
            ("tableRowStyleSuggestionState" Core..=)
              Core.<$> tableRowStyleSuggestionState
          ]
      )

-- | A suggested change to a TextStyle.
--
-- /See:/ 'newSuggestedTextStyle' smart constructor.
data SuggestedTextStyle = SuggestedTextStyle
  { -- | A TextStyle that only includes the changes made in this suggestion. This can be used along with the text/style/suggestion_state to see which fields have changed and their new values.
    textStyle :: (Core.Maybe TextStyle),
    -- | A mask that indicates which of the fields on the base TextStyle have been changed in this suggestion.
    textStyleSuggestionState :: (Core.Maybe TextStyleSuggestionState)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'SuggestedTextStyle' with the minimum fields required to make a request.
newSuggestedTextStyle ::
  SuggestedTextStyle
newSuggestedTextStyle =
  SuggestedTextStyle
    { textStyle = Core.Nothing,
      textStyleSuggestionState = Core.Nothing
    }

instance Core.FromJSON SuggestedTextStyle where
  parseJSON =
    Core.withObject
      "SuggestedTextStyle"
      ( \o ->
          SuggestedTextStyle
            Core.<$> (o Core..:? "textStyle")
            Core.<*> (o Core..:? "textStyleSuggestionState")
      )

instance Core.ToJSON SuggestedTextStyle where
  toJSON SuggestedTextStyle {..} =
    Core.object
      ( Core.catMaybes
          [ ("textStyle" Core..=) Core.<$> textStyle,
            ("textStyleSuggestionState" Core..=)
              Core.<$> textStyleSuggestionState
          ]
      )

-- | A tab in a document.
--
-- /See:/ 'newTab' smart constructor.
data Tab = Tab
  { -- | The child tabs nested within this tab.
    childTabs :: (Core.Maybe [Tab]),
    -- | A tab with document contents, like text and images.
    documentTab :: (Core.Maybe DocumentTab),
    -- | The properties of the tab, like ID and title.
    tabProperties :: (Core.Maybe TabProperties)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Tab' with the minimum fields required to make a request.
newTab ::
  Tab
newTab =
  Tab
    { childTabs = Core.Nothing,
      documentTab = Core.Nothing,
      tabProperties = Core.Nothing
    }

instance Core.FromJSON Tab where
  parseJSON =
    Core.withObject
      "Tab"
      ( \o ->
          Tab
            Core.<$> (o Core..:? "childTabs")
            Core.<*> (o Core..:? "documentTab")
            Core.<*> (o Core..:? "tabProperties")
      )

instance Core.ToJSON Tab where
  toJSON Tab {..} =
    Core.object
      ( Core.catMaybes
          [ ("childTabs" Core..=) Core.<$> childTabs,
            ("documentTab" Core..=) Core.<$> documentTab,
            ("tabProperties" Core..=) Core.<$> tabProperties
          ]
      )

-- | Properties of a tab.
--
-- /See:/ 'newTabProperties' smart constructor.
data TabProperties = TabProperties
  { -- | The zero-based index of the tab within the parent.
    index :: (Core.Maybe Core.Int32),
    -- | Output only. The depth of the tab within the document. Root-level tabs start at 0.
    nestingLevel :: (Core.Maybe Core.Int32),
    -- | Optional. The ID of the parent tab. Empty when the current tab is a root-level tab, which means it doesn\'t have any parents.
    parentTabId :: (Core.Maybe Core.Text),
    -- | Output only. The ID of the tab. This field can\'t be changed.
    tabId :: (Core.Maybe Core.Text),
    -- | The user-visible name of the tab.
    title :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TabProperties' with the minimum fields required to make a request.
newTabProperties ::
  TabProperties
newTabProperties =
  TabProperties
    { index = Core.Nothing,
      nestingLevel = Core.Nothing,
      parentTabId = Core.Nothing,
      tabId = Core.Nothing,
      title = Core.Nothing
    }

instance Core.FromJSON TabProperties where
  parseJSON =
    Core.withObject
      "TabProperties"
      ( \o ->
          TabProperties
            Core.<$> (o Core..:? "index")
            Core.<*> (o Core..:? "nestingLevel")
            Core.<*> (o Core..:? "parentTabId")
            Core.<*> (o Core..:? "tabId")
            Core.<*> (o Core..:? "title")
      )

instance Core.ToJSON TabProperties where
  toJSON TabProperties {..} =
    Core.object
      ( Core.catMaybes
          [ ("index" Core..=) Core.<$> index,
            ("nestingLevel" Core..=) Core.<$> nestingLevel,
            ("parentTabId" Core..=) Core.<$> parentTabId,
            ("tabId" Core..=) Core.<$> tabId,
            ("title" Core..=) Core.<$> title
          ]
      )

-- | A tab stop within a paragraph.
--
-- /See:/ 'newTabStop' smart constructor.
data TabStop = TabStop
  { -- | The alignment of this tab stop. If unset, the value defaults to START.
    alignment :: (Core.Maybe TabStop_Alignment),
    -- | The offset between this tab stop and the start margin.
    offset :: (Core.Maybe Dimension)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TabStop' with the minimum fields required to make a request.
newTabStop ::
  TabStop
newTabStop =
  TabStop {alignment = Core.Nothing, offset = Core.Nothing}

instance Core.FromJSON TabStop where
  parseJSON =
    Core.withObject
      "TabStop"
      ( \o ->
          TabStop
            Core.<$> (o Core..:? "alignment")
            Core.<*> (o Core..:? "offset")
      )

instance Core.ToJSON TabStop where
  toJSON TabStop {..} =
    Core.object
      ( Core.catMaybes
          [ ("alignment" Core..=) Core.<$> alignment,
            ("offset" Core..=) Core.<$> offset
          ]
      )

-- | A StructuralElement representing a table.
--
-- /See:/ 'newTable' smart constructor.
data Table = Table
  { -- | Number of columns in the table. It\'s possible for a table to be non-rectangular, so some rows may have a different number of cells.
    columns :: (Core.Maybe Core.Int32),
    -- | Number of rows in the table.
    rows :: (Core.Maybe Core.Int32),
    -- | The suggested deletion IDs. If empty, then there are no suggested deletions of this content.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested insertion IDs. A Table may have multiple insertion IDs if it\'s a nested suggested change. If empty, then this is not a suggested insertion.
    suggestedInsertionIds :: (Core.Maybe [Core.Text]),
    -- | The contents and style of each row.
    tableRows :: (Core.Maybe [TableRow]),
    -- | The style of the table.
    tableStyle :: (Core.Maybe TableStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Table' with the minimum fields required to make a request.
newTable ::
  Table
newTable =
  Table
    { columns = Core.Nothing,
      rows = Core.Nothing,
      suggestedDeletionIds = Core.Nothing,
      suggestedInsertionIds = Core.Nothing,
      tableRows = Core.Nothing,
      tableStyle = Core.Nothing
    }

instance Core.FromJSON Table where
  parseJSON =
    Core.withObject
      "Table"
      ( \o ->
          Table
            Core.<$> (o Core..:? "columns")
            Core.<*> (o Core..:? "rows")
            Core.<*> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionIds")
            Core.<*> (o Core..:? "tableRows")
            Core.<*> (o Core..:? "tableStyle")
      )

instance Core.ToJSON Table where
  toJSON Table {..} =
    Core.object
      ( Core.catMaybes
          [ ("columns" Core..=) Core.<$> columns,
            ("rows" Core..=) Core.<$> rows,
            ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionIds" Core..=) Core.<$> suggestedInsertionIds,
            ("tableRows" Core..=) Core.<$> tableRows,
            ("tableStyle" Core..=) Core.<$> tableStyle
          ]
      )

-- | The contents and style of a cell in a Table.
--
-- /See:/ 'newTableCell' smart constructor.
data TableCell = TableCell
  { -- | The content of the cell.
    content :: (Core.Maybe [StructuralElement]),
    -- | The zero-based end index of this cell, exclusive, in UTF-16 code units.
    endIndex :: (Core.Maybe Core.Int32),
    -- | The zero-based start index of this cell, in UTF-16 code units.
    startIndex :: (Core.Maybe Core.Int32),
    -- | The suggested deletion IDs. If empty, then there are no suggested deletions of this content.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested insertion IDs. A TableCell may have multiple insertion IDs if it\'s a nested suggested change. If empty, then this is not a suggested insertion.
    suggestedInsertionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested changes to the table cell style, keyed by suggestion ID.
    suggestedTableCellStyleChanges :: (Core.Maybe TableCell_SuggestedTableCellStyleChanges),
    -- | The style of the cell.
    tableCellStyle :: (Core.Maybe TableCellStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TableCell' with the minimum fields required to make a request.
newTableCell ::
  TableCell
newTableCell =
  TableCell
    { content = Core.Nothing,
      endIndex = Core.Nothing,
      startIndex = Core.Nothing,
      suggestedDeletionIds = Core.Nothing,
      suggestedInsertionIds = Core.Nothing,
      suggestedTableCellStyleChanges = Core.Nothing,
      tableCellStyle = Core.Nothing
    }

instance Core.FromJSON TableCell where
  parseJSON =
    Core.withObject
      "TableCell"
      ( \o ->
          TableCell
            Core.<$> (o Core..:? "content")
            Core.<*> (o Core..:? "endIndex")
            Core.<*> (o Core..:? "startIndex")
            Core.<*> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionIds")
            Core.<*> (o Core..:? "suggestedTableCellStyleChanges")
            Core.<*> (o Core..:? "tableCellStyle")
      )

instance Core.ToJSON TableCell where
  toJSON TableCell {..} =
    Core.object
      ( Core.catMaybes
          [ ("content" Core..=) Core.<$> content,
            ("endIndex" Core..=) Core.<$> endIndex,
            ("startIndex" Core..=) Core.<$> startIndex,
            ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionIds" Core..=) Core.<$> suggestedInsertionIds,
            ("suggestedTableCellStyleChanges" Core..=)
              Core.<$> suggestedTableCellStyleChanges,
            ("tableCellStyle" Core..=) Core.<$> tableCellStyle
          ]
      )

-- | The suggested changes to the table cell style, keyed by suggestion ID.
--
-- /See:/ 'newTableCell_SuggestedTableCellStyleChanges' smart constructor.
newtype TableCell_SuggestedTableCellStyleChanges = TableCell_SuggestedTableCellStyleChanges
  { additional :: (Core.HashMap Core.Text SuggestedTableCellStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TableCell_SuggestedTableCellStyleChanges' with the minimum fields required to make a request.
newTableCell_SuggestedTableCellStyleChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedTableCellStyle ->
  TableCell_SuggestedTableCellStyleChanges
newTableCell_SuggestedTableCellStyleChanges additional =
  TableCell_SuggestedTableCellStyleChanges {additional = additional}

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

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

-- | A border around a table cell. Table cell borders cannot be transparent. To hide a table cell border, make its width 0.
--
-- /See:/ 'newTableCellBorder' smart constructor.
data TableCellBorder = TableCellBorder
  { -- | The color of the border. This color cannot be transparent.
    color :: (Core.Maybe OptionalColor),
    -- | The dash style of the border.
    dashStyle :: (Core.Maybe TableCellBorder_DashStyle),
    -- | The width of the border.
    width :: (Core.Maybe Dimension)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TableCellBorder' with the minimum fields required to make a request.
newTableCellBorder ::
  TableCellBorder
newTableCellBorder =
  TableCellBorder
    { color = Core.Nothing,
      dashStyle = Core.Nothing,
      width = Core.Nothing
    }

instance Core.FromJSON TableCellBorder where
  parseJSON =
    Core.withObject
      "TableCellBorder"
      ( \o ->
          TableCellBorder
            Core.<$> (o Core..:? "color")
            Core.<*> (o Core..:? "dashStyle")
            Core.<*> (o Core..:? "width")
      )

instance Core.ToJSON TableCellBorder where
  toJSON TableCellBorder {..} =
    Core.object
      ( Core.catMaybes
          [ ("color" Core..=) Core.<$> color,
            ("dashStyle" Core..=) Core.<$> dashStyle,
            ("width" Core..=) Core.<$> width
          ]
      )

-- | Location of a single cell within a table.
--
-- /See:/ 'newTableCellLocation' smart constructor.
data TableCellLocation = TableCellLocation
  { -- | The zero-based column index. For example, the second column in the table has a column index of 1.
    columnIndex :: (Core.Maybe Core.Int32),
    -- | The zero-based row index. For example, the second row in the table has a row index of 1.
    rowIndex :: (Core.Maybe Core.Int32),
    -- | The location where the table starts in the document.
    tableStartLocation :: (Core.Maybe Location)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TableCellLocation' with the minimum fields required to make a request.
newTableCellLocation ::
  TableCellLocation
newTableCellLocation =
  TableCellLocation
    { columnIndex = Core.Nothing,
      rowIndex = Core.Nothing,
      tableStartLocation = Core.Nothing
    }

instance Core.FromJSON TableCellLocation where
  parseJSON =
    Core.withObject
      "TableCellLocation"
      ( \o ->
          TableCellLocation
            Core.<$> (o Core..:? "columnIndex")
            Core.<*> (o Core..:? "rowIndex")
            Core.<*> (o Core..:? "tableStartLocation")
      )

instance Core.ToJSON TableCellLocation where
  toJSON TableCellLocation {..} =
    Core.object
      ( Core.catMaybes
          [ ("columnIndex" Core..=) Core.<$> columnIndex,
            ("rowIndex" Core..=) Core.<$> rowIndex,
            ("tableStartLocation" Core..=) Core.<$> tableStartLocation
          ]
      )

-- | The style of a TableCell. Inherited table cell styles are represented as unset fields in this message. A table cell style can inherit from the table\'s style.
--
-- /See:/ 'newTableCellStyle' smart constructor.
data TableCellStyle = TableCellStyle
  { -- | The background color of the cell.
    backgroundColor :: (Core.Maybe OptionalColor),
    -- | The bottom border of the cell.
    borderBottom :: (Core.Maybe TableCellBorder),
    -- | The left border of the cell.
    borderLeft :: (Core.Maybe TableCellBorder),
    -- | The right border of the cell.
    borderRight :: (Core.Maybe TableCellBorder),
    -- | The top border of the cell.
    borderTop :: (Core.Maybe TableCellBorder),
    -- | The column span of the cell. This property is read-only.
    columnSpan :: (Core.Maybe Core.Int32),
    -- | The alignment of the content in the table cell. The default alignment matches the alignment for newly created table cells in the Docs editor.
    contentAlignment :: (Core.Maybe TableCellStyle_ContentAlignment),
    -- | The bottom padding of the cell.
    paddingBottom :: (Core.Maybe Dimension),
    -- | The left padding of the cell.
    paddingLeft :: (Core.Maybe Dimension),
    -- | The right padding of the cell.
    paddingRight :: (Core.Maybe Dimension),
    -- | The top padding of the cell.
    paddingTop :: (Core.Maybe Dimension),
    -- | The row span of the cell. This property is read-only.
    rowSpan :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TableCellStyle' with the minimum fields required to make a request.
newTableCellStyle ::
  TableCellStyle
newTableCellStyle =
  TableCellStyle
    { backgroundColor = Core.Nothing,
      borderBottom = Core.Nothing,
      borderLeft = Core.Nothing,
      borderRight = Core.Nothing,
      borderTop = Core.Nothing,
      columnSpan = Core.Nothing,
      contentAlignment = Core.Nothing,
      paddingBottom = Core.Nothing,
      paddingLeft = Core.Nothing,
      paddingRight = Core.Nothing,
      paddingTop = Core.Nothing,
      rowSpan = Core.Nothing
    }

instance Core.FromJSON TableCellStyle where
  parseJSON =
    Core.withObject
      "TableCellStyle"
      ( \o ->
          TableCellStyle
            Core.<$> (o Core..:? "backgroundColor")
            Core.<*> (o Core..:? "borderBottom")
            Core.<*> (o Core..:? "borderLeft")
            Core.<*> (o Core..:? "borderRight")
            Core.<*> (o Core..:? "borderTop")
            Core.<*> (o Core..:? "columnSpan")
            Core.<*> (o Core..:? "contentAlignment")
            Core.<*> (o Core..:? "paddingBottom")
            Core.<*> (o Core..:? "paddingLeft")
            Core.<*> (o Core..:? "paddingRight")
            Core.<*> (o Core..:? "paddingTop")
            Core.<*> (o Core..:? "rowSpan")
      )

instance Core.ToJSON TableCellStyle where
  toJSON TableCellStyle {..} =
    Core.object
      ( Core.catMaybes
          [ ("backgroundColor" Core..=) Core.<$> backgroundColor,
            ("borderBottom" Core..=) Core.<$> borderBottom,
            ("borderLeft" Core..=) Core.<$> borderLeft,
            ("borderRight" Core..=) Core.<$> borderRight,
            ("borderTop" Core..=) Core.<$> borderTop,
            ("columnSpan" Core..=) Core.<$> columnSpan,
            ("contentAlignment" Core..=) Core.<$> contentAlignment,
            ("paddingBottom" Core..=) Core.<$> paddingBottom,
            ("paddingLeft" Core..=) Core.<$> paddingLeft,
            ("paddingRight" Core..=) Core.<$> paddingRight,
            ("paddingTop" Core..=) Core.<$> paddingTop,
            ("rowSpan" Core..=) Core.<$> rowSpan
          ]
      )

-- | A mask that indicates which of the fields on the base TableCellStyle have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newTableCellStyleSuggestionState' smart constructor.
data TableCellStyleSuggestionState = TableCellStyleSuggestionState
  { -- | Indicates if there was a suggested change to background_color.
    backgroundColorSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to border_bottom.
    borderBottomSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to border_left.
    borderLeftSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to border_right.
    borderRightSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to border_top.
    borderTopSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to column_span.
    columnSpanSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to content_alignment.
    contentAlignmentSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to padding_bottom.
    paddingBottomSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to padding_left.
    paddingLeftSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to padding_right.
    paddingRightSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to padding_top.
    paddingTopSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to row_span.
    rowSpanSuggested :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TableCellStyleSuggestionState' with the minimum fields required to make a request.
newTableCellStyleSuggestionState ::
  TableCellStyleSuggestionState
newTableCellStyleSuggestionState =
  TableCellStyleSuggestionState
    { backgroundColorSuggested =
        Core.Nothing,
      borderBottomSuggested = Core.Nothing,
      borderLeftSuggested = Core.Nothing,
      borderRightSuggested = Core.Nothing,
      borderTopSuggested = Core.Nothing,
      columnSpanSuggested = Core.Nothing,
      contentAlignmentSuggested = Core.Nothing,
      paddingBottomSuggested = Core.Nothing,
      paddingLeftSuggested = Core.Nothing,
      paddingRightSuggested = Core.Nothing,
      paddingTopSuggested = Core.Nothing,
      rowSpanSuggested = Core.Nothing
    }

instance Core.FromJSON TableCellStyleSuggestionState where
  parseJSON =
    Core.withObject
      "TableCellStyleSuggestionState"
      ( \o ->
          TableCellStyleSuggestionState
            Core.<$> (o Core..:? "backgroundColorSuggested")
            Core.<*> (o Core..:? "borderBottomSuggested")
            Core.<*> (o Core..:? "borderLeftSuggested")
            Core.<*> (o Core..:? "borderRightSuggested")
            Core.<*> (o Core..:? "borderTopSuggested")
            Core.<*> (o Core..:? "columnSpanSuggested")
            Core.<*> (o Core..:? "contentAlignmentSuggested")
            Core.<*> (o Core..:? "paddingBottomSuggested")
            Core.<*> (o Core..:? "paddingLeftSuggested")
            Core.<*> (o Core..:? "paddingRightSuggested")
            Core.<*> (o Core..:? "paddingTopSuggested")
            Core.<*> (o Core..:? "rowSpanSuggested")
      )

instance Core.ToJSON TableCellStyleSuggestionState where
  toJSON TableCellStyleSuggestionState {..} =
    Core.object
      ( Core.catMaybes
          [ ("backgroundColorSuggested" Core..=)
              Core.<$> backgroundColorSuggested,
            ("borderBottomSuggested" Core..=) Core.<$> borderBottomSuggested,
            ("borderLeftSuggested" Core..=) Core.<$> borderLeftSuggested,
            ("borderRightSuggested" Core..=) Core.<$> borderRightSuggested,
            ("borderTopSuggested" Core..=) Core.<$> borderTopSuggested,
            ("columnSpanSuggested" Core..=) Core.<$> columnSpanSuggested,
            ("contentAlignmentSuggested" Core..=)
              Core.<$> contentAlignmentSuggested,
            ("paddingBottomSuggested" Core..=) Core.<$> paddingBottomSuggested,
            ("paddingLeftSuggested" Core..=) Core.<$> paddingLeftSuggested,
            ("paddingRightSuggested" Core..=) Core.<$> paddingRightSuggested,
            ("paddingTopSuggested" Core..=) Core.<$> paddingTopSuggested,
            ("rowSpanSuggested" Core..=) Core.<$> rowSpanSuggested
          ]
      )

-- | The properties of a column in a table.
--
-- /See:/ 'newTableColumnProperties' smart constructor.
data TableColumnProperties = TableColumnProperties
  { -- | The width of the column. Set when the column\'s @width_type@ is FIXED_WIDTH.
    width :: (Core.Maybe Dimension),
    -- | The width type of the column.
    widthType :: (Core.Maybe TableColumnProperties_WidthType)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TableColumnProperties' with the minimum fields required to make a request.
newTableColumnProperties ::
  TableColumnProperties
newTableColumnProperties =
  TableColumnProperties
    { width = Core.Nothing,
      widthType = Core.Nothing
    }

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

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

-- | A StructuralElement representing a table of contents.
--
-- /See:/ 'newTableOfContents' smart constructor.
data TableOfContents = TableOfContents
  { -- | The content of the table of contents.
    content :: (Core.Maybe [StructuralElement]),
    -- | The suggested deletion IDs. If empty, then there are no suggested deletions of this content.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested insertion IDs. A TableOfContents may have multiple insertion IDs if it is a nested suggested change. If empty, then this is not a suggested insertion.
    suggestedInsertionIds :: (Core.Maybe [Core.Text])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TableOfContents' with the minimum fields required to make a request.
newTableOfContents ::
  TableOfContents
newTableOfContents =
  TableOfContents
    { content = Core.Nothing,
      suggestedDeletionIds = Core.Nothing,
      suggestedInsertionIds = Core.Nothing
    }

instance Core.FromJSON TableOfContents where
  parseJSON =
    Core.withObject
      "TableOfContents"
      ( \o ->
          TableOfContents
            Core.<$> (o Core..:? "content")
            Core.<*> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionIds")
      )

instance Core.ToJSON TableOfContents where
  toJSON TableOfContents {..} =
    Core.object
      ( Core.catMaybes
          [ ("content" Core..=) Core.<$> content,
            ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionIds" Core..=) Core.<$> suggestedInsertionIds
          ]
      )

-- | A table range represents a reference to a subset of a table. It\'s important to note that the cells specified by a table range do not necessarily form a rectangle. For example, let\'s say we have a 3 x 3 table where all the cells of the last row are merged together. The table looks like this: [ ] A table range with table cell location = (table/start/location, row = 0, column = 0), row span = 3 and column span = 2 specifies the following cells: x x [ x x x ]
--
-- /See:/ 'newTableRange' smart constructor.
data TableRange = TableRange
  { -- | The column span of the table range.
    columnSpan :: (Core.Maybe Core.Int32),
    -- | The row span of the table range.
    rowSpan :: (Core.Maybe Core.Int32),
    -- | The cell location where the table range starts.
    tableCellLocation :: (Core.Maybe TableCellLocation)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TableRange' with the minimum fields required to make a request.
newTableRange ::
  TableRange
newTableRange =
  TableRange
    { columnSpan = Core.Nothing,
      rowSpan = Core.Nothing,
      tableCellLocation = Core.Nothing
    }

instance Core.FromJSON TableRange where
  parseJSON =
    Core.withObject
      "TableRange"
      ( \o ->
          TableRange
            Core.<$> (o Core..:? "columnSpan")
            Core.<*> (o Core..:? "rowSpan")
            Core.<*> (o Core..:? "tableCellLocation")
      )

instance Core.ToJSON TableRange where
  toJSON TableRange {..} =
    Core.object
      ( Core.catMaybes
          [ ("columnSpan" Core..=) Core.<$> columnSpan,
            ("rowSpan" Core..=) Core.<$> rowSpan,
            ("tableCellLocation" Core..=) Core.<$> tableCellLocation
          ]
      )

-- | The contents and style of a row in a Table.
--
-- /See:/ 'newTableRow' smart constructor.
data TableRow = TableRow
  { -- | The zero-based end index of this row, exclusive, in UTF-16 code units.
    endIndex :: (Core.Maybe Core.Int32),
    -- | The zero-based start index of this row, in UTF-16 code units.
    startIndex :: (Core.Maybe Core.Int32),
    -- | The suggested deletion IDs. If empty, then there are no suggested deletions of this content.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested insertion IDs. A TableRow may have multiple insertion IDs if it\'s a nested suggested change. If empty, then this is not a suggested insertion.
    suggestedInsertionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested style changes to this row, keyed by suggestion ID.
    suggestedTableRowStyleChanges :: (Core.Maybe TableRow_SuggestedTableRowStyleChanges),
    -- | The contents and style of each cell in this row. It\'s possible for a table to be non-rectangular, so some rows may have a different number of cells than other rows in the same table.
    tableCells :: (Core.Maybe [TableCell]),
    -- | The style of the table row.
    tableRowStyle :: (Core.Maybe TableRowStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TableRow' with the minimum fields required to make a request.
newTableRow ::
  TableRow
newTableRow =
  TableRow
    { endIndex = Core.Nothing,
      startIndex = Core.Nothing,
      suggestedDeletionIds = Core.Nothing,
      suggestedInsertionIds = Core.Nothing,
      suggestedTableRowStyleChanges = Core.Nothing,
      tableCells = Core.Nothing,
      tableRowStyle = Core.Nothing
    }

instance Core.FromJSON TableRow where
  parseJSON =
    Core.withObject
      "TableRow"
      ( \o ->
          TableRow
            Core.<$> (o Core..:? "endIndex")
            Core.<*> (o Core..:? "startIndex")
            Core.<*> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionIds")
            Core.<*> (o Core..:? "suggestedTableRowStyleChanges")
            Core.<*> (o Core..:? "tableCells")
            Core.<*> (o Core..:? "tableRowStyle")
      )

instance Core.ToJSON TableRow where
  toJSON TableRow {..} =
    Core.object
      ( Core.catMaybes
          [ ("endIndex" Core..=) Core.<$> endIndex,
            ("startIndex" Core..=) Core.<$> startIndex,
            ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionIds" Core..=) Core.<$> suggestedInsertionIds,
            ("suggestedTableRowStyleChanges" Core..=)
              Core.<$> suggestedTableRowStyleChanges,
            ("tableCells" Core..=) Core.<$> tableCells,
            ("tableRowStyle" Core..=) Core.<$> tableRowStyle
          ]
      )

-- | The suggested style changes to this row, keyed by suggestion ID.
--
-- /See:/ 'newTableRow_SuggestedTableRowStyleChanges' smart constructor.
newtype TableRow_SuggestedTableRowStyleChanges = TableRow_SuggestedTableRowStyleChanges
  { additional :: (Core.HashMap Core.Text SuggestedTableRowStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TableRow_SuggestedTableRowStyleChanges' with the minimum fields required to make a request.
newTableRow_SuggestedTableRowStyleChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedTableRowStyle ->
  TableRow_SuggestedTableRowStyleChanges
newTableRow_SuggestedTableRowStyleChanges additional =
  TableRow_SuggestedTableRowStyleChanges {additional = additional}

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

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

-- | Styles that apply to a table row.
--
-- /See:/ 'newTableRowStyle' smart constructor.
data TableRowStyle = TableRowStyle
  { -- | The minimum height of the row. The row will be rendered in the Docs editor at a height equal to or greater than this value in order to show all the content in the row\'s cells.
    minRowHeight :: (Core.Maybe Dimension),
    -- | Whether the row cannot overflow across page or column boundaries.
    preventOverflow :: (Core.Maybe Core.Bool),
    -- | Whether the row is a table header.
    tableHeader :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TableRowStyle' with the minimum fields required to make a request.
newTableRowStyle ::
  TableRowStyle
newTableRowStyle =
  TableRowStyle
    { minRowHeight = Core.Nothing,
      preventOverflow = Core.Nothing,
      tableHeader = Core.Nothing
    }

instance Core.FromJSON TableRowStyle where
  parseJSON =
    Core.withObject
      "TableRowStyle"
      ( \o ->
          TableRowStyle
            Core.<$> (o Core..:? "minRowHeight")
            Core.<*> (o Core..:? "preventOverflow")
            Core.<*> (o Core..:? "tableHeader")
      )

instance Core.ToJSON TableRowStyle where
  toJSON TableRowStyle {..} =
    Core.object
      ( Core.catMaybes
          [ ("minRowHeight" Core..=) Core.<$> minRowHeight,
            ("preventOverflow" Core..=) Core.<$> preventOverflow,
            ("tableHeader" Core..=) Core.<$> tableHeader
          ]
      )

-- | A mask that indicates which of the fields on the base TableRowStyle have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newTableRowStyleSuggestionState' smart constructor.
newtype TableRowStyleSuggestionState = TableRowStyleSuggestionState
  { -- | Indicates if there was a suggested change to min/row/height.
    minRowHeightSuggested :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Styles that apply to a table.
--
-- /See:/ 'newTableStyle' smart constructor.
newtype TableStyle = TableStyle
  { -- | The properties of each column. Note that in Docs, tables contain rows and rows contain cells, similar to HTML. So the properties for a row can be found on the row\'s table/row/style.
    tableColumnProperties :: (Core.Maybe [TableColumnProperties])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A criteria that specifies in which tabs a request executes.
--
-- /See:/ 'newTabsCriteria' smart constructor.
newtype TabsCriteria = TabsCriteria
  { -- | The list of tab IDs in which the request executes.
    tabIds :: (Core.Maybe [Core.Text])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | A ParagraphElement that represents a run of text that all has the same styling.
--
-- /See:/ 'newTextRun' smart constructor.
data TextRun = TextRun
  { -- | The text of this run. Any non-text elements in the run are replaced with the Unicode character U+E907.
    content :: (Core.Maybe Core.Text),
    -- | The suggested deletion IDs. If empty, then there are no suggested deletions of this content.
    suggestedDeletionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested insertion IDs. A TextRun may have multiple insertion IDs if it\'s a nested suggested change. If empty, then this is not a suggested insertion.
    suggestedInsertionIds :: (Core.Maybe [Core.Text]),
    -- | The suggested text style changes to this run, keyed by suggestion ID.
    suggestedTextStyleChanges :: (Core.Maybe TextRun_SuggestedTextStyleChanges),
    -- | The text style of this run.
    textStyle :: (Core.Maybe TextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TextRun' with the minimum fields required to make a request.
newTextRun ::
  TextRun
newTextRun =
  TextRun
    { content = Core.Nothing,
      suggestedDeletionIds = Core.Nothing,
      suggestedInsertionIds = Core.Nothing,
      suggestedTextStyleChanges = Core.Nothing,
      textStyle = Core.Nothing
    }

instance Core.FromJSON TextRun where
  parseJSON =
    Core.withObject
      "TextRun"
      ( \o ->
          TextRun
            Core.<$> (o Core..:? "content")
            Core.<*> (o Core..:? "suggestedDeletionIds")
            Core.<*> (o Core..:? "suggestedInsertionIds")
            Core.<*> (o Core..:? "suggestedTextStyleChanges")
            Core.<*> (o Core..:? "textStyle")
      )

instance Core.ToJSON TextRun where
  toJSON TextRun {..} =
    Core.object
      ( Core.catMaybes
          [ ("content" Core..=) Core.<$> content,
            ("suggestedDeletionIds" Core..=) Core.<$> suggestedDeletionIds,
            ("suggestedInsertionIds" Core..=) Core.<$> suggestedInsertionIds,
            ("suggestedTextStyleChanges" Core..=)
              Core.<$> suggestedTextStyleChanges,
            ("textStyle" Core..=) Core.<$> textStyle
          ]
      )

-- | The suggested text style changes to this run, keyed by suggestion ID.
--
-- /See:/ 'newTextRun_SuggestedTextStyleChanges' smart constructor.
newtype TextRun_SuggestedTextStyleChanges = TextRun_SuggestedTextStyleChanges
  { additional :: (Core.HashMap Core.Text SuggestedTextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TextRun_SuggestedTextStyleChanges' with the minimum fields required to make a request.
newTextRun_SuggestedTextStyleChanges ::
  -- |  See 'additional'.
  Core.HashMap Core.Text SuggestedTextStyle ->
  TextRun_SuggestedTextStyleChanges
newTextRun_SuggestedTextStyleChanges additional =
  TextRun_SuggestedTextStyleChanges {additional = additional}

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

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

-- | Represents the styling that can be applied to text. Inherited text styles are represented as unset fields in this message. A text style\'s parent depends on where the text style is defined: * The TextStyle of text in a Paragraph inherits from the paragraph\'s corresponding named style type. * The TextStyle on a named style inherits from the normal text named style. * The TextStyle of the normal text named style inherits from the default text style in the Docs editor. * The TextStyle on a Paragraph element that\'s contained in a table may inherit its text style from the table style. If the text style does not inherit from a parent, unsetting fields will revert the style to a value matching the defaults in the Docs editor.
--
-- /See:/ 'newTextStyle' smart constructor.
data TextStyle = TextStyle
  { -- | The background color of the text. If set, the color is either an RGB color or transparent, depending on the @color@ field.
    backgroundColor :: (Core.Maybe OptionalColor),
    -- | The text\'s vertical offset from its normal position. Text with @SUPERSCRIPT@ or @SUBSCRIPT@ baseline offsets is automatically rendered in a smaller font size, computed based on the @font_size@ field. Changes in this field don\'t affect the @font_size@.
    baselineOffset :: (Core.Maybe TextStyle_BaselineOffset),
    -- | Whether or not the text is rendered as bold.
    bold :: (Core.Maybe Core.Bool),
    -- | The size of the text\'s font.
    fontSize :: (Core.Maybe Dimension),
    -- | The foreground color of the text. If set, the color is either an RGB color or transparent, depending on the @color@ field.
    foregroundColor :: (Core.Maybe OptionalColor),
    -- | Whether or not the text is italicized.
    italic :: (Core.Maybe Core.Bool),
    -- | The hyperlink destination of the text. If unset, there\'s no link. Links are not inherited from parent text. Changing the link in an update request causes some other changes to the text style of the range: * When setting a link, the text foreground color will be updated to the default link color and the text will be underlined. If these fields are modified in the same request, those values will be used instead of the link defaults. * Setting a link on a text range that overlaps with an existing link will also update the existing link to point to the new URL. * Links are not settable on newline characters. As a result, setting a link on a text range that crosses a paragraph boundary, such as @\"ABC\\n123\"@, will separate the newline character(s) into their own text runs. The link will be applied separately to the runs before and after the newline. * Removing a link will update the text style of the range to match the style of the preceding text (or the default text styles if the preceding text is another
    -- link) unless different styles are being set in the same request.
    link :: (Core.Maybe Link),
    -- | Whether or not the text is in small capital letters.
    smallCaps :: (Core.Maybe Core.Bool),
    -- | Whether or not the text is struck through.
    strikethrough :: (Core.Maybe Core.Bool),
    -- | Whether or not the text is underlined.
    underline :: (Core.Maybe Core.Bool),
    -- | The font family and rendered weight of the text. If an update request specifies values for both @weighted_font_family@ and @bold@, the @weighted_font_family@ is applied first, then @bold@. If @weighted_font_family#weight@ is not set, it defaults to @400@. If @weighted_font_family@ is set, then @weighted_font_family#font_family@ must also be set with a non-empty value. Otherwise, a 400 bad request error is returned.
    weightedFontFamily :: (Core.Maybe WeightedFontFamily)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TextStyle' with the minimum fields required to make a request.
newTextStyle ::
  TextStyle
newTextStyle =
  TextStyle
    { backgroundColor = Core.Nothing,
      baselineOffset = Core.Nothing,
      bold = Core.Nothing,
      fontSize = Core.Nothing,
      foregroundColor = Core.Nothing,
      italic = Core.Nothing,
      link = Core.Nothing,
      smallCaps = Core.Nothing,
      strikethrough = Core.Nothing,
      underline = Core.Nothing,
      weightedFontFamily = Core.Nothing
    }

instance Core.FromJSON TextStyle where
  parseJSON =
    Core.withObject
      "TextStyle"
      ( \o ->
          TextStyle
            Core.<$> (o Core..:? "backgroundColor")
            Core.<*> (o Core..:? "baselineOffset")
            Core.<*> (o Core..:? "bold")
            Core.<*> (o Core..:? "fontSize")
            Core.<*> (o Core..:? "foregroundColor")
            Core.<*> (o Core..:? "italic")
            Core.<*> (o Core..:? "link")
            Core.<*> (o Core..:? "smallCaps")
            Core.<*> (o Core..:? "strikethrough")
            Core.<*> (o Core..:? "underline")
            Core.<*> (o Core..:? "weightedFontFamily")
      )

instance Core.ToJSON TextStyle where
  toJSON TextStyle {..} =
    Core.object
      ( Core.catMaybes
          [ ("backgroundColor" Core..=) Core.<$> backgroundColor,
            ("baselineOffset" Core..=) Core.<$> baselineOffset,
            ("bold" Core..=) Core.<$> bold,
            ("fontSize" Core..=) Core.<$> fontSize,
            ("foregroundColor" Core..=) Core.<$> foregroundColor,
            ("italic" Core..=) Core.<$> italic,
            ("link" Core..=) Core.<$> link,
            ("smallCaps" Core..=) Core.<$> smallCaps,
            ("strikethrough" Core..=) Core.<$> strikethrough,
            ("underline" Core..=) Core.<$> underline,
            ("weightedFontFamily" Core..=) Core.<$> weightedFontFamily
          ]
      )

-- | A mask that indicates which of the fields on the base TextStyle have been changed in this suggestion. For any field set to true, there\'s a new suggested value.
--
-- /See:/ 'newTextStyleSuggestionState' smart constructor.
data TextStyleSuggestionState = TextStyleSuggestionState
  { -- | Indicates if there was a suggested change to background_color.
    backgroundColorSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to baseline_offset.
    baselineOffsetSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to bold.
    boldSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to font_size.
    fontSizeSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to foreground_color.
    foregroundColorSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to italic.
    italicSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to link.
    linkSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to small_caps.
    smallCapsSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to strikethrough.
    strikethroughSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to underline.
    underlineSuggested :: (Core.Maybe Core.Bool),
    -- | Indicates if there was a suggested change to weighted/font/family.
    weightedFontFamilySuggested :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'TextStyleSuggestionState' with the minimum fields required to make a request.
newTextStyleSuggestionState ::
  TextStyleSuggestionState
newTextStyleSuggestionState =
  TextStyleSuggestionState
    { backgroundColorSuggested = Core.Nothing,
      baselineOffsetSuggested = Core.Nothing,
      boldSuggested = Core.Nothing,
      fontSizeSuggested = Core.Nothing,
      foregroundColorSuggested = Core.Nothing,
      italicSuggested = Core.Nothing,
      linkSuggested = Core.Nothing,
      smallCapsSuggested = Core.Nothing,
      strikethroughSuggested = Core.Nothing,
      underlineSuggested = Core.Nothing,
      weightedFontFamilySuggested = Core.Nothing
    }

instance Core.FromJSON TextStyleSuggestionState where
  parseJSON =
    Core.withObject
      "TextStyleSuggestionState"
      ( \o ->
          TextStyleSuggestionState
            Core.<$> (o Core..:? "backgroundColorSuggested")
            Core.<*> (o Core..:? "baselineOffsetSuggested")
            Core.<*> (o Core..:? "boldSuggested")
            Core.<*> (o Core..:? "fontSizeSuggested")
            Core.<*> (o Core..:? "foregroundColorSuggested")
            Core.<*> (o Core..:? "italicSuggested")
            Core.<*> (o Core..:? "linkSuggested")
            Core.<*> (o Core..:? "smallCapsSuggested")
            Core.<*> (o Core..:? "strikethroughSuggested")
            Core.<*> (o Core..:? "underlineSuggested")
            Core.<*> (o Core..:? "weightedFontFamilySuggested")
      )

instance Core.ToJSON TextStyleSuggestionState where
  toJSON TextStyleSuggestionState {..} =
    Core.object
      ( Core.catMaybes
          [ ("backgroundColorSuggested" Core..=)
              Core.<$> backgroundColorSuggested,
            ("baselineOffsetSuggested" Core..=)
              Core.<$> baselineOffsetSuggested,
            ("boldSuggested" Core..=) Core.<$> boldSuggested,
            ("fontSizeSuggested" Core..=) Core.<$> fontSizeSuggested,
            ("foregroundColorSuggested" Core..=)
              Core.<$> foregroundColorSuggested,
            ("italicSuggested" Core..=) Core.<$> italicSuggested,
            ("linkSuggested" Core..=) Core.<$> linkSuggested,
            ("smallCapsSuggested" Core..=) Core.<$> smallCapsSuggested,
            ("strikethroughSuggested" Core..=) Core.<$> strikethroughSuggested,
            ("underlineSuggested" Core..=) Core.<$> underlineSuggested,
            ("weightedFontFamilySuggested" Core..=)
              Core.<$> weightedFontFamilySuggested
          ]
      )

-- | Unmerges cells in a Table.
--
-- /See:/ 'newUnmergeTableCellsRequest' smart constructor.
newtype UnmergeTableCellsRequest = UnmergeTableCellsRequest
  { -- | The table range specifying which cells of the table to unmerge. All merged cells in this range will be unmerged, and cells that are already unmerged will not be affected. If the range has no merged cells, the request will do nothing. If there is text in any of the merged cells, the text will remain in the \"head\" cell of the resulting block of unmerged cells. The \"head\" cell is the upper-left cell when the content direction is from left to right, and the upper-right otherwise.
    tableRange :: (Core.Maybe TableRange)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

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

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

-- | Updates the DocumentStyle.
--
-- /See:/ 'newUpdateDocumentStyleRequest' smart constructor.
data UpdateDocumentStyleRequest = UpdateDocumentStyleRequest
  { -- | The styles to set on the document. Certain document style changes may cause other changes in order to mirror the behavior of the Docs editor. See the documentation of DocumentStyle for more information.
    documentStyle :: (Core.Maybe DocumentStyle),
    -- | The fields that should be updated. At least one field must be specified. The root @document_style@ is implied and should not be specified. A single @\"*\"@ can be used as short-hand for listing every field. For example to update the background, set @fields@ to @\"background\"@.
    fields :: (Core.Maybe Core.FieldMask),
    -- | The tab that contains the style to update. When omitted, the request applies to the first tab. In a document containing a single tab: - If provided, must match the singular tab\'s ID. - If omitted, the request applies to the singular tab. In a document containing multiple tabs: - If provided, the request applies to the specified tab. - If not provided, the request applies to the first tab in the document.
    tabId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'UpdateDocumentStyleRequest' with the minimum fields required to make a request.
newUpdateDocumentStyleRequest ::
  UpdateDocumentStyleRequest
newUpdateDocumentStyleRequest =
  UpdateDocumentStyleRequest
    { documentStyle = Core.Nothing,
      fields = Core.Nothing,
      tabId = Core.Nothing
    }

instance Core.FromJSON UpdateDocumentStyleRequest where
  parseJSON =
    Core.withObject
      "UpdateDocumentStyleRequest"
      ( \o ->
          UpdateDocumentStyleRequest
            Core.<$> (o Core..:? "documentStyle")
            Core.<*> (o Core..:? "fields")
            Core.<*> (o Core..:? "tabId")
      )

instance Core.ToJSON UpdateDocumentStyleRequest where
  toJSON UpdateDocumentStyleRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("documentStyle" Core..=) Core.<$> documentStyle,
            ("fields" Core..=) Core.<$> fields,
            ("tabId" Core..=) Core.<$> tabId
          ]
      )

-- | Update the styling of all paragraphs that overlap with the given range.
--
-- /See:/ 'newUpdateParagraphStyleRequest' smart constructor.
data UpdateParagraphStyleRequest = UpdateParagraphStyleRequest
  { -- | The fields that should be updated. At least one field must be specified. The root @paragraph_style@ is implied and should not be specified. A single @\"*\"@ can be used as short-hand for listing every field. For example, to update the paragraph style\'s alignment property, set @fields@ to @\"alignment\"@. To reset a property to its default value, include its field name in the field mask but leave the field itself unset.
    fields :: (Core.Maybe Core.FieldMask),
    -- | The styles to set on the paragraphs. Certain paragraph style changes may cause other changes in order to mirror the behavior of the Docs editor. See the documentation of ParagraphStyle for more information.
    paragraphStyle :: (Core.Maybe ParagraphStyle),
    -- | The range overlapping the paragraphs to style.
    range :: (Core.Maybe Range)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'UpdateParagraphStyleRequest' with the minimum fields required to make a request.
newUpdateParagraphStyleRequest ::
  UpdateParagraphStyleRequest
newUpdateParagraphStyleRequest =
  UpdateParagraphStyleRequest
    { fields = Core.Nothing,
      paragraphStyle = Core.Nothing,
      range = Core.Nothing
    }

instance Core.FromJSON UpdateParagraphStyleRequest where
  parseJSON =
    Core.withObject
      "UpdateParagraphStyleRequest"
      ( \o ->
          UpdateParagraphStyleRequest
            Core.<$> (o Core..:? "fields")
            Core.<*> (o Core..:? "paragraphStyle")
            Core.<*> (o Core..:? "range")
      )

instance Core.ToJSON UpdateParagraphStyleRequest where
  toJSON UpdateParagraphStyleRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("fields" Core..=) Core.<$> fields,
            ("paragraphStyle" Core..=) Core.<$> paragraphStyle,
            ("range" Core..=) Core.<$> range
          ]
      )

-- | Updates the SectionStyle.
--
-- /See:/ 'newUpdateSectionStyleRequest' smart constructor.
data UpdateSectionStyleRequest = UpdateSectionStyleRequest
  { -- | The fields that should be updated. At least one field must be specified. The root @section_style@ is implied and must not be specified. A single @\"*\"@ can be used as short-hand for listing every field. For example to update the left margin, set @fields@ to @\"margin_left\"@.
    fields :: (Core.Maybe Core.FieldMask),
    -- | The range overlapping the sections to style. Because section breaks can only be inserted inside the body, the segment ID field must be empty.
    range :: (Core.Maybe Range),
    -- | The styles to be set on the section. Certain section style changes may cause other changes in order to mirror the behavior of the Docs editor. See the documentation of SectionStyle for more information.
    sectionStyle :: (Core.Maybe SectionStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'UpdateSectionStyleRequest' with the minimum fields required to make a request.
newUpdateSectionStyleRequest ::
  UpdateSectionStyleRequest
newUpdateSectionStyleRequest =
  UpdateSectionStyleRequest
    { fields = Core.Nothing,
      range = Core.Nothing,
      sectionStyle = Core.Nothing
    }

instance Core.FromJSON UpdateSectionStyleRequest where
  parseJSON =
    Core.withObject
      "UpdateSectionStyleRequest"
      ( \o ->
          UpdateSectionStyleRequest
            Core.<$> (o Core..:? "fields")
            Core.<*> (o Core..:? "range")
            Core.<*> (o Core..:? "sectionStyle")
      )

instance Core.ToJSON UpdateSectionStyleRequest where
  toJSON UpdateSectionStyleRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("fields" Core..=) Core.<$> fields,
            ("range" Core..=) Core.<$> range,
            ("sectionStyle" Core..=) Core.<$> sectionStyle
          ]
      )

-- | Updates the style of a range of table cells.
--
-- /See:/ 'newUpdateTableCellStyleRequest' smart constructor.
data UpdateTableCellStyleRequest = UpdateTableCellStyleRequest
  { -- | The fields that should be updated. At least one field must be specified. The root @tableCellStyle@ is implied and should not be specified. A single @\"*\"@ can be used as short-hand for listing every field. For example to update the table cell background color, set @fields@ to @\"backgroundColor\"@. To reset a property to its default value, include its field name in the field mask but leave the field itself unset.
    fields :: (Core.Maybe Core.FieldMask),
    -- | The style to set on the table cells. When updating borders, if a cell shares a border with an adjacent cell, the corresponding border property of the adjacent cell is updated as well. Borders that are merged and invisible are not updated. Since updating a border shared by adjacent cells in the same request can cause conflicting border updates, border updates are applied in the following order: - @border_right@ - @border_left@ - @border_bottom@ - @border_top@
    tableCellStyle :: (Core.Maybe TableCellStyle),
    -- | The table range representing the subset of the table to which the updates are applied.
    tableRange :: (Core.Maybe TableRange),
    -- | The location where the table starts in the document. When specified, the updates are applied to all the cells in the table.
    tableStartLocation :: (Core.Maybe Location)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'UpdateTableCellStyleRequest' with the minimum fields required to make a request.
newUpdateTableCellStyleRequest ::
  UpdateTableCellStyleRequest
newUpdateTableCellStyleRequest =
  UpdateTableCellStyleRequest
    { fields = Core.Nothing,
      tableCellStyle = Core.Nothing,
      tableRange = Core.Nothing,
      tableStartLocation = Core.Nothing
    }

instance Core.FromJSON UpdateTableCellStyleRequest where
  parseJSON =
    Core.withObject
      "UpdateTableCellStyleRequest"
      ( \o ->
          UpdateTableCellStyleRequest
            Core.<$> (o Core..:? "fields")
            Core.<*> (o Core..:? "tableCellStyle")
            Core.<*> (o Core..:? "tableRange")
            Core.<*> (o Core..:? "tableStartLocation")
      )

instance Core.ToJSON UpdateTableCellStyleRequest where
  toJSON UpdateTableCellStyleRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("fields" Core..=) Core.<$> fields,
            ("tableCellStyle" Core..=) Core.<$> tableCellStyle,
            ("tableRange" Core..=) Core.<$> tableRange,
            ("tableStartLocation" Core..=) Core.<$> tableStartLocation
          ]
      )

-- | Updates the TableColumnProperties of columns in a table.
--
-- /See:/ 'newUpdateTableColumnPropertiesRequest' smart constructor.
data UpdateTableColumnPropertiesRequest = UpdateTableColumnPropertiesRequest
  { -- | The list of zero-based column indices whose property should be updated. If no indices are specified, all columns will be updated.
    columnIndices :: (Core.Maybe [Core.Int32]),
    -- | The fields that should be updated. At least one field must be specified. The root @tableColumnProperties@ is implied and should not be specified. A single @\"*\"@ can be used as short-hand for listing every field. For example to update the column width, set @fields@ to @\"width\"@.
    fields :: (Core.Maybe Core.FieldMask),
    -- | The table column properties to update. If the value of @table_column_properties#width@ is less than 5 points (5\/72 inch), a 400 bad request error is returned.
    tableColumnProperties :: (Core.Maybe TableColumnProperties),
    -- | The location where the table starts in the document.
    tableStartLocation :: (Core.Maybe Location)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'UpdateTableColumnPropertiesRequest' with the minimum fields required to make a request.
newUpdateTableColumnPropertiesRequest ::
  UpdateTableColumnPropertiesRequest
newUpdateTableColumnPropertiesRequest =
  UpdateTableColumnPropertiesRequest
    { columnIndices = Core.Nothing,
      fields = Core.Nothing,
      tableColumnProperties = Core.Nothing,
      tableStartLocation = Core.Nothing
    }

instance Core.FromJSON UpdateTableColumnPropertiesRequest where
  parseJSON =
    Core.withObject
      "UpdateTableColumnPropertiesRequest"
      ( \o ->
          UpdateTableColumnPropertiesRequest
            Core.<$> (o Core..:? "columnIndices")
            Core.<*> (o Core..:? "fields")
            Core.<*> (o Core..:? "tableColumnProperties")
            Core.<*> (o Core..:? "tableStartLocation")
      )

instance Core.ToJSON UpdateTableColumnPropertiesRequest where
  toJSON UpdateTableColumnPropertiesRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("columnIndices" Core..=) Core.<$> columnIndices,
            ("fields" Core..=) Core.<$> fields,
            ("tableColumnProperties" Core..=) Core.<$> tableColumnProperties,
            ("tableStartLocation" Core..=) Core.<$> tableStartLocation
          ]
      )

-- | Updates the TableRowStyle of rows in a table.
--
-- /See:/ 'newUpdateTableRowStyleRequest' smart constructor.
data UpdateTableRowStyleRequest = UpdateTableRowStyleRequest
  { -- | The fields that should be updated. At least one field must be specified. The root @tableRowStyle@ is implied and should not be specified. A single @\"*\"@ can be used as short-hand for listing every field. For example to update the minimum row height, set @fields@ to @\"min_row_height\"@.
    fields :: (Core.Maybe Core.FieldMask),
    -- | The list of zero-based row indices whose style should be updated. If no indices are specified, all rows will be updated.
    rowIndices :: (Core.Maybe [Core.Int32]),
    -- | The styles to be set on the rows.
    tableRowStyle :: (Core.Maybe TableRowStyle),
    -- | The location where the table starts in the document.
    tableStartLocation :: (Core.Maybe Location)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'UpdateTableRowStyleRequest' with the minimum fields required to make a request.
newUpdateTableRowStyleRequest ::
  UpdateTableRowStyleRequest
newUpdateTableRowStyleRequest =
  UpdateTableRowStyleRequest
    { fields = Core.Nothing,
      rowIndices = Core.Nothing,
      tableRowStyle = Core.Nothing,
      tableStartLocation = Core.Nothing
    }

instance Core.FromJSON UpdateTableRowStyleRequest where
  parseJSON =
    Core.withObject
      "UpdateTableRowStyleRequest"
      ( \o ->
          UpdateTableRowStyleRequest
            Core.<$> (o Core..:? "fields")
            Core.<*> (o Core..:? "rowIndices")
            Core.<*> (o Core..:? "tableRowStyle")
            Core.<*> (o Core..:? "tableStartLocation")
      )

instance Core.ToJSON UpdateTableRowStyleRequest where
  toJSON UpdateTableRowStyleRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("fields" Core..=) Core.<$> fields,
            ("rowIndices" Core..=) Core.<$> rowIndices,
            ("tableRowStyle" Core..=) Core.<$> tableRowStyle,
            ("tableStartLocation" Core..=) Core.<$> tableStartLocation
          ]
      )

-- | Update the styling of text.
--
-- /See:/ 'newUpdateTextStyleRequest' smart constructor.
data UpdateTextStyleRequest = UpdateTextStyleRequest
  { -- | The fields that should be updated. At least one field must be specified. The root @text_style@ is implied and should not be specified. A single @\"*\"@ can be used as short-hand for listing every field. For example, to update the text style to bold, set @fields@ to @\"bold\"@. To reset a property to its default value, include its field name in the field mask but leave the field itself unset.
    fields :: (Core.Maybe Core.FieldMask),
    -- | The range of text to style. The range may be extended to include adjacent newlines. If the range fully contains a paragraph belonging to a list, the paragraph\'s bullet is also updated with the matching text style. Ranges cannot be inserted inside a relative UpdateTextStyleRequest.
    range :: (Core.Maybe Range),
    -- | The styles to set on the text. If the value for a particular style matches that of the parent, that style will be set to inherit. Certain text style changes may cause other changes in order to to mirror the behavior of the Docs editor. See the documentation of TextStyle for more information.
    textStyle :: (Core.Maybe TextStyle)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'UpdateTextStyleRequest' with the minimum fields required to make a request.
newUpdateTextStyleRequest ::
  UpdateTextStyleRequest
newUpdateTextStyleRequest =
  UpdateTextStyleRequest
    { fields = Core.Nothing,
      range = Core.Nothing,
      textStyle = Core.Nothing
    }

instance Core.FromJSON UpdateTextStyleRequest where
  parseJSON =
    Core.withObject
      "UpdateTextStyleRequest"
      ( \o ->
          UpdateTextStyleRequest
            Core.<$> (o Core..:? "fields")
            Core.<*> (o Core..:? "range")
            Core.<*> (o Core..:? "textStyle")
      )

instance Core.ToJSON UpdateTextStyleRequest where
  toJSON UpdateTextStyleRequest {..} =
    Core.object
      ( Core.catMaybes
          [ ("fields" Core..=) Core.<$> fields,
            ("range" Core..=) Core.<$> range,
            ("textStyle" Core..=) Core.<$> textStyle
          ]
      )

-- | Represents a font family and weight of text.
--
-- /See:/ 'newWeightedFontFamily' smart constructor.
data WeightedFontFamily = WeightedFontFamily
  { -- | The font family of the text. The font family can be any font from the Font menu in Docs or from [Google Fonts] (https:\/\/fonts.google.com\/). If the font name is unrecognized, the text is rendered in @Arial@.
    fontFamily :: (Core.Maybe Core.Text),
    -- | The weight of the font. This field can have any value that\'s a multiple of @100@ between @100@ and @900@, inclusive. This range corresponds to the numerical values described in the CSS 2.1 Specification, <https://www.w3.org/TR/CSS21/fonts.html#font-boldness section 15.6>, with non-numerical values disallowed. The default value is @400@ (\"normal\"). The font weight makes up just one component of the rendered font weight. A combination of the @weight@ and the text style\'s resolved @bold@ value determine the rendered weight, after accounting for inheritance: * If the text is bold and the weight is less than @400@, the rendered weight is 400. * If the text is bold and the weight is greater than or equal to @400@ but is less than @700@, the rendered weight is @700@. * If the weight is greater than or equal to @700@, the rendered weight is equal to the weight. * If the text is not bold, the rendered weight is equal to the weight.
    weight :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'WeightedFontFamily' with the minimum fields required to make a request.
newWeightedFontFamily ::
  WeightedFontFamily
newWeightedFontFamily =
  WeightedFontFamily
    { fontFamily = Core.Nothing,
      weight = Core.Nothing
    }

instance Core.FromJSON WeightedFontFamily where
  parseJSON =
    Core.withObject
      "WeightedFontFamily"
      ( \o ->
          WeightedFontFamily
            Core.<$> (o Core..:? "fontFamily")
            Core.<*> (o Core..:? "weight")
      )

instance Core.ToJSON WeightedFontFamily where
  toJSON WeightedFontFamily {..} =
    Core.object
      ( Core.catMaybes
          [ ("fontFamily" Core..=) Core.<$> fontFamily,
            ("weight" Core..=) Core.<$> weight
          ]
      )

-- | Provides control over how write requests are executed.
--
-- /See:/ 'newWriteControl' smart constructor.
data WriteControl = WriteControl
  { -- | The optional revision ID of the document the write request is applied to. If this is not the latest revision of the document, the request is not processed and returns a 400 bad request error. When a required revision ID is returned in a response, it indicates the revision ID of the document after the request was applied.
    requiredRevisionId :: (Core.Maybe Core.Text),
    -- | The optional target revision ID of the document the write request is applied to. If collaborator changes have occurred after the document was read using the API, the changes produced by this write request are applied against the collaborator changes. This results in a new revision of the document that incorporates both the collaborator changes and the changes in the request, with the Docs server resolving conflicting changes. When using target revision ID, the API client can be thought of as another collaborator of the document. The target revision ID can only be used to write to recent versions of a document. If the target revision is too far behind the latest revision, the request is not processed and returns a 400 bad request error. The request should be tried again after retrieving the latest version of the document. Usually a revision ID remains valid for use as a target revision for several minutes after it\'s read, but for frequently edited documents this window might be shorter.
    targetRevisionId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'WriteControl' with the minimum fields required to make a request.
newWriteControl ::
  WriteControl
newWriteControl =
  WriteControl
    { requiredRevisionId = Core.Nothing,
      targetRevisionId = Core.Nothing
    }

instance Core.FromJSON WriteControl where
  parseJSON =
    Core.withObject
      "WriteControl"
      ( \o ->
          WriteControl
            Core.<$> (o Core..:? "requiredRevisionId")
            Core.<*> (o Core..:? "targetRevisionId")
      )

instance Core.ToJSON WriteControl where
  toJSON WriteControl {..} =
    Core.object
      ( Core.catMaybes
          [ ("requiredRevisionId" Core..=) Core.<$> requiredRevisionId,
            ("targetRevisionId" Core..=) Core.<$> targetRevisionId
          ]
      )