haskell-google-genai-client-0.1.0: lib/GenAI/Client/ModelLens.hs

{-
   Generative Language API

   The Gemini API allows developers to build generative AI applications using Gemini models. Gemini is our most capable model, built from the ground up to be multimodal. It can generalize and seamlessly understand, operate across, and combine different types of information including language, images, audio, video, and code. You can use the Gemini API for use cases like reasoning across text and images, content generation, dialogue agents, summarization and classification systems, and more.

   OpenAPI Version: 3.0.3
   Generative Language API API version: v1beta
   Generated by OpenAPI Generator (https://openapi-generator.tech)
-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE RecordWildCards #-}
{-# OPTIONS_GHC -fno-warn-name-shadowing -fno-warn-unused-matches -fno-warn-unused-binds -fno-warn-unused-imports #-}

{- |
Module : GenAI.Client.Lens
-}
module GenAI.Client.ModelLens where

import Data.Aeson qualified as A
import Data.ByteString.Lazy qualified as BL
import Data.Data qualified as P (Data, Typeable)
import Data.Map qualified as Map
import Data.Set qualified as Set
import Data.Time qualified as TI

import Data.Text (Text)

import Prelude (Applicative, Bool (..), Char, Double, FilePath, Float, Functor, Int, Integer, Maybe (..), Monad, String, fmap, maybe, mempty, pure, undefined, ($), (.), (<$>), (<*>), (=<<))
import Prelude qualified as P

import GenAI.Client.Core
import GenAI.Client.Model

-- * AttributionSourceId

-- | 'attributionSourceIdGroundingPassage' Lens
attributionSourceIdGroundingPassageL :: Lens_' AttributionSourceId (Maybe GroundingPassageId)
attributionSourceIdGroundingPassageL f AttributionSourceId {..} = (\attributionSourceIdGroundingPassage -> AttributionSourceId {attributionSourceIdGroundingPassage, ..}) <$> f attributionSourceIdGroundingPassage
{-# INLINE attributionSourceIdGroundingPassageL #-}

-- | 'attributionSourceIdSemanticRetrieverChunk' Lens
attributionSourceIdSemanticRetrieverChunkL :: Lens_' AttributionSourceId (Maybe SemanticRetrieverChunk)
attributionSourceIdSemanticRetrieverChunkL f AttributionSourceId {..} = (\attributionSourceIdSemanticRetrieverChunk -> AttributionSourceId {attributionSourceIdSemanticRetrieverChunk, ..}) <$> f attributionSourceIdSemanticRetrieverChunk
{-# INLINE attributionSourceIdSemanticRetrieverChunkL #-}

-- * BaseOperation

-- | 'baseOperationDone' Lens
baseOperationDoneL :: Lens_' BaseOperation (Maybe Bool)
baseOperationDoneL f BaseOperation {..} = (\baseOperationDone -> BaseOperation {baseOperationDone, ..}) <$> f baseOperationDone
{-# INLINE baseOperationDoneL #-}

-- | 'baseOperationName' Lens
baseOperationNameL :: Lens_' BaseOperation (Maybe Text)
baseOperationNameL f BaseOperation {..} = (\baseOperationName -> BaseOperation {baseOperationName, ..}) <$> f baseOperationName
{-# INLINE baseOperationNameL #-}

-- | 'baseOperationError' Lens
baseOperationErrorL :: Lens_' BaseOperation (Maybe Status)
baseOperationErrorL f BaseOperation {..} = (\baseOperationError -> BaseOperation {baseOperationError, ..}) <$> f baseOperationError
{-# INLINE baseOperationErrorL #-}

-- * BatchCreateChunksRequest

-- | 'batchCreateChunksRequestRequests' Lens
batchCreateChunksRequestRequestsL :: Lens_' BatchCreateChunksRequest ([CreateChunkRequest])
batchCreateChunksRequestRequestsL f BatchCreateChunksRequest {..} = (\batchCreateChunksRequestRequests -> BatchCreateChunksRequest {batchCreateChunksRequestRequests, ..}) <$> f batchCreateChunksRequestRequests
{-# INLINE batchCreateChunksRequestRequestsL #-}

-- * BatchCreateChunksResponse

-- | 'batchCreateChunksResponseChunks' Lens
batchCreateChunksResponseChunksL :: Lens_' BatchCreateChunksResponse (Maybe [Chunk])
batchCreateChunksResponseChunksL f BatchCreateChunksResponse {..} = (\batchCreateChunksResponseChunks -> BatchCreateChunksResponse {batchCreateChunksResponseChunks, ..}) <$> f batchCreateChunksResponseChunks
{-# INLINE batchCreateChunksResponseChunksL #-}

-- * BatchDeleteChunksRequest

-- | 'batchDeleteChunksRequestRequests' Lens
batchDeleteChunksRequestRequestsL :: Lens_' BatchDeleteChunksRequest ([DeleteChunkRequest])
batchDeleteChunksRequestRequestsL f BatchDeleteChunksRequest {..} = (\batchDeleteChunksRequestRequests -> BatchDeleteChunksRequest {batchDeleteChunksRequestRequests, ..}) <$> f batchDeleteChunksRequestRequests
{-# INLINE batchDeleteChunksRequestRequestsL #-}

-- * BatchEmbedContentsRequest

-- | 'batchEmbedContentsRequestRequests' Lens
batchEmbedContentsRequestRequestsL :: Lens_' BatchEmbedContentsRequest ([EmbedContentRequest])
batchEmbedContentsRequestRequestsL f BatchEmbedContentsRequest {..} = (\batchEmbedContentsRequestRequests -> BatchEmbedContentsRequest {batchEmbedContentsRequestRequests, ..}) <$> f batchEmbedContentsRequestRequests
{-# INLINE batchEmbedContentsRequestRequestsL #-}

-- * BatchEmbedContentsResponse

-- | 'batchEmbedContentsResponseEmbeddings' Lens
batchEmbedContentsResponseEmbeddingsL :: Lens_' BatchEmbedContentsResponse (Maybe [ContentEmbedding])
batchEmbedContentsResponseEmbeddingsL f BatchEmbedContentsResponse {..} = (\batchEmbedContentsResponseEmbeddings -> BatchEmbedContentsResponse {batchEmbedContentsResponseEmbeddings, ..}) <$> f batchEmbedContentsResponseEmbeddings
{-# INLINE batchEmbedContentsResponseEmbeddingsL #-}

-- * BatchEmbedTextRequest

-- | 'batchEmbedTextRequestRequests' Lens
batchEmbedTextRequestRequestsL :: Lens_' BatchEmbedTextRequest (Maybe [EmbedTextRequest])
batchEmbedTextRequestRequestsL f BatchEmbedTextRequest {..} = (\batchEmbedTextRequestRequests -> BatchEmbedTextRequest {batchEmbedTextRequestRequests, ..}) <$> f batchEmbedTextRequestRequests
{-# INLINE batchEmbedTextRequestRequestsL #-}

-- | 'batchEmbedTextRequestTexts' Lens
batchEmbedTextRequestTextsL :: Lens_' BatchEmbedTextRequest (Maybe [Text])
batchEmbedTextRequestTextsL f BatchEmbedTextRequest {..} = (\batchEmbedTextRequestTexts -> BatchEmbedTextRequest {batchEmbedTextRequestTexts, ..}) <$> f batchEmbedTextRequestTexts
{-# INLINE batchEmbedTextRequestTextsL #-}

-- * BatchEmbedTextResponse

-- | 'batchEmbedTextResponseEmbeddings' Lens
batchEmbedTextResponseEmbeddingsL :: Lens_' BatchEmbedTextResponse (Maybe [Embedding])
batchEmbedTextResponseEmbeddingsL f BatchEmbedTextResponse {..} = (\batchEmbedTextResponseEmbeddings -> BatchEmbedTextResponse {batchEmbedTextResponseEmbeddings, ..}) <$> f batchEmbedTextResponseEmbeddings
{-# INLINE batchEmbedTextResponseEmbeddingsL #-}

-- * BatchUpdateChunksRequest

-- | 'batchUpdateChunksRequestRequests' Lens
batchUpdateChunksRequestRequestsL :: Lens_' BatchUpdateChunksRequest ([UpdateChunkRequest])
batchUpdateChunksRequestRequestsL f BatchUpdateChunksRequest {..} = (\batchUpdateChunksRequestRequests -> BatchUpdateChunksRequest {batchUpdateChunksRequestRequests, ..}) <$> f batchUpdateChunksRequestRequests
{-# INLINE batchUpdateChunksRequestRequestsL #-}

-- * BatchUpdateChunksResponse

-- | 'batchUpdateChunksResponseChunks' Lens
batchUpdateChunksResponseChunksL :: Lens_' BatchUpdateChunksResponse (Maybe [Chunk])
batchUpdateChunksResponseChunksL f BatchUpdateChunksResponse {..} = (\batchUpdateChunksResponseChunks -> BatchUpdateChunksResponse {batchUpdateChunksResponseChunks, ..}) <$> f batchUpdateChunksResponseChunks
{-# INLINE batchUpdateChunksResponseChunksL #-}

-- * Blob

-- | 'blobData' Lens
blobDataL :: Lens_' Blob (Maybe ByteArray)
blobDataL f Blob {..} = (\blobData -> Blob {blobData, ..}) <$> f blobData
{-# INLINE blobDataL #-}

-- | 'blobMimeType' Lens
blobMimeTypeL :: Lens_' Blob (Maybe Text)
blobMimeTypeL f Blob {..} = (\blobMimeType -> Blob {blobMimeType, ..}) <$> f blobMimeType
{-# INLINE blobMimeTypeL #-}

-- * CachedContent

-- | 'cachedContentTools' Lens
cachedContentToolsL :: Lens_' CachedContent (Maybe [Tool])
cachedContentToolsL f CachedContent {..} = (\cachedContentTools -> CachedContent {cachedContentTools, ..}) <$> f cachedContentTools
{-# INLINE cachedContentToolsL #-}

-- | 'cachedContentDisplayName' Lens
cachedContentDisplayNameL :: Lens_' CachedContent (Maybe Text)
cachedContentDisplayNameL f CachedContent {..} = (\cachedContentDisplayName -> CachedContent {cachedContentDisplayName, ..}) <$> f cachedContentDisplayName
{-# INLINE cachedContentDisplayNameL #-}

-- | 'cachedContentModel' Lens
cachedContentModelL :: Lens_' CachedContent (Text)
cachedContentModelL f CachedContent {..} = (\cachedContentModel -> CachedContent {cachedContentModel, ..}) <$> f cachedContentModel
{-# INLINE cachedContentModelL #-}

-- | 'cachedContentExpireTime' Lens
cachedContentExpireTimeL :: Lens_' CachedContent (Maybe DateTime)
cachedContentExpireTimeL f CachedContent {..} = (\cachedContentExpireTime -> CachedContent {cachedContentExpireTime, ..}) <$> f cachedContentExpireTime
{-# INLINE cachedContentExpireTimeL #-}

-- | 'cachedContentUsageMetadata' Lens
cachedContentUsageMetadataL :: Lens_' CachedContent (Maybe CachedContentUsageMetadata)
cachedContentUsageMetadataL f CachedContent {..} = (\cachedContentUsageMetadata -> CachedContent {cachedContentUsageMetadata, ..}) <$> f cachedContentUsageMetadata
{-# INLINE cachedContentUsageMetadataL #-}

-- | 'cachedContentName' Lens
cachedContentNameL :: Lens_' CachedContent (Maybe Text)
cachedContentNameL f CachedContent {..} = (\cachedContentName -> CachedContent {cachedContentName, ..}) <$> f cachedContentName
{-# INLINE cachedContentNameL #-}

-- | 'cachedContentContents' Lens
cachedContentContentsL :: Lens_' CachedContent (Maybe [Content])
cachedContentContentsL f CachedContent {..} = (\cachedContentContents -> CachedContent {cachedContentContents, ..}) <$> f cachedContentContents
{-# INLINE cachedContentContentsL #-}

-- | 'cachedContentSystemInstruction' Lens
cachedContentSystemInstructionL :: Lens_' CachedContent (Maybe Content)
cachedContentSystemInstructionL f CachedContent {..} = (\cachedContentSystemInstruction -> CachedContent {cachedContentSystemInstruction, ..}) <$> f cachedContentSystemInstruction
{-# INLINE cachedContentSystemInstructionL #-}

-- | 'cachedContentToolConfig' Lens
cachedContentToolConfigL :: Lens_' CachedContent (Maybe ToolConfig)
cachedContentToolConfigL f CachedContent {..} = (\cachedContentToolConfig -> CachedContent {cachedContentToolConfig, ..}) <$> f cachedContentToolConfig
{-# INLINE cachedContentToolConfigL #-}

-- | 'cachedContentCreateTime' Lens
cachedContentCreateTimeL :: Lens_' CachedContent (Maybe DateTime)
cachedContentCreateTimeL f CachedContent {..} = (\cachedContentCreateTime -> CachedContent {cachedContentCreateTime, ..}) <$> f cachedContentCreateTime
{-# INLINE cachedContentCreateTimeL #-}

-- | 'cachedContentTtl' Lens
cachedContentTtlL :: Lens_' CachedContent (Maybe Text)
cachedContentTtlL f CachedContent {..} = (\cachedContentTtl -> CachedContent {cachedContentTtl, ..}) <$> f cachedContentTtl
{-# INLINE cachedContentTtlL #-}

-- | 'cachedContentUpdateTime' Lens
cachedContentUpdateTimeL :: Lens_' CachedContent (Maybe DateTime)
cachedContentUpdateTimeL f CachedContent {..} = (\cachedContentUpdateTime -> CachedContent {cachedContentUpdateTime, ..}) <$> f cachedContentUpdateTime
{-# INLINE cachedContentUpdateTimeL #-}

-- * CachedContentUsageMetadata

-- | 'cachedContentUsageMetadataTotalTokenCount' Lens
cachedContentUsageMetadataTotalTokenCountL :: Lens_' CachedContentUsageMetadata (Maybe Int)
cachedContentUsageMetadataTotalTokenCountL f CachedContentUsageMetadata {..} = (\cachedContentUsageMetadataTotalTokenCount -> CachedContentUsageMetadata {cachedContentUsageMetadataTotalTokenCount, ..}) <$> f cachedContentUsageMetadataTotalTokenCount
{-# INLINE cachedContentUsageMetadataTotalTokenCountL #-}

-- * Candidate

-- | 'candidateCitationMetadata' Lens
candidateCitationMetadataL :: Lens_' Candidate (Maybe CitationMetadata)
candidateCitationMetadataL f Candidate {..} = (\candidateCitationMetadata -> Candidate {candidateCitationMetadata, ..}) <$> f candidateCitationMetadata
{-# INLINE candidateCitationMetadataL #-}

-- | 'candidateGroundingMetadata' Lens
candidateGroundingMetadataL :: Lens_' Candidate (Maybe GroundingMetadata)
candidateGroundingMetadataL f Candidate {..} = (\candidateGroundingMetadata -> Candidate {candidateGroundingMetadata, ..}) <$> f candidateGroundingMetadata
{-# INLINE candidateGroundingMetadataL #-}

-- | 'candidateUrlContextMetadata' Lens
candidateUrlContextMetadataL :: Lens_' Candidate (Maybe UrlContextMetadata)
candidateUrlContextMetadataL f Candidate {..} = (\candidateUrlContextMetadata -> Candidate {candidateUrlContextMetadata, ..}) <$> f candidateUrlContextMetadata
{-# INLINE candidateUrlContextMetadataL #-}

-- | 'candidateGroundingAttributions' Lens
candidateGroundingAttributionsL :: Lens_' Candidate (Maybe [GroundingAttribution])
candidateGroundingAttributionsL f Candidate {..} = (\candidateGroundingAttributions -> Candidate {candidateGroundingAttributions, ..}) <$> f candidateGroundingAttributions
{-# INLINE candidateGroundingAttributionsL #-}

-- | 'candidateLogprobsResult' Lens
candidateLogprobsResultL :: Lens_' Candidate (Maybe LogprobsResult)
candidateLogprobsResultL f Candidate {..} = (\candidateLogprobsResult -> Candidate {candidateLogprobsResult, ..}) <$> f candidateLogprobsResult
{-# INLINE candidateLogprobsResultL #-}

-- | 'candidateContent' Lens
candidateContentL :: Lens_' Candidate (Maybe Content)
candidateContentL f Candidate {..} = (\candidateContent -> Candidate {candidateContent, ..}) <$> f candidateContent
{-# INLINE candidateContentL #-}

-- | 'candidateAvgLogprobs' Lens
candidateAvgLogprobsL :: Lens_' Candidate (Maybe Double)
candidateAvgLogprobsL f Candidate {..} = (\candidateAvgLogprobs -> Candidate {candidateAvgLogprobs, ..}) <$> f candidateAvgLogprobs
{-# INLINE candidateAvgLogprobsL #-}

-- | 'candidateIndex' Lens
candidateIndexL :: Lens_' Candidate (Maybe Int)
candidateIndexL f Candidate {..} = (\candidateIndex -> Candidate {candidateIndex, ..}) <$> f candidateIndex
{-# INLINE candidateIndexL #-}

-- | 'candidateFinishReason' Lens
candidateFinishReasonL :: Lens_' Candidate (Maybe E'FinishReason)
candidateFinishReasonL f Candidate {..} = (\candidateFinishReason -> Candidate {candidateFinishReason, ..}) <$> f candidateFinishReason
{-# INLINE candidateFinishReasonL #-}

-- | 'candidateSafetyRatings' Lens
candidateSafetyRatingsL :: Lens_' Candidate (Maybe [SafetyRating])
candidateSafetyRatingsL f Candidate {..} = (\candidateSafetyRatings -> Candidate {candidateSafetyRatings, ..}) <$> f candidateSafetyRatings
{-# INLINE candidateSafetyRatingsL #-}

-- | 'candidateTokenCount' Lens
candidateTokenCountL :: Lens_' Candidate (Maybe Int)
candidateTokenCountL f Candidate {..} = (\candidateTokenCount -> Candidate {candidateTokenCount, ..}) <$> f candidateTokenCount
{-# INLINE candidateTokenCountL #-}

-- * Chunk

-- | 'chunkCreateTime' Lens
chunkCreateTimeL :: Lens_' Chunk (Maybe DateTime)
chunkCreateTimeL f Chunk {..} = (\chunkCreateTime -> Chunk {chunkCreateTime, ..}) <$> f chunkCreateTime
{-# INLINE chunkCreateTimeL #-}

-- | 'chunkCustomMetadata' Lens
chunkCustomMetadataL :: Lens_' Chunk (Maybe [CustomMetadata])
chunkCustomMetadataL f Chunk {..} = (\chunkCustomMetadata -> Chunk {chunkCustomMetadata, ..}) <$> f chunkCustomMetadata
{-# INLINE chunkCustomMetadataL #-}

-- | 'chunkData' Lens
chunkDataL :: Lens_' Chunk (ChunkData)
chunkDataL f Chunk {..} = (\chunkData -> Chunk {chunkData, ..}) <$> f chunkData
{-# INLINE chunkDataL #-}

-- | 'chunkUpdateTime' Lens
chunkUpdateTimeL :: Lens_' Chunk (Maybe DateTime)
chunkUpdateTimeL f Chunk {..} = (\chunkUpdateTime -> Chunk {chunkUpdateTime, ..}) <$> f chunkUpdateTime
{-# INLINE chunkUpdateTimeL #-}

-- | 'chunkState' Lens
chunkStateL :: Lens_' Chunk (Maybe E'State4)
chunkStateL f Chunk {..} = (\chunkState -> Chunk {chunkState, ..}) <$> f chunkState
{-# INLINE chunkStateL #-}

-- | 'chunkName' Lens
chunkNameL :: Lens_' Chunk (Maybe Text)
chunkNameL f Chunk {..} = (\chunkName -> Chunk {chunkName, ..}) <$> f chunkName
{-# INLINE chunkNameL #-}

-- * ChunkData

-- | 'chunkDataStringValue' Lens
chunkDataStringValueL :: Lens_' ChunkData (Maybe Text)
chunkDataStringValueL f ChunkData {..} = (\chunkDataStringValue -> ChunkData {chunkDataStringValue, ..}) <$> f chunkDataStringValue
{-# INLINE chunkDataStringValueL #-}

-- * CitationMetadata

-- | 'citationMetadataCitationSources' Lens
citationMetadataCitationSourcesL :: Lens_' CitationMetadata (Maybe [CitationSource])
citationMetadataCitationSourcesL f CitationMetadata {..} = (\citationMetadataCitationSources -> CitationMetadata {citationMetadataCitationSources, ..}) <$> f citationMetadataCitationSources
{-# INLINE citationMetadataCitationSourcesL #-}

-- * CitationSource

-- | 'citationSourceStartIndex' Lens
citationSourceStartIndexL :: Lens_' CitationSource (Maybe Int)
citationSourceStartIndexL f CitationSource {..} = (\citationSourceStartIndex -> CitationSource {citationSourceStartIndex, ..}) <$> f citationSourceStartIndex
{-# INLINE citationSourceStartIndexL #-}

-- | 'citationSourceUri' Lens
citationSourceUriL :: Lens_' CitationSource (Maybe Text)
citationSourceUriL f CitationSource {..} = (\citationSourceUri -> CitationSource {citationSourceUri, ..}) <$> f citationSourceUri
{-# INLINE citationSourceUriL #-}

-- | 'citationSourceEndIndex' Lens
citationSourceEndIndexL :: Lens_' CitationSource (Maybe Int)
citationSourceEndIndexL f CitationSource {..} = (\citationSourceEndIndex -> CitationSource {citationSourceEndIndex, ..}) <$> f citationSourceEndIndex
{-# INLINE citationSourceEndIndexL #-}

-- | 'citationSourceLicense' Lens
citationSourceLicenseL :: Lens_' CitationSource (Maybe Text)
citationSourceLicenseL f CitationSource {..} = (\citationSourceLicense -> CitationSource {citationSourceLicense, ..}) <$> f citationSourceLicense
{-# INLINE citationSourceLicenseL #-}

-- * CodeExecutionResult

-- | 'codeExecutionResultOutcome' Lens
codeExecutionResultOutcomeL :: Lens_' CodeExecutionResult (E'Outcome)
codeExecutionResultOutcomeL f CodeExecutionResult {..} = (\codeExecutionResultOutcome -> CodeExecutionResult {codeExecutionResultOutcome, ..}) <$> f codeExecutionResultOutcome
{-# INLINE codeExecutionResultOutcomeL #-}

-- | 'codeExecutionResultOutput' Lens
codeExecutionResultOutputL :: Lens_' CodeExecutionResult (Maybe Text)
codeExecutionResultOutputL f CodeExecutionResult {..} = (\codeExecutionResultOutput -> CodeExecutionResult {codeExecutionResultOutput, ..}) <$> f codeExecutionResultOutput
{-# INLINE codeExecutionResultOutputL #-}

-- * Condition

-- | 'conditionNumericValue' Lens
conditionNumericValueL :: Lens_' Condition (Maybe Float)
conditionNumericValueL f Condition {..} = (\conditionNumericValue -> Condition {conditionNumericValue, ..}) <$> f conditionNumericValue
{-# INLINE conditionNumericValueL #-}

-- | 'conditionOperation' Lens
conditionOperationL :: Lens_' Condition (E'Operation)
conditionOperationL f Condition {..} = (\conditionOperation -> Condition {conditionOperation, ..}) <$> f conditionOperation
{-# INLINE conditionOperationL #-}

-- | 'conditionStringValue' Lens
conditionStringValueL :: Lens_' Condition (Maybe Text)
conditionStringValueL f Condition {..} = (\conditionStringValue -> Condition {conditionStringValue, ..}) <$> f conditionStringValue
{-# INLINE conditionStringValueL #-}

-- * Content

-- | 'contentParts' Lens
contentPartsL :: Lens_' Content (Maybe [Part])
contentPartsL f Content {..} = (\contentParts -> Content {contentParts, ..}) <$> f contentParts
{-# INLINE contentPartsL #-}

-- | 'contentRole' Lens
contentRoleL :: Lens_' Content (Maybe Text)
contentRoleL f Content {..} = (\contentRole -> Content {contentRole, ..}) <$> f contentRole
{-# INLINE contentRoleL #-}

-- * ContentEmbedding

-- | 'contentEmbeddingValues' Lens
contentEmbeddingValuesL :: Lens_' ContentEmbedding (Maybe [Float])
contentEmbeddingValuesL f ContentEmbedding {..} = (\contentEmbeddingValues -> ContentEmbedding {contentEmbeddingValues, ..}) <$> f contentEmbeddingValues
{-# INLINE contentEmbeddingValuesL #-}

-- * ContentFilter

-- | 'contentFilterReason' Lens
contentFilterReasonL :: Lens_' ContentFilter (Maybe E'Reason)
contentFilterReasonL f ContentFilter {..} = (\contentFilterReason -> ContentFilter {contentFilterReason, ..}) <$> f contentFilterReason
{-# INLINE contentFilterReasonL #-}

-- | 'contentFilterMessage' Lens
contentFilterMessageL :: Lens_' ContentFilter (Maybe Text)
contentFilterMessageL f ContentFilter {..} = (\contentFilterMessage -> ContentFilter {contentFilterMessage, ..}) <$> f contentFilterMessage
{-# INLINE contentFilterMessageL #-}

-- * Corpus

-- | 'corpusUpdateTime' Lens
corpusUpdateTimeL :: Lens_' Corpus (Maybe DateTime)
corpusUpdateTimeL f Corpus {..} = (\corpusUpdateTime -> Corpus {corpusUpdateTime, ..}) <$> f corpusUpdateTime
{-# INLINE corpusUpdateTimeL #-}

-- | 'corpusCreateTime' Lens
corpusCreateTimeL :: Lens_' Corpus (Maybe DateTime)
corpusCreateTimeL f Corpus {..} = (\corpusCreateTime -> Corpus {corpusCreateTime, ..}) <$> f corpusCreateTime
{-# INLINE corpusCreateTimeL #-}

-- | 'corpusDisplayName' Lens
corpusDisplayNameL :: Lens_' Corpus (Maybe Text)
corpusDisplayNameL f Corpus {..} = (\corpusDisplayName -> Corpus {corpusDisplayName, ..}) <$> f corpusDisplayName
{-# INLINE corpusDisplayNameL #-}

-- | 'corpusName' Lens
corpusNameL :: Lens_' Corpus (Maybe Text)
corpusNameL f Corpus {..} = (\corpusName -> Corpus {corpusName, ..}) <$> f corpusName
{-# INLINE corpusNameL #-}

-- * CountMessageTokensRequest

-- | 'countMessageTokensRequestPrompt' Lens
countMessageTokensRequestPromptL :: Lens_' CountMessageTokensRequest (MessagePrompt)
countMessageTokensRequestPromptL f CountMessageTokensRequest {..} = (\countMessageTokensRequestPrompt -> CountMessageTokensRequest {countMessageTokensRequestPrompt, ..}) <$> f countMessageTokensRequestPrompt
{-# INLINE countMessageTokensRequestPromptL #-}

-- * CountMessageTokensResponse

-- | 'countMessageTokensResponseTokenCount' Lens
countMessageTokensResponseTokenCountL :: Lens_' CountMessageTokensResponse (Maybe Int)
countMessageTokensResponseTokenCountL f CountMessageTokensResponse {..} = (\countMessageTokensResponseTokenCount -> CountMessageTokensResponse {countMessageTokensResponseTokenCount, ..}) <$> f countMessageTokensResponseTokenCount
{-# INLINE countMessageTokensResponseTokenCountL #-}

-- * CountTextTokensRequest

-- | 'countTextTokensRequestPrompt' Lens
countTextTokensRequestPromptL :: Lens_' CountTextTokensRequest (TextPrompt)
countTextTokensRequestPromptL f CountTextTokensRequest {..} = (\countTextTokensRequestPrompt -> CountTextTokensRequest {countTextTokensRequestPrompt, ..}) <$> f countTextTokensRequestPrompt
{-# INLINE countTextTokensRequestPromptL #-}

-- * CountTextTokensResponse

-- | 'countTextTokensResponseTokenCount' Lens
countTextTokensResponseTokenCountL :: Lens_' CountTextTokensResponse (Maybe Int)
countTextTokensResponseTokenCountL f CountTextTokensResponse {..} = (\countTextTokensResponseTokenCount -> CountTextTokensResponse {countTextTokensResponseTokenCount, ..}) <$> f countTextTokensResponseTokenCount
{-# INLINE countTextTokensResponseTokenCountL #-}

-- * CountTokensRequest

-- | 'countTokensRequestContents' Lens
countTokensRequestContentsL :: Lens_' CountTokensRequest (Maybe [Content])
countTokensRequestContentsL f CountTokensRequest {..} = (\countTokensRequestContents -> CountTokensRequest {countTokensRequestContents, ..}) <$> f countTokensRequestContents
{-# INLINE countTokensRequestContentsL #-}

-- | 'countTokensRequestGenerateContentRequest' Lens
countTokensRequestGenerateContentRequestL :: Lens_' CountTokensRequest (Maybe GenerateContentRequest)
countTokensRequestGenerateContentRequestL f CountTokensRequest {..} = (\countTokensRequestGenerateContentRequest -> CountTokensRequest {countTokensRequestGenerateContentRequest, ..}) <$> f countTokensRequestGenerateContentRequest
{-# INLINE countTokensRequestGenerateContentRequestL #-}

-- * CountTokensResponse

-- | 'countTokensResponseCacheTokensDetails' Lens
countTokensResponseCacheTokensDetailsL :: Lens_' CountTokensResponse (Maybe [ModalityTokenCount])
countTokensResponseCacheTokensDetailsL f CountTokensResponse {..} = (\countTokensResponseCacheTokensDetails -> CountTokensResponse {countTokensResponseCacheTokensDetails, ..}) <$> f countTokensResponseCacheTokensDetails
{-# INLINE countTokensResponseCacheTokensDetailsL #-}

-- | 'countTokensResponsePromptTokensDetails' Lens
countTokensResponsePromptTokensDetailsL :: Lens_' CountTokensResponse (Maybe [ModalityTokenCount])
countTokensResponsePromptTokensDetailsL f CountTokensResponse {..} = (\countTokensResponsePromptTokensDetails -> CountTokensResponse {countTokensResponsePromptTokensDetails, ..}) <$> f countTokensResponsePromptTokensDetails
{-# INLINE countTokensResponsePromptTokensDetailsL #-}

-- | 'countTokensResponseTotalTokens' Lens
countTokensResponseTotalTokensL :: Lens_' CountTokensResponse (Maybe Int)
countTokensResponseTotalTokensL f CountTokensResponse {..} = (\countTokensResponseTotalTokens -> CountTokensResponse {countTokensResponseTotalTokens, ..}) <$> f countTokensResponseTotalTokens
{-# INLINE countTokensResponseTotalTokensL #-}

-- | 'countTokensResponseCachedContentTokenCount' Lens
countTokensResponseCachedContentTokenCountL :: Lens_' CountTokensResponse (Maybe Int)
countTokensResponseCachedContentTokenCountL f CountTokensResponse {..} = (\countTokensResponseCachedContentTokenCount -> CountTokensResponse {countTokensResponseCachedContentTokenCount, ..}) <$> f countTokensResponseCachedContentTokenCount
{-# INLINE countTokensResponseCachedContentTokenCountL #-}

-- * CreateChunkRequest

-- | 'createChunkRequestParent' Lens
createChunkRequestParentL :: Lens_' CreateChunkRequest (Text)
createChunkRequestParentL f CreateChunkRequest {..} = (\createChunkRequestParent -> CreateChunkRequest {createChunkRequestParent, ..}) <$> f createChunkRequestParent
{-# INLINE createChunkRequestParentL #-}

-- | 'createChunkRequestChunk' Lens
createChunkRequestChunkL :: Lens_' CreateChunkRequest (Chunk)
createChunkRequestChunkL f CreateChunkRequest {..} = (\createChunkRequestChunk -> CreateChunkRequest {createChunkRequestChunk, ..}) <$> f createChunkRequestChunk
{-# INLINE createChunkRequestChunkL #-}

-- * CreateFileRequest

-- | 'createFileRequestFile' Lens
createFileRequestFileL :: Lens_' CreateFileRequest (Maybe File)
createFileRequestFileL f CreateFileRequest {..} = (\createFileRequestFile -> CreateFileRequest {createFileRequestFile, ..}) <$> f createFileRequestFile
{-# INLINE createFileRequestFileL #-}

-- * CreateFileResponse

-- | 'createFileResponseFile' Lens
createFileResponseFileL :: Lens_' CreateFileResponse (Maybe File)
createFileResponseFileL f CreateFileResponse {..} = (\createFileResponseFile -> CreateFileResponse {createFileResponseFile, ..}) <$> f createFileResponseFile
{-# INLINE createFileResponseFileL #-}

-- * CreateTunedModelMetadata

-- | 'createTunedModelMetadataCompletedPercent' Lens
createTunedModelMetadataCompletedPercentL :: Lens_' CreateTunedModelMetadata (Maybe Float)
createTunedModelMetadataCompletedPercentL f CreateTunedModelMetadata {..} = (\createTunedModelMetadataCompletedPercent -> CreateTunedModelMetadata {createTunedModelMetadataCompletedPercent, ..}) <$> f createTunedModelMetadataCompletedPercent
{-# INLINE createTunedModelMetadataCompletedPercentL #-}

-- | 'createTunedModelMetadataCompletedSteps' Lens
createTunedModelMetadataCompletedStepsL :: Lens_' CreateTunedModelMetadata (Maybe Int)
createTunedModelMetadataCompletedStepsL f CreateTunedModelMetadata {..} = (\createTunedModelMetadataCompletedSteps -> CreateTunedModelMetadata {createTunedModelMetadataCompletedSteps, ..}) <$> f createTunedModelMetadataCompletedSteps
{-# INLINE createTunedModelMetadataCompletedStepsL #-}

-- | 'createTunedModelMetadataTotalSteps' Lens
createTunedModelMetadataTotalStepsL :: Lens_' CreateTunedModelMetadata (Maybe Int)
createTunedModelMetadataTotalStepsL f CreateTunedModelMetadata {..} = (\createTunedModelMetadataTotalSteps -> CreateTunedModelMetadata {createTunedModelMetadataTotalSteps, ..}) <$> f createTunedModelMetadataTotalSteps
{-# INLINE createTunedModelMetadataTotalStepsL #-}

-- | 'createTunedModelMetadataSnapshots' Lens
createTunedModelMetadataSnapshotsL :: Lens_' CreateTunedModelMetadata (Maybe [TuningSnapshot])
createTunedModelMetadataSnapshotsL f CreateTunedModelMetadata {..} = (\createTunedModelMetadataSnapshots -> CreateTunedModelMetadata {createTunedModelMetadataSnapshots, ..}) <$> f createTunedModelMetadataSnapshots
{-# INLINE createTunedModelMetadataSnapshotsL #-}

-- | 'createTunedModelMetadataTunedModel' Lens
createTunedModelMetadataTunedModelL :: Lens_' CreateTunedModelMetadata (Maybe Text)
createTunedModelMetadataTunedModelL f CreateTunedModelMetadata {..} = (\createTunedModelMetadataTunedModel -> CreateTunedModelMetadata {createTunedModelMetadataTunedModel, ..}) <$> f createTunedModelMetadataTunedModel
{-# INLINE createTunedModelMetadataTunedModelL #-}

-- * CreateTunedModelOperation

-- | 'createTunedModelOperationDone' Lens
createTunedModelOperationDoneL :: Lens_' CreateTunedModelOperation (Maybe Bool)
createTunedModelOperationDoneL f CreateTunedModelOperation {..} = (\createTunedModelOperationDone -> CreateTunedModelOperation {createTunedModelOperationDone, ..}) <$> f createTunedModelOperationDone
{-# INLINE createTunedModelOperationDoneL #-}

-- | 'createTunedModelOperationName' Lens
createTunedModelOperationNameL :: Lens_' CreateTunedModelOperation (Maybe Text)
createTunedModelOperationNameL f CreateTunedModelOperation {..} = (\createTunedModelOperationName -> CreateTunedModelOperation {createTunedModelOperationName, ..}) <$> f createTunedModelOperationName
{-# INLINE createTunedModelOperationNameL #-}

-- | 'createTunedModelOperationError' Lens
createTunedModelOperationErrorL :: Lens_' CreateTunedModelOperation (Maybe Status)
createTunedModelOperationErrorL f CreateTunedModelOperation {..} = (\createTunedModelOperationError -> CreateTunedModelOperation {createTunedModelOperationError, ..}) <$> f createTunedModelOperationError
{-# INLINE createTunedModelOperationErrorL #-}

-- | 'createTunedModelOperationMetadata' Lens
createTunedModelOperationMetadataL :: Lens_' CreateTunedModelOperation (Maybe CreateTunedModelMetadata)
createTunedModelOperationMetadataL f CreateTunedModelOperation {..} = (\createTunedModelOperationMetadata -> CreateTunedModelOperation {createTunedModelOperationMetadata, ..}) <$> f createTunedModelOperationMetadata
{-# INLINE createTunedModelOperationMetadataL #-}

-- | 'createTunedModelOperationResponse' Lens
createTunedModelOperationResponseL :: Lens_' CreateTunedModelOperation (Maybe TunedModel)
createTunedModelOperationResponseL f CreateTunedModelOperation {..} = (\createTunedModelOperationResponse -> CreateTunedModelOperation {createTunedModelOperationResponse, ..}) <$> f createTunedModelOperationResponse
{-# INLINE createTunedModelOperationResponseL #-}

-- * CustomMetadata

-- | 'customMetadataStringListValue' Lens
customMetadataStringListValueL :: Lens_' CustomMetadata (Maybe StringList)
customMetadataStringListValueL f CustomMetadata {..} = (\customMetadataStringListValue -> CustomMetadata {customMetadataStringListValue, ..}) <$> f customMetadataStringListValue
{-# INLINE customMetadataStringListValueL #-}

-- | 'customMetadataStringValue' Lens
customMetadataStringValueL :: Lens_' CustomMetadata (Maybe Text)
customMetadataStringValueL f CustomMetadata {..} = (\customMetadataStringValue -> CustomMetadata {customMetadataStringValue, ..}) <$> f customMetadataStringValue
{-# INLINE customMetadataStringValueL #-}

-- | 'customMetadataKey' Lens
customMetadataKeyL :: Lens_' CustomMetadata (Text)
customMetadataKeyL f CustomMetadata {..} = (\customMetadataKey -> CustomMetadata {customMetadataKey, ..}) <$> f customMetadataKey
{-# INLINE customMetadataKeyL #-}

-- | 'customMetadataNumericValue' Lens
customMetadataNumericValueL :: Lens_' CustomMetadata (Maybe Float)
customMetadataNumericValueL f CustomMetadata {..} = (\customMetadataNumericValue -> CustomMetadata {customMetadataNumericValue, ..}) <$> f customMetadataNumericValue
{-# INLINE customMetadataNumericValueL #-}

-- * Dataset

-- | 'datasetExamples' Lens
datasetExamplesL :: Lens_' Dataset (Maybe TuningExamples)
datasetExamplesL f Dataset {..} = (\datasetExamples -> Dataset {datasetExamples, ..}) <$> f datasetExamples
{-# INLINE datasetExamplesL #-}

-- * DeleteChunkRequest

-- | 'deleteChunkRequestName' Lens
deleteChunkRequestNameL :: Lens_' DeleteChunkRequest (Text)
deleteChunkRequestNameL f DeleteChunkRequest {..} = (\deleteChunkRequestName -> DeleteChunkRequest {deleteChunkRequestName, ..}) <$> f deleteChunkRequestName
{-# INLINE deleteChunkRequestNameL #-}

-- * Document

-- | 'documentUpdateTime' Lens
documentUpdateTimeL :: Lens_' Document (Maybe DateTime)
documentUpdateTimeL f Document {..} = (\documentUpdateTime -> Document {documentUpdateTime, ..}) <$> f documentUpdateTime
{-# INLINE documentUpdateTimeL #-}

-- | 'documentName' Lens
documentNameL :: Lens_' Document (Maybe Text)
documentNameL f Document {..} = (\documentName -> Document {documentName, ..}) <$> f documentName
{-# INLINE documentNameL #-}

-- | 'documentCustomMetadata' Lens
documentCustomMetadataL :: Lens_' Document (Maybe [CustomMetadata])
documentCustomMetadataL f Document {..} = (\documentCustomMetadata -> Document {documentCustomMetadata, ..}) <$> f documentCustomMetadata
{-# INLINE documentCustomMetadataL #-}

-- | 'documentCreateTime' Lens
documentCreateTimeL :: Lens_' Document (Maybe DateTime)
documentCreateTimeL f Document {..} = (\documentCreateTime -> Document {documentCreateTime, ..}) <$> f documentCreateTime
{-# INLINE documentCreateTimeL #-}

-- | 'documentDisplayName' Lens
documentDisplayNameL :: Lens_' Document (Maybe Text)
documentDisplayNameL f Document {..} = (\documentDisplayName -> Document {documentDisplayName, ..}) <$> f documentDisplayName
{-# INLINE documentDisplayNameL #-}

-- * DynamicRetrievalConfig

-- | 'dynamicRetrievalConfigDynamicThreshold' Lens
dynamicRetrievalConfigDynamicThresholdL :: Lens_' DynamicRetrievalConfig (Maybe Float)
dynamicRetrievalConfigDynamicThresholdL f DynamicRetrievalConfig {..} = (\dynamicRetrievalConfigDynamicThreshold -> DynamicRetrievalConfig {dynamicRetrievalConfigDynamicThreshold, ..}) <$> f dynamicRetrievalConfigDynamicThreshold
{-# INLINE dynamicRetrievalConfigDynamicThresholdL #-}

-- | 'dynamicRetrievalConfigMode' Lens
dynamicRetrievalConfigModeL :: Lens_' DynamicRetrievalConfig (Maybe E'Mode)
dynamicRetrievalConfigModeL f DynamicRetrievalConfig {..} = (\dynamicRetrievalConfigMode -> DynamicRetrievalConfig {dynamicRetrievalConfigMode, ..}) <$> f dynamicRetrievalConfigMode
{-# INLINE dynamicRetrievalConfigModeL #-}

-- * EmbedContentRequest

-- | 'embedContentRequestTaskType' Lens
embedContentRequestTaskTypeL :: Lens_' EmbedContentRequest (Maybe TaskType)
embedContentRequestTaskTypeL f EmbedContentRequest {..} = (\embedContentRequestTaskType -> EmbedContentRequest {embedContentRequestTaskType, ..}) <$> f embedContentRequestTaskType
{-# INLINE embedContentRequestTaskTypeL #-}

-- | 'embedContentRequestContent' Lens
embedContentRequestContentL :: Lens_' EmbedContentRequest (Content)
embedContentRequestContentL f EmbedContentRequest {..} = (\embedContentRequestContent -> EmbedContentRequest {embedContentRequestContent, ..}) <$> f embedContentRequestContent
{-# INLINE embedContentRequestContentL #-}

-- | 'embedContentRequestOutputDimensionality' Lens
embedContentRequestOutputDimensionalityL :: Lens_' EmbedContentRequest (Maybe Int)
embedContentRequestOutputDimensionalityL f EmbedContentRequest {..} = (\embedContentRequestOutputDimensionality -> EmbedContentRequest {embedContentRequestOutputDimensionality, ..}) <$> f embedContentRequestOutputDimensionality
{-# INLINE embedContentRequestOutputDimensionalityL #-}

-- | 'embedContentRequestModel' Lens
embedContentRequestModelL :: Lens_' EmbedContentRequest (Text)
embedContentRequestModelL f EmbedContentRequest {..} = (\embedContentRequestModel -> EmbedContentRequest {embedContentRequestModel, ..}) <$> f embedContentRequestModel
{-# INLINE embedContentRequestModelL #-}

-- | 'embedContentRequestTitle' Lens
embedContentRequestTitleL :: Lens_' EmbedContentRequest (Maybe Text)
embedContentRequestTitleL f EmbedContentRequest {..} = (\embedContentRequestTitle -> EmbedContentRequest {embedContentRequestTitle, ..}) <$> f embedContentRequestTitle
{-# INLINE embedContentRequestTitleL #-}

-- * EmbedContentResponse

-- | 'embedContentResponseEmbedding' Lens
embedContentResponseEmbeddingL :: Lens_' EmbedContentResponse (Maybe ContentEmbedding)
embedContentResponseEmbeddingL f EmbedContentResponse {..} = (\embedContentResponseEmbedding -> EmbedContentResponse {embedContentResponseEmbedding, ..}) <$> f embedContentResponseEmbedding
{-# INLINE embedContentResponseEmbeddingL #-}

-- * EmbedTextRequest

-- | 'embedTextRequestText' Lens
embedTextRequestTextL :: Lens_' EmbedTextRequest (Maybe Text)
embedTextRequestTextL f EmbedTextRequest {..} = (\embedTextRequestText -> EmbedTextRequest {embedTextRequestText, ..}) <$> f embedTextRequestText
{-# INLINE embedTextRequestTextL #-}

-- | 'embedTextRequestModel' Lens
embedTextRequestModelL :: Lens_' EmbedTextRequest (Text)
embedTextRequestModelL f EmbedTextRequest {..} = (\embedTextRequestModel -> EmbedTextRequest {embedTextRequestModel, ..}) <$> f embedTextRequestModel
{-# INLINE embedTextRequestModelL #-}

-- * EmbedTextResponse

-- | 'embedTextResponseEmbedding' Lens
embedTextResponseEmbeddingL :: Lens_' EmbedTextResponse (Maybe Embedding)
embedTextResponseEmbeddingL f EmbedTextResponse {..} = (\embedTextResponseEmbedding -> EmbedTextResponse {embedTextResponseEmbedding, ..}) <$> f embedTextResponseEmbedding
{-# INLINE embedTextResponseEmbeddingL #-}

-- * Embedding

-- | 'embeddingValue' Lens
embeddingValueL :: Lens_' Embedding (Maybe [Float])
embeddingValueL f Embedding {..} = (\embeddingValue -> Embedding {embeddingValue, ..}) <$> f embeddingValue
{-# INLINE embeddingValueL #-}

-- * Example

-- | 'exampleOutput' Lens
exampleOutputL :: Lens_' Example (Message)
exampleOutputL f Example {..} = (\exampleOutput -> Example {exampleOutput, ..}) <$> f exampleOutput
{-# INLINE exampleOutputL #-}

-- | 'exampleInput' Lens
exampleInputL :: Lens_' Example (Message)
exampleInputL f Example {..} = (\exampleInput -> Example {exampleInput, ..}) <$> f exampleInput
{-# INLINE exampleInputL #-}

-- * ExecutableCode

-- | 'executableCodeLanguage' Lens
executableCodeLanguageL :: Lens_' ExecutableCode (E'Language)
executableCodeLanguageL f ExecutableCode {..} = (\executableCodeLanguage -> ExecutableCode {executableCodeLanguage, ..}) <$> f executableCodeLanguage
{-# INLINE executableCodeLanguageL #-}

-- | 'executableCodeCode' Lens
executableCodeCodeL :: Lens_' ExecutableCode (Text)
executableCodeCodeL f ExecutableCode {..} = (\executableCodeCode -> ExecutableCode {executableCodeCode, ..}) <$> f executableCodeCode
{-# INLINE executableCodeCodeL #-}

-- * File

-- | 'fileUri' Lens
fileUriL :: Lens_' File (Maybe Text)
fileUriL f File {..} = (\fileUri -> File {fileUri, ..}) <$> f fileUri
{-# INLINE fileUriL #-}

-- | 'fileName' Lens
fileNameL :: Lens_' File (Maybe Text)
fileNameL f File {..} = (\fileName -> File {fileName, ..}) <$> f fileName
{-# INLINE fileNameL #-}

-- | 'fileExpirationTime' Lens
fileExpirationTimeL :: Lens_' File (Maybe DateTime)
fileExpirationTimeL f File {..} = (\fileExpirationTime -> File {fileExpirationTime, ..}) <$> f fileExpirationTime
{-# INLINE fileExpirationTimeL #-}

-- | 'fileDisplayName' Lens
fileDisplayNameL :: Lens_' File (Maybe Text)
fileDisplayNameL f File {..} = (\fileDisplayName -> File {fileDisplayName, ..}) <$> f fileDisplayName
{-# INLINE fileDisplayNameL #-}

-- | 'fileVideoMetadata' Lens
fileVideoMetadataL :: Lens_' File (Maybe VideoFileMetadata)
fileVideoMetadataL f File {..} = (\fileVideoMetadata -> File {fileVideoMetadata, ..}) <$> f fileVideoMetadata
{-# INLINE fileVideoMetadataL #-}

-- | 'fileState' Lens
fileStateL :: Lens_' File (Maybe E'State)
fileStateL f File {..} = (\fileState -> File {fileState, ..}) <$> f fileState
{-# INLINE fileStateL #-}

-- | 'fileSource' Lens
fileSourceL :: Lens_' File (Maybe E'Source)
fileSourceL f File {..} = (\fileSource -> File {fileSource, ..}) <$> f fileSource
{-# INLINE fileSourceL #-}

-- | 'fileMimeType' Lens
fileMimeTypeL :: Lens_' File (Maybe Text)
fileMimeTypeL f File {..} = (\fileMimeType -> File {fileMimeType, ..}) <$> f fileMimeType
{-# INLINE fileMimeTypeL #-}

-- | 'fileCreateTime' Lens
fileCreateTimeL :: Lens_' File (Maybe DateTime)
fileCreateTimeL f File {..} = (\fileCreateTime -> File {fileCreateTime, ..}) <$> f fileCreateTime
{-# INLINE fileCreateTimeL #-}

-- | 'fileError' Lens
fileErrorL :: Lens_' File (Maybe Status)
fileErrorL f File {..} = (\fileError -> File {fileError, ..}) <$> f fileError
{-# INLINE fileErrorL #-}

-- | 'fileDownloadUri' Lens
fileDownloadUriL :: Lens_' File (Maybe Text)
fileDownloadUriL f File {..} = (\fileDownloadUri -> File {fileDownloadUri, ..}) <$> f fileDownloadUri
{-# INLINE fileDownloadUriL #-}

-- | 'fileSizeBytes' Lens
fileSizeBytesL :: Lens_' File (Maybe Text)
fileSizeBytesL f File {..} = (\fileSizeBytes -> File {fileSizeBytes, ..}) <$> f fileSizeBytes
{-# INLINE fileSizeBytesL #-}

-- | 'fileSha256Hash' Lens
fileSha256HashL :: Lens_' File (Maybe ByteArray)
fileSha256HashL f File {..} = (\fileSha256Hash -> File {fileSha256Hash, ..}) <$> f fileSha256Hash
{-# INLINE fileSha256HashL #-}

-- | 'fileUpdateTime' Lens
fileUpdateTimeL :: Lens_' File (Maybe DateTime)
fileUpdateTimeL f File {..} = (\fileUpdateTime -> File {fileUpdateTime, ..}) <$> f fileUpdateTime
{-# INLINE fileUpdateTimeL #-}

-- * FileData

-- | 'fileDataMimeType' Lens
fileDataMimeTypeL :: Lens_' FileData (Maybe Text)
fileDataMimeTypeL f FileData {..} = (\fileDataMimeType -> FileData {fileDataMimeType, ..}) <$> f fileDataMimeType
{-# INLINE fileDataMimeTypeL #-}

-- | 'fileDataFileUri' Lens
fileDataFileUriL :: Lens_' FileData (Text)
fileDataFileUriL f FileData {..} = (\fileDataFileUri -> FileData {fileDataFileUri, ..}) <$> f fileDataFileUri
{-# INLINE fileDataFileUriL #-}

-- * FunctionCall

-- | 'functionCallArgs' Lens
functionCallArgsL :: Lens_' FunctionCall (Maybe (Map.Map String String))
functionCallArgsL f FunctionCall {..} = (\functionCallArgs -> FunctionCall {functionCallArgs, ..}) <$> f functionCallArgs
{-# INLINE functionCallArgsL #-}

-- | 'functionCallId' Lens
functionCallIdL :: Lens_' FunctionCall (Maybe Text)
functionCallIdL f FunctionCall {..} = (\functionCallId -> FunctionCall {functionCallId, ..}) <$> f functionCallId
{-# INLINE functionCallIdL #-}

-- | 'functionCallName' Lens
functionCallNameL :: Lens_' FunctionCall (Text)
functionCallNameL f FunctionCall {..} = (\functionCallName -> FunctionCall {functionCallName, ..}) <$> f functionCallName
{-# INLINE functionCallNameL #-}

-- * FunctionCallingConfig

-- | 'functionCallingConfigMode' Lens
functionCallingConfigModeL :: Lens_' FunctionCallingConfig (Maybe E'Mode2)
functionCallingConfigModeL f FunctionCallingConfig {..} = (\functionCallingConfigMode -> FunctionCallingConfig {functionCallingConfigMode, ..}) <$> f functionCallingConfigMode
{-# INLINE functionCallingConfigModeL #-}

-- | 'functionCallingConfigAllowedFunctionNames' Lens
functionCallingConfigAllowedFunctionNamesL :: Lens_' FunctionCallingConfig (Maybe [Text])
functionCallingConfigAllowedFunctionNamesL f FunctionCallingConfig {..} = (\functionCallingConfigAllowedFunctionNames -> FunctionCallingConfig {functionCallingConfigAllowedFunctionNames, ..}) <$> f functionCallingConfigAllowedFunctionNames
{-# INLINE functionCallingConfigAllowedFunctionNamesL #-}

-- * FunctionDeclaration

-- | 'functionDeclarationParameters' Lens
functionDeclarationParametersL :: Lens_' FunctionDeclaration (Maybe Schema)
functionDeclarationParametersL f FunctionDeclaration {..} = (\functionDeclarationParameters -> FunctionDeclaration {functionDeclarationParameters, ..}) <$> f functionDeclarationParameters
{-# INLINE functionDeclarationParametersL #-}

-- | 'functionDeclarationName' Lens
functionDeclarationNameL :: Lens_' FunctionDeclaration (Text)
functionDeclarationNameL f FunctionDeclaration {..} = (\functionDeclarationName -> FunctionDeclaration {functionDeclarationName, ..}) <$> f functionDeclarationName
{-# INLINE functionDeclarationNameL #-}

-- | 'functionDeclarationBehavior' Lens
functionDeclarationBehaviorL :: Lens_' FunctionDeclaration (Maybe E'Behavior)
functionDeclarationBehaviorL f FunctionDeclaration {..} = (\functionDeclarationBehavior -> FunctionDeclaration {functionDeclarationBehavior, ..}) <$> f functionDeclarationBehavior
{-# INLINE functionDeclarationBehaviorL #-}

-- | 'functionDeclarationDescription' Lens
functionDeclarationDescriptionL :: Lens_' FunctionDeclaration (Text)
functionDeclarationDescriptionL f FunctionDeclaration {..} = (\functionDeclarationDescription -> FunctionDeclaration {functionDeclarationDescription, ..}) <$> f functionDeclarationDescription
{-# INLINE functionDeclarationDescriptionL #-}

-- | 'functionDeclarationResponse' Lens
functionDeclarationResponseL :: Lens_' FunctionDeclaration (Maybe Schema)
functionDeclarationResponseL f FunctionDeclaration {..} = (\functionDeclarationResponse -> FunctionDeclaration {functionDeclarationResponse, ..}) <$> f functionDeclarationResponse
{-# INLINE functionDeclarationResponseL #-}

-- | 'functionDeclarationResponseJsonSchema' Lens
functionDeclarationResponseJsonSchemaL :: Lens_' FunctionDeclaration (Maybe String)
functionDeclarationResponseJsonSchemaL f FunctionDeclaration {..} = (\functionDeclarationResponseJsonSchema -> FunctionDeclaration {functionDeclarationResponseJsonSchema, ..}) <$> f functionDeclarationResponseJsonSchema
{-# INLINE functionDeclarationResponseJsonSchemaL #-}

-- | 'functionDeclarationParametersJsonSchema' Lens
functionDeclarationParametersJsonSchemaL :: Lens_' FunctionDeclaration (Maybe String)
functionDeclarationParametersJsonSchemaL f FunctionDeclaration {..} = (\functionDeclarationParametersJsonSchema -> FunctionDeclaration {functionDeclarationParametersJsonSchema, ..}) <$> f functionDeclarationParametersJsonSchema
{-# INLINE functionDeclarationParametersJsonSchemaL #-}

-- * FunctionResponse

-- | 'functionResponseScheduling' Lens
functionResponseSchedulingL :: Lens_' FunctionResponse (Maybe E'Scheduling)
functionResponseSchedulingL f FunctionResponse {..} = (\functionResponseScheduling -> FunctionResponse {functionResponseScheduling, ..}) <$> f functionResponseScheduling
{-# INLINE functionResponseSchedulingL #-}

-- | 'functionResponseId' Lens
functionResponseIdL :: Lens_' FunctionResponse (Maybe Text)
functionResponseIdL f FunctionResponse {..} = (\functionResponseId -> FunctionResponse {functionResponseId, ..}) <$> f functionResponseId
{-# INLINE functionResponseIdL #-}

-- | 'functionResponseWillContinue' Lens
functionResponseWillContinueL :: Lens_' FunctionResponse (Maybe Bool)
functionResponseWillContinueL f FunctionResponse {..} = (\functionResponseWillContinue -> FunctionResponse {functionResponseWillContinue, ..}) <$> f functionResponseWillContinue
{-# INLINE functionResponseWillContinueL #-}

-- | 'functionResponseName' Lens
functionResponseNameL :: Lens_' FunctionResponse (Text)
functionResponseNameL f FunctionResponse {..} = (\functionResponseName -> FunctionResponse {functionResponseName, ..}) <$> f functionResponseName
{-# INLINE functionResponseNameL #-}

-- | 'functionResponseResponse' Lens
functionResponseResponseL :: Lens_' FunctionResponse ((Map.Map String String))
functionResponseResponseL f FunctionResponse {..} = (\functionResponseResponse -> FunctionResponse {functionResponseResponse, ..}) <$> f functionResponseResponse
{-# INLINE functionResponseResponseL #-}

-- * GenerateAnswerRequest

-- | 'generateAnswerRequestSemanticRetriever' Lens
generateAnswerRequestSemanticRetrieverL :: Lens_' GenerateAnswerRequest (Maybe SemanticRetrieverConfig)
generateAnswerRequestSemanticRetrieverL f GenerateAnswerRequest {..} = (\generateAnswerRequestSemanticRetriever -> GenerateAnswerRequest {generateAnswerRequestSemanticRetriever, ..}) <$> f generateAnswerRequestSemanticRetriever
{-# INLINE generateAnswerRequestSemanticRetrieverL #-}

-- | 'generateAnswerRequestTemperature' Lens
generateAnswerRequestTemperatureL :: Lens_' GenerateAnswerRequest (Maybe Float)
generateAnswerRequestTemperatureL f GenerateAnswerRequest {..} = (\generateAnswerRequestTemperature -> GenerateAnswerRequest {generateAnswerRequestTemperature, ..}) <$> f generateAnswerRequestTemperature
{-# INLINE generateAnswerRequestTemperatureL #-}

-- | 'generateAnswerRequestAnswerStyle' Lens
generateAnswerRequestAnswerStyleL :: Lens_' GenerateAnswerRequest (E'AnswerStyle)
generateAnswerRequestAnswerStyleL f GenerateAnswerRequest {..} = (\generateAnswerRequestAnswerStyle -> GenerateAnswerRequest {generateAnswerRequestAnswerStyle, ..}) <$> f generateAnswerRequestAnswerStyle
{-# INLINE generateAnswerRequestAnswerStyleL #-}

-- | 'generateAnswerRequestContents' Lens
generateAnswerRequestContentsL :: Lens_' GenerateAnswerRequest ([Content])
generateAnswerRequestContentsL f GenerateAnswerRequest {..} = (\generateAnswerRequestContents -> GenerateAnswerRequest {generateAnswerRequestContents, ..}) <$> f generateAnswerRequestContents
{-# INLINE generateAnswerRequestContentsL #-}

-- | 'generateAnswerRequestSafetySettings' Lens
generateAnswerRequestSafetySettingsL :: Lens_' GenerateAnswerRequest (Maybe [SafetySetting])
generateAnswerRequestSafetySettingsL f GenerateAnswerRequest {..} = (\generateAnswerRequestSafetySettings -> GenerateAnswerRequest {generateAnswerRequestSafetySettings, ..}) <$> f generateAnswerRequestSafetySettings
{-# INLINE generateAnswerRequestSafetySettingsL #-}

-- | 'generateAnswerRequestInlinePassages' Lens
generateAnswerRequestInlinePassagesL :: Lens_' GenerateAnswerRequest (Maybe GroundingPassages)
generateAnswerRequestInlinePassagesL f GenerateAnswerRequest {..} = (\generateAnswerRequestInlinePassages -> GenerateAnswerRequest {generateAnswerRequestInlinePassages, ..}) <$> f generateAnswerRequestInlinePassages
{-# INLINE generateAnswerRequestInlinePassagesL #-}

-- * GenerateAnswerResponse

-- | 'generateAnswerResponseAnswer' Lens
generateAnswerResponseAnswerL :: Lens_' GenerateAnswerResponse (Maybe Candidate)
generateAnswerResponseAnswerL f GenerateAnswerResponse {..} = (\generateAnswerResponseAnswer -> GenerateAnswerResponse {generateAnswerResponseAnswer, ..}) <$> f generateAnswerResponseAnswer
{-# INLINE generateAnswerResponseAnswerL #-}

-- | 'generateAnswerResponseInputFeedback' Lens
generateAnswerResponseInputFeedbackL :: Lens_' GenerateAnswerResponse (Maybe InputFeedback)
generateAnswerResponseInputFeedbackL f GenerateAnswerResponse {..} = (\generateAnswerResponseInputFeedback -> GenerateAnswerResponse {generateAnswerResponseInputFeedback, ..}) <$> f generateAnswerResponseInputFeedback
{-# INLINE generateAnswerResponseInputFeedbackL #-}

-- | 'generateAnswerResponseAnswerableProbability' Lens
generateAnswerResponseAnswerableProbabilityL :: Lens_' GenerateAnswerResponse (Maybe Float)
generateAnswerResponseAnswerableProbabilityL f GenerateAnswerResponse {..} = (\generateAnswerResponseAnswerableProbability -> GenerateAnswerResponse {generateAnswerResponseAnswerableProbability, ..}) <$> f generateAnswerResponseAnswerableProbability
{-# INLINE generateAnswerResponseAnswerableProbabilityL #-}

-- * GenerateContentRequest

-- | 'generateContentRequestToolConfig' Lens
generateContentRequestToolConfigL :: Lens_' GenerateContentRequest (Maybe ToolConfig)
generateContentRequestToolConfigL f GenerateContentRequest {..} = (\generateContentRequestToolConfig -> GenerateContentRequest {generateContentRequestToolConfig, ..}) <$> f generateContentRequestToolConfig
{-# INLINE generateContentRequestToolConfigL #-}

-- | 'generateContentRequestTools' Lens
generateContentRequestToolsL :: Lens_' GenerateContentRequest (Maybe [Tool])
generateContentRequestToolsL f GenerateContentRequest {..} = (\generateContentRequestTools -> GenerateContentRequest {generateContentRequestTools, ..}) <$> f generateContentRequestTools
{-# INLINE generateContentRequestToolsL #-}

-- | 'generateContentRequestContents' Lens
generateContentRequestContentsL :: Lens_' GenerateContentRequest ([Content])
generateContentRequestContentsL f GenerateContentRequest {..} = (\generateContentRequestContents -> GenerateContentRequest {generateContentRequestContents, ..}) <$> f generateContentRequestContents
{-# INLINE generateContentRequestContentsL #-}

-- | 'generateContentRequestSystemInstruction' Lens
generateContentRequestSystemInstructionL :: Lens_' GenerateContentRequest (Maybe Content)
generateContentRequestSystemInstructionL f GenerateContentRequest {..} = (\generateContentRequestSystemInstruction -> GenerateContentRequest {generateContentRequestSystemInstruction, ..}) <$> f generateContentRequestSystemInstruction
{-# INLINE generateContentRequestSystemInstructionL #-}

-- | 'generateContentRequestCachedContent' Lens
generateContentRequestCachedContentL :: Lens_' GenerateContentRequest (Maybe Text)
generateContentRequestCachedContentL f GenerateContentRequest {..} = (\generateContentRequestCachedContent -> GenerateContentRequest {generateContentRequestCachedContent, ..}) <$> f generateContentRequestCachedContent
{-# INLINE generateContentRequestCachedContentL #-}

-- | 'generateContentRequestSafetySettings' Lens
generateContentRequestSafetySettingsL :: Lens_' GenerateContentRequest (Maybe [SafetySetting])
generateContentRequestSafetySettingsL f GenerateContentRequest {..} = (\generateContentRequestSafetySettings -> GenerateContentRequest {generateContentRequestSafetySettings, ..}) <$> f generateContentRequestSafetySettings
{-# INLINE generateContentRequestSafetySettingsL #-}

-- | 'generateContentRequestModel' Lens
generateContentRequestModelL :: Lens_' GenerateContentRequest (Text)
generateContentRequestModelL f GenerateContentRequest {..} = (\generateContentRequestModel -> GenerateContentRequest {generateContentRequestModel, ..}) <$> f generateContentRequestModel
{-# INLINE generateContentRequestModelL #-}

-- | 'generateContentRequestGenerationConfig' Lens
generateContentRequestGenerationConfigL :: Lens_' GenerateContentRequest (Maybe GenerationConfig)
generateContentRequestGenerationConfigL f GenerateContentRequest {..} = (\generateContentRequestGenerationConfig -> GenerateContentRequest {generateContentRequestGenerationConfig, ..}) <$> f generateContentRequestGenerationConfig
{-# INLINE generateContentRequestGenerationConfigL #-}

-- * GenerateContentResponse

-- | 'generateContentResponseCandidates' Lens
generateContentResponseCandidatesL :: Lens_' GenerateContentResponse (Maybe [Candidate])
generateContentResponseCandidatesL f GenerateContentResponse {..} = (\generateContentResponseCandidates -> GenerateContentResponse {generateContentResponseCandidates, ..}) <$> f generateContentResponseCandidates
{-# INLINE generateContentResponseCandidatesL #-}

-- | 'generateContentResponseUsageMetadata' Lens
generateContentResponseUsageMetadataL :: Lens_' GenerateContentResponse (Maybe UsageMetadata)
generateContentResponseUsageMetadataL f GenerateContentResponse {..} = (\generateContentResponseUsageMetadata -> GenerateContentResponse {generateContentResponseUsageMetadata, ..}) <$> f generateContentResponseUsageMetadata
{-# INLINE generateContentResponseUsageMetadataL #-}

-- | 'generateContentResponseModelVersion' Lens
generateContentResponseModelVersionL :: Lens_' GenerateContentResponse (Maybe Text)
generateContentResponseModelVersionL f GenerateContentResponse {..} = (\generateContentResponseModelVersion -> GenerateContentResponse {generateContentResponseModelVersion, ..}) <$> f generateContentResponseModelVersion
{-# INLINE generateContentResponseModelVersionL #-}

-- | 'generateContentResponsePromptFeedback' Lens
generateContentResponsePromptFeedbackL :: Lens_' GenerateContentResponse (Maybe PromptFeedback)
generateContentResponsePromptFeedbackL f GenerateContentResponse {..} = (\generateContentResponsePromptFeedback -> GenerateContentResponse {generateContentResponsePromptFeedback, ..}) <$> f generateContentResponsePromptFeedback
{-# INLINE generateContentResponsePromptFeedbackL #-}

-- | 'generateContentResponseResponseId' Lens
generateContentResponseResponseIdL :: Lens_' GenerateContentResponse (Maybe Text)
generateContentResponseResponseIdL f GenerateContentResponse {..} = (\generateContentResponseResponseId -> GenerateContentResponse {generateContentResponseResponseId, ..}) <$> f generateContentResponseResponseId
{-# INLINE generateContentResponseResponseIdL #-}

-- * GenerateMessageRequest

-- | 'generateMessageRequestTemperature' Lens
generateMessageRequestTemperatureL :: Lens_' GenerateMessageRequest (Maybe Float)
generateMessageRequestTemperatureL f GenerateMessageRequest {..} = (\generateMessageRequestTemperature -> GenerateMessageRequest {generateMessageRequestTemperature, ..}) <$> f generateMessageRequestTemperature
{-# INLINE generateMessageRequestTemperatureL #-}

-- | 'generateMessageRequestTopP' Lens
generateMessageRequestTopPL :: Lens_' GenerateMessageRequest (Maybe Float)
generateMessageRequestTopPL f GenerateMessageRequest {..} = (\generateMessageRequestTopP -> GenerateMessageRequest {generateMessageRequestTopP, ..}) <$> f generateMessageRequestTopP
{-# INLINE generateMessageRequestTopPL #-}

-- | 'generateMessageRequestCandidateCount' Lens
generateMessageRequestCandidateCountL :: Lens_' GenerateMessageRequest (Maybe Int)
generateMessageRequestCandidateCountL f GenerateMessageRequest {..} = (\generateMessageRequestCandidateCount -> GenerateMessageRequest {generateMessageRequestCandidateCount, ..}) <$> f generateMessageRequestCandidateCount
{-# INLINE generateMessageRequestCandidateCountL #-}

-- | 'generateMessageRequestTopK' Lens
generateMessageRequestTopKL :: Lens_' GenerateMessageRequest (Maybe Int)
generateMessageRequestTopKL f GenerateMessageRequest {..} = (\generateMessageRequestTopK -> GenerateMessageRequest {generateMessageRequestTopK, ..}) <$> f generateMessageRequestTopK
{-# INLINE generateMessageRequestTopKL #-}

-- | 'generateMessageRequestPrompt' Lens
generateMessageRequestPromptL :: Lens_' GenerateMessageRequest (MessagePrompt)
generateMessageRequestPromptL f GenerateMessageRequest {..} = (\generateMessageRequestPrompt -> GenerateMessageRequest {generateMessageRequestPrompt, ..}) <$> f generateMessageRequestPrompt
{-# INLINE generateMessageRequestPromptL #-}

-- * GenerateMessageResponse

-- | 'generateMessageResponseCandidates' Lens
generateMessageResponseCandidatesL :: Lens_' GenerateMessageResponse (Maybe [Message])
generateMessageResponseCandidatesL f GenerateMessageResponse {..} = (\generateMessageResponseCandidates -> GenerateMessageResponse {generateMessageResponseCandidates, ..}) <$> f generateMessageResponseCandidates
{-# INLINE generateMessageResponseCandidatesL #-}

-- | 'generateMessageResponseMessages' Lens
generateMessageResponseMessagesL :: Lens_' GenerateMessageResponse (Maybe [Message])
generateMessageResponseMessagesL f GenerateMessageResponse {..} = (\generateMessageResponseMessages -> GenerateMessageResponse {generateMessageResponseMessages, ..}) <$> f generateMessageResponseMessages
{-# INLINE generateMessageResponseMessagesL #-}

-- | 'generateMessageResponseFilters' Lens
generateMessageResponseFiltersL :: Lens_' GenerateMessageResponse (Maybe [ContentFilter])
generateMessageResponseFiltersL f GenerateMessageResponse {..} = (\generateMessageResponseFilters -> GenerateMessageResponse {generateMessageResponseFilters, ..}) <$> f generateMessageResponseFilters
{-# INLINE generateMessageResponseFiltersL #-}

-- * GenerateTextRequest

-- | 'generateTextRequestStopSequences' Lens
generateTextRequestStopSequencesL :: Lens_' GenerateTextRequest (Maybe [Text])
generateTextRequestStopSequencesL f GenerateTextRequest {..} = (\generateTextRequestStopSequences -> GenerateTextRequest {generateTextRequestStopSequences, ..}) <$> f generateTextRequestStopSequences
{-# INLINE generateTextRequestStopSequencesL #-}

-- | 'generateTextRequestPrompt' Lens
generateTextRequestPromptL :: Lens_' GenerateTextRequest (TextPrompt)
generateTextRequestPromptL f GenerateTextRequest {..} = (\generateTextRequestPrompt -> GenerateTextRequest {generateTextRequestPrompt, ..}) <$> f generateTextRequestPrompt
{-# INLINE generateTextRequestPromptL #-}

-- | 'generateTextRequestMaxOutputTokens' Lens
generateTextRequestMaxOutputTokensL :: Lens_' GenerateTextRequest (Maybe Int)
generateTextRequestMaxOutputTokensL f GenerateTextRequest {..} = (\generateTextRequestMaxOutputTokens -> GenerateTextRequest {generateTextRequestMaxOutputTokens, ..}) <$> f generateTextRequestMaxOutputTokens
{-# INLINE generateTextRequestMaxOutputTokensL #-}

-- | 'generateTextRequestSafetySettings' Lens
generateTextRequestSafetySettingsL :: Lens_' GenerateTextRequest (Maybe [SafetySetting])
generateTextRequestSafetySettingsL f GenerateTextRequest {..} = (\generateTextRequestSafetySettings -> GenerateTextRequest {generateTextRequestSafetySettings, ..}) <$> f generateTextRequestSafetySettings
{-# INLINE generateTextRequestSafetySettingsL #-}

-- | 'generateTextRequestTemperature' Lens
generateTextRequestTemperatureL :: Lens_' GenerateTextRequest (Maybe Float)
generateTextRequestTemperatureL f GenerateTextRequest {..} = (\generateTextRequestTemperature -> GenerateTextRequest {generateTextRequestTemperature, ..}) <$> f generateTextRequestTemperature
{-# INLINE generateTextRequestTemperatureL #-}

-- | 'generateTextRequestTopK' Lens
generateTextRequestTopKL :: Lens_' GenerateTextRequest (Maybe Int)
generateTextRequestTopKL f GenerateTextRequest {..} = (\generateTextRequestTopK -> GenerateTextRequest {generateTextRequestTopK, ..}) <$> f generateTextRequestTopK
{-# INLINE generateTextRequestTopKL #-}

-- | 'generateTextRequestTopP' Lens
generateTextRequestTopPL :: Lens_' GenerateTextRequest (Maybe Float)
generateTextRequestTopPL f GenerateTextRequest {..} = (\generateTextRequestTopP -> GenerateTextRequest {generateTextRequestTopP, ..}) <$> f generateTextRequestTopP
{-# INLINE generateTextRequestTopPL #-}

-- | 'generateTextRequestCandidateCount' Lens
generateTextRequestCandidateCountL :: Lens_' GenerateTextRequest (Maybe Int)
generateTextRequestCandidateCountL f GenerateTextRequest {..} = (\generateTextRequestCandidateCount -> GenerateTextRequest {generateTextRequestCandidateCount, ..}) <$> f generateTextRequestCandidateCount
{-# INLINE generateTextRequestCandidateCountL #-}

-- * GenerateTextResponse

-- | 'generateTextResponseSafetyFeedback' Lens
generateTextResponseSafetyFeedbackL :: Lens_' GenerateTextResponse (Maybe [SafetyFeedback])
generateTextResponseSafetyFeedbackL f GenerateTextResponse {..} = (\generateTextResponseSafetyFeedback -> GenerateTextResponse {generateTextResponseSafetyFeedback, ..}) <$> f generateTextResponseSafetyFeedback
{-# INLINE generateTextResponseSafetyFeedbackL #-}

-- | 'generateTextResponseCandidates' Lens
generateTextResponseCandidatesL :: Lens_' GenerateTextResponse (Maybe [TextCompletion])
generateTextResponseCandidatesL f GenerateTextResponse {..} = (\generateTextResponseCandidates -> GenerateTextResponse {generateTextResponseCandidates, ..}) <$> f generateTextResponseCandidates
{-# INLINE generateTextResponseCandidatesL #-}

-- | 'generateTextResponseFilters' Lens
generateTextResponseFiltersL :: Lens_' GenerateTextResponse (Maybe [ContentFilter])
generateTextResponseFiltersL f GenerateTextResponse {..} = (\generateTextResponseFilters -> GenerateTextResponse {generateTextResponseFilters, ..}) <$> f generateTextResponseFilters
{-# INLINE generateTextResponseFiltersL #-}

-- * GenerateVideoResponse

-- | 'generateVideoResponseGeneratedSamples' Lens
generateVideoResponseGeneratedSamplesL :: Lens_' GenerateVideoResponse (Maybe [Media])
generateVideoResponseGeneratedSamplesL f GenerateVideoResponse {..} = (\generateVideoResponseGeneratedSamples -> GenerateVideoResponse {generateVideoResponseGeneratedSamples, ..}) <$> f generateVideoResponseGeneratedSamples
{-# INLINE generateVideoResponseGeneratedSamplesL #-}

-- | 'generateVideoResponseRaiMediaFilteredCount' Lens
generateVideoResponseRaiMediaFilteredCountL :: Lens_' GenerateVideoResponse (Maybe Int)
generateVideoResponseRaiMediaFilteredCountL f GenerateVideoResponse {..} = (\generateVideoResponseRaiMediaFilteredCount -> GenerateVideoResponse {generateVideoResponseRaiMediaFilteredCount, ..}) <$> f generateVideoResponseRaiMediaFilteredCount
{-# INLINE generateVideoResponseRaiMediaFilteredCountL #-}

-- | 'generateVideoResponseRaiMediaFilteredReasons' Lens
generateVideoResponseRaiMediaFilteredReasonsL :: Lens_' GenerateVideoResponse (Maybe [Text])
generateVideoResponseRaiMediaFilteredReasonsL f GenerateVideoResponse {..} = (\generateVideoResponseRaiMediaFilteredReasons -> GenerateVideoResponse {generateVideoResponseRaiMediaFilteredReasons, ..}) <$> f generateVideoResponseRaiMediaFilteredReasons
{-# INLINE generateVideoResponseRaiMediaFilteredReasonsL #-}

-- * GeneratedFile

-- | 'generatedFileError' Lens
generatedFileErrorL :: Lens_' GeneratedFile (Maybe Status)
generatedFileErrorL f GeneratedFile {..} = (\generatedFileError -> GeneratedFile {generatedFileError, ..}) <$> f generatedFileError
{-# INLINE generatedFileErrorL #-}

-- | 'generatedFileName' Lens
generatedFileNameL :: Lens_' GeneratedFile (Maybe Text)
generatedFileNameL f GeneratedFile {..} = (\generatedFileName -> GeneratedFile {generatedFileName, ..}) <$> f generatedFileName
{-# INLINE generatedFileNameL #-}

-- | 'generatedFileState' Lens
generatedFileStateL :: Lens_' GeneratedFile (Maybe E'State2)
generatedFileStateL f GeneratedFile {..} = (\generatedFileState -> GeneratedFile {generatedFileState, ..}) <$> f generatedFileState
{-# INLINE generatedFileStateL #-}

-- | 'generatedFileMimeType' Lens
generatedFileMimeTypeL :: Lens_' GeneratedFile (Maybe Text)
generatedFileMimeTypeL f GeneratedFile {..} = (\generatedFileMimeType -> GeneratedFile {generatedFileMimeType, ..}) <$> f generatedFileMimeType
{-# INLINE generatedFileMimeTypeL #-}

-- * GenerationConfig

-- | 'generationConfigResponseSchema' Lens
generationConfigResponseSchemaL :: Lens_' GenerationConfig (Maybe Schema)
generationConfigResponseSchemaL f GenerationConfig {..} = (\generationConfigResponseSchema -> GenerationConfig {generationConfigResponseSchema, ..}) <$> f generationConfigResponseSchema
{-# INLINE generationConfigResponseSchemaL #-}

-- | 'generationConfigThinkingConfig' Lens
generationConfigThinkingConfigL :: Lens_' GenerationConfig (Maybe ThinkingConfig)
generationConfigThinkingConfigL f GenerationConfig {..} = (\generationConfigThinkingConfig -> GenerationConfig {generationConfigThinkingConfig, ..}) <$> f generationConfigThinkingConfig
{-# INLINE generationConfigThinkingConfigL #-}

-- | 'generationConfigLogprobs' Lens
generationConfigLogprobsL :: Lens_' GenerationConfig (Maybe Int)
generationConfigLogprobsL f GenerationConfig {..} = (\generationConfigLogprobs -> GenerationConfig {generationConfigLogprobs, ..}) <$> f generationConfigLogprobs
{-# INLINE generationConfigLogprobsL #-}

-- | 'generationConfigMediaResolution' Lens
generationConfigMediaResolutionL :: Lens_' GenerationConfig (Maybe E'MediaResolution)
generationConfigMediaResolutionL f GenerationConfig {..} = (\generationConfigMediaResolution -> GenerationConfig {generationConfigMediaResolution, ..}) <$> f generationConfigMediaResolution
{-# INLINE generationConfigMediaResolutionL #-}

-- | 'generationConfigStopSequences' Lens
generationConfigStopSequencesL :: Lens_' GenerationConfig (Maybe [Text])
generationConfigStopSequencesL f GenerationConfig {..} = (\generationConfigStopSequences -> GenerationConfig {generationConfigStopSequences, ..}) <$> f generationConfigStopSequences
{-# INLINE generationConfigStopSequencesL #-}

-- | 'generationConfigSpeechConfig' Lens
generationConfigSpeechConfigL :: Lens_' GenerationConfig (Maybe SpeechConfig)
generationConfigSpeechConfigL f GenerationConfig {..} = (\generationConfigSpeechConfig -> GenerationConfig {generationConfigSpeechConfig, ..}) <$> f generationConfigSpeechConfig
{-# INLINE generationConfigSpeechConfigL #-}

-- | 'generationConfigResponseJsonSchema' Lens
generationConfigResponseJsonSchemaL :: Lens_' GenerationConfig (Maybe String)
generationConfigResponseJsonSchemaL f GenerationConfig {..} = (\generationConfigResponseJsonSchema -> GenerationConfig {generationConfigResponseJsonSchema, ..}) <$> f generationConfigResponseJsonSchema
{-# INLINE generationConfigResponseJsonSchemaL #-}

-- | 'generationConfigPresencePenalty' Lens
generationConfigPresencePenaltyL :: Lens_' GenerationConfig (Maybe Float)
generationConfigPresencePenaltyL f GenerationConfig {..} = (\generationConfigPresencePenalty -> GenerationConfig {generationConfigPresencePenalty, ..}) <$> f generationConfigPresencePenalty
{-# INLINE generationConfigPresencePenaltyL #-}

-- | 'generationConfigTopP' Lens
generationConfigTopPL :: Lens_' GenerationConfig (Maybe Float)
generationConfigTopPL f GenerationConfig {..} = (\generationConfigTopP -> GenerationConfig {generationConfigTopP, ..}) <$> f generationConfigTopP
{-# INLINE generationConfigTopPL #-}

-- | 'generationConfigTemperature' Lens
generationConfigTemperatureL :: Lens_' GenerationConfig (Maybe Float)
generationConfigTemperatureL f GenerationConfig {..} = (\generationConfigTemperature -> GenerationConfig {generationConfigTemperature, ..}) <$> f generationConfigTemperature
{-# INLINE generationConfigTemperatureL #-}

-- | 'generationConfigTopK' Lens
generationConfigTopKL :: Lens_' GenerationConfig (Maybe Int)
generationConfigTopKL f GenerationConfig {..} = (\generationConfigTopK -> GenerationConfig {generationConfigTopK, ..}) <$> f generationConfigTopK
{-# INLINE generationConfigTopKL #-}

-- | 'generationConfigCandidateCount' Lens
generationConfigCandidateCountL :: Lens_' GenerationConfig (Maybe Int)
generationConfigCandidateCountL f GenerationConfig {..} = (\generationConfigCandidateCount -> GenerationConfig {generationConfigCandidateCount, ..}) <$> f generationConfigCandidateCount
{-# INLINE generationConfigCandidateCountL #-}

-- | 'generationConfigEnableEnhancedCivicAnswers' Lens
generationConfigEnableEnhancedCivicAnswersL :: Lens_' GenerationConfig (Maybe Bool)
generationConfigEnableEnhancedCivicAnswersL f GenerationConfig {..} = (\generationConfigEnableEnhancedCivicAnswers -> GenerationConfig {generationConfigEnableEnhancedCivicAnswers, ..}) <$> f generationConfigEnableEnhancedCivicAnswers
{-# INLINE generationConfigEnableEnhancedCivicAnswersL #-}

-- | 'generationConfigResponseLogprobs' Lens
generationConfigResponseLogprobsL :: Lens_' GenerationConfig (Maybe Bool)
generationConfigResponseLogprobsL f GenerationConfig {..} = (\generationConfigResponseLogprobs -> GenerationConfig {generationConfigResponseLogprobs, ..}) <$> f generationConfigResponseLogprobs
{-# INLINE generationConfigResponseLogprobsL #-}

-- | 'generationConfigResponseModalities' Lens
generationConfigResponseModalitiesL :: Lens_' GenerationConfig (Maybe [E'ResponseModalities])
generationConfigResponseModalitiesL f GenerationConfig {..} = (\generationConfigResponseModalities -> GenerationConfig {generationConfigResponseModalities, ..}) <$> f generationConfigResponseModalities
{-# INLINE generationConfigResponseModalitiesL #-}

-- | 'generationConfigFrequencyPenalty' Lens
generationConfigFrequencyPenaltyL :: Lens_' GenerationConfig (Maybe Float)
generationConfigFrequencyPenaltyL f GenerationConfig {..} = (\generationConfigFrequencyPenalty -> GenerationConfig {generationConfigFrequencyPenalty, ..}) <$> f generationConfigFrequencyPenalty
{-# INLINE generationConfigFrequencyPenaltyL #-}

-- | 'generationConfigSeed' Lens
generationConfigSeedL :: Lens_' GenerationConfig (Maybe Int)
generationConfigSeedL f GenerationConfig {..} = (\generationConfigSeed -> GenerationConfig {generationConfigSeed, ..}) <$> f generationConfigSeed
{-# INLINE generationConfigSeedL #-}

-- | 'generationConfigMaxOutputTokens' Lens
generationConfigMaxOutputTokensL :: Lens_' GenerationConfig (Maybe Int)
generationConfigMaxOutputTokensL f GenerationConfig {..} = (\generationConfigMaxOutputTokens -> GenerationConfig {generationConfigMaxOutputTokens, ..}) <$> f generationConfigMaxOutputTokens
{-# INLINE generationConfigMaxOutputTokensL #-}

-- | 'generationConfigResponseMimeType' Lens
generationConfigResponseMimeTypeL :: Lens_' GenerationConfig (Maybe Text)
generationConfigResponseMimeTypeL f GenerationConfig {..} = (\generationConfigResponseMimeType -> GenerationConfig {generationConfigResponseMimeType, ..}) <$> f generationConfigResponseMimeType
{-# INLINE generationConfigResponseMimeTypeL #-}

-- * GoogleSearch

-- | 'googleSearchTimeRangeFilter' Lens
googleSearchTimeRangeFilterL :: Lens_' GoogleSearch (Maybe Interval)
googleSearchTimeRangeFilterL f GoogleSearch {..} = (\googleSearchTimeRangeFilter -> GoogleSearch {googleSearchTimeRangeFilter, ..}) <$> f googleSearchTimeRangeFilter
{-# INLINE googleSearchTimeRangeFilterL #-}

-- * GoogleSearchRetrieval

-- | 'googleSearchRetrievalDynamicRetrievalConfig' Lens
googleSearchRetrievalDynamicRetrievalConfigL :: Lens_' GoogleSearchRetrieval (Maybe DynamicRetrievalConfig)
googleSearchRetrievalDynamicRetrievalConfigL f GoogleSearchRetrieval {..} = (\googleSearchRetrievalDynamicRetrievalConfig -> GoogleSearchRetrieval {googleSearchRetrievalDynamicRetrievalConfig, ..}) <$> f googleSearchRetrievalDynamicRetrievalConfig
{-# INLINE googleSearchRetrievalDynamicRetrievalConfigL #-}

-- * GroundingAttribution

-- | 'groundingAttributionSourceId' Lens
groundingAttributionSourceIdL :: Lens_' GroundingAttribution (Maybe AttributionSourceId)
groundingAttributionSourceIdL f GroundingAttribution {..} = (\groundingAttributionSourceId -> GroundingAttribution {groundingAttributionSourceId, ..}) <$> f groundingAttributionSourceId
{-# INLINE groundingAttributionSourceIdL #-}

-- | 'groundingAttributionContent' Lens
groundingAttributionContentL :: Lens_' GroundingAttribution (Maybe Content)
groundingAttributionContentL f GroundingAttribution {..} = (\groundingAttributionContent -> GroundingAttribution {groundingAttributionContent, ..}) <$> f groundingAttributionContent
{-# INLINE groundingAttributionContentL #-}

-- * GroundingChunk

-- | 'groundingChunkWeb' Lens
groundingChunkWebL :: Lens_' GroundingChunk (Maybe Web)
groundingChunkWebL f GroundingChunk {..} = (\groundingChunkWeb -> GroundingChunk {groundingChunkWeb, ..}) <$> f groundingChunkWeb
{-# INLINE groundingChunkWebL #-}

-- * GroundingMetadata

-- | 'groundingMetadataRetrievalMetadata' Lens
groundingMetadataRetrievalMetadataL :: Lens_' GroundingMetadata (Maybe RetrievalMetadata)
groundingMetadataRetrievalMetadataL f GroundingMetadata {..} = (\groundingMetadataRetrievalMetadata -> GroundingMetadata {groundingMetadataRetrievalMetadata, ..}) <$> f groundingMetadataRetrievalMetadata
{-# INLINE groundingMetadataRetrievalMetadataL #-}

-- | 'groundingMetadataWebSearchQueries' Lens
groundingMetadataWebSearchQueriesL :: Lens_' GroundingMetadata (Maybe [Text])
groundingMetadataWebSearchQueriesL f GroundingMetadata {..} = (\groundingMetadataWebSearchQueries -> GroundingMetadata {groundingMetadataWebSearchQueries, ..}) <$> f groundingMetadataWebSearchQueries
{-# INLINE groundingMetadataWebSearchQueriesL #-}

-- | 'groundingMetadataGroundingChunks' Lens
groundingMetadataGroundingChunksL :: Lens_' GroundingMetadata (Maybe [GroundingChunk])
groundingMetadataGroundingChunksL f GroundingMetadata {..} = (\groundingMetadataGroundingChunks -> GroundingMetadata {groundingMetadataGroundingChunks, ..}) <$> f groundingMetadataGroundingChunks
{-# INLINE groundingMetadataGroundingChunksL #-}

-- | 'groundingMetadataSearchEntryPoint' Lens
groundingMetadataSearchEntryPointL :: Lens_' GroundingMetadata (Maybe SearchEntryPoint)
groundingMetadataSearchEntryPointL f GroundingMetadata {..} = (\groundingMetadataSearchEntryPoint -> GroundingMetadata {groundingMetadataSearchEntryPoint, ..}) <$> f groundingMetadataSearchEntryPoint
{-# INLINE groundingMetadataSearchEntryPointL #-}

-- | 'groundingMetadataGroundingSupports' Lens
groundingMetadataGroundingSupportsL :: Lens_' GroundingMetadata (Maybe [GroundingSupport])
groundingMetadataGroundingSupportsL f GroundingMetadata {..} = (\groundingMetadataGroundingSupports -> GroundingMetadata {groundingMetadataGroundingSupports, ..}) <$> f groundingMetadataGroundingSupports
{-# INLINE groundingMetadataGroundingSupportsL #-}

-- * GroundingPassage

-- | 'groundingPassageContent' Lens
groundingPassageContentL :: Lens_' GroundingPassage (Maybe Content)
groundingPassageContentL f GroundingPassage {..} = (\groundingPassageContent -> GroundingPassage {groundingPassageContent, ..}) <$> f groundingPassageContent
{-# INLINE groundingPassageContentL #-}

-- | 'groundingPassageId' Lens
groundingPassageIdL :: Lens_' GroundingPassage (Maybe Text)
groundingPassageIdL f GroundingPassage {..} = (\groundingPassageId -> GroundingPassage {groundingPassageId, ..}) <$> f groundingPassageId
{-# INLINE groundingPassageIdL #-}

-- * GroundingPassageId

-- | 'groundingPassageIdPassageId' Lens
groundingPassageIdPassageIdL :: Lens_' GroundingPassageId (Maybe Text)
groundingPassageIdPassageIdL f GroundingPassageId {..} = (\groundingPassageIdPassageId -> GroundingPassageId {groundingPassageIdPassageId, ..}) <$> f groundingPassageIdPassageId
{-# INLINE groundingPassageIdPassageIdL #-}

-- | 'groundingPassageIdPartIndex' Lens
groundingPassageIdPartIndexL :: Lens_' GroundingPassageId (Maybe Int)
groundingPassageIdPartIndexL f GroundingPassageId {..} = (\groundingPassageIdPartIndex -> GroundingPassageId {groundingPassageIdPartIndex, ..}) <$> f groundingPassageIdPartIndex
{-# INLINE groundingPassageIdPartIndexL #-}

-- * GroundingPassages

-- | 'groundingPassagesPassages' Lens
groundingPassagesPassagesL :: Lens_' GroundingPassages (Maybe [GroundingPassage])
groundingPassagesPassagesL f GroundingPassages {..} = (\groundingPassagesPassages -> GroundingPassages {groundingPassagesPassages, ..}) <$> f groundingPassagesPassages
{-# INLINE groundingPassagesPassagesL #-}

-- * GroundingSupport

-- | 'groundingSupportConfidenceScores' Lens
groundingSupportConfidenceScoresL :: Lens_' GroundingSupport (Maybe [Float])
groundingSupportConfidenceScoresL f GroundingSupport {..} = (\groundingSupportConfidenceScores -> GroundingSupport {groundingSupportConfidenceScores, ..}) <$> f groundingSupportConfidenceScores
{-# INLINE groundingSupportConfidenceScoresL #-}

-- | 'groundingSupportGroundingChunkIndices' Lens
groundingSupportGroundingChunkIndicesL :: Lens_' GroundingSupport (Maybe [Int])
groundingSupportGroundingChunkIndicesL f GroundingSupport {..} = (\groundingSupportGroundingChunkIndices -> GroundingSupport {groundingSupportGroundingChunkIndices, ..}) <$> f groundingSupportGroundingChunkIndices
{-# INLINE groundingSupportGroundingChunkIndicesL #-}

-- | 'groundingSupportSegment' Lens
groundingSupportSegmentL :: Lens_' GroundingSupport (Maybe Segment)
groundingSupportSegmentL f GroundingSupport {..} = (\groundingSupportSegment -> GroundingSupport {groundingSupportSegment, ..}) <$> f groundingSupportSegment
{-# INLINE groundingSupportSegmentL #-}

-- * HarmCategory

-- * Hyperparameters

-- | 'hyperparametersEpochCount' Lens
hyperparametersEpochCountL :: Lens_' Hyperparameters (Maybe Int)
hyperparametersEpochCountL f Hyperparameters {..} = (\hyperparametersEpochCount -> Hyperparameters {hyperparametersEpochCount, ..}) <$> f hyperparametersEpochCount
{-# INLINE hyperparametersEpochCountL #-}

-- | 'hyperparametersLearningRate' Lens
hyperparametersLearningRateL :: Lens_' Hyperparameters (Maybe Float)
hyperparametersLearningRateL f Hyperparameters {..} = (\hyperparametersLearningRate -> Hyperparameters {hyperparametersLearningRate, ..}) <$> f hyperparametersLearningRate
{-# INLINE hyperparametersLearningRateL #-}

-- | 'hyperparametersLearningRateMultiplier' Lens
hyperparametersLearningRateMultiplierL :: Lens_' Hyperparameters (Maybe Float)
hyperparametersLearningRateMultiplierL f Hyperparameters {..} = (\hyperparametersLearningRateMultiplier -> Hyperparameters {hyperparametersLearningRateMultiplier, ..}) <$> f hyperparametersLearningRateMultiplier
{-# INLINE hyperparametersLearningRateMultiplierL #-}

-- | 'hyperparametersBatchSize' Lens
hyperparametersBatchSizeL :: Lens_' Hyperparameters (Maybe Int)
hyperparametersBatchSizeL f Hyperparameters {..} = (\hyperparametersBatchSize -> Hyperparameters {hyperparametersBatchSize, ..}) <$> f hyperparametersBatchSize
{-# INLINE hyperparametersBatchSizeL #-}

-- * InputFeedback

-- | 'inputFeedbackSafetyRatings' Lens
inputFeedbackSafetyRatingsL :: Lens_' InputFeedback (Maybe [SafetyRating])
inputFeedbackSafetyRatingsL f InputFeedback {..} = (\inputFeedbackSafetyRatings -> InputFeedback {inputFeedbackSafetyRatings, ..}) <$> f inputFeedbackSafetyRatings
{-# INLINE inputFeedbackSafetyRatingsL #-}

-- | 'inputFeedbackBlockReason' Lens
inputFeedbackBlockReasonL :: Lens_' InputFeedback (Maybe E'BlockReason2)
inputFeedbackBlockReasonL f InputFeedback {..} = (\inputFeedbackBlockReason -> InputFeedback {inputFeedbackBlockReason, ..}) <$> f inputFeedbackBlockReason
{-# INLINE inputFeedbackBlockReasonL #-}

-- * Interval

-- | 'intervalStartTime' Lens
intervalStartTimeL :: Lens_' Interval (Maybe DateTime)
intervalStartTimeL f Interval {..} = (\intervalStartTime -> Interval {intervalStartTime, ..}) <$> f intervalStartTime
{-# INLINE intervalStartTimeL #-}

-- | 'intervalEndTime' Lens
intervalEndTimeL :: Lens_' Interval (Maybe DateTime)
intervalEndTimeL f Interval {..} = (\intervalEndTime -> Interval {intervalEndTime, ..}) <$> f intervalEndTime
{-# INLINE intervalEndTimeL #-}

-- * ListCachedContentsResponse

-- | 'listCachedContentsResponseNextPageToken' Lens
listCachedContentsResponseNextPageTokenL :: Lens_' ListCachedContentsResponse (Maybe Text)
listCachedContentsResponseNextPageTokenL f ListCachedContentsResponse {..} = (\listCachedContentsResponseNextPageToken -> ListCachedContentsResponse {listCachedContentsResponseNextPageToken, ..}) <$> f listCachedContentsResponseNextPageToken
{-# INLINE listCachedContentsResponseNextPageTokenL #-}

-- | 'listCachedContentsResponseCachedContents' Lens
listCachedContentsResponseCachedContentsL :: Lens_' ListCachedContentsResponse (Maybe [CachedContent])
listCachedContentsResponseCachedContentsL f ListCachedContentsResponse {..} = (\listCachedContentsResponseCachedContents -> ListCachedContentsResponse {listCachedContentsResponseCachedContents, ..}) <$> f listCachedContentsResponseCachedContents
{-# INLINE listCachedContentsResponseCachedContentsL #-}

-- * ListChunksResponse

-- | 'listChunksResponseNextPageToken' Lens
listChunksResponseNextPageTokenL :: Lens_' ListChunksResponse (Maybe Text)
listChunksResponseNextPageTokenL f ListChunksResponse {..} = (\listChunksResponseNextPageToken -> ListChunksResponse {listChunksResponseNextPageToken, ..}) <$> f listChunksResponseNextPageToken
{-# INLINE listChunksResponseNextPageTokenL #-}

-- | 'listChunksResponseChunks' Lens
listChunksResponseChunksL :: Lens_' ListChunksResponse (Maybe [Chunk])
listChunksResponseChunksL f ListChunksResponse {..} = (\listChunksResponseChunks -> ListChunksResponse {listChunksResponseChunks, ..}) <$> f listChunksResponseChunks
{-# INLINE listChunksResponseChunksL #-}

-- * ListCorporaResponse

-- | 'listCorporaResponseCorpora' Lens
listCorporaResponseCorporaL :: Lens_' ListCorporaResponse (Maybe [Corpus])
listCorporaResponseCorporaL f ListCorporaResponse {..} = (\listCorporaResponseCorpora -> ListCorporaResponse {listCorporaResponseCorpora, ..}) <$> f listCorporaResponseCorpora
{-# INLINE listCorporaResponseCorporaL #-}

-- | 'listCorporaResponseNextPageToken' Lens
listCorporaResponseNextPageTokenL :: Lens_' ListCorporaResponse (Maybe Text)
listCorporaResponseNextPageTokenL f ListCorporaResponse {..} = (\listCorporaResponseNextPageToken -> ListCorporaResponse {listCorporaResponseNextPageToken, ..}) <$> f listCorporaResponseNextPageToken
{-# INLINE listCorporaResponseNextPageTokenL #-}

-- * ListDocumentsResponse

-- | 'listDocumentsResponseNextPageToken' Lens
listDocumentsResponseNextPageTokenL :: Lens_' ListDocumentsResponse (Maybe Text)
listDocumentsResponseNextPageTokenL f ListDocumentsResponse {..} = (\listDocumentsResponseNextPageToken -> ListDocumentsResponse {listDocumentsResponseNextPageToken, ..}) <$> f listDocumentsResponseNextPageToken
{-# INLINE listDocumentsResponseNextPageTokenL #-}

-- | 'listDocumentsResponseDocuments' Lens
listDocumentsResponseDocumentsL :: Lens_' ListDocumentsResponse (Maybe [Document])
listDocumentsResponseDocumentsL f ListDocumentsResponse {..} = (\listDocumentsResponseDocuments -> ListDocumentsResponse {listDocumentsResponseDocuments, ..}) <$> f listDocumentsResponseDocuments
{-# INLINE listDocumentsResponseDocumentsL #-}

-- * ListFilesResponse

-- | 'listFilesResponseNextPageToken' Lens
listFilesResponseNextPageTokenL :: Lens_' ListFilesResponse (Maybe Text)
listFilesResponseNextPageTokenL f ListFilesResponse {..} = (\listFilesResponseNextPageToken -> ListFilesResponse {listFilesResponseNextPageToken, ..}) <$> f listFilesResponseNextPageToken
{-# INLINE listFilesResponseNextPageTokenL #-}

-- | 'listFilesResponseFiles' Lens
listFilesResponseFilesL :: Lens_' ListFilesResponse (Maybe [File])
listFilesResponseFilesL f ListFilesResponse {..} = (\listFilesResponseFiles -> ListFilesResponse {listFilesResponseFiles, ..}) <$> f listFilesResponseFiles
{-# INLINE listFilesResponseFilesL #-}

-- * ListGeneratedFilesResponse

-- | 'listGeneratedFilesResponseNextPageToken' Lens
listGeneratedFilesResponseNextPageTokenL :: Lens_' ListGeneratedFilesResponse (Maybe Text)
listGeneratedFilesResponseNextPageTokenL f ListGeneratedFilesResponse {..} = (\listGeneratedFilesResponseNextPageToken -> ListGeneratedFilesResponse {listGeneratedFilesResponseNextPageToken, ..}) <$> f listGeneratedFilesResponseNextPageToken
{-# INLINE listGeneratedFilesResponseNextPageTokenL #-}

-- | 'listGeneratedFilesResponseGeneratedFiles' Lens
listGeneratedFilesResponseGeneratedFilesL :: Lens_' ListGeneratedFilesResponse (Maybe [GeneratedFile])
listGeneratedFilesResponseGeneratedFilesL f ListGeneratedFilesResponse {..} = (\listGeneratedFilesResponseGeneratedFiles -> ListGeneratedFilesResponse {listGeneratedFilesResponseGeneratedFiles, ..}) <$> f listGeneratedFilesResponseGeneratedFiles
{-# INLINE listGeneratedFilesResponseGeneratedFilesL #-}

-- * ListModelsResponse

-- | 'listModelsResponseModels' Lens
listModelsResponseModelsL :: Lens_' ListModelsResponse (Maybe [Model])
listModelsResponseModelsL f ListModelsResponse {..} = (\listModelsResponseModels -> ListModelsResponse {listModelsResponseModels, ..}) <$> f listModelsResponseModels
{-# INLINE listModelsResponseModelsL #-}

-- | 'listModelsResponseNextPageToken' Lens
listModelsResponseNextPageTokenL :: Lens_' ListModelsResponse (Maybe Text)
listModelsResponseNextPageTokenL f ListModelsResponse {..} = (\listModelsResponseNextPageToken -> ListModelsResponse {listModelsResponseNextPageToken, ..}) <$> f listModelsResponseNextPageToken
{-# INLINE listModelsResponseNextPageTokenL #-}

-- * ListOperationsResponse

-- | 'listOperationsResponseNextPageToken' Lens
listOperationsResponseNextPageTokenL :: Lens_' ListOperationsResponse (Maybe Text)
listOperationsResponseNextPageTokenL f ListOperationsResponse {..} = (\listOperationsResponseNextPageToken -> ListOperationsResponse {listOperationsResponseNextPageToken, ..}) <$> f listOperationsResponseNextPageToken
{-# INLINE listOperationsResponseNextPageTokenL #-}

-- | 'listOperationsResponseOperations' Lens
listOperationsResponseOperationsL :: Lens_' ListOperationsResponse (Maybe [Operation])
listOperationsResponseOperationsL f ListOperationsResponse {..} = (\listOperationsResponseOperations -> ListOperationsResponse {listOperationsResponseOperations, ..}) <$> f listOperationsResponseOperations
{-# INLINE listOperationsResponseOperationsL #-}

-- * ListPermissionsResponse

-- | 'listPermissionsResponsePermissions' Lens
listPermissionsResponsePermissionsL :: Lens_' ListPermissionsResponse (Maybe [Permission])
listPermissionsResponsePermissionsL f ListPermissionsResponse {..} = (\listPermissionsResponsePermissions -> ListPermissionsResponse {listPermissionsResponsePermissions, ..}) <$> f listPermissionsResponsePermissions
{-# INLINE listPermissionsResponsePermissionsL #-}

-- | 'listPermissionsResponseNextPageToken' Lens
listPermissionsResponseNextPageTokenL :: Lens_' ListPermissionsResponse (Maybe Text)
listPermissionsResponseNextPageTokenL f ListPermissionsResponse {..} = (\listPermissionsResponseNextPageToken -> ListPermissionsResponse {listPermissionsResponseNextPageToken, ..}) <$> f listPermissionsResponseNextPageToken
{-# INLINE listPermissionsResponseNextPageTokenL #-}

-- * ListTunedModelsResponse

-- | 'listTunedModelsResponseNextPageToken' Lens
listTunedModelsResponseNextPageTokenL :: Lens_' ListTunedModelsResponse (Maybe Text)
listTunedModelsResponseNextPageTokenL f ListTunedModelsResponse {..} = (\listTunedModelsResponseNextPageToken -> ListTunedModelsResponse {listTunedModelsResponseNextPageToken, ..}) <$> f listTunedModelsResponseNextPageToken
{-# INLINE listTunedModelsResponseNextPageTokenL #-}

-- | 'listTunedModelsResponseTunedModels' Lens
listTunedModelsResponseTunedModelsL :: Lens_' ListTunedModelsResponse (Maybe [TunedModel])
listTunedModelsResponseTunedModelsL f ListTunedModelsResponse {..} = (\listTunedModelsResponseTunedModels -> ListTunedModelsResponse {listTunedModelsResponseTunedModels, ..}) <$> f listTunedModelsResponseTunedModels
{-# INLINE listTunedModelsResponseTunedModelsL #-}

-- * LogprobsResult

-- | 'logprobsResultChosenCandidates' Lens
logprobsResultChosenCandidatesL :: Lens_' LogprobsResult (Maybe [LogprobsResultCandidate])
logprobsResultChosenCandidatesL f LogprobsResult {..} = (\logprobsResultChosenCandidates -> LogprobsResult {logprobsResultChosenCandidates, ..}) <$> f logprobsResultChosenCandidates
{-# INLINE logprobsResultChosenCandidatesL #-}

-- | 'logprobsResultTopCandidates' Lens
logprobsResultTopCandidatesL :: Lens_' LogprobsResult (Maybe [TopCandidates])
logprobsResultTopCandidatesL f LogprobsResult {..} = (\logprobsResultTopCandidates -> LogprobsResult {logprobsResultTopCandidates, ..}) <$> f logprobsResultTopCandidates
{-# INLINE logprobsResultTopCandidatesL #-}

-- * LogprobsResultCandidate

-- | 'logprobsResultCandidateLogProbability' Lens
logprobsResultCandidateLogProbabilityL :: Lens_' LogprobsResultCandidate (Maybe Float)
logprobsResultCandidateLogProbabilityL f LogprobsResultCandidate {..} = (\logprobsResultCandidateLogProbability -> LogprobsResultCandidate {logprobsResultCandidateLogProbability, ..}) <$> f logprobsResultCandidateLogProbability
{-# INLINE logprobsResultCandidateLogProbabilityL #-}

-- | 'logprobsResultCandidateTokenId' Lens
logprobsResultCandidateTokenIdL :: Lens_' LogprobsResultCandidate (Maybe Int)
logprobsResultCandidateTokenIdL f LogprobsResultCandidate {..} = (\logprobsResultCandidateTokenId -> LogprobsResultCandidate {logprobsResultCandidateTokenId, ..}) <$> f logprobsResultCandidateTokenId
{-# INLINE logprobsResultCandidateTokenIdL #-}

-- | 'logprobsResultCandidateToken' Lens
logprobsResultCandidateTokenL :: Lens_' LogprobsResultCandidate (Maybe Text)
logprobsResultCandidateTokenL f LogprobsResultCandidate {..} = (\logprobsResultCandidateToken -> LogprobsResultCandidate {logprobsResultCandidateToken, ..}) <$> f logprobsResultCandidateToken
{-# INLINE logprobsResultCandidateTokenL #-}

-- * Media

-- | 'mediaVideo' Lens
mediaVideoL :: Lens_' Media (Maybe Video)
mediaVideoL f Media {..} = (\mediaVideo -> Media {mediaVideo, ..}) <$> f mediaVideo
{-# INLINE mediaVideoL #-}

-- * Message

-- | 'messageCitationMetadata' Lens
messageCitationMetadataL :: Lens_' Message (Maybe CitationMetadata)
messageCitationMetadataL f Message {..} = (\messageCitationMetadata -> Message {messageCitationMetadata, ..}) <$> f messageCitationMetadata
{-# INLINE messageCitationMetadataL #-}

-- | 'messageAuthor' Lens
messageAuthorL :: Lens_' Message (Maybe Text)
messageAuthorL f Message {..} = (\messageAuthor -> Message {messageAuthor, ..}) <$> f messageAuthor
{-# INLINE messageAuthorL #-}

-- | 'messageContent' Lens
messageContentL :: Lens_' Message (Text)
messageContentL f Message {..} = (\messageContent -> Message {messageContent, ..}) <$> f messageContent
{-# INLINE messageContentL #-}

-- * MessagePrompt

-- | 'messagePromptContext' Lens
messagePromptContextL :: Lens_' MessagePrompt (Maybe Text)
messagePromptContextL f MessagePrompt {..} = (\messagePromptContext -> MessagePrompt {messagePromptContext, ..}) <$> f messagePromptContext
{-# INLINE messagePromptContextL #-}

-- | 'messagePromptMessages' Lens
messagePromptMessagesL :: Lens_' MessagePrompt ([Message])
messagePromptMessagesL f MessagePrompt {..} = (\messagePromptMessages -> MessagePrompt {messagePromptMessages, ..}) <$> f messagePromptMessages
{-# INLINE messagePromptMessagesL #-}

-- | 'messagePromptExamples' Lens
messagePromptExamplesL :: Lens_' MessagePrompt (Maybe [Example])
messagePromptExamplesL f MessagePrompt {..} = (\messagePromptExamples -> MessagePrompt {messagePromptExamples, ..}) <$> f messagePromptExamples
{-# INLINE messagePromptExamplesL #-}

-- * MetadataFilter

-- | 'metadataFilterConditions' Lens
metadataFilterConditionsL :: Lens_' MetadataFilter ([Condition])
metadataFilterConditionsL f MetadataFilter {..} = (\metadataFilterConditions -> MetadataFilter {metadataFilterConditions, ..}) <$> f metadataFilterConditions
{-# INLINE metadataFilterConditionsL #-}

-- | 'metadataFilterKey' Lens
metadataFilterKeyL :: Lens_' MetadataFilter (Text)
metadataFilterKeyL f MetadataFilter {..} = (\metadataFilterKey -> MetadataFilter {metadataFilterKey, ..}) <$> f metadataFilterKey
{-# INLINE metadataFilterKeyL #-}

-- * Modality

-- * ModalityTokenCount

-- | 'modalityTokenCountTokenCount' Lens
modalityTokenCountTokenCountL :: Lens_' ModalityTokenCount (Maybe Int)
modalityTokenCountTokenCountL f ModalityTokenCount {..} = (\modalityTokenCountTokenCount -> ModalityTokenCount {modalityTokenCountTokenCount, ..}) <$> f modalityTokenCountTokenCount
{-# INLINE modalityTokenCountTokenCountL #-}

-- | 'modalityTokenCountModality' Lens
modalityTokenCountModalityL :: Lens_' ModalityTokenCount (Maybe Modality)
modalityTokenCountModalityL f ModalityTokenCount {..} = (\modalityTokenCountModality -> ModalityTokenCount {modalityTokenCountModality, ..}) <$> f modalityTokenCountModality
{-# INLINE modalityTokenCountModalityL #-}

-- * Model

-- | 'modelTopK' Lens
modelTopKL :: Lens_' Model (Maybe Int)
modelTopKL f Model {..} = (\modelTopK -> Model {modelTopK, ..}) <$> f modelTopK
{-# INLINE modelTopKL #-}

-- | 'modelName' Lens
modelNameL :: Lens_' Model (Text)
modelNameL f Model {..} = (\modelName -> Model {modelName, ..}) <$> f modelName
{-# INLINE modelNameL #-}

-- | 'modelBaseModelId' Lens
modelBaseModelIdL :: Lens_' Model (Text)
modelBaseModelIdL f Model {..} = (\modelBaseModelId -> Model {modelBaseModelId, ..}) <$> f modelBaseModelId
{-# INLINE modelBaseModelIdL #-}

-- | 'modelVersion' Lens
modelVersionL :: Lens_' Model (Text)
modelVersionL f Model {..} = (\modelVersion -> Model {modelVersion, ..}) <$> f modelVersion
{-# INLINE modelVersionL #-}

-- | 'modelInputTokenLimit' Lens
modelInputTokenLimitL :: Lens_' Model (Maybe Int)
modelInputTokenLimitL f Model {..} = (\modelInputTokenLimit -> Model {modelInputTokenLimit, ..}) <$> f modelInputTokenLimit
{-# INLINE modelInputTokenLimitL #-}

-- | 'modelTopP' Lens
modelTopPL :: Lens_' Model (Maybe Float)
modelTopPL f Model {..} = (\modelTopP -> Model {modelTopP, ..}) <$> f modelTopP
{-# INLINE modelTopPL #-}

-- | 'modelSupportedGenerationMethods' Lens
modelSupportedGenerationMethodsL :: Lens_' Model (Maybe [Text])
modelSupportedGenerationMethodsL f Model {..} = (\modelSupportedGenerationMethods -> Model {modelSupportedGenerationMethods, ..}) <$> f modelSupportedGenerationMethods
{-# INLINE modelSupportedGenerationMethodsL #-}

-- | 'modelTemperature' Lens
modelTemperatureL :: Lens_' Model (Maybe Float)
modelTemperatureL f Model {..} = (\modelTemperature -> Model {modelTemperature, ..}) <$> f modelTemperature
{-# INLINE modelTemperatureL #-}

-- | 'modelDisplayName' Lens
modelDisplayNameL :: Lens_' Model (Maybe Text)
modelDisplayNameL f Model {..} = (\modelDisplayName -> Model {modelDisplayName, ..}) <$> f modelDisplayName
{-# INLINE modelDisplayNameL #-}

-- | 'modelDescription' Lens
modelDescriptionL :: Lens_' Model (Maybe Text)
modelDescriptionL f Model {..} = (\modelDescription -> Model {modelDescription, ..}) <$> f modelDescription
{-# INLINE modelDescriptionL #-}

-- | 'modelMaxTemperature' Lens
modelMaxTemperatureL :: Lens_' Model (Maybe Float)
modelMaxTemperatureL f Model {..} = (\modelMaxTemperature -> Model {modelMaxTemperature, ..}) <$> f modelMaxTemperature
{-# INLINE modelMaxTemperatureL #-}

-- | 'modelOutputTokenLimit' Lens
modelOutputTokenLimitL :: Lens_' Model (Maybe Int)
modelOutputTokenLimitL f Model {..} = (\modelOutputTokenLimit -> Model {modelOutputTokenLimit, ..}) <$> f modelOutputTokenLimit
{-# INLINE modelOutputTokenLimitL #-}

-- * ModelType

-- * MultiSpeakerVoiceConfig

-- | 'multiSpeakerVoiceConfigSpeakerVoiceConfigs' Lens
multiSpeakerVoiceConfigSpeakerVoiceConfigsL :: Lens_' MultiSpeakerVoiceConfig ([SpeakerVoiceConfig])
multiSpeakerVoiceConfigSpeakerVoiceConfigsL f MultiSpeakerVoiceConfig {..} = (\multiSpeakerVoiceConfigSpeakerVoiceConfigs -> MultiSpeakerVoiceConfig {multiSpeakerVoiceConfigSpeakerVoiceConfigs, ..}) <$> f multiSpeakerVoiceConfigSpeakerVoiceConfigs
{-# INLINE multiSpeakerVoiceConfigSpeakerVoiceConfigsL #-}

-- * Operation

-- | 'operationDone' Lens
operationDoneL :: Lens_' Operation (Maybe Bool)
operationDoneL f Operation {..} = (\operationDone -> Operation {operationDone, ..}) <$> f operationDone
{-# INLINE operationDoneL #-}

-- | 'operationName' Lens
operationNameL :: Lens_' Operation (Maybe Text)
operationNameL f Operation {..} = (\operationName -> Operation {operationName, ..}) <$> f operationName
{-# INLINE operationNameL #-}

-- | 'operationError' Lens
operationErrorL :: Lens_' Operation (Maybe Status)
operationErrorL f Operation {..} = (\operationError -> Operation {operationError, ..}) <$> f operationError
{-# INLINE operationErrorL #-}

-- | 'operationMetadata' Lens
operationMetadataL :: Lens_' Operation (Maybe (Map.Map String String))
operationMetadataL f Operation {..} = (\operationMetadata -> Operation {operationMetadata, ..}) <$> f operationMetadata
{-# INLINE operationMetadataL #-}

-- | 'operationResponse' Lens
operationResponseL :: Lens_' Operation (Maybe (Map.Map String String))
operationResponseL f Operation {..} = (\operationResponse -> Operation {operationResponse, ..}) <$> f operationResponse
{-# INLINE operationResponseL #-}

-- * Part

-- | 'partInlineData' Lens
partInlineDataL :: Lens_' Part (Maybe Blob)
partInlineDataL f Part {..} = (\partInlineData -> Part {partInlineData, ..}) <$> f partInlineData
{-# INLINE partInlineDataL #-}

-- | 'partFunctionResponse' Lens
partFunctionResponseL :: Lens_' Part (Maybe FunctionResponse)
partFunctionResponseL f Part {..} = (\partFunctionResponse -> Part {partFunctionResponse, ..}) <$> f partFunctionResponse
{-# INLINE partFunctionResponseL #-}

-- | 'partCodeExecutionResult' Lens
partCodeExecutionResultL :: Lens_' Part (Maybe CodeExecutionResult)
partCodeExecutionResultL f Part {..} = (\partCodeExecutionResult -> Part {partCodeExecutionResult, ..}) <$> f partCodeExecutionResult
{-# INLINE partCodeExecutionResultL #-}

-- | 'partFileData' Lens
partFileDataL :: Lens_' Part (Maybe FileData)
partFileDataL f Part {..} = (\partFileData -> Part {partFileData, ..}) <$> f partFileData
{-# INLINE partFileDataL #-}

-- | 'partExecutableCode' Lens
partExecutableCodeL :: Lens_' Part (Maybe ExecutableCode)
partExecutableCodeL f Part {..} = (\partExecutableCode -> Part {partExecutableCode, ..}) <$> f partExecutableCode
{-# INLINE partExecutableCodeL #-}

-- | 'partVideoMetadata' Lens
partVideoMetadataL :: Lens_' Part (Maybe VideoMetadata)
partVideoMetadataL f Part {..} = (\partVideoMetadata -> Part {partVideoMetadata, ..}) <$> f partVideoMetadata
{-# INLINE partVideoMetadataL #-}

-- | 'partThought' Lens
partThoughtL :: Lens_' Part (Maybe Bool)
partThoughtL f Part {..} = (\partThought -> Part {partThought, ..}) <$> f partThought
{-# INLINE partThoughtL #-}

-- | 'partText' Lens
partTextL :: Lens_' Part (Maybe Text)
partTextL f Part {..} = (\partText -> Part {partText, ..}) <$> f partText
{-# INLINE partTextL #-}

-- | 'partThoughtSignature' Lens
partThoughtSignatureL :: Lens_' Part (Maybe ByteArray)
partThoughtSignatureL f Part {..} = (\partThoughtSignature -> Part {partThoughtSignature, ..}) <$> f partThoughtSignature
{-# INLINE partThoughtSignatureL #-}

-- | 'partFunctionCall' Lens
partFunctionCallL :: Lens_' Part (Maybe FunctionCall)
partFunctionCallL f Part {..} = (\partFunctionCall -> Part {partFunctionCall, ..}) <$> f partFunctionCall
{-# INLINE partFunctionCallL #-}

-- * Permission

-- | 'permissionName' Lens
permissionNameL :: Lens_' Permission (Maybe Text)
permissionNameL f Permission {..} = (\permissionName -> Permission {permissionName, ..}) <$> f permissionName
{-# INLINE permissionNameL #-}

-- | 'permissionGranteeType' Lens
permissionGranteeTypeL :: Lens_' Permission (Maybe E'GranteeType)
permissionGranteeTypeL f Permission {..} = (\permissionGranteeType -> Permission {permissionGranteeType, ..}) <$> f permissionGranteeType
{-# INLINE permissionGranteeTypeL #-}

-- | 'permissionRole' Lens
permissionRoleL :: Lens_' Permission (E'Role)
permissionRoleL f Permission {..} = (\permissionRole -> Permission {permissionRole, ..}) <$> f permissionRole
{-# INLINE permissionRoleL #-}

-- | 'permissionEmailAddress' Lens
permissionEmailAddressL :: Lens_' Permission (Maybe Text)
permissionEmailAddressL f Permission {..} = (\permissionEmailAddress -> Permission {permissionEmailAddress, ..}) <$> f permissionEmailAddress
{-# INLINE permissionEmailAddressL #-}

-- * PrebuiltVoiceConfig

-- | 'prebuiltVoiceConfigVoiceName' Lens
prebuiltVoiceConfigVoiceNameL :: Lens_' PrebuiltVoiceConfig (Maybe Text)
prebuiltVoiceConfigVoiceNameL f PrebuiltVoiceConfig {..} = (\prebuiltVoiceConfigVoiceName -> PrebuiltVoiceConfig {prebuiltVoiceConfigVoiceName, ..}) <$> f prebuiltVoiceConfigVoiceName
{-# INLINE prebuiltVoiceConfigVoiceNameL #-}

-- * PredictLongRunningOperation

-- | 'predictLongRunningOperationDone' Lens
predictLongRunningOperationDoneL :: Lens_' PredictLongRunningOperation (Maybe Bool)
predictLongRunningOperationDoneL f PredictLongRunningOperation {..} = (\predictLongRunningOperationDone -> PredictLongRunningOperation {predictLongRunningOperationDone, ..}) <$> f predictLongRunningOperationDone
{-# INLINE predictLongRunningOperationDoneL #-}

-- | 'predictLongRunningOperationName' Lens
predictLongRunningOperationNameL :: Lens_' PredictLongRunningOperation (Maybe Text)
predictLongRunningOperationNameL f PredictLongRunningOperation {..} = (\predictLongRunningOperationName -> PredictLongRunningOperation {predictLongRunningOperationName, ..}) <$> f predictLongRunningOperationName
{-# INLINE predictLongRunningOperationNameL #-}

-- | 'predictLongRunningOperationError' Lens
predictLongRunningOperationErrorL :: Lens_' PredictLongRunningOperation (Maybe Status)
predictLongRunningOperationErrorL f PredictLongRunningOperation {..} = (\predictLongRunningOperationError -> PredictLongRunningOperation {predictLongRunningOperationError, ..}) <$> f predictLongRunningOperationError
{-# INLINE predictLongRunningOperationErrorL #-}

-- | 'predictLongRunningOperationMetadata' Lens
predictLongRunningOperationMetadataL :: Lens_' PredictLongRunningOperation (Maybe A.Value)
predictLongRunningOperationMetadataL f PredictLongRunningOperation {..} = (\predictLongRunningOperationMetadata -> PredictLongRunningOperation {predictLongRunningOperationMetadata, ..}) <$> f predictLongRunningOperationMetadata
{-# INLINE predictLongRunningOperationMetadataL #-}

-- | 'predictLongRunningOperationResponse' Lens
predictLongRunningOperationResponseL :: Lens_' PredictLongRunningOperation (Maybe PredictLongRunningResponse)
predictLongRunningOperationResponseL f PredictLongRunningOperation {..} = (\predictLongRunningOperationResponse -> PredictLongRunningOperation {predictLongRunningOperationResponse, ..}) <$> f predictLongRunningOperationResponse
{-# INLINE predictLongRunningOperationResponseL #-}

-- * PredictLongRunningRequest

-- | 'predictLongRunningRequestParameters' Lens
predictLongRunningRequestParametersL :: Lens_' PredictLongRunningRequest (Maybe String)
predictLongRunningRequestParametersL f PredictLongRunningRequest {..} = (\predictLongRunningRequestParameters -> PredictLongRunningRequest {predictLongRunningRequestParameters, ..}) <$> f predictLongRunningRequestParameters
{-# INLINE predictLongRunningRequestParametersL #-}

-- | 'predictLongRunningRequestInstances' Lens
predictLongRunningRequestInstancesL :: Lens_' PredictLongRunningRequest ([String])
predictLongRunningRequestInstancesL f PredictLongRunningRequest {..} = (\predictLongRunningRequestInstances -> PredictLongRunningRequest {predictLongRunningRequestInstances, ..}) <$> f predictLongRunningRequestInstances
{-# INLINE predictLongRunningRequestInstancesL #-}

-- * PredictLongRunningResponse

-- | 'predictLongRunningResponseGenerateVideoResponse' Lens
predictLongRunningResponseGenerateVideoResponseL :: Lens_' PredictLongRunningResponse (Maybe GenerateVideoResponse)
predictLongRunningResponseGenerateVideoResponseL f PredictLongRunningResponse {..} = (\predictLongRunningResponseGenerateVideoResponse -> PredictLongRunningResponse {predictLongRunningResponseGenerateVideoResponse, ..}) <$> f predictLongRunningResponseGenerateVideoResponse
{-# INLINE predictLongRunningResponseGenerateVideoResponseL #-}

-- * PredictRequest

-- | 'predictRequestInstances' Lens
predictRequestInstancesL :: Lens_' PredictRequest ([String])
predictRequestInstancesL f PredictRequest {..} = (\predictRequestInstances -> PredictRequest {predictRequestInstances, ..}) <$> f predictRequestInstances
{-# INLINE predictRequestInstancesL #-}

-- | 'predictRequestParameters' Lens
predictRequestParametersL :: Lens_' PredictRequest (Maybe String)
predictRequestParametersL f PredictRequest {..} = (\predictRequestParameters -> PredictRequest {predictRequestParameters, ..}) <$> f predictRequestParameters
{-# INLINE predictRequestParametersL #-}

-- * PredictResponse

-- | 'predictResponsePredictions' Lens
predictResponsePredictionsL :: Lens_' PredictResponse (Maybe [String])
predictResponsePredictionsL f PredictResponse {..} = (\predictResponsePredictions -> PredictResponse {predictResponsePredictions, ..}) <$> f predictResponsePredictions
{-# INLINE predictResponsePredictionsL #-}

-- * PromptFeedback

-- | 'promptFeedbackBlockReason' Lens
promptFeedbackBlockReasonL :: Lens_' PromptFeedback (Maybe E'BlockReason)
promptFeedbackBlockReasonL f PromptFeedback {..} = (\promptFeedbackBlockReason -> PromptFeedback {promptFeedbackBlockReason, ..}) <$> f promptFeedbackBlockReason
{-# INLINE promptFeedbackBlockReasonL #-}

-- | 'promptFeedbackSafetyRatings' Lens
promptFeedbackSafetyRatingsL :: Lens_' PromptFeedback (Maybe [SafetyRating])
promptFeedbackSafetyRatingsL f PromptFeedback {..} = (\promptFeedbackSafetyRatings -> PromptFeedback {promptFeedbackSafetyRatings, ..}) <$> f promptFeedbackSafetyRatings
{-# INLINE promptFeedbackSafetyRatingsL #-}

-- * QueryCorpusRequest

-- | 'queryCorpusRequestMetadataFilters' Lens
queryCorpusRequestMetadataFiltersL :: Lens_' QueryCorpusRequest (Maybe [MetadataFilter])
queryCorpusRequestMetadataFiltersL f QueryCorpusRequest {..} = (\queryCorpusRequestMetadataFilters -> QueryCorpusRequest {queryCorpusRequestMetadataFilters, ..}) <$> f queryCorpusRequestMetadataFilters
{-# INLINE queryCorpusRequestMetadataFiltersL #-}

-- | 'queryCorpusRequestQuery' Lens
queryCorpusRequestQueryL :: Lens_' QueryCorpusRequest (Text)
queryCorpusRequestQueryL f QueryCorpusRequest {..} = (\queryCorpusRequestQuery -> QueryCorpusRequest {queryCorpusRequestQuery, ..}) <$> f queryCorpusRequestQuery
{-# INLINE queryCorpusRequestQueryL #-}

-- | 'queryCorpusRequestResultsCount' Lens
queryCorpusRequestResultsCountL :: Lens_' QueryCorpusRequest (Maybe Int)
queryCorpusRequestResultsCountL f QueryCorpusRequest {..} = (\queryCorpusRequestResultsCount -> QueryCorpusRequest {queryCorpusRequestResultsCount, ..}) <$> f queryCorpusRequestResultsCount
{-# INLINE queryCorpusRequestResultsCountL #-}

-- * QueryCorpusResponse

-- | 'queryCorpusResponseRelevantChunks' Lens
queryCorpusResponseRelevantChunksL :: Lens_' QueryCorpusResponse (Maybe [RelevantChunk])
queryCorpusResponseRelevantChunksL f QueryCorpusResponse {..} = (\queryCorpusResponseRelevantChunks -> QueryCorpusResponse {queryCorpusResponseRelevantChunks, ..}) <$> f queryCorpusResponseRelevantChunks
{-# INLINE queryCorpusResponseRelevantChunksL #-}

-- * QueryDocumentRequest

-- | 'queryDocumentRequestQuery' Lens
queryDocumentRequestQueryL :: Lens_' QueryDocumentRequest (Text)
queryDocumentRequestQueryL f QueryDocumentRequest {..} = (\queryDocumentRequestQuery -> QueryDocumentRequest {queryDocumentRequestQuery, ..}) <$> f queryDocumentRequestQuery
{-# INLINE queryDocumentRequestQueryL #-}

-- | 'queryDocumentRequestResultsCount' Lens
queryDocumentRequestResultsCountL :: Lens_' QueryDocumentRequest (Maybe Int)
queryDocumentRequestResultsCountL f QueryDocumentRequest {..} = (\queryDocumentRequestResultsCount -> QueryDocumentRequest {queryDocumentRequestResultsCount, ..}) <$> f queryDocumentRequestResultsCount
{-# INLINE queryDocumentRequestResultsCountL #-}

-- | 'queryDocumentRequestMetadataFilters' Lens
queryDocumentRequestMetadataFiltersL :: Lens_' QueryDocumentRequest (Maybe [MetadataFilter])
queryDocumentRequestMetadataFiltersL f QueryDocumentRequest {..} = (\queryDocumentRequestMetadataFilters -> QueryDocumentRequest {queryDocumentRequestMetadataFilters, ..}) <$> f queryDocumentRequestMetadataFilters
{-# INLINE queryDocumentRequestMetadataFiltersL #-}

-- * QueryDocumentResponse

-- | 'queryDocumentResponseRelevantChunks' Lens
queryDocumentResponseRelevantChunksL :: Lens_' QueryDocumentResponse (Maybe [RelevantChunk])
queryDocumentResponseRelevantChunksL f QueryDocumentResponse {..} = (\queryDocumentResponseRelevantChunks -> QueryDocumentResponse {queryDocumentResponseRelevantChunks, ..}) <$> f queryDocumentResponseRelevantChunks
{-# INLINE queryDocumentResponseRelevantChunksL #-}

-- * RelevantChunk

-- | 'relevantChunkChunk' Lens
relevantChunkChunkL :: Lens_' RelevantChunk (Maybe Chunk)
relevantChunkChunkL f RelevantChunk {..} = (\relevantChunkChunk -> RelevantChunk {relevantChunkChunk, ..}) <$> f relevantChunkChunk
{-# INLINE relevantChunkChunkL #-}

-- | 'relevantChunkChunkRelevanceScore' Lens
relevantChunkChunkRelevanceScoreL :: Lens_' RelevantChunk (Maybe Float)
relevantChunkChunkRelevanceScoreL f RelevantChunk {..} = (\relevantChunkChunkRelevanceScore -> RelevantChunk {relevantChunkChunkRelevanceScore, ..}) <$> f relevantChunkChunkRelevanceScore
{-# INLINE relevantChunkChunkRelevanceScoreL #-}

-- * RetrievalMetadata

-- | 'retrievalMetadataGoogleSearchDynamicRetrievalScore' Lens
retrievalMetadataGoogleSearchDynamicRetrievalScoreL :: Lens_' RetrievalMetadata (Maybe Float)
retrievalMetadataGoogleSearchDynamicRetrievalScoreL f RetrievalMetadata {..} = (\retrievalMetadataGoogleSearchDynamicRetrievalScore -> RetrievalMetadata {retrievalMetadataGoogleSearchDynamicRetrievalScore, ..}) <$> f retrievalMetadataGoogleSearchDynamicRetrievalScore
{-# INLINE retrievalMetadataGoogleSearchDynamicRetrievalScoreL #-}

-- * SafetyFeedback

-- | 'safetyFeedbackSetting' Lens
safetyFeedbackSettingL :: Lens_' SafetyFeedback (Maybe SafetySetting)
safetyFeedbackSettingL f SafetyFeedback {..} = (\safetyFeedbackSetting -> SafetyFeedback {safetyFeedbackSetting, ..}) <$> f safetyFeedbackSetting
{-# INLINE safetyFeedbackSettingL #-}

-- | 'safetyFeedbackRating' Lens
safetyFeedbackRatingL :: Lens_' SafetyFeedback (Maybe SafetyRating)
safetyFeedbackRatingL f SafetyFeedback {..} = (\safetyFeedbackRating -> SafetyFeedback {safetyFeedbackRating, ..}) <$> f safetyFeedbackRating
{-# INLINE safetyFeedbackRatingL #-}

-- * SafetyRating

-- | 'safetyRatingCategory' Lens
safetyRatingCategoryL :: Lens_' SafetyRating (HarmCategory)
safetyRatingCategoryL f SafetyRating {..} = (\safetyRatingCategory -> SafetyRating {safetyRatingCategory, ..}) <$> f safetyRatingCategory
{-# INLINE safetyRatingCategoryL #-}

-- | 'safetyRatingBlocked' Lens
safetyRatingBlockedL :: Lens_' SafetyRating (Maybe Bool)
safetyRatingBlockedL f SafetyRating {..} = (\safetyRatingBlocked -> SafetyRating {safetyRatingBlocked, ..}) <$> f safetyRatingBlocked
{-# INLINE safetyRatingBlockedL #-}

-- | 'safetyRatingProbability' Lens
safetyRatingProbabilityL :: Lens_' SafetyRating (E'Probability)
safetyRatingProbabilityL f SafetyRating {..} = (\safetyRatingProbability -> SafetyRating {safetyRatingProbability, ..}) <$> f safetyRatingProbability
{-# INLINE safetyRatingProbabilityL #-}

-- * SafetySetting

-- | 'safetySettingThreshold' Lens
safetySettingThresholdL :: Lens_' SafetySetting (E'Threshold)
safetySettingThresholdL f SafetySetting {..} = (\safetySettingThreshold -> SafetySetting {safetySettingThreshold, ..}) <$> f safetySettingThreshold
{-# INLINE safetySettingThresholdL #-}

-- | 'safetySettingCategory' Lens
safetySettingCategoryL :: Lens_' SafetySetting (HarmCategory)
safetySettingCategoryL f SafetySetting {..} = (\safetySettingCategory -> SafetySetting {safetySettingCategory, ..}) <$> f safetySettingCategory
{-# INLINE safetySettingCategoryL #-}

-- * Schema

-- | 'schemaItems' Lens
schemaItemsL :: Lens_' Schema (Maybe Schema)
schemaItemsL f Schema {..} = (\schemaItems -> Schema {schemaItems, ..}) <$> f schemaItems
{-# INLINE schemaItemsL #-}

-- | 'schemaAnyOf' Lens
schemaAnyOfL :: Lens_' Schema (Maybe [Schema])
schemaAnyOfL f Schema {..} = (\schemaAnyOf -> Schema {schemaAnyOf, ..}) <$> f schemaAnyOf
{-# INLINE schemaAnyOfL #-}

-- | 'schemaMinLength' Lens
schemaMinLengthL :: Lens_' Schema (Maybe Text)
schemaMinLengthL f Schema {..} = (\schemaMinLength -> Schema {schemaMinLength, ..}) <$> f schemaMinLength
{-# INLINE schemaMinLengthL #-}

-- | 'schemaMaximum' Lens
schemaMaximumL :: Lens_' Schema (Maybe Double)
schemaMaximumL f Schema {..} = (\schemaMaximum -> Schema {schemaMaximum, ..}) <$> f schemaMaximum
{-# INLINE schemaMaximumL #-}

-- | 'schemaPropertyOrdering' Lens
schemaPropertyOrderingL :: Lens_' Schema (Maybe [Text])
schemaPropertyOrderingL f Schema {..} = (\schemaPropertyOrdering -> Schema {schemaPropertyOrdering, ..}) <$> f schemaPropertyOrdering
{-# INLINE schemaPropertyOrderingL #-}

-- | 'schemaNullable' Lens
schemaNullableL :: Lens_' Schema (Maybe Bool)
schemaNullableL f Schema {..} = (\schemaNullable -> Schema {schemaNullable, ..}) <$> f schemaNullable
{-# INLINE schemaNullableL #-}

-- | 'schemaRequired' Lens
schemaRequiredL :: Lens_' Schema (Maybe [Text])
schemaRequiredL f Schema {..} = (\schemaRequired -> Schema {schemaRequired, ..}) <$> f schemaRequired
{-# INLINE schemaRequiredL #-}

-- | 'schemaMinProperties' Lens
schemaMinPropertiesL :: Lens_' Schema (Maybe Text)
schemaMinPropertiesL f Schema {..} = (\schemaMinProperties -> Schema {schemaMinProperties, ..}) <$> f schemaMinProperties
{-# INLINE schemaMinPropertiesL #-}

-- | 'schemaMaxItems' Lens
schemaMaxItemsL :: Lens_' Schema (Maybe Text)
schemaMaxItemsL f Schema {..} = (\schemaMaxItems -> Schema {schemaMaxItems, ..}) <$> f schemaMaxItems
{-# INLINE schemaMaxItemsL #-}

-- | 'schemaExample' Lens
schemaExampleL :: Lens_' Schema (Maybe String)
schemaExampleL f Schema {..} = (\schemaExample -> Schema {schemaExample, ..}) <$> f schemaExample
{-# INLINE schemaExampleL #-}

-- | 'schemaTitle' Lens
schemaTitleL :: Lens_' Schema (Maybe Text)
schemaTitleL f Schema {..} = (\schemaTitle -> Schema {schemaTitle, ..}) <$> f schemaTitle
{-# INLINE schemaTitleL #-}

-- | 'schemaMinItems' Lens
schemaMinItemsL :: Lens_' Schema (Maybe Text)
schemaMinItemsL f Schema {..} = (\schemaMinItems -> Schema {schemaMinItems, ..}) <$> f schemaMinItems
{-# INLINE schemaMinItemsL #-}

-- | 'schemaDescription' Lens
schemaDescriptionL :: Lens_' Schema (Maybe Text)
schemaDescriptionL f Schema {..} = (\schemaDescription -> Schema {schemaDescription, ..}) <$> f schemaDescription
{-# INLINE schemaDescriptionL #-}

-- | 'schemaType' Lens
schemaTypeL :: Lens_' Schema (ModelType)
schemaTypeL f Schema {..} = (\schemaType -> Schema {schemaType, ..}) <$> f schemaType
{-# INLINE schemaTypeL #-}

-- | 'schemaDefault' Lens
schemaDefaultL :: Lens_' Schema (Maybe String)
schemaDefaultL f Schema {..} = (\schemaDefault -> Schema {schemaDefault, ..}) <$> f schemaDefault
{-# INLINE schemaDefaultL #-}

-- | 'schemaMinimum' Lens
schemaMinimumL :: Lens_' Schema (Maybe Double)
schemaMinimumL f Schema {..} = (\schemaMinimum -> Schema {schemaMinimum, ..}) <$> f schemaMinimum
{-# INLINE schemaMinimumL #-}

-- | 'schemaPattern' Lens
schemaPatternL :: Lens_' Schema (Maybe Text)
schemaPatternL f Schema {..} = (\schemaPattern -> Schema {schemaPattern, ..}) <$> f schemaPattern
{-# INLINE schemaPatternL #-}

-- | 'schemaProperties' Lens
schemaPropertiesL :: Lens_' Schema (Maybe (Map.Map String Schema))
schemaPropertiesL f Schema {..} = (\schemaProperties -> Schema {schemaProperties, ..}) <$> f schemaProperties
{-# INLINE schemaPropertiesL #-}

-- | 'schemaMaxProperties' Lens
schemaMaxPropertiesL :: Lens_' Schema (Maybe Text)
schemaMaxPropertiesL f Schema {..} = (\schemaMaxProperties -> Schema {schemaMaxProperties, ..}) <$> f schemaMaxProperties
{-# INLINE schemaMaxPropertiesL #-}

-- | 'schemaFormat' Lens
schemaFormatL :: Lens_' Schema (Maybe Text)
schemaFormatL f Schema {..} = (\schemaFormat -> Schema {schemaFormat, ..}) <$> f schemaFormat
{-# INLINE schemaFormatL #-}

-- | 'schemaEnum' Lens
schemaEnumL :: Lens_' Schema (Maybe [Text])
schemaEnumL f Schema {..} = (\schemaEnum -> Schema {schemaEnum, ..}) <$> f schemaEnum
{-# INLINE schemaEnumL #-}

-- | 'schemaMaxLength' Lens
schemaMaxLengthL :: Lens_' Schema (Maybe Text)
schemaMaxLengthL f Schema {..} = (\schemaMaxLength -> Schema {schemaMaxLength, ..}) <$> f schemaMaxLength
{-# INLINE schemaMaxLengthL #-}

-- * SearchEntryPoint

-- | 'searchEntryPointSdkBlob' Lens
searchEntryPointSdkBlobL :: Lens_' SearchEntryPoint (Maybe ByteArray)
searchEntryPointSdkBlobL f SearchEntryPoint {..} = (\searchEntryPointSdkBlob -> SearchEntryPoint {searchEntryPointSdkBlob, ..}) <$> f searchEntryPointSdkBlob
{-# INLINE searchEntryPointSdkBlobL #-}

-- | 'searchEntryPointRenderedContent' Lens
searchEntryPointRenderedContentL :: Lens_' SearchEntryPoint (Maybe Text)
searchEntryPointRenderedContentL f SearchEntryPoint {..} = (\searchEntryPointRenderedContent -> SearchEntryPoint {searchEntryPointRenderedContent, ..}) <$> f searchEntryPointRenderedContent
{-# INLINE searchEntryPointRenderedContentL #-}

-- * Segment

-- | 'segmentPartIndex' Lens
segmentPartIndexL :: Lens_' Segment (Maybe Int)
segmentPartIndexL f Segment {..} = (\segmentPartIndex -> Segment {segmentPartIndex, ..}) <$> f segmentPartIndex
{-# INLINE segmentPartIndexL #-}

-- | 'segmentStartIndex' Lens
segmentStartIndexL :: Lens_' Segment (Maybe Int)
segmentStartIndexL f Segment {..} = (\segmentStartIndex -> Segment {segmentStartIndex, ..}) <$> f segmentStartIndex
{-# INLINE segmentStartIndexL #-}

-- | 'segmentText' Lens
segmentTextL :: Lens_' Segment (Maybe Text)
segmentTextL f Segment {..} = (\segmentText -> Segment {segmentText, ..}) <$> f segmentText
{-# INLINE segmentTextL #-}

-- | 'segmentEndIndex' Lens
segmentEndIndexL :: Lens_' Segment (Maybe Int)
segmentEndIndexL f Segment {..} = (\segmentEndIndex -> Segment {segmentEndIndex, ..}) <$> f segmentEndIndex
{-# INLINE segmentEndIndexL #-}

-- * SemanticRetrieverChunk

-- | 'semanticRetrieverChunkChunk' Lens
semanticRetrieverChunkChunkL :: Lens_' SemanticRetrieverChunk (Maybe Text)
semanticRetrieverChunkChunkL f SemanticRetrieverChunk {..} = (\semanticRetrieverChunkChunk -> SemanticRetrieverChunk {semanticRetrieverChunkChunk, ..}) <$> f semanticRetrieverChunkChunk
{-# INLINE semanticRetrieverChunkChunkL #-}

-- | 'semanticRetrieverChunkSource' Lens
semanticRetrieverChunkSourceL :: Lens_' SemanticRetrieverChunk (Maybe Text)
semanticRetrieverChunkSourceL f SemanticRetrieverChunk {..} = (\semanticRetrieverChunkSource -> SemanticRetrieverChunk {semanticRetrieverChunkSource, ..}) <$> f semanticRetrieverChunkSource
{-# INLINE semanticRetrieverChunkSourceL #-}

-- * SemanticRetrieverConfig

-- | 'semanticRetrieverConfigSource' Lens
semanticRetrieverConfigSourceL :: Lens_' SemanticRetrieverConfig (Text)
semanticRetrieverConfigSourceL f SemanticRetrieverConfig {..} = (\semanticRetrieverConfigSource -> SemanticRetrieverConfig {semanticRetrieverConfigSource, ..}) <$> f semanticRetrieverConfigSource
{-# INLINE semanticRetrieverConfigSourceL #-}

-- | 'semanticRetrieverConfigQuery' Lens
semanticRetrieverConfigQueryL :: Lens_' SemanticRetrieverConfig (Content)
semanticRetrieverConfigQueryL f SemanticRetrieverConfig {..} = (\semanticRetrieverConfigQuery -> SemanticRetrieverConfig {semanticRetrieverConfigQuery, ..}) <$> f semanticRetrieverConfigQuery
{-# INLINE semanticRetrieverConfigQueryL #-}

-- | 'semanticRetrieverConfigMaxChunksCount' Lens
semanticRetrieverConfigMaxChunksCountL :: Lens_' SemanticRetrieverConfig (Maybe Int)
semanticRetrieverConfigMaxChunksCountL f SemanticRetrieverConfig {..} = (\semanticRetrieverConfigMaxChunksCount -> SemanticRetrieverConfig {semanticRetrieverConfigMaxChunksCount, ..}) <$> f semanticRetrieverConfigMaxChunksCount
{-# INLINE semanticRetrieverConfigMaxChunksCountL #-}

-- | 'semanticRetrieverConfigMetadataFilters' Lens
semanticRetrieverConfigMetadataFiltersL :: Lens_' SemanticRetrieverConfig (Maybe [MetadataFilter])
semanticRetrieverConfigMetadataFiltersL f SemanticRetrieverConfig {..} = (\semanticRetrieverConfigMetadataFilters -> SemanticRetrieverConfig {semanticRetrieverConfigMetadataFilters, ..}) <$> f semanticRetrieverConfigMetadataFilters
{-# INLINE semanticRetrieverConfigMetadataFiltersL #-}

-- | 'semanticRetrieverConfigMinimumRelevanceScore' Lens
semanticRetrieverConfigMinimumRelevanceScoreL :: Lens_' SemanticRetrieverConfig (Maybe Float)
semanticRetrieverConfigMinimumRelevanceScoreL f SemanticRetrieverConfig {..} = (\semanticRetrieverConfigMinimumRelevanceScore -> SemanticRetrieverConfig {semanticRetrieverConfigMinimumRelevanceScore, ..}) <$> f semanticRetrieverConfigMinimumRelevanceScore
{-# INLINE semanticRetrieverConfigMinimumRelevanceScoreL #-}

-- * SpeakerVoiceConfig

-- | 'speakerVoiceConfigVoiceConfig' Lens
speakerVoiceConfigVoiceConfigL :: Lens_' SpeakerVoiceConfig (VoiceConfig)
speakerVoiceConfigVoiceConfigL f SpeakerVoiceConfig {..} = (\speakerVoiceConfigVoiceConfig -> SpeakerVoiceConfig {speakerVoiceConfigVoiceConfig, ..}) <$> f speakerVoiceConfigVoiceConfig
{-# INLINE speakerVoiceConfigVoiceConfigL #-}

-- | 'speakerVoiceConfigSpeaker' Lens
speakerVoiceConfigSpeakerL :: Lens_' SpeakerVoiceConfig (Text)
speakerVoiceConfigSpeakerL f SpeakerVoiceConfig {..} = (\speakerVoiceConfigSpeaker -> SpeakerVoiceConfig {speakerVoiceConfigSpeaker, ..}) <$> f speakerVoiceConfigSpeaker
{-# INLINE speakerVoiceConfigSpeakerL #-}

-- * SpeechConfig

-- | 'speechConfigVoiceConfig' Lens
speechConfigVoiceConfigL :: Lens_' SpeechConfig (Maybe VoiceConfig)
speechConfigVoiceConfigL f SpeechConfig {..} = (\speechConfigVoiceConfig -> SpeechConfig {speechConfigVoiceConfig, ..}) <$> f speechConfigVoiceConfig
{-# INLINE speechConfigVoiceConfigL #-}

-- | 'speechConfigLanguageCode' Lens
speechConfigLanguageCodeL :: Lens_' SpeechConfig (Maybe Text)
speechConfigLanguageCodeL f SpeechConfig {..} = (\speechConfigLanguageCode -> SpeechConfig {speechConfigLanguageCode, ..}) <$> f speechConfigLanguageCode
{-# INLINE speechConfigLanguageCodeL #-}

-- | 'speechConfigMultiSpeakerVoiceConfig' Lens
speechConfigMultiSpeakerVoiceConfigL :: Lens_' SpeechConfig (Maybe MultiSpeakerVoiceConfig)
speechConfigMultiSpeakerVoiceConfigL f SpeechConfig {..} = (\speechConfigMultiSpeakerVoiceConfig -> SpeechConfig {speechConfigMultiSpeakerVoiceConfig, ..}) <$> f speechConfigMultiSpeakerVoiceConfig
{-# INLINE speechConfigMultiSpeakerVoiceConfigL #-}

-- * Status

-- | 'statusCode' Lens
statusCodeL :: Lens_' Status (Maybe Int)
statusCodeL f Status {..} = (\statusCode -> Status {statusCode, ..}) <$> f statusCode
{-# INLINE statusCodeL #-}

-- | 'statusDetails' Lens
statusDetailsL :: Lens_' Status (Maybe [(Map.Map String String)])
statusDetailsL f Status {..} = (\statusDetails -> Status {statusDetails, ..}) <$> f statusDetails
{-# INLINE statusDetailsL #-}

-- | 'statusMessage' Lens
statusMessageL :: Lens_' Status (Maybe Text)
statusMessageL f Status {..} = (\statusMessage -> Status {statusMessage, ..}) <$> f statusMessage
{-# INLINE statusMessageL #-}

-- * StringList

-- | 'stringListValues' Lens
stringListValuesL :: Lens_' StringList (Maybe [Text])
stringListValuesL f StringList {..} = (\stringListValues -> StringList {stringListValues, ..}) <$> f stringListValues
{-# INLINE stringListValuesL #-}

-- * TaskType

-- * TextCompletion

-- | 'textCompletionSafetyRatings' Lens
textCompletionSafetyRatingsL :: Lens_' TextCompletion (Maybe [SafetyRating])
textCompletionSafetyRatingsL f TextCompletion {..} = (\textCompletionSafetyRatings -> TextCompletion {textCompletionSafetyRatings, ..}) <$> f textCompletionSafetyRatings
{-# INLINE textCompletionSafetyRatingsL #-}

-- | 'textCompletionOutput' Lens
textCompletionOutputL :: Lens_' TextCompletion (Maybe Text)
textCompletionOutputL f TextCompletion {..} = (\textCompletionOutput -> TextCompletion {textCompletionOutput, ..}) <$> f textCompletionOutput
{-# INLINE textCompletionOutputL #-}

-- | 'textCompletionCitationMetadata' Lens
textCompletionCitationMetadataL :: Lens_' TextCompletion (Maybe CitationMetadata)
textCompletionCitationMetadataL f TextCompletion {..} = (\textCompletionCitationMetadata -> TextCompletion {textCompletionCitationMetadata, ..}) <$> f textCompletionCitationMetadata
{-# INLINE textCompletionCitationMetadataL #-}

-- * TextPrompt

-- | 'textPromptText' Lens
textPromptTextL :: Lens_' TextPrompt (Text)
textPromptTextL f TextPrompt {..} = (\textPromptText -> TextPrompt {textPromptText, ..}) <$> f textPromptText
{-# INLINE textPromptTextL #-}

-- * ThinkingConfig

-- | 'thinkingConfigThinkingBudget' Lens
thinkingConfigThinkingBudgetL :: Lens_' ThinkingConfig (Maybe Int)
thinkingConfigThinkingBudgetL f ThinkingConfig {..} = (\thinkingConfigThinkingBudget -> ThinkingConfig {thinkingConfigThinkingBudget, ..}) <$> f thinkingConfigThinkingBudget
{-# INLINE thinkingConfigThinkingBudgetL #-}

-- | 'thinkingConfigIncludeThoughts' Lens
thinkingConfigIncludeThoughtsL :: Lens_' ThinkingConfig (Maybe Bool)
thinkingConfigIncludeThoughtsL f ThinkingConfig {..} = (\thinkingConfigIncludeThoughts -> ThinkingConfig {thinkingConfigIncludeThoughts, ..}) <$> f thinkingConfigIncludeThoughts
{-# INLINE thinkingConfigIncludeThoughtsL #-}

-- * Tool

-- | 'toolFunctionDeclarations' Lens
toolFunctionDeclarationsL :: Lens_' Tool (Maybe [FunctionDeclaration])
toolFunctionDeclarationsL f Tool {..} = (\toolFunctionDeclarations -> Tool {toolFunctionDeclarations, ..}) <$> f toolFunctionDeclarations
{-# INLINE toolFunctionDeclarationsL #-}

-- | 'toolGoogleSearchRetrieval' Lens
toolGoogleSearchRetrievalL :: Lens_' Tool (Maybe GoogleSearchRetrieval)
toolGoogleSearchRetrievalL f Tool {..} = (\toolGoogleSearchRetrieval -> Tool {toolGoogleSearchRetrieval, ..}) <$> f toolGoogleSearchRetrieval
{-# INLINE toolGoogleSearchRetrievalL #-}

-- | 'toolGoogleSearch' Lens
toolGoogleSearchL :: Lens_' Tool (Maybe GoogleSearch)
toolGoogleSearchL f Tool {..} = (\toolGoogleSearch -> Tool {toolGoogleSearch, ..}) <$> f toolGoogleSearch
{-# INLINE toolGoogleSearchL #-}

-- | 'toolCodeExecution' Lens
toolCodeExecutionL :: Lens_' Tool (Maybe A.Value)
toolCodeExecutionL f Tool {..} = (\toolCodeExecution -> Tool {toolCodeExecution, ..}) <$> f toolCodeExecution
{-# INLINE toolCodeExecutionL #-}

-- | 'toolUrlContext' Lens
toolUrlContextL :: Lens_' Tool (Maybe A.Value)
toolUrlContextL f Tool {..} = (\toolUrlContext -> Tool {toolUrlContext, ..}) <$> f toolUrlContext
{-# INLINE toolUrlContextL #-}

-- * ToolConfig

-- | 'toolConfigFunctionCallingConfig' Lens
toolConfigFunctionCallingConfigL :: Lens_' ToolConfig (Maybe FunctionCallingConfig)
toolConfigFunctionCallingConfigL f ToolConfig {..} = (\toolConfigFunctionCallingConfig -> ToolConfig {toolConfigFunctionCallingConfig, ..}) <$> f toolConfigFunctionCallingConfig
{-# INLINE toolConfigFunctionCallingConfigL #-}

-- * TopCandidates

-- | 'topCandidatesCandidates' Lens
topCandidatesCandidatesL :: Lens_' TopCandidates (Maybe [LogprobsResultCandidate])
topCandidatesCandidatesL f TopCandidates {..} = (\topCandidatesCandidates -> TopCandidates {topCandidatesCandidates, ..}) <$> f topCandidatesCandidates
{-# INLINE topCandidatesCandidatesL #-}

-- * TransferOwnershipRequest

-- | 'transferOwnershipRequestEmailAddress' Lens
transferOwnershipRequestEmailAddressL :: Lens_' TransferOwnershipRequest (Text)
transferOwnershipRequestEmailAddressL f TransferOwnershipRequest {..} = (\transferOwnershipRequestEmailAddress -> TransferOwnershipRequest {transferOwnershipRequestEmailAddress, ..}) <$> f transferOwnershipRequestEmailAddress
{-# INLINE transferOwnershipRequestEmailAddressL #-}

-- * TunedModel

-- | 'tunedModelUpdateTime' Lens
tunedModelUpdateTimeL :: Lens_' TunedModel (Maybe DateTime)
tunedModelUpdateTimeL f TunedModel {..} = (\tunedModelUpdateTime -> TunedModel {tunedModelUpdateTime, ..}) <$> f tunedModelUpdateTime
{-# INLINE tunedModelUpdateTimeL #-}

-- | 'tunedModelName' Lens
tunedModelNameL :: Lens_' TunedModel (Maybe Text)
tunedModelNameL f TunedModel {..} = (\tunedModelName -> TunedModel {tunedModelName, ..}) <$> f tunedModelName
{-# INLINE tunedModelNameL #-}

-- | 'tunedModelCreateTime' Lens
tunedModelCreateTimeL :: Lens_' TunedModel (Maybe DateTime)
tunedModelCreateTimeL f TunedModel {..} = (\tunedModelCreateTime -> TunedModel {tunedModelCreateTime, ..}) <$> f tunedModelCreateTime
{-# INLINE tunedModelCreateTimeL #-}

-- | 'tunedModelTuningTask' Lens
tunedModelTuningTaskL :: Lens_' TunedModel (TuningTask)
tunedModelTuningTaskL f TunedModel {..} = (\tunedModelTuningTask -> TunedModel {tunedModelTuningTask, ..}) <$> f tunedModelTuningTask
{-# INLINE tunedModelTuningTaskL #-}

-- | 'tunedModelTunedModelSource' Lens
tunedModelTunedModelSourceL :: Lens_' TunedModel (Maybe TunedModelSource)
tunedModelTunedModelSourceL f TunedModel {..} = (\tunedModelTunedModelSource -> TunedModel {tunedModelTunedModelSource, ..}) <$> f tunedModelTunedModelSource
{-# INLINE tunedModelTunedModelSourceL #-}

-- | 'tunedModelBaseModel' Lens
tunedModelBaseModelL :: Lens_' TunedModel (Maybe Text)
tunedModelBaseModelL f TunedModel {..} = (\tunedModelBaseModel -> TunedModel {tunedModelBaseModel, ..}) <$> f tunedModelBaseModel
{-# INLINE tunedModelBaseModelL #-}

-- | 'tunedModelReaderProjectNumbers' Lens
tunedModelReaderProjectNumbersL :: Lens_' TunedModel (Maybe [Text])
tunedModelReaderProjectNumbersL f TunedModel {..} = (\tunedModelReaderProjectNumbers -> TunedModel {tunedModelReaderProjectNumbers, ..}) <$> f tunedModelReaderProjectNumbers
{-# INLINE tunedModelReaderProjectNumbersL #-}

-- | 'tunedModelDisplayName' Lens
tunedModelDisplayNameL :: Lens_' TunedModel (Maybe Text)
tunedModelDisplayNameL f TunedModel {..} = (\tunedModelDisplayName -> TunedModel {tunedModelDisplayName, ..}) <$> f tunedModelDisplayName
{-# INLINE tunedModelDisplayNameL #-}

-- | 'tunedModelTemperature' Lens
tunedModelTemperatureL :: Lens_' TunedModel (Maybe Float)
tunedModelTemperatureL f TunedModel {..} = (\tunedModelTemperature -> TunedModel {tunedModelTemperature, ..}) <$> f tunedModelTemperature
{-# INLINE tunedModelTemperatureL #-}

-- | 'tunedModelDescription' Lens
tunedModelDescriptionL :: Lens_' TunedModel (Maybe Text)
tunedModelDescriptionL f TunedModel {..} = (\tunedModelDescription -> TunedModel {tunedModelDescription, ..}) <$> f tunedModelDescription
{-# INLINE tunedModelDescriptionL #-}

-- | 'tunedModelTopP' Lens
tunedModelTopPL :: Lens_' TunedModel (Maybe Float)
tunedModelTopPL f TunedModel {..} = (\tunedModelTopP -> TunedModel {tunedModelTopP, ..}) <$> f tunedModelTopP
{-# INLINE tunedModelTopPL #-}

-- | 'tunedModelTopK' Lens
tunedModelTopKL :: Lens_' TunedModel (Maybe Int)
tunedModelTopKL f TunedModel {..} = (\tunedModelTopK -> TunedModel {tunedModelTopK, ..}) <$> f tunedModelTopK
{-# INLINE tunedModelTopKL #-}

-- | 'tunedModelState' Lens
tunedModelStateL :: Lens_' TunedModel (Maybe E'State3)
tunedModelStateL f TunedModel {..} = (\tunedModelState -> TunedModel {tunedModelState, ..}) <$> f tunedModelState
{-# INLINE tunedModelStateL #-}

-- * TunedModelSource

-- | 'tunedModelSourceTunedModel' Lens
tunedModelSourceTunedModelL :: Lens_' TunedModelSource (Maybe Text)
tunedModelSourceTunedModelL f TunedModelSource {..} = (\tunedModelSourceTunedModel -> TunedModelSource {tunedModelSourceTunedModel, ..}) <$> f tunedModelSourceTunedModel
{-# INLINE tunedModelSourceTunedModelL #-}

-- | 'tunedModelSourceBaseModel' Lens
tunedModelSourceBaseModelL :: Lens_' TunedModelSource (Maybe Text)
tunedModelSourceBaseModelL f TunedModelSource {..} = (\tunedModelSourceBaseModel -> TunedModelSource {tunedModelSourceBaseModel, ..}) <$> f tunedModelSourceBaseModel
{-# INLINE tunedModelSourceBaseModelL #-}

-- * TuningExample

-- | 'tuningExampleTextInput' Lens
tuningExampleTextInputL :: Lens_' TuningExample (Maybe Text)
tuningExampleTextInputL f TuningExample {..} = (\tuningExampleTextInput -> TuningExample {tuningExampleTextInput, ..}) <$> f tuningExampleTextInput
{-# INLINE tuningExampleTextInputL #-}

-- | 'tuningExampleOutput' Lens
tuningExampleOutputL :: Lens_' TuningExample (Text)
tuningExampleOutputL f TuningExample {..} = (\tuningExampleOutput -> TuningExample {tuningExampleOutput, ..}) <$> f tuningExampleOutput
{-# INLINE tuningExampleOutputL #-}

-- * TuningExamples

-- | 'tuningExamplesExamples' Lens
tuningExamplesExamplesL :: Lens_' TuningExamples (Maybe [TuningExample])
tuningExamplesExamplesL f TuningExamples {..} = (\tuningExamplesExamples -> TuningExamples {tuningExamplesExamples, ..}) <$> f tuningExamplesExamples
{-# INLINE tuningExamplesExamplesL #-}

-- * TuningSnapshot

-- | 'tuningSnapshotMeanLoss' Lens
tuningSnapshotMeanLossL :: Lens_' TuningSnapshot (Maybe Float)
tuningSnapshotMeanLossL f TuningSnapshot {..} = (\tuningSnapshotMeanLoss -> TuningSnapshot {tuningSnapshotMeanLoss, ..}) <$> f tuningSnapshotMeanLoss
{-# INLINE tuningSnapshotMeanLossL #-}

-- | 'tuningSnapshotComputeTime' Lens
tuningSnapshotComputeTimeL :: Lens_' TuningSnapshot (Maybe DateTime)
tuningSnapshotComputeTimeL f TuningSnapshot {..} = (\tuningSnapshotComputeTime -> TuningSnapshot {tuningSnapshotComputeTime, ..}) <$> f tuningSnapshotComputeTime
{-# INLINE tuningSnapshotComputeTimeL #-}

-- | 'tuningSnapshotStep' Lens
tuningSnapshotStepL :: Lens_' TuningSnapshot (Maybe Int)
tuningSnapshotStepL f TuningSnapshot {..} = (\tuningSnapshotStep -> TuningSnapshot {tuningSnapshotStep, ..}) <$> f tuningSnapshotStep
{-# INLINE tuningSnapshotStepL #-}

-- | 'tuningSnapshotEpoch' Lens
tuningSnapshotEpochL :: Lens_' TuningSnapshot (Maybe Int)
tuningSnapshotEpochL f TuningSnapshot {..} = (\tuningSnapshotEpoch -> TuningSnapshot {tuningSnapshotEpoch, ..}) <$> f tuningSnapshotEpoch
{-# INLINE tuningSnapshotEpochL #-}

-- * TuningTask

-- | 'tuningTaskStartTime' Lens
tuningTaskStartTimeL :: Lens_' TuningTask (Maybe DateTime)
tuningTaskStartTimeL f TuningTask {..} = (\tuningTaskStartTime -> TuningTask {tuningTaskStartTime, ..}) <$> f tuningTaskStartTime
{-# INLINE tuningTaskStartTimeL #-}

-- | 'tuningTaskTrainingData' Lens
tuningTaskTrainingDataL :: Lens_' TuningTask (Dataset)
tuningTaskTrainingDataL f TuningTask {..} = (\tuningTaskTrainingData -> TuningTask {tuningTaskTrainingData, ..}) <$> f tuningTaskTrainingData
{-# INLINE tuningTaskTrainingDataL #-}

-- | 'tuningTaskHyperparameters' Lens
tuningTaskHyperparametersL :: Lens_' TuningTask (Maybe Hyperparameters)
tuningTaskHyperparametersL f TuningTask {..} = (\tuningTaskHyperparameters -> TuningTask {tuningTaskHyperparameters, ..}) <$> f tuningTaskHyperparameters
{-# INLINE tuningTaskHyperparametersL #-}

-- | 'tuningTaskCompleteTime' Lens
tuningTaskCompleteTimeL :: Lens_' TuningTask (Maybe DateTime)
tuningTaskCompleteTimeL f TuningTask {..} = (\tuningTaskCompleteTime -> TuningTask {tuningTaskCompleteTime, ..}) <$> f tuningTaskCompleteTime
{-# INLINE tuningTaskCompleteTimeL #-}

-- | 'tuningTaskSnapshots' Lens
tuningTaskSnapshotsL :: Lens_' TuningTask (Maybe [TuningSnapshot])
tuningTaskSnapshotsL f TuningTask {..} = (\tuningTaskSnapshots -> TuningTask {tuningTaskSnapshots, ..}) <$> f tuningTaskSnapshots
{-# INLINE tuningTaskSnapshotsL #-}

-- * UpdateChunkRequest

-- | 'updateChunkRequestUpdateMask' Lens
updateChunkRequestUpdateMaskL :: Lens_' UpdateChunkRequest (Text)
updateChunkRequestUpdateMaskL f UpdateChunkRequest {..} = (\updateChunkRequestUpdateMask -> UpdateChunkRequest {updateChunkRequestUpdateMask, ..}) <$> f updateChunkRequestUpdateMask
{-# INLINE updateChunkRequestUpdateMaskL #-}

-- | 'updateChunkRequestChunk' Lens
updateChunkRequestChunkL :: Lens_' UpdateChunkRequest (Chunk)
updateChunkRequestChunkL f UpdateChunkRequest {..} = (\updateChunkRequestChunk -> UpdateChunkRequest {updateChunkRequestChunk, ..}) <$> f updateChunkRequestChunk
{-# INLINE updateChunkRequestChunkL #-}

-- * UrlContextMetadata

-- | 'urlContextMetadataUrlMetadata' Lens
urlContextMetadataUrlMetadataL :: Lens_' UrlContextMetadata (Maybe [UrlMetadata])
urlContextMetadataUrlMetadataL f UrlContextMetadata {..} = (\urlContextMetadataUrlMetadata -> UrlContextMetadata {urlContextMetadataUrlMetadata, ..}) <$> f urlContextMetadataUrlMetadata
{-# INLINE urlContextMetadataUrlMetadataL #-}

-- * UrlMetadata

-- | 'urlMetadataRetrievedUrl' Lens
urlMetadataRetrievedUrlL :: Lens_' UrlMetadata (Maybe Text)
urlMetadataRetrievedUrlL f UrlMetadata {..} = (\urlMetadataRetrievedUrl -> UrlMetadata {urlMetadataRetrievedUrl, ..}) <$> f urlMetadataRetrievedUrl
{-# INLINE urlMetadataRetrievedUrlL #-}

-- | 'urlMetadataUrlRetrievalStatus' Lens
urlMetadataUrlRetrievalStatusL :: Lens_' UrlMetadata (Maybe E'UrlRetrievalStatus)
urlMetadataUrlRetrievalStatusL f UrlMetadata {..} = (\urlMetadataUrlRetrievalStatus -> UrlMetadata {urlMetadataUrlRetrievalStatus, ..}) <$> f urlMetadataUrlRetrievalStatus
{-# INLINE urlMetadataUrlRetrievalStatusL #-}

-- * UsageMetadata

-- | 'usageMetadataCandidatesTokensDetails' Lens
usageMetadataCandidatesTokensDetailsL :: Lens_' UsageMetadata (Maybe [ModalityTokenCount])
usageMetadataCandidatesTokensDetailsL f UsageMetadata {..} = (\usageMetadataCandidatesTokensDetails -> UsageMetadata {usageMetadataCandidatesTokensDetails, ..}) <$> f usageMetadataCandidatesTokensDetails
{-# INLINE usageMetadataCandidatesTokensDetailsL #-}

-- | 'usageMetadataThoughtsTokenCount' Lens
usageMetadataThoughtsTokenCountL :: Lens_' UsageMetadata (Maybe Int)
usageMetadataThoughtsTokenCountL f UsageMetadata {..} = (\usageMetadataThoughtsTokenCount -> UsageMetadata {usageMetadataThoughtsTokenCount, ..}) <$> f usageMetadataThoughtsTokenCount
{-# INLINE usageMetadataThoughtsTokenCountL #-}

-- | 'usageMetadataToolUsePromptTokenCount' Lens
usageMetadataToolUsePromptTokenCountL :: Lens_' UsageMetadata (Maybe Int)
usageMetadataToolUsePromptTokenCountL f UsageMetadata {..} = (\usageMetadataToolUsePromptTokenCount -> UsageMetadata {usageMetadataToolUsePromptTokenCount, ..}) <$> f usageMetadataToolUsePromptTokenCount
{-# INLINE usageMetadataToolUsePromptTokenCountL #-}

-- | 'usageMetadataCachedContentTokenCount' Lens
usageMetadataCachedContentTokenCountL :: Lens_' UsageMetadata (Maybe Int)
usageMetadataCachedContentTokenCountL f UsageMetadata {..} = (\usageMetadataCachedContentTokenCount -> UsageMetadata {usageMetadataCachedContentTokenCount, ..}) <$> f usageMetadataCachedContentTokenCount
{-# INLINE usageMetadataCachedContentTokenCountL #-}

-- | 'usageMetadataPromptTokenCount' Lens
usageMetadataPromptTokenCountL :: Lens_' UsageMetadata (Maybe Int)
usageMetadataPromptTokenCountL f UsageMetadata {..} = (\usageMetadataPromptTokenCount -> UsageMetadata {usageMetadataPromptTokenCount, ..}) <$> f usageMetadataPromptTokenCount
{-# INLINE usageMetadataPromptTokenCountL #-}

-- | 'usageMetadataCandidatesTokenCount' Lens
usageMetadataCandidatesTokenCountL :: Lens_' UsageMetadata (Maybe Int)
usageMetadataCandidatesTokenCountL f UsageMetadata {..} = (\usageMetadataCandidatesTokenCount -> UsageMetadata {usageMetadataCandidatesTokenCount, ..}) <$> f usageMetadataCandidatesTokenCount
{-# INLINE usageMetadataCandidatesTokenCountL #-}

-- | 'usageMetadataPromptTokensDetails' Lens
usageMetadataPromptTokensDetailsL :: Lens_' UsageMetadata (Maybe [ModalityTokenCount])
usageMetadataPromptTokensDetailsL f UsageMetadata {..} = (\usageMetadataPromptTokensDetails -> UsageMetadata {usageMetadataPromptTokensDetails, ..}) <$> f usageMetadataPromptTokensDetails
{-# INLINE usageMetadataPromptTokensDetailsL #-}

-- | 'usageMetadataTotalTokenCount' Lens
usageMetadataTotalTokenCountL :: Lens_' UsageMetadata (Maybe Int)
usageMetadataTotalTokenCountL f UsageMetadata {..} = (\usageMetadataTotalTokenCount -> UsageMetadata {usageMetadataTotalTokenCount, ..}) <$> f usageMetadataTotalTokenCount
{-# INLINE usageMetadataTotalTokenCountL #-}

-- | 'usageMetadataCacheTokensDetails' Lens
usageMetadataCacheTokensDetailsL :: Lens_' UsageMetadata (Maybe [ModalityTokenCount])
usageMetadataCacheTokensDetailsL f UsageMetadata {..} = (\usageMetadataCacheTokensDetails -> UsageMetadata {usageMetadataCacheTokensDetails, ..}) <$> f usageMetadataCacheTokensDetails
{-# INLINE usageMetadataCacheTokensDetailsL #-}

-- | 'usageMetadataToolUsePromptTokensDetails' Lens
usageMetadataToolUsePromptTokensDetailsL :: Lens_' UsageMetadata (Maybe [ModalityTokenCount])
usageMetadataToolUsePromptTokensDetailsL f UsageMetadata {..} = (\usageMetadataToolUsePromptTokensDetails -> UsageMetadata {usageMetadataToolUsePromptTokensDetails, ..}) <$> f usageMetadataToolUsePromptTokensDetails
{-# INLINE usageMetadataToolUsePromptTokensDetailsL #-}

-- * Video

-- | 'videoVideo' Lens
videoVideoL :: Lens_' Video (Maybe ByteArray)
videoVideoL f Video {..} = (\videoVideo -> Video {videoVideo, ..}) <$> f videoVideo
{-# INLINE videoVideoL #-}

-- | 'videoUri' Lens
videoUriL :: Lens_' Video (Maybe Text)
videoUriL f Video {..} = (\videoUri -> Video {videoUri, ..}) <$> f videoUri
{-# INLINE videoUriL #-}

-- * VideoFileMetadata

-- | 'videoFileMetadataVideoDuration' Lens
videoFileMetadataVideoDurationL :: Lens_' VideoFileMetadata (Maybe Text)
videoFileMetadataVideoDurationL f VideoFileMetadata {..} = (\videoFileMetadataVideoDuration -> VideoFileMetadata {videoFileMetadataVideoDuration, ..}) <$> f videoFileMetadataVideoDuration
{-# INLINE videoFileMetadataVideoDurationL #-}

-- * VideoMetadata

-- | 'videoMetadataEndOffset' Lens
videoMetadataEndOffsetL :: Lens_' VideoMetadata (Maybe Text)
videoMetadataEndOffsetL f VideoMetadata {..} = (\videoMetadataEndOffset -> VideoMetadata {videoMetadataEndOffset, ..}) <$> f videoMetadataEndOffset
{-# INLINE videoMetadataEndOffsetL #-}

-- | 'videoMetadataStartOffset' Lens
videoMetadataStartOffsetL :: Lens_' VideoMetadata (Maybe Text)
videoMetadataStartOffsetL f VideoMetadata {..} = (\videoMetadataStartOffset -> VideoMetadata {videoMetadataStartOffset, ..}) <$> f videoMetadataStartOffset
{-# INLINE videoMetadataStartOffsetL #-}

-- | 'videoMetadataFps' Lens
videoMetadataFpsL :: Lens_' VideoMetadata (Maybe Double)
videoMetadataFpsL f VideoMetadata {..} = (\videoMetadataFps -> VideoMetadata {videoMetadataFps, ..}) <$> f videoMetadataFps
{-# INLINE videoMetadataFpsL #-}

-- * VoiceConfig

-- | 'voiceConfigPrebuiltVoiceConfig' Lens
voiceConfigPrebuiltVoiceConfigL :: Lens_' VoiceConfig (Maybe PrebuiltVoiceConfig)
voiceConfigPrebuiltVoiceConfigL f VoiceConfig {..} = (\voiceConfigPrebuiltVoiceConfig -> VoiceConfig {voiceConfigPrebuiltVoiceConfig, ..}) <$> f voiceConfigPrebuiltVoiceConfig
{-# INLINE voiceConfigPrebuiltVoiceConfigL #-}

-- * Web

-- | 'webTitle' Lens
webTitleL :: Lens_' Web (Maybe Text)
webTitleL f Web {..} = (\webTitle -> Web {webTitle, ..}) <$> f webTitle
{-# INLINE webTitleL #-}

-- | 'webUri' Lens
webUriL :: Lens_' Web (Maybe Text)
webUriL f Web {..} = (\webUri -> Web {webUri, ..}) <$> f webUri
{-# INLINE webUriL #-}