ModelLens.hs

{-
   Gitea API.

   This documentation describes the Gitea API.

   OpenAPI Version: 3.0.1
   Gitea API. API version: 1.20.6
   Generated by OpenAPI Generator (https://openapi-generator.tech)
-}

{-|
Module : Gitea.Lens
-}

{-# 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 Gitea.ModelLens where

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

import Data.Text (Text)

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

import Gitea.Model
import Gitea.Core


-- * APIError

-- | 'aPIErrorMessage' Lens
aPIErrorMessageL :: Lens_' APIError (Maybe Text)
aPIErrorMessageL f APIError{..} = (\aPIErrorMessage -> APIError { aPIErrorMessage, ..} ) <$> f aPIErrorMessage
{-# INLINE aPIErrorMessageL #-}

-- | 'aPIErrorUrl' Lens
aPIErrorUrlL :: Lens_' APIError (Maybe Text)
aPIErrorUrlL f APIError{..} = (\aPIErrorUrl -> APIError { aPIErrorUrl, ..} ) <$> f aPIErrorUrl
{-# INLINE aPIErrorUrlL #-}



-- * AccessToken

-- | 'accessTokenId' Lens
accessTokenIdL :: Lens_' AccessToken (Maybe Integer)
accessTokenIdL f AccessToken{..} = (\accessTokenId -> AccessToken { accessTokenId, ..} ) <$> f accessTokenId
{-# INLINE accessTokenIdL #-}

-- | 'accessTokenName' Lens
accessTokenNameL :: Lens_' AccessToken (Maybe Text)
accessTokenNameL f AccessToken{..} = (\accessTokenName -> AccessToken { accessTokenName, ..} ) <$> f accessTokenName
{-# INLINE accessTokenNameL #-}

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

-- | 'accessTokenSha1' Lens
accessTokenSha1L :: Lens_' AccessToken (Maybe Text)
accessTokenSha1L f AccessToken{..} = (\accessTokenSha1 -> AccessToken { accessTokenSha1, ..} ) <$> f accessTokenSha1
{-# INLINE accessTokenSha1L #-}

-- | 'accessTokenTokenLastEight' Lens
accessTokenTokenLastEightL :: Lens_' AccessToken (Maybe Text)
accessTokenTokenLastEightL f AccessToken{..} = (\accessTokenTokenLastEight -> AccessToken { accessTokenTokenLastEight, ..} ) <$> f accessTokenTokenLastEight
{-# INLINE accessTokenTokenLastEightL #-}



-- * Activity

-- | 'activityActUser' Lens
activityActUserL :: Lens_' Activity (Maybe User)
activityActUserL f Activity{..} = (\activityActUser -> Activity { activityActUser, ..} ) <$> f activityActUser
{-# INLINE activityActUserL #-}

-- | 'activityActUserId' Lens
activityActUserIdL :: Lens_' Activity (Maybe Integer)
activityActUserIdL f Activity{..} = (\activityActUserId -> Activity { activityActUserId, ..} ) <$> f activityActUserId
{-# INLINE activityActUserIdL #-}

-- | 'activityComment' Lens
activityCommentL :: Lens_' Activity (Maybe Comment)
activityCommentL f Activity{..} = (\activityComment -> Activity { activityComment, ..} ) <$> f activityComment
{-# INLINE activityCommentL #-}

-- | 'activityCommentId' Lens
activityCommentIdL :: Lens_' Activity (Maybe Integer)
activityCommentIdL f Activity{..} = (\activityCommentId -> Activity { activityCommentId, ..} ) <$> f activityCommentId
{-# INLINE activityCommentIdL #-}

-- | 'activityContent' Lens
activityContentL :: Lens_' Activity (Maybe Text)
activityContentL f Activity{..} = (\activityContent -> Activity { activityContent, ..} ) <$> f activityContent
{-# INLINE activityContentL #-}

-- | 'activityCreated' Lens
activityCreatedL :: Lens_' Activity (Maybe DateTime)
activityCreatedL f Activity{..} = (\activityCreated -> Activity { activityCreated, ..} ) <$> f activityCreated
{-# INLINE activityCreatedL #-}

-- | 'activityId' Lens
activityIdL :: Lens_' Activity (Maybe Integer)
activityIdL f Activity{..} = (\activityId -> Activity { activityId, ..} ) <$> f activityId
{-# INLINE activityIdL #-}

-- | 'activityIsPrivate' Lens
activityIsPrivateL :: Lens_' Activity (Maybe Bool)
activityIsPrivateL f Activity{..} = (\activityIsPrivate -> Activity { activityIsPrivate, ..} ) <$> f activityIsPrivate
{-# INLINE activityIsPrivateL #-}

-- | 'activityOpType' Lens
activityOpTypeL :: Lens_' Activity (Maybe Text)
activityOpTypeL f Activity{..} = (\activityOpType -> Activity { activityOpType, ..} ) <$> f activityOpType
{-# INLINE activityOpTypeL #-}

-- | 'activityRefName' Lens
activityRefNameL :: Lens_' Activity (Maybe Text)
activityRefNameL f Activity{..} = (\activityRefName -> Activity { activityRefName, ..} ) <$> f activityRefName
{-# INLINE activityRefNameL #-}

-- | 'activityRepo' Lens
activityRepoL :: Lens_' Activity (Maybe Repository)
activityRepoL f Activity{..} = (\activityRepo -> Activity { activityRepo, ..} ) <$> f activityRepo
{-# INLINE activityRepoL #-}

-- | 'activityRepoId' Lens
activityRepoIdL :: Lens_' Activity (Maybe Integer)
activityRepoIdL f Activity{..} = (\activityRepoId -> Activity { activityRepoId, ..} ) <$> f activityRepoId
{-# INLINE activityRepoIdL #-}

-- | 'activityUserId' Lens
activityUserIdL :: Lens_' Activity (Maybe Integer)
activityUserIdL f Activity{..} = (\activityUserId -> Activity { activityUserId, ..} ) <$> f activityUserId
{-# INLINE activityUserIdL #-}



-- * ActivityPub

-- | 'activityPubContext' Lens
activityPubContextL :: Lens_' ActivityPub (Maybe Text)
activityPubContextL f ActivityPub{..} = (\activityPubContext -> ActivityPub { activityPubContext, ..} ) <$> f activityPubContext
{-# INLINE activityPubContextL #-}



-- * AddCollaboratorOption

-- | 'addCollaboratorOptionPermission' Lens
addCollaboratorOptionPermissionL :: Lens_' AddCollaboratorOption (Maybe Text)
addCollaboratorOptionPermissionL f AddCollaboratorOption{..} = (\addCollaboratorOptionPermission -> AddCollaboratorOption { addCollaboratorOptionPermission, ..} ) <$> f addCollaboratorOptionPermission
{-# INLINE addCollaboratorOptionPermissionL #-}



-- * AddTimeOption

-- | 'addTimeOptionCreated' Lens
addTimeOptionCreatedL :: Lens_' AddTimeOption (Maybe DateTime)
addTimeOptionCreatedL f AddTimeOption{..} = (\addTimeOptionCreated -> AddTimeOption { addTimeOptionCreated, ..} ) <$> f addTimeOptionCreated
{-# INLINE addTimeOptionCreatedL #-}

-- | 'addTimeOptionTime' Lens
addTimeOptionTimeL :: Lens_' AddTimeOption (Integer)
addTimeOptionTimeL f AddTimeOption{..} = (\addTimeOptionTime -> AddTimeOption { addTimeOptionTime, ..} ) <$> f addTimeOptionTime
{-# INLINE addTimeOptionTimeL #-}

-- | 'addTimeOptionUserName' Lens
addTimeOptionUserNameL :: Lens_' AddTimeOption (Maybe Text)
addTimeOptionUserNameL f AddTimeOption{..} = (\addTimeOptionUserName -> AddTimeOption { addTimeOptionUserName, ..} ) <$> f addTimeOptionUserName
{-# INLINE addTimeOptionUserNameL #-}



-- * AnnotatedTag

-- | 'annotatedTagMessage' Lens
annotatedTagMessageL :: Lens_' AnnotatedTag (Maybe Text)
annotatedTagMessageL f AnnotatedTag{..} = (\annotatedTagMessage -> AnnotatedTag { annotatedTagMessage, ..} ) <$> f annotatedTagMessage
{-# INLINE annotatedTagMessageL #-}

-- | 'annotatedTagObject' Lens
annotatedTagObjectL :: Lens_' AnnotatedTag (Maybe AnnotatedTagObject)
annotatedTagObjectL f AnnotatedTag{..} = (\annotatedTagObject -> AnnotatedTag { annotatedTagObject, ..} ) <$> f annotatedTagObject
{-# INLINE annotatedTagObjectL #-}

-- | 'annotatedTagSha' Lens
annotatedTagShaL :: Lens_' AnnotatedTag (Maybe Text)
annotatedTagShaL f AnnotatedTag{..} = (\annotatedTagSha -> AnnotatedTag { annotatedTagSha, ..} ) <$> f annotatedTagSha
{-# INLINE annotatedTagShaL #-}

-- | 'annotatedTagTag' Lens
annotatedTagTagL :: Lens_' AnnotatedTag (Maybe Text)
annotatedTagTagL f AnnotatedTag{..} = (\annotatedTagTag -> AnnotatedTag { annotatedTagTag, ..} ) <$> f annotatedTagTag
{-# INLINE annotatedTagTagL #-}

-- | 'annotatedTagTagger' Lens
annotatedTagTaggerL :: Lens_' AnnotatedTag (Maybe CommitUser)
annotatedTagTaggerL f AnnotatedTag{..} = (\annotatedTagTagger -> AnnotatedTag { annotatedTagTagger, ..} ) <$> f annotatedTagTagger
{-# INLINE annotatedTagTaggerL #-}

-- | 'annotatedTagUrl' Lens
annotatedTagUrlL :: Lens_' AnnotatedTag (Maybe Text)
annotatedTagUrlL f AnnotatedTag{..} = (\annotatedTagUrl -> AnnotatedTag { annotatedTagUrl, ..} ) <$> f annotatedTagUrl
{-# INLINE annotatedTagUrlL #-}

-- | 'annotatedTagVerification' Lens
annotatedTagVerificationL :: Lens_' AnnotatedTag (Maybe PayloadCommitVerification)
annotatedTagVerificationL f AnnotatedTag{..} = (\annotatedTagVerification -> AnnotatedTag { annotatedTagVerification, ..} ) <$> f annotatedTagVerification
{-# INLINE annotatedTagVerificationL #-}



-- * AnnotatedTagObject

-- | 'annotatedTagObjectSha' Lens
annotatedTagObjectShaL :: Lens_' AnnotatedTagObject (Maybe Text)
annotatedTagObjectShaL f AnnotatedTagObject{..} = (\annotatedTagObjectSha -> AnnotatedTagObject { annotatedTagObjectSha, ..} ) <$> f annotatedTagObjectSha
{-# INLINE annotatedTagObjectShaL #-}

-- | 'annotatedTagObjectType' Lens
annotatedTagObjectTypeL :: Lens_' AnnotatedTagObject (Maybe Text)
annotatedTagObjectTypeL f AnnotatedTagObject{..} = (\annotatedTagObjectType -> AnnotatedTagObject { annotatedTagObjectType, ..} ) <$> f annotatedTagObjectType
{-# INLINE annotatedTagObjectTypeL #-}

-- | 'annotatedTagObjectUrl' Lens
annotatedTagObjectUrlL :: Lens_' AnnotatedTagObject (Maybe Text)
annotatedTagObjectUrlL f AnnotatedTagObject{..} = (\annotatedTagObjectUrl -> AnnotatedTagObject { annotatedTagObjectUrl, ..} ) <$> f annotatedTagObjectUrl
{-# INLINE annotatedTagObjectUrlL #-}



-- * Attachment

-- | 'attachmentBrowserDownloadUrl' Lens
attachmentBrowserDownloadUrlL :: Lens_' Attachment (Maybe Text)
attachmentBrowserDownloadUrlL f Attachment{..} = (\attachmentBrowserDownloadUrl -> Attachment { attachmentBrowserDownloadUrl, ..} ) <$> f attachmentBrowserDownloadUrl
{-# INLINE attachmentBrowserDownloadUrlL #-}

-- | 'attachmentCreatedAt' Lens
attachmentCreatedAtL :: Lens_' Attachment (Maybe DateTime)
attachmentCreatedAtL f Attachment{..} = (\attachmentCreatedAt -> Attachment { attachmentCreatedAt, ..} ) <$> f attachmentCreatedAt
{-# INLINE attachmentCreatedAtL #-}

-- | 'attachmentDownloadCount' Lens
attachmentDownloadCountL :: Lens_' Attachment (Maybe Integer)
attachmentDownloadCountL f Attachment{..} = (\attachmentDownloadCount -> Attachment { attachmentDownloadCount, ..} ) <$> f attachmentDownloadCount
{-# INLINE attachmentDownloadCountL #-}

-- | 'attachmentId' Lens
attachmentIdL :: Lens_' Attachment (Maybe Integer)
attachmentIdL f Attachment{..} = (\attachmentId -> Attachment { attachmentId, ..} ) <$> f attachmentId
{-# INLINE attachmentIdL #-}

-- | 'attachmentName' Lens
attachmentNameL :: Lens_' Attachment (Maybe Text)
attachmentNameL f Attachment{..} = (\attachmentName -> Attachment { attachmentName, ..} ) <$> f attachmentName
{-# INLINE attachmentNameL #-}

-- | 'attachmentSize' Lens
attachmentSizeL :: Lens_' Attachment (Maybe Integer)
attachmentSizeL f Attachment{..} = (\attachmentSize -> Attachment { attachmentSize, ..} ) <$> f attachmentSize
{-# INLINE attachmentSizeL #-}

-- | 'attachmentUuid' Lens
attachmentUuidL :: Lens_' Attachment (Maybe Text)
attachmentUuidL f Attachment{..} = (\attachmentUuid -> Attachment { attachmentUuid, ..} ) <$> f attachmentUuid
{-# INLINE attachmentUuidL #-}



-- * Branch

-- | 'branchCommit' Lens
branchCommitL :: Lens_' Branch (Maybe PayloadCommit)
branchCommitL f Branch{..} = (\branchCommit -> Branch { branchCommit, ..} ) <$> f branchCommit
{-# INLINE branchCommitL #-}

-- | 'branchEffectiveBranchProtectionName' Lens
branchEffectiveBranchProtectionNameL :: Lens_' Branch (Maybe Text)
branchEffectiveBranchProtectionNameL f Branch{..} = (\branchEffectiveBranchProtectionName -> Branch { branchEffectiveBranchProtectionName, ..} ) <$> f branchEffectiveBranchProtectionName
{-# INLINE branchEffectiveBranchProtectionNameL #-}

-- | 'branchEnableStatusCheck' Lens
branchEnableStatusCheckL :: Lens_' Branch (Maybe Bool)
branchEnableStatusCheckL f Branch{..} = (\branchEnableStatusCheck -> Branch { branchEnableStatusCheck, ..} ) <$> f branchEnableStatusCheck
{-# INLINE branchEnableStatusCheckL #-}

-- | 'branchName' Lens
branchNameL :: Lens_' Branch (Maybe Text)
branchNameL f Branch{..} = (\branchName -> Branch { branchName, ..} ) <$> f branchName
{-# INLINE branchNameL #-}

-- | 'branchProtected' Lens
branchProtectedL :: Lens_' Branch (Maybe Bool)
branchProtectedL f Branch{..} = (\branchProtected -> Branch { branchProtected, ..} ) <$> f branchProtected
{-# INLINE branchProtectedL #-}

-- | 'branchRequiredApprovals' Lens
branchRequiredApprovalsL :: Lens_' Branch (Maybe Integer)
branchRequiredApprovalsL f Branch{..} = (\branchRequiredApprovals -> Branch { branchRequiredApprovals, ..} ) <$> f branchRequiredApprovals
{-# INLINE branchRequiredApprovalsL #-}

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

-- | 'branchUserCanMerge' Lens
branchUserCanMergeL :: Lens_' Branch (Maybe Bool)
branchUserCanMergeL f Branch{..} = (\branchUserCanMerge -> Branch { branchUserCanMerge, ..} ) <$> f branchUserCanMerge
{-# INLINE branchUserCanMergeL #-}

-- | 'branchUserCanPush' Lens
branchUserCanPushL :: Lens_' Branch (Maybe Bool)
branchUserCanPushL f Branch{..} = (\branchUserCanPush -> Branch { branchUserCanPush, ..} ) <$> f branchUserCanPush
{-# INLINE branchUserCanPushL #-}



-- * BranchProtection

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

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

-- | 'branchProtectionBlockOnOfficialReviewRequests' Lens
branchProtectionBlockOnOfficialReviewRequestsL :: Lens_' BranchProtection (Maybe Bool)
branchProtectionBlockOnOfficialReviewRequestsL f BranchProtection{..} = (\branchProtectionBlockOnOfficialReviewRequests -> BranchProtection { branchProtectionBlockOnOfficialReviewRequests, ..} ) <$> f branchProtectionBlockOnOfficialReviewRequests
{-# INLINE branchProtectionBlockOnOfficialReviewRequestsL #-}

-- | 'branchProtectionBlockOnOutdatedBranch' Lens
branchProtectionBlockOnOutdatedBranchL :: Lens_' BranchProtection (Maybe Bool)
branchProtectionBlockOnOutdatedBranchL f BranchProtection{..} = (\branchProtectionBlockOnOutdatedBranch -> BranchProtection { branchProtectionBlockOnOutdatedBranch, ..} ) <$> f branchProtectionBlockOnOutdatedBranch
{-# INLINE branchProtectionBlockOnOutdatedBranchL #-}

-- | 'branchProtectionBlockOnRejectedReviews' Lens
branchProtectionBlockOnRejectedReviewsL :: Lens_' BranchProtection (Maybe Bool)
branchProtectionBlockOnRejectedReviewsL f BranchProtection{..} = (\branchProtectionBlockOnRejectedReviews -> BranchProtection { branchProtectionBlockOnRejectedReviews, ..} ) <$> f branchProtectionBlockOnRejectedReviews
{-# INLINE branchProtectionBlockOnRejectedReviewsL #-}

-- | 'branchProtectionBranchName' Lens
branchProtectionBranchNameL :: Lens_' BranchProtection (Maybe Text)
branchProtectionBranchNameL f BranchProtection{..} = (\branchProtectionBranchName -> BranchProtection { branchProtectionBranchName, ..} ) <$> f branchProtectionBranchName
{-# INLINE branchProtectionBranchNameL #-}

-- | 'branchProtectionCreatedAt' Lens
branchProtectionCreatedAtL :: Lens_' BranchProtection (Maybe DateTime)
branchProtectionCreatedAtL f BranchProtection{..} = (\branchProtectionCreatedAt -> BranchProtection { branchProtectionCreatedAt, ..} ) <$> f branchProtectionCreatedAt
{-# INLINE branchProtectionCreatedAtL #-}

-- | 'branchProtectionDismissStaleApprovals' Lens
branchProtectionDismissStaleApprovalsL :: Lens_' BranchProtection (Maybe Bool)
branchProtectionDismissStaleApprovalsL f BranchProtection{..} = (\branchProtectionDismissStaleApprovals -> BranchProtection { branchProtectionDismissStaleApprovals, ..} ) <$> f branchProtectionDismissStaleApprovals
{-# INLINE branchProtectionDismissStaleApprovalsL #-}

-- | 'branchProtectionEnableApprovalsWhitelist' Lens
branchProtectionEnableApprovalsWhitelistL :: Lens_' BranchProtection (Maybe Bool)
branchProtectionEnableApprovalsWhitelistL f BranchProtection{..} = (\branchProtectionEnableApprovalsWhitelist -> BranchProtection { branchProtectionEnableApprovalsWhitelist, ..} ) <$> f branchProtectionEnableApprovalsWhitelist
{-# INLINE branchProtectionEnableApprovalsWhitelistL #-}

-- | 'branchProtectionEnableMergeWhitelist' Lens
branchProtectionEnableMergeWhitelistL :: Lens_' BranchProtection (Maybe Bool)
branchProtectionEnableMergeWhitelistL f BranchProtection{..} = (\branchProtectionEnableMergeWhitelist -> BranchProtection { branchProtectionEnableMergeWhitelist, ..} ) <$> f branchProtectionEnableMergeWhitelist
{-# INLINE branchProtectionEnableMergeWhitelistL #-}

-- | 'branchProtectionEnablePush' Lens
branchProtectionEnablePushL :: Lens_' BranchProtection (Maybe Bool)
branchProtectionEnablePushL f BranchProtection{..} = (\branchProtectionEnablePush -> BranchProtection { branchProtectionEnablePush, ..} ) <$> f branchProtectionEnablePush
{-# INLINE branchProtectionEnablePushL #-}

-- | 'branchProtectionEnablePushWhitelist' Lens
branchProtectionEnablePushWhitelistL :: Lens_' BranchProtection (Maybe Bool)
branchProtectionEnablePushWhitelistL f BranchProtection{..} = (\branchProtectionEnablePushWhitelist -> BranchProtection { branchProtectionEnablePushWhitelist, ..} ) <$> f branchProtectionEnablePushWhitelist
{-# INLINE branchProtectionEnablePushWhitelistL #-}

-- | 'branchProtectionEnableStatusCheck' Lens
branchProtectionEnableStatusCheckL :: Lens_' BranchProtection (Maybe Bool)
branchProtectionEnableStatusCheckL f BranchProtection{..} = (\branchProtectionEnableStatusCheck -> BranchProtection { branchProtectionEnableStatusCheck, ..} ) <$> f branchProtectionEnableStatusCheck
{-# INLINE branchProtectionEnableStatusCheckL #-}

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

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

-- | 'branchProtectionProtectedFilePatterns' Lens
branchProtectionProtectedFilePatternsL :: Lens_' BranchProtection (Maybe Text)
branchProtectionProtectedFilePatternsL f BranchProtection{..} = (\branchProtectionProtectedFilePatterns -> BranchProtection { branchProtectionProtectedFilePatterns, ..} ) <$> f branchProtectionProtectedFilePatterns
{-# INLINE branchProtectionProtectedFilePatternsL #-}

-- | 'branchProtectionPushWhitelistDeployKeys' Lens
branchProtectionPushWhitelistDeployKeysL :: Lens_' BranchProtection (Maybe Bool)
branchProtectionPushWhitelistDeployKeysL f BranchProtection{..} = (\branchProtectionPushWhitelistDeployKeys -> BranchProtection { branchProtectionPushWhitelistDeployKeys, ..} ) <$> f branchProtectionPushWhitelistDeployKeys
{-# INLINE branchProtectionPushWhitelistDeployKeysL #-}

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

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

-- | 'branchProtectionRequireSignedCommits' Lens
branchProtectionRequireSignedCommitsL :: Lens_' BranchProtection (Maybe Bool)
branchProtectionRequireSignedCommitsL f BranchProtection{..} = (\branchProtectionRequireSignedCommits -> BranchProtection { branchProtectionRequireSignedCommits, ..} ) <$> f branchProtectionRequireSignedCommits
{-# INLINE branchProtectionRequireSignedCommitsL #-}

-- | 'branchProtectionRequiredApprovals' Lens
branchProtectionRequiredApprovalsL :: Lens_' BranchProtection (Maybe Integer)
branchProtectionRequiredApprovalsL f BranchProtection{..} = (\branchProtectionRequiredApprovals -> BranchProtection { branchProtectionRequiredApprovals, ..} ) <$> f branchProtectionRequiredApprovals
{-# INLINE branchProtectionRequiredApprovalsL #-}

-- | 'branchProtectionRuleName' Lens
branchProtectionRuleNameL :: Lens_' BranchProtection (Maybe Text)
branchProtectionRuleNameL f BranchProtection{..} = (\branchProtectionRuleName -> BranchProtection { branchProtectionRuleName, ..} ) <$> f branchProtectionRuleName
{-# INLINE branchProtectionRuleNameL #-}

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

-- | 'branchProtectionUnprotectedFilePatterns' Lens
branchProtectionUnprotectedFilePatternsL :: Lens_' BranchProtection (Maybe Text)
branchProtectionUnprotectedFilePatternsL f BranchProtection{..} = (\branchProtectionUnprotectedFilePatterns -> BranchProtection { branchProtectionUnprotectedFilePatterns, ..} ) <$> f branchProtectionUnprotectedFilePatterns
{-# INLINE branchProtectionUnprotectedFilePatternsL #-}

-- | 'branchProtectionUpdatedAt' Lens
branchProtectionUpdatedAtL :: Lens_' BranchProtection (Maybe DateTime)
branchProtectionUpdatedAtL f BranchProtection{..} = (\branchProtectionUpdatedAt -> BranchProtection { branchProtectionUpdatedAt, ..} ) <$> f branchProtectionUpdatedAt
{-# INLINE branchProtectionUpdatedAtL #-}



-- * ChangeFileOperation

-- | 'changeFileOperationContent' Lens
changeFileOperationContentL :: Lens_' ChangeFileOperation (Maybe Text)
changeFileOperationContentL f ChangeFileOperation{..} = (\changeFileOperationContent -> ChangeFileOperation { changeFileOperationContent, ..} ) <$> f changeFileOperationContent
{-# INLINE changeFileOperationContentL #-}

-- | 'changeFileOperationFromPath' Lens
changeFileOperationFromPathL :: Lens_' ChangeFileOperation (Maybe Text)
changeFileOperationFromPathL f ChangeFileOperation{..} = (\changeFileOperationFromPath -> ChangeFileOperation { changeFileOperationFromPath, ..} ) <$> f changeFileOperationFromPath
{-# INLINE changeFileOperationFromPathL #-}

-- | 'changeFileOperationOperation' Lens
changeFileOperationOperationL :: Lens_' ChangeFileOperation (E'Operation)
changeFileOperationOperationL f ChangeFileOperation{..} = (\changeFileOperationOperation -> ChangeFileOperation { changeFileOperationOperation, ..} ) <$> f changeFileOperationOperation
{-# INLINE changeFileOperationOperationL #-}

-- | 'changeFileOperationPath' Lens
changeFileOperationPathL :: Lens_' ChangeFileOperation (Text)
changeFileOperationPathL f ChangeFileOperation{..} = (\changeFileOperationPath -> ChangeFileOperation { changeFileOperationPath, ..} ) <$> f changeFileOperationPath
{-# INLINE changeFileOperationPathL #-}

-- | 'changeFileOperationSha' Lens
changeFileOperationShaL :: Lens_' ChangeFileOperation (Maybe Text)
changeFileOperationShaL f ChangeFileOperation{..} = (\changeFileOperationSha -> ChangeFileOperation { changeFileOperationSha, ..} ) <$> f changeFileOperationSha
{-# INLINE changeFileOperationShaL #-}



-- * ChangeFilesOptions

-- | 'changeFilesOptionsAuthor' Lens
changeFilesOptionsAuthorL :: Lens_' ChangeFilesOptions (Maybe Identity)
changeFilesOptionsAuthorL f ChangeFilesOptions{..} = (\changeFilesOptionsAuthor -> ChangeFilesOptions { changeFilesOptionsAuthor, ..} ) <$> f changeFilesOptionsAuthor
{-# INLINE changeFilesOptionsAuthorL #-}

-- | 'changeFilesOptionsBranch' Lens
changeFilesOptionsBranchL :: Lens_' ChangeFilesOptions (Maybe Text)
changeFilesOptionsBranchL f ChangeFilesOptions{..} = (\changeFilesOptionsBranch -> ChangeFilesOptions { changeFilesOptionsBranch, ..} ) <$> f changeFilesOptionsBranch
{-# INLINE changeFilesOptionsBranchL #-}

-- | 'changeFilesOptionsCommitter' Lens
changeFilesOptionsCommitterL :: Lens_' ChangeFilesOptions (Maybe Identity)
changeFilesOptionsCommitterL f ChangeFilesOptions{..} = (\changeFilesOptionsCommitter -> ChangeFilesOptions { changeFilesOptionsCommitter, ..} ) <$> f changeFilesOptionsCommitter
{-# INLINE changeFilesOptionsCommitterL #-}

-- | 'changeFilesOptionsDates' Lens
changeFilesOptionsDatesL :: Lens_' ChangeFilesOptions (Maybe CommitDateOptions)
changeFilesOptionsDatesL f ChangeFilesOptions{..} = (\changeFilesOptionsDates -> ChangeFilesOptions { changeFilesOptionsDates, ..} ) <$> f changeFilesOptionsDates
{-# INLINE changeFilesOptionsDatesL #-}

-- | 'changeFilesOptionsFiles' Lens
changeFilesOptionsFilesL :: Lens_' ChangeFilesOptions ([ChangeFileOperation])
changeFilesOptionsFilesL f ChangeFilesOptions{..} = (\changeFilesOptionsFiles -> ChangeFilesOptions { changeFilesOptionsFiles, ..} ) <$> f changeFilesOptionsFiles
{-# INLINE changeFilesOptionsFilesL #-}

-- | 'changeFilesOptionsMessage' Lens
changeFilesOptionsMessageL :: Lens_' ChangeFilesOptions (Maybe Text)
changeFilesOptionsMessageL f ChangeFilesOptions{..} = (\changeFilesOptionsMessage -> ChangeFilesOptions { changeFilesOptionsMessage, ..} ) <$> f changeFilesOptionsMessage
{-# INLINE changeFilesOptionsMessageL #-}

-- | 'changeFilesOptionsNewBranch' Lens
changeFilesOptionsNewBranchL :: Lens_' ChangeFilesOptions (Maybe Text)
changeFilesOptionsNewBranchL f ChangeFilesOptions{..} = (\changeFilesOptionsNewBranch -> ChangeFilesOptions { changeFilesOptionsNewBranch, ..} ) <$> f changeFilesOptionsNewBranch
{-# INLINE changeFilesOptionsNewBranchL #-}

-- | 'changeFilesOptionsSignoff' Lens
changeFilesOptionsSignoffL :: Lens_' ChangeFilesOptions (Maybe Bool)
changeFilesOptionsSignoffL f ChangeFilesOptions{..} = (\changeFilesOptionsSignoff -> ChangeFilesOptions { changeFilesOptionsSignoff, ..} ) <$> f changeFilesOptionsSignoff
{-# INLINE changeFilesOptionsSignoffL #-}



-- * ChangedFile

-- | 'changedFileAdditions' Lens
changedFileAdditionsL :: Lens_' ChangedFile (Maybe Integer)
changedFileAdditionsL f ChangedFile{..} = (\changedFileAdditions -> ChangedFile { changedFileAdditions, ..} ) <$> f changedFileAdditions
{-# INLINE changedFileAdditionsL #-}

-- | 'changedFileChanges' Lens
changedFileChangesL :: Lens_' ChangedFile (Maybe Integer)
changedFileChangesL f ChangedFile{..} = (\changedFileChanges -> ChangedFile { changedFileChanges, ..} ) <$> f changedFileChanges
{-# INLINE changedFileChangesL #-}

-- | 'changedFileContentsUrl' Lens
changedFileContentsUrlL :: Lens_' ChangedFile (Maybe Text)
changedFileContentsUrlL f ChangedFile{..} = (\changedFileContentsUrl -> ChangedFile { changedFileContentsUrl, ..} ) <$> f changedFileContentsUrl
{-# INLINE changedFileContentsUrlL #-}

-- | 'changedFileDeletions' Lens
changedFileDeletionsL :: Lens_' ChangedFile (Maybe Integer)
changedFileDeletionsL f ChangedFile{..} = (\changedFileDeletions -> ChangedFile { changedFileDeletions, ..} ) <$> f changedFileDeletions
{-# INLINE changedFileDeletionsL #-}

-- | 'changedFileFilename' Lens
changedFileFilenameL :: Lens_' ChangedFile (Maybe Text)
changedFileFilenameL f ChangedFile{..} = (\changedFileFilename -> ChangedFile { changedFileFilename, ..} ) <$> f changedFileFilename
{-# INLINE changedFileFilenameL #-}

-- | 'changedFileHtmlUrl' Lens
changedFileHtmlUrlL :: Lens_' ChangedFile (Maybe Text)
changedFileHtmlUrlL f ChangedFile{..} = (\changedFileHtmlUrl -> ChangedFile { changedFileHtmlUrl, ..} ) <$> f changedFileHtmlUrl
{-# INLINE changedFileHtmlUrlL #-}

-- | 'changedFilePreviousFilename' Lens
changedFilePreviousFilenameL :: Lens_' ChangedFile (Maybe Text)
changedFilePreviousFilenameL f ChangedFile{..} = (\changedFilePreviousFilename -> ChangedFile { changedFilePreviousFilename, ..} ) <$> f changedFilePreviousFilename
{-# INLINE changedFilePreviousFilenameL #-}

-- | 'changedFileRawUrl' Lens
changedFileRawUrlL :: Lens_' ChangedFile (Maybe Text)
changedFileRawUrlL f ChangedFile{..} = (\changedFileRawUrl -> ChangedFile { changedFileRawUrl, ..} ) <$> f changedFileRawUrl
{-# INLINE changedFileRawUrlL #-}

-- | 'changedFileStatus' Lens
changedFileStatusL :: Lens_' ChangedFile (Maybe Text)
changedFileStatusL f ChangedFile{..} = (\changedFileStatus -> ChangedFile { changedFileStatus, ..} ) <$> f changedFileStatus
{-# INLINE changedFileStatusL #-}



-- * CombinedStatus

-- | 'combinedStatusCommitUrl' Lens
combinedStatusCommitUrlL :: Lens_' CombinedStatus (Maybe Text)
combinedStatusCommitUrlL f CombinedStatus{..} = (\combinedStatusCommitUrl -> CombinedStatus { combinedStatusCommitUrl, ..} ) <$> f combinedStatusCommitUrl
{-# INLINE combinedStatusCommitUrlL #-}

-- | 'combinedStatusRepository' Lens
combinedStatusRepositoryL :: Lens_' CombinedStatus (Maybe Repository)
combinedStatusRepositoryL f CombinedStatus{..} = (\combinedStatusRepository -> CombinedStatus { combinedStatusRepository, ..} ) <$> f combinedStatusRepository
{-# INLINE combinedStatusRepositoryL #-}

-- | 'combinedStatusSha' Lens
combinedStatusShaL :: Lens_' CombinedStatus (Maybe Text)
combinedStatusShaL f CombinedStatus{..} = (\combinedStatusSha -> CombinedStatus { combinedStatusSha, ..} ) <$> f combinedStatusSha
{-# INLINE combinedStatusShaL #-}

-- | 'combinedStatusState' Lens
combinedStatusStateL :: Lens_' CombinedStatus (Maybe Text)
combinedStatusStateL f CombinedStatus{..} = (\combinedStatusState -> CombinedStatus { combinedStatusState, ..} ) <$> f combinedStatusState
{-# INLINE combinedStatusStateL #-}

-- | 'combinedStatusStatuses' Lens
combinedStatusStatusesL :: Lens_' CombinedStatus (Maybe [CommitStatus])
combinedStatusStatusesL f CombinedStatus{..} = (\combinedStatusStatuses -> CombinedStatus { combinedStatusStatuses, ..} ) <$> f combinedStatusStatuses
{-# INLINE combinedStatusStatusesL #-}

-- | 'combinedStatusTotalCount' Lens
combinedStatusTotalCountL :: Lens_' CombinedStatus (Maybe Integer)
combinedStatusTotalCountL f CombinedStatus{..} = (\combinedStatusTotalCount -> CombinedStatus { combinedStatusTotalCount, ..} ) <$> f combinedStatusTotalCount
{-# INLINE combinedStatusTotalCountL #-}

-- | 'combinedStatusUrl' Lens
combinedStatusUrlL :: Lens_' CombinedStatus (Maybe Text)
combinedStatusUrlL f CombinedStatus{..} = (\combinedStatusUrl -> CombinedStatus { combinedStatusUrl, ..} ) <$> f combinedStatusUrl
{-# INLINE combinedStatusUrlL #-}



-- * Comment

-- | 'commentAssets' Lens
commentAssetsL :: Lens_' Comment (Maybe [Attachment])
commentAssetsL f Comment{..} = (\commentAssets -> Comment { commentAssets, ..} ) <$> f commentAssets
{-# INLINE commentAssetsL #-}

-- | 'commentBody' Lens
commentBodyL :: Lens_' Comment (Maybe Text)
commentBodyL f Comment{..} = (\commentBody -> Comment { commentBody, ..} ) <$> f commentBody
{-# INLINE commentBodyL #-}

-- | 'commentCreatedAt' Lens
commentCreatedAtL :: Lens_' Comment (Maybe DateTime)
commentCreatedAtL f Comment{..} = (\commentCreatedAt -> Comment { commentCreatedAt, ..} ) <$> f commentCreatedAt
{-# INLINE commentCreatedAtL #-}

-- | 'commentHtmlUrl' Lens
commentHtmlUrlL :: Lens_' Comment (Maybe Text)
commentHtmlUrlL f Comment{..} = (\commentHtmlUrl -> Comment { commentHtmlUrl, ..} ) <$> f commentHtmlUrl
{-# INLINE commentHtmlUrlL #-}

-- | 'commentId' Lens
commentIdL :: Lens_' Comment (Maybe Integer)
commentIdL f Comment{..} = (\commentId -> Comment { commentId, ..} ) <$> f commentId
{-# INLINE commentIdL #-}

-- | 'commentIssueUrl' Lens
commentIssueUrlL :: Lens_' Comment (Maybe Text)
commentIssueUrlL f Comment{..} = (\commentIssueUrl -> Comment { commentIssueUrl, ..} ) <$> f commentIssueUrl
{-# INLINE commentIssueUrlL #-}

-- | 'commentOriginalAuthor' Lens
commentOriginalAuthorL :: Lens_' Comment (Maybe Text)
commentOriginalAuthorL f Comment{..} = (\commentOriginalAuthor -> Comment { commentOriginalAuthor, ..} ) <$> f commentOriginalAuthor
{-# INLINE commentOriginalAuthorL #-}

-- | 'commentOriginalAuthorId' Lens
commentOriginalAuthorIdL :: Lens_' Comment (Maybe Integer)
commentOriginalAuthorIdL f Comment{..} = (\commentOriginalAuthorId -> Comment { commentOriginalAuthorId, ..} ) <$> f commentOriginalAuthorId
{-# INLINE commentOriginalAuthorIdL #-}

-- | 'commentPullRequestUrl' Lens
commentPullRequestUrlL :: Lens_' Comment (Maybe Text)
commentPullRequestUrlL f Comment{..} = (\commentPullRequestUrl -> Comment { commentPullRequestUrl, ..} ) <$> f commentPullRequestUrl
{-# INLINE commentPullRequestUrlL #-}

-- | 'commentUpdatedAt' Lens
commentUpdatedAtL :: Lens_' Comment (Maybe DateTime)
commentUpdatedAtL f Comment{..} = (\commentUpdatedAt -> Comment { commentUpdatedAt, ..} ) <$> f commentUpdatedAt
{-# INLINE commentUpdatedAtL #-}

-- | 'commentUser' Lens
commentUserL :: Lens_' Comment (Maybe User)
commentUserL f Comment{..} = (\commentUser -> Comment { commentUser, ..} ) <$> f commentUser
{-# INLINE commentUserL #-}



-- * Commit

-- | 'commitAuthor' Lens
commitAuthorL :: Lens_' Commit (Maybe User)
commitAuthorL f Commit{..} = (\commitAuthor -> Commit { commitAuthor, ..} ) <$> f commitAuthor
{-# INLINE commitAuthorL #-}

-- | 'commitCommit' Lens
commitCommitL :: Lens_' Commit (Maybe RepoCommit)
commitCommitL f Commit{..} = (\commitCommit -> Commit { commitCommit, ..} ) <$> f commitCommit
{-# INLINE commitCommitL #-}

-- | 'commitCommitter' Lens
commitCommitterL :: Lens_' Commit (Maybe User)
commitCommitterL f Commit{..} = (\commitCommitter -> Commit { commitCommitter, ..} ) <$> f commitCommitter
{-# INLINE commitCommitterL #-}

-- | 'commitCreated' Lens
commitCreatedL :: Lens_' Commit (Maybe DateTime)
commitCreatedL f Commit{..} = (\commitCreated -> Commit { commitCreated, ..} ) <$> f commitCreated
{-# INLINE commitCreatedL #-}

-- | 'commitFiles' Lens
commitFilesL :: Lens_' Commit (Maybe [CommitAffectedFiles])
commitFilesL f Commit{..} = (\commitFiles -> Commit { commitFiles, ..} ) <$> f commitFiles
{-# INLINE commitFilesL #-}

-- | 'commitHtmlUrl' Lens
commitHtmlUrlL :: Lens_' Commit (Maybe Text)
commitHtmlUrlL f Commit{..} = (\commitHtmlUrl -> Commit { commitHtmlUrl, ..} ) <$> f commitHtmlUrl
{-# INLINE commitHtmlUrlL #-}

-- | 'commitParents' Lens
commitParentsL :: Lens_' Commit (Maybe [CommitMeta])
commitParentsL f Commit{..} = (\commitParents -> Commit { commitParents, ..} ) <$> f commitParents
{-# INLINE commitParentsL #-}

-- | 'commitSha' Lens
commitShaL :: Lens_' Commit (Maybe Text)
commitShaL f Commit{..} = (\commitSha -> Commit { commitSha, ..} ) <$> f commitSha
{-# INLINE commitShaL #-}

-- | 'commitStats' Lens
commitStatsL :: Lens_' Commit (Maybe CommitStats)
commitStatsL f Commit{..} = (\commitStats -> Commit { commitStats, ..} ) <$> f commitStats
{-# INLINE commitStatsL #-}

-- | 'commitUrl' Lens
commitUrlL :: Lens_' Commit (Maybe Text)
commitUrlL f Commit{..} = (\commitUrl -> Commit { commitUrl, ..} ) <$> f commitUrl
{-# INLINE commitUrlL #-}



-- * CommitAffectedFiles

-- | 'commitAffectedFilesFilename' Lens
commitAffectedFilesFilenameL :: Lens_' CommitAffectedFiles (Maybe Text)
commitAffectedFilesFilenameL f CommitAffectedFiles{..} = (\commitAffectedFilesFilename -> CommitAffectedFiles { commitAffectedFilesFilename, ..} ) <$> f commitAffectedFilesFilename
{-# INLINE commitAffectedFilesFilenameL #-}



-- * CommitDateOptions

-- | 'commitDateOptionsAuthor' Lens
commitDateOptionsAuthorL :: Lens_' CommitDateOptions (Maybe DateTime)
commitDateOptionsAuthorL f CommitDateOptions{..} = (\commitDateOptionsAuthor -> CommitDateOptions { commitDateOptionsAuthor, ..} ) <$> f commitDateOptionsAuthor
{-# INLINE commitDateOptionsAuthorL #-}

-- | 'commitDateOptionsCommitter' Lens
commitDateOptionsCommitterL :: Lens_' CommitDateOptions (Maybe DateTime)
commitDateOptionsCommitterL f CommitDateOptions{..} = (\commitDateOptionsCommitter -> CommitDateOptions { commitDateOptionsCommitter, ..} ) <$> f commitDateOptionsCommitter
{-# INLINE commitDateOptionsCommitterL #-}



-- * CommitMeta

-- | 'commitMetaCreated' Lens
commitMetaCreatedL :: Lens_' CommitMeta (Maybe DateTime)
commitMetaCreatedL f CommitMeta{..} = (\commitMetaCreated -> CommitMeta { commitMetaCreated, ..} ) <$> f commitMetaCreated
{-# INLINE commitMetaCreatedL #-}

-- | 'commitMetaSha' Lens
commitMetaShaL :: Lens_' CommitMeta (Maybe Text)
commitMetaShaL f CommitMeta{..} = (\commitMetaSha -> CommitMeta { commitMetaSha, ..} ) <$> f commitMetaSha
{-# INLINE commitMetaShaL #-}

-- | 'commitMetaUrl' Lens
commitMetaUrlL :: Lens_' CommitMeta (Maybe Text)
commitMetaUrlL f CommitMeta{..} = (\commitMetaUrl -> CommitMeta { commitMetaUrl, ..} ) <$> f commitMetaUrl
{-# INLINE commitMetaUrlL #-}



-- * CommitStats

-- | 'commitStatsAdditions' Lens
commitStatsAdditionsL :: Lens_' CommitStats (Maybe Integer)
commitStatsAdditionsL f CommitStats{..} = (\commitStatsAdditions -> CommitStats { commitStatsAdditions, ..} ) <$> f commitStatsAdditions
{-# INLINE commitStatsAdditionsL #-}

-- | 'commitStatsDeletions' Lens
commitStatsDeletionsL :: Lens_' CommitStats (Maybe Integer)
commitStatsDeletionsL f CommitStats{..} = (\commitStatsDeletions -> CommitStats { commitStatsDeletions, ..} ) <$> f commitStatsDeletions
{-# INLINE commitStatsDeletionsL #-}

-- | 'commitStatsTotal' Lens
commitStatsTotalL :: Lens_' CommitStats (Maybe Integer)
commitStatsTotalL f CommitStats{..} = (\commitStatsTotal -> CommitStats { commitStatsTotal, ..} ) <$> f commitStatsTotal
{-# INLINE commitStatsTotalL #-}



-- * CommitStatus

-- | 'commitStatusContext' Lens
commitStatusContextL :: Lens_' CommitStatus (Maybe Text)
commitStatusContextL f CommitStatus{..} = (\commitStatusContext -> CommitStatus { commitStatusContext, ..} ) <$> f commitStatusContext
{-# INLINE commitStatusContextL #-}

-- | 'commitStatusCreatedAt' Lens
commitStatusCreatedAtL :: Lens_' CommitStatus (Maybe DateTime)
commitStatusCreatedAtL f CommitStatus{..} = (\commitStatusCreatedAt -> CommitStatus { commitStatusCreatedAt, ..} ) <$> f commitStatusCreatedAt
{-# INLINE commitStatusCreatedAtL #-}

-- | 'commitStatusCreator' Lens
commitStatusCreatorL :: Lens_' CommitStatus (Maybe User)
commitStatusCreatorL f CommitStatus{..} = (\commitStatusCreator -> CommitStatus { commitStatusCreator, ..} ) <$> f commitStatusCreator
{-# INLINE commitStatusCreatorL #-}

-- | 'commitStatusDescription' Lens
commitStatusDescriptionL :: Lens_' CommitStatus (Maybe Text)
commitStatusDescriptionL f CommitStatus{..} = (\commitStatusDescription -> CommitStatus { commitStatusDescription, ..} ) <$> f commitStatusDescription
{-# INLINE commitStatusDescriptionL #-}

-- | 'commitStatusId' Lens
commitStatusIdL :: Lens_' CommitStatus (Maybe Integer)
commitStatusIdL f CommitStatus{..} = (\commitStatusId -> CommitStatus { commitStatusId, ..} ) <$> f commitStatusId
{-# INLINE commitStatusIdL #-}

-- | 'commitStatusStatus' Lens
commitStatusStatusL :: Lens_' CommitStatus (Maybe Text)
commitStatusStatusL f CommitStatus{..} = (\commitStatusStatus -> CommitStatus { commitStatusStatus, ..} ) <$> f commitStatusStatus
{-# INLINE commitStatusStatusL #-}

-- | 'commitStatusTargetUrl' Lens
commitStatusTargetUrlL :: Lens_' CommitStatus (Maybe Text)
commitStatusTargetUrlL f CommitStatus{..} = (\commitStatusTargetUrl -> CommitStatus { commitStatusTargetUrl, ..} ) <$> f commitStatusTargetUrl
{-# INLINE commitStatusTargetUrlL #-}

-- | 'commitStatusUpdatedAt' Lens
commitStatusUpdatedAtL :: Lens_' CommitStatus (Maybe DateTime)
commitStatusUpdatedAtL f CommitStatus{..} = (\commitStatusUpdatedAt -> CommitStatus { commitStatusUpdatedAt, ..} ) <$> f commitStatusUpdatedAt
{-# INLINE commitStatusUpdatedAtL #-}

-- | 'commitStatusUrl' Lens
commitStatusUrlL :: Lens_' CommitStatus (Maybe Text)
commitStatusUrlL f CommitStatus{..} = (\commitStatusUrl -> CommitStatus { commitStatusUrl, ..} ) <$> f commitStatusUrl
{-# INLINE commitStatusUrlL #-}



-- * CommitUser

-- | 'commitUserDate' Lens
commitUserDateL :: Lens_' CommitUser (Maybe Text)
commitUserDateL f CommitUser{..} = (\commitUserDate -> CommitUser { commitUserDate, ..} ) <$> f commitUserDate
{-# INLINE commitUserDateL #-}

-- | 'commitUserEmail' Lens
commitUserEmailL :: Lens_' CommitUser (Maybe Text)
commitUserEmailL f CommitUser{..} = (\commitUserEmail -> CommitUser { commitUserEmail, ..} ) <$> f commitUserEmail
{-# INLINE commitUserEmailL #-}

-- | 'commitUserName' Lens
commitUserNameL :: Lens_' CommitUser (Maybe Text)
commitUserNameL f CommitUser{..} = (\commitUserName -> CommitUser { commitUserName, ..} ) <$> f commitUserName
{-# INLINE commitUserNameL #-}



-- * ContentsResponse

-- | 'contentsResponseLinks' Lens
contentsResponseLinksL :: Lens_' ContentsResponse (Maybe FileLinksResponse)
contentsResponseLinksL f ContentsResponse{..} = (\contentsResponseLinks -> ContentsResponse { contentsResponseLinks, ..} ) <$> f contentsResponseLinks
{-# INLINE contentsResponseLinksL #-}

-- | 'contentsResponseContent' Lens
contentsResponseContentL :: Lens_' ContentsResponse (Maybe Text)
contentsResponseContentL f ContentsResponse{..} = (\contentsResponseContent -> ContentsResponse { contentsResponseContent, ..} ) <$> f contentsResponseContent
{-# INLINE contentsResponseContentL #-}

-- | 'contentsResponseDownloadUrl' Lens
contentsResponseDownloadUrlL :: Lens_' ContentsResponse (Maybe Text)
contentsResponseDownloadUrlL f ContentsResponse{..} = (\contentsResponseDownloadUrl -> ContentsResponse { contentsResponseDownloadUrl, ..} ) <$> f contentsResponseDownloadUrl
{-# INLINE contentsResponseDownloadUrlL #-}

-- | 'contentsResponseEncoding' Lens
contentsResponseEncodingL :: Lens_' ContentsResponse (Maybe Text)
contentsResponseEncodingL f ContentsResponse{..} = (\contentsResponseEncoding -> ContentsResponse { contentsResponseEncoding, ..} ) <$> f contentsResponseEncoding
{-# INLINE contentsResponseEncodingL #-}

-- | 'contentsResponseGitUrl' Lens
contentsResponseGitUrlL :: Lens_' ContentsResponse (Maybe Text)
contentsResponseGitUrlL f ContentsResponse{..} = (\contentsResponseGitUrl -> ContentsResponse { contentsResponseGitUrl, ..} ) <$> f contentsResponseGitUrl
{-# INLINE contentsResponseGitUrlL #-}

-- | 'contentsResponseHtmlUrl' Lens
contentsResponseHtmlUrlL :: Lens_' ContentsResponse (Maybe Text)
contentsResponseHtmlUrlL f ContentsResponse{..} = (\contentsResponseHtmlUrl -> ContentsResponse { contentsResponseHtmlUrl, ..} ) <$> f contentsResponseHtmlUrl
{-# INLINE contentsResponseHtmlUrlL #-}

-- | 'contentsResponseLastCommitSha' Lens
contentsResponseLastCommitShaL :: Lens_' ContentsResponse (Maybe Text)
contentsResponseLastCommitShaL f ContentsResponse{..} = (\contentsResponseLastCommitSha -> ContentsResponse { contentsResponseLastCommitSha, ..} ) <$> f contentsResponseLastCommitSha
{-# INLINE contentsResponseLastCommitShaL #-}

-- | 'contentsResponseName' Lens
contentsResponseNameL :: Lens_' ContentsResponse (Maybe Text)
contentsResponseNameL f ContentsResponse{..} = (\contentsResponseName -> ContentsResponse { contentsResponseName, ..} ) <$> f contentsResponseName
{-# INLINE contentsResponseNameL #-}

-- | 'contentsResponsePath' Lens
contentsResponsePathL :: Lens_' ContentsResponse (Maybe Text)
contentsResponsePathL f ContentsResponse{..} = (\contentsResponsePath -> ContentsResponse { contentsResponsePath, ..} ) <$> f contentsResponsePath
{-# INLINE contentsResponsePathL #-}

-- | 'contentsResponseSha' Lens
contentsResponseShaL :: Lens_' ContentsResponse (Maybe Text)
contentsResponseShaL f ContentsResponse{..} = (\contentsResponseSha -> ContentsResponse { contentsResponseSha, ..} ) <$> f contentsResponseSha
{-# INLINE contentsResponseShaL #-}

-- | 'contentsResponseSize' Lens
contentsResponseSizeL :: Lens_' ContentsResponse (Maybe Integer)
contentsResponseSizeL f ContentsResponse{..} = (\contentsResponseSize -> ContentsResponse { contentsResponseSize, ..} ) <$> f contentsResponseSize
{-# INLINE contentsResponseSizeL #-}

-- | 'contentsResponseSubmoduleGitUrl' Lens
contentsResponseSubmoduleGitUrlL :: Lens_' ContentsResponse (Maybe Text)
contentsResponseSubmoduleGitUrlL f ContentsResponse{..} = (\contentsResponseSubmoduleGitUrl -> ContentsResponse { contentsResponseSubmoduleGitUrl, ..} ) <$> f contentsResponseSubmoduleGitUrl
{-# INLINE contentsResponseSubmoduleGitUrlL #-}

-- | 'contentsResponseTarget' Lens
contentsResponseTargetL :: Lens_' ContentsResponse (Maybe Text)
contentsResponseTargetL f ContentsResponse{..} = (\contentsResponseTarget -> ContentsResponse { contentsResponseTarget, ..} ) <$> f contentsResponseTarget
{-# INLINE contentsResponseTargetL #-}

-- | 'contentsResponseType' Lens
contentsResponseTypeL :: Lens_' ContentsResponse (Maybe Text)
contentsResponseTypeL f ContentsResponse{..} = (\contentsResponseType -> ContentsResponse { contentsResponseType, ..} ) <$> f contentsResponseType
{-# INLINE contentsResponseTypeL #-}

-- | 'contentsResponseUrl' Lens
contentsResponseUrlL :: Lens_' ContentsResponse (Maybe Text)
contentsResponseUrlL f ContentsResponse{..} = (\contentsResponseUrl -> ContentsResponse { contentsResponseUrl, ..} ) <$> f contentsResponseUrl
{-# INLINE contentsResponseUrlL #-}



-- * CreateAccessTokenOption

-- | 'createAccessTokenOptionName' Lens
createAccessTokenOptionNameL :: Lens_' CreateAccessTokenOption (Text)
createAccessTokenOptionNameL f CreateAccessTokenOption{..} = (\createAccessTokenOptionName -> CreateAccessTokenOption { createAccessTokenOptionName, ..} ) <$> f createAccessTokenOptionName
{-# INLINE createAccessTokenOptionNameL #-}

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



-- * CreateBranchProtectionOption

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

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

-- | 'createBranchProtectionOptionBlockOnOfficialReviewRequests' Lens
createBranchProtectionOptionBlockOnOfficialReviewRequestsL :: Lens_' CreateBranchProtectionOption (Maybe Bool)
createBranchProtectionOptionBlockOnOfficialReviewRequestsL f CreateBranchProtectionOption{..} = (\createBranchProtectionOptionBlockOnOfficialReviewRequests -> CreateBranchProtectionOption { createBranchProtectionOptionBlockOnOfficialReviewRequests, ..} ) <$> f createBranchProtectionOptionBlockOnOfficialReviewRequests
{-# INLINE createBranchProtectionOptionBlockOnOfficialReviewRequestsL #-}

-- | 'createBranchProtectionOptionBlockOnOutdatedBranch' Lens
createBranchProtectionOptionBlockOnOutdatedBranchL :: Lens_' CreateBranchProtectionOption (Maybe Bool)
createBranchProtectionOptionBlockOnOutdatedBranchL f CreateBranchProtectionOption{..} = (\createBranchProtectionOptionBlockOnOutdatedBranch -> CreateBranchProtectionOption { createBranchProtectionOptionBlockOnOutdatedBranch, ..} ) <$> f createBranchProtectionOptionBlockOnOutdatedBranch
{-# INLINE createBranchProtectionOptionBlockOnOutdatedBranchL #-}

-- | 'createBranchProtectionOptionBlockOnRejectedReviews' Lens
createBranchProtectionOptionBlockOnRejectedReviewsL :: Lens_' CreateBranchProtectionOption (Maybe Bool)
createBranchProtectionOptionBlockOnRejectedReviewsL f CreateBranchProtectionOption{..} = (\createBranchProtectionOptionBlockOnRejectedReviews -> CreateBranchProtectionOption { createBranchProtectionOptionBlockOnRejectedReviews, ..} ) <$> f createBranchProtectionOptionBlockOnRejectedReviews
{-# INLINE createBranchProtectionOptionBlockOnRejectedReviewsL #-}

-- | 'createBranchProtectionOptionBranchName' Lens
createBranchProtectionOptionBranchNameL :: Lens_' CreateBranchProtectionOption (Maybe Text)
createBranchProtectionOptionBranchNameL f CreateBranchProtectionOption{..} = (\createBranchProtectionOptionBranchName -> CreateBranchProtectionOption { createBranchProtectionOptionBranchName, ..} ) <$> f createBranchProtectionOptionBranchName
{-# INLINE createBranchProtectionOptionBranchNameL #-}

-- | 'createBranchProtectionOptionDismissStaleApprovals' Lens
createBranchProtectionOptionDismissStaleApprovalsL :: Lens_' CreateBranchProtectionOption (Maybe Bool)
createBranchProtectionOptionDismissStaleApprovalsL f CreateBranchProtectionOption{..} = (\createBranchProtectionOptionDismissStaleApprovals -> CreateBranchProtectionOption { createBranchProtectionOptionDismissStaleApprovals, ..} ) <$> f createBranchProtectionOptionDismissStaleApprovals
{-# INLINE createBranchProtectionOptionDismissStaleApprovalsL #-}

-- | 'createBranchProtectionOptionEnableApprovalsWhitelist' Lens
createBranchProtectionOptionEnableApprovalsWhitelistL :: Lens_' CreateBranchProtectionOption (Maybe Bool)
createBranchProtectionOptionEnableApprovalsWhitelistL f CreateBranchProtectionOption{..} = (\createBranchProtectionOptionEnableApprovalsWhitelist -> CreateBranchProtectionOption { createBranchProtectionOptionEnableApprovalsWhitelist, ..} ) <$> f createBranchProtectionOptionEnableApprovalsWhitelist
{-# INLINE createBranchProtectionOptionEnableApprovalsWhitelistL #-}

-- | 'createBranchProtectionOptionEnableMergeWhitelist' Lens
createBranchProtectionOptionEnableMergeWhitelistL :: Lens_' CreateBranchProtectionOption (Maybe Bool)
createBranchProtectionOptionEnableMergeWhitelistL f CreateBranchProtectionOption{..} = (\createBranchProtectionOptionEnableMergeWhitelist -> CreateBranchProtectionOption { createBranchProtectionOptionEnableMergeWhitelist, ..} ) <$> f createBranchProtectionOptionEnableMergeWhitelist
{-# INLINE createBranchProtectionOptionEnableMergeWhitelistL #-}

-- | 'createBranchProtectionOptionEnablePush' Lens
createBranchProtectionOptionEnablePushL :: Lens_' CreateBranchProtectionOption (Maybe Bool)
createBranchProtectionOptionEnablePushL f CreateBranchProtectionOption{..} = (\createBranchProtectionOptionEnablePush -> CreateBranchProtectionOption { createBranchProtectionOptionEnablePush, ..} ) <$> f createBranchProtectionOptionEnablePush
{-# INLINE createBranchProtectionOptionEnablePushL #-}

-- | 'createBranchProtectionOptionEnablePushWhitelist' Lens
createBranchProtectionOptionEnablePushWhitelistL :: Lens_' CreateBranchProtectionOption (Maybe Bool)
createBranchProtectionOptionEnablePushWhitelistL f CreateBranchProtectionOption{..} = (\createBranchProtectionOptionEnablePushWhitelist -> CreateBranchProtectionOption { createBranchProtectionOptionEnablePushWhitelist, ..} ) <$> f createBranchProtectionOptionEnablePushWhitelist
{-# INLINE createBranchProtectionOptionEnablePushWhitelistL #-}

-- | 'createBranchProtectionOptionEnableStatusCheck' Lens
createBranchProtectionOptionEnableStatusCheckL :: Lens_' CreateBranchProtectionOption (Maybe Bool)
createBranchProtectionOptionEnableStatusCheckL f CreateBranchProtectionOption{..} = (\createBranchProtectionOptionEnableStatusCheck -> CreateBranchProtectionOption { createBranchProtectionOptionEnableStatusCheck, ..} ) <$> f createBranchProtectionOptionEnableStatusCheck
{-# INLINE createBranchProtectionOptionEnableStatusCheckL #-}

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

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

-- | 'createBranchProtectionOptionProtectedFilePatterns' Lens
createBranchProtectionOptionProtectedFilePatternsL :: Lens_' CreateBranchProtectionOption (Maybe Text)
createBranchProtectionOptionProtectedFilePatternsL f CreateBranchProtectionOption{..} = (\createBranchProtectionOptionProtectedFilePatterns -> CreateBranchProtectionOption { createBranchProtectionOptionProtectedFilePatterns, ..} ) <$> f createBranchProtectionOptionProtectedFilePatterns
{-# INLINE createBranchProtectionOptionProtectedFilePatternsL #-}

-- | 'createBranchProtectionOptionPushWhitelistDeployKeys' Lens
createBranchProtectionOptionPushWhitelistDeployKeysL :: Lens_' CreateBranchProtectionOption (Maybe Bool)
createBranchProtectionOptionPushWhitelistDeployKeysL f CreateBranchProtectionOption{..} = (\createBranchProtectionOptionPushWhitelistDeployKeys -> CreateBranchProtectionOption { createBranchProtectionOptionPushWhitelistDeployKeys, ..} ) <$> f createBranchProtectionOptionPushWhitelistDeployKeys
{-# INLINE createBranchProtectionOptionPushWhitelistDeployKeysL #-}

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

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

-- | 'createBranchProtectionOptionRequireSignedCommits' Lens
createBranchProtectionOptionRequireSignedCommitsL :: Lens_' CreateBranchProtectionOption (Maybe Bool)
createBranchProtectionOptionRequireSignedCommitsL f CreateBranchProtectionOption{..} = (\createBranchProtectionOptionRequireSignedCommits -> CreateBranchProtectionOption { createBranchProtectionOptionRequireSignedCommits, ..} ) <$> f createBranchProtectionOptionRequireSignedCommits
{-# INLINE createBranchProtectionOptionRequireSignedCommitsL #-}

-- | 'createBranchProtectionOptionRequiredApprovals' Lens
createBranchProtectionOptionRequiredApprovalsL :: Lens_' CreateBranchProtectionOption (Maybe Integer)
createBranchProtectionOptionRequiredApprovalsL f CreateBranchProtectionOption{..} = (\createBranchProtectionOptionRequiredApprovals -> CreateBranchProtectionOption { createBranchProtectionOptionRequiredApprovals, ..} ) <$> f createBranchProtectionOptionRequiredApprovals
{-# INLINE createBranchProtectionOptionRequiredApprovalsL #-}

-- | 'createBranchProtectionOptionRuleName' Lens
createBranchProtectionOptionRuleNameL :: Lens_' CreateBranchProtectionOption (Maybe Text)
createBranchProtectionOptionRuleNameL f CreateBranchProtectionOption{..} = (\createBranchProtectionOptionRuleName -> CreateBranchProtectionOption { createBranchProtectionOptionRuleName, ..} ) <$> f createBranchProtectionOptionRuleName
{-# INLINE createBranchProtectionOptionRuleNameL #-}

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

-- | 'createBranchProtectionOptionUnprotectedFilePatterns' Lens
createBranchProtectionOptionUnprotectedFilePatternsL :: Lens_' CreateBranchProtectionOption (Maybe Text)
createBranchProtectionOptionUnprotectedFilePatternsL f CreateBranchProtectionOption{..} = (\createBranchProtectionOptionUnprotectedFilePatterns -> CreateBranchProtectionOption { createBranchProtectionOptionUnprotectedFilePatterns, ..} ) <$> f createBranchProtectionOptionUnprotectedFilePatterns
{-# INLINE createBranchProtectionOptionUnprotectedFilePatternsL #-}



-- * CreateBranchRepoOption

-- | 'createBranchRepoOptionNewBranchName' Lens
createBranchRepoOptionNewBranchNameL :: Lens_' CreateBranchRepoOption (Text)
createBranchRepoOptionNewBranchNameL f CreateBranchRepoOption{..} = (\createBranchRepoOptionNewBranchName -> CreateBranchRepoOption { createBranchRepoOptionNewBranchName, ..} ) <$> f createBranchRepoOptionNewBranchName
{-# INLINE createBranchRepoOptionNewBranchNameL #-}

-- | 'createBranchRepoOptionOldBranchName' Lens
createBranchRepoOptionOldBranchNameL :: Lens_' CreateBranchRepoOption (Maybe Text)
createBranchRepoOptionOldBranchNameL f CreateBranchRepoOption{..} = (\createBranchRepoOptionOldBranchName -> CreateBranchRepoOption { createBranchRepoOptionOldBranchName, ..} ) <$> f createBranchRepoOptionOldBranchName
{-# INLINE createBranchRepoOptionOldBranchNameL #-}

-- | 'createBranchRepoOptionOldRefName' Lens
createBranchRepoOptionOldRefNameL :: Lens_' CreateBranchRepoOption (Maybe Text)
createBranchRepoOptionOldRefNameL f CreateBranchRepoOption{..} = (\createBranchRepoOptionOldRefName -> CreateBranchRepoOption { createBranchRepoOptionOldRefName, ..} ) <$> f createBranchRepoOptionOldRefName
{-# INLINE createBranchRepoOptionOldRefNameL #-}



-- * CreateEmailOption

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



-- * CreateFileOptions

-- | 'createFileOptionsAuthor' Lens
createFileOptionsAuthorL :: Lens_' CreateFileOptions (Maybe Identity)
createFileOptionsAuthorL f CreateFileOptions{..} = (\createFileOptionsAuthor -> CreateFileOptions { createFileOptionsAuthor, ..} ) <$> f createFileOptionsAuthor
{-# INLINE createFileOptionsAuthorL #-}

-- | 'createFileOptionsBranch' Lens
createFileOptionsBranchL :: Lens_' CreateFileOptions (Maybe Text)
createFileOptionsBranchL f CreateFileOptions{..} = (\createFileOptionsBranch -> CreateFileOptions { createFileOptionsBranch, ..} ) <$> f createFileOptionsBranch
{-# INLINE createFileOptionsBranchL #-}

-- | 'createFileOptionsCommitter' Lens
createFileOptionsCommitterL :: Lens_' CreateFileOptions (Maybe Identity)
createFileOptionsCommitterL f CreateFileOptions{..} = (\createFileOptionsCommitter -> CreateFileOptions { createFileOptionsCommitter, ..} ) <$> f createFileOptionsCommitter
{-# INLINE createFileOptionsCommitterL #-}

-- | 'createFileOptionsContent' Lens
createFileOptionsContentL :: Lens_' CreateFileOptions (Text)
createFileOptionsContentL f CreateFileOptions{..} = (\createFileOptionsContent -> CreateFileOptions { createFileOptionsContent, ..} ) <$> f createFileOptionsContent
{-# INLINE createFileOptionsContentL #-}

-- | 'createFileOptionsDates' Lens
createFileOptionsDatesL :: Lens_' CreateFileOptions (Maybe CommitDateOptions)
createFileOptionsDatesL f CreateFileOptions{..} = (\createFileOptionsDates -> CreateFileOptions { createFileOptionsDates, ..} ) <$> f createFileOptionsDates
{-# INLINE createFileOptionsDatesL #-}

-- | 'createFileOptionsMessage' Lens
createFileOptionsMessageL :: Lens_' CreateFileOptions (Maybe Text)
createFileOptionsMessageL f CreateFileOptions{..} = (\createFileOptionsMessage -> CreateFileOptions { createFileOptionsMessage, ..} ) <$> f createFileOptionsMessage
{-# INLINE createFileOptionsMessageL #-}

-- | 'createFileOptionsNewBranch' Lens
createFileOptionsNewBranchL :: Lens_' CreateFileOptions (Maybe Text)
createFileOptionsNewBranchL f CreateFileOptions{..} = (\createFileOptionsNewBranch -> CreateFileOptions { createFileOptionsNewBranch, ..} ) <$> f createFileOptionsNewBranch
{-# INLINE createFileOptionsNewBranchL #-}

-- | 'createFileOptionsSignoff' Lens
createFileOptionsSignoffL :: Lens_' CreateFileOptions (Maybe Bool)
createFileOptionsSignoffL f CreateFileOptions{..} = (\createFileOptionsSignoff -> CreateFileOptions { createFileOptionsSignoff, ..} ) <$> f createFileOptionsSignoff
{-# INLINE createFileOptionsSignoffL #-}



-- * CreateForkOption

-- | 'createForkOptionName' Lens
createForkOptionNameL :: Lens_' CreateForkOption (Maybe Text)
createForkOptionNameL f CreateForkOption{..} = (\createForkOptionName -> CreateForkOption { createForkOptionName, ..} ) <$> f createForkOptionName
{-# INLINE createForkOptionNameL #-}

-- | 'createForkOptionOrganization' Lens
createForkOptionOrganizationL :: Lens_' CreateForkOption (Maybe Text)
createForkOptionOrganizationL f CreateForkOption{..} = (\createForkOptionOrganization -> CreateForkOption { createForkOptionOrganization, ..} ) <$> f createForkOptionOrganization
{-# INLINE createForkOptionOrganizationL #-}



-- * CreateGPGKeyOption

-- | 'createGPGKeyOptionArmoredPublicKey' Lens
createGPGKeyOptionArmoredPublicKeyL :: Lens_' CreateGPGKeyOption (Text)
createGPGKeyOptionArmoredPublicKeyL f CreateGPGKeyOption{..} = (\createGPGKeyOptionArmoredPublicKey -> CreateGPGKeyOption { createGPGKeyOptionArmoredPublicKey, ..} ) <$> f createGPGKeyOptionArmoredPublicKey
{-# INLINE createGPGKeyOptionArmoredPublicKeyL #-}

-- | 'createGPGKeyOptionArmoredSignature' Lens
createGPGKeyOptionArmoredSignatureL :: Lens_' CreateGPGKeyOption (Maybe Text)
createGPGKeyOptionArmoredSignatureL f CreateGPGKeyOption{..} = (\createGPGKeyOptionArmoredSignature -> CreateGPGKeyOption { createGPGKeyOptionArmoredSignature, ..} ) <$> f createGPGKeyOptionArmoredSignature
{-# INLINE createGPGKeyOptionArmoredSignatureL #-}



-- * CreateHookOption

-- | 'createHookOptionActive' Lens
createHookOptionActiveL :: Lens_' CreateHookOption (Maybe Bool)
createHookOptionActiveL f CreateHookOption{..} = (\createHookOptionActive -> CreateHookOption { createHookOptionActive, ..} ) <$> f createHookOptionActive
{-# INLINE createHookOptionActiveL #-}

-- | 'createHookOptionAuthorizationHeader' Lens
createHookOptionAuthorizationHeaderL :: Lens_' CreateHookOption (Maybe Text)
createHookOptionAuthorizationHeaderL f CreateHookOption{..} = (\createHookOptionAuthorizationHeader -> CreateHookOption { createHookOptionAuthorizationHeader, ..} ) <$> f createHookOptionAuthorizationHeader
{-# INLINE createHookOptionAuthorizationHeaderL #-}

-- | 'createHookOptionBranchFilter' Lens
createHookOptionBranchFilterL :: Lens_' CreateHookOption (Maybe Text)
createHookOptionBranchFilterL f CreateHookOption{..} = (\createHookOptionBranchFilter -> CreateHookOption { createHookOptionBranchFilter, ..} ) <$> f createHookOptionBranchFilter
{-# INLINE createHookOptionBranchFilterL #-}

-- | 'createHookOptionConfig' Lens
createHookOptionConfigL :: Lens_' CreateHookOption ((Map.Map String Text))
createHookOptionConfigL f CreateHookOption{..} = (\createHookOptionConfig -> CreateHookOption { createHookOptionConfig, ..} ) <$> f createHookOptionConfig
{-# INLINE createHookOptionConfigL #-}

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

-- | 'createHookOptionType' Lens
createHookOptionTypeL :: Lens_' CreateHookOption (E'Type)
createHookOptionTypeL f CreateHookOption{..} = (\createHookOptionType -> CreateHookOption { createHookOptionType, ..} ) <$> f createHookOptionType
{-# INLINE createHookOptionTypeL #-}



-- * CreateIssueCommentOption

-- | 'createIssueCommentOptionBody' Lens
createIssueCommentOptionBodyL :: Lens_' CreateIssueCommentOption (Text)
createIssueCommentOptionBodyL f CreateIssueCommentOption{..} = (\createIssueCommentOptionBody -> CreateIssueCommentOption { createIssueCommentOptionBody, ..} ) <$> f createIssueCommentOptionBody
{-# INLINE createIssueCommentOptionBodyL #-}



-- * CreateIssueOption

-- | 'createIssueOptionAssignee' Lens
createIssueOptionAssigneeL :: Lens_' CreateIssueOption (Maybe Text)
createIssueOptionAssigneeL f CreateIssueOption{..} = (\createIssueOptionAssignee -> CreateIssueOption { createIssueOptionAssignee, ..} ) <$> f createIssueOptionAssignee
{-# INLINE createIssueOptionAssigneeL #-}

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

-- | 'createIssueOptionBody' Lens
createIssueOptionBodyL :: Lens_' CreateIssueOption (Maybe Text)
createIssueOptionBodyL f CreateIssueOption{..} = (\createIssueOptionBody -> CreateIssueOption { createIssueOptionBody, ..} ) <$> f createIssueOptionBody
{-# INLINE createIssueOptionBodyL #-}

-- | 'createIssueOptionClosed' Lens
createIssueOptionClosedL :: Lens_' CreateIssueOption (Maybe Bool)
createIssueOptionClosedL f CreateIssueOption{..} = (\createIssueOptionClosed -> CreateIssueOption { createIssueOptionClosed, ..} ) <$> f createIssueOptionClosed
{-# INLINE createIssueOptionClosedL #-}

-- | 'createIssueOptionDueDate' Lens
createIssueOptionDueDateL :: Lens_' CreateIssueOption (Maybe DateTime)
createIssueOptionDueDateL f CreateIssueOption{..} = (\createIssueOptionDueDate -> CreateIssueOption { createIssueOptionDueDate, ..} ) <$> f createIssueOptionDueDate
{-# INLINE createIssueOptionDueDateL #-}

-- | 'createIssueOptionLabels' Lens
createIssueOptionLabelsL :: Lens_' CreateIssueOption (Maybe [Integer])
createIssueOptionLabelsL f CreateIssueOption{..} = (\createIssueOptionLabels -> CreateIssueOption { createIssueOptionLabels, ..} ) <$> f createIssueOptionLabels
{-# INLINE createIssueOptionLabelsL #-}

-- | 'createIssueOptionMilestone' Lens
createIssueOptionMilestoneL :: Lens_' CreateIssueOption (Maybe Integer)
createIssueOptionMilestoneL f CreateIssueOption{..} = (\createIssueOptionMilestone -> CreateIssueOption { createIssueOptionMilestone, ..} ) <$> f createIssueOptionMilestone
{-# INLINE createIssueOptionMilestoneL #-}

-- | 'createIssueOptionRef' Lens
createIssueOptionRefL :: Lens_' CreateIssueOption (Maybe Text)
createIssueOptionRefL f CreateIssueOption{..} = (\createIssueOptionRef -> CreateIssueOption { createIssueOptionRef, ..} ) <$> f createIssueOptionRef
{-# INLINE createIssueOptionRefL #-}

-- | 'createIssueOptionTitle' Lens
createIssueOptionTitleL :: Lens_' CreateIssueOption (Text)
createIssueOptionTitleL f CreateIssueOption{..} = (\createIssueOptionTitle -> CreateIssueOption { createIssueOptionTitle, ..} ) <$> f createIssueOptionTitle
{-# INLINE createIssueOptionTitleL #-}



-- * CreateKeyOption

-- | 'createKeyOptionKey' Lens
createKeyOptionKeyL :: Lens_' CreateKeyOption (Text)
createKeyOptionKeyL f CreateKeyOption{..} = (\createKeyOptionKey -> CreateKeyOption { createKeyOptionKey, ..} ) <$> f createKeyOptionKey
{-# INLINE createKeyOptionKeyL #-}

-- | 'createKeyOptionReadOnly' Lens
createKeyOptionReadOnlyL :: Lens_' CreateKeyOption (Maybe Bool)
createKeyOptionReadOnlyL f CreateKeyOption{..} = (\createKeyOptionReadOnly -> CreateKeyOption { createKeyOptionReadOnly, ..} ) <$> f createKeyOptionReadOnly
{-# INLINE createKeyOptionReadOnlyL #-}

-- | 'createKeyOptionTitle' Lens
createKeyOptionTitleL :: Lens_' CreateKeyOption (Text)
createKeyOptionTitleL f CreateKeyOption{..} = (\createKeyOptionTitle -> CreateKeyOption { createKeyOptionTitle, ..} ) <$> f createKeyOptionTitle
{-# INLINE createKeyOptionTitleL #-}



-- * CreateLabelOption

-- | 'createLabelOptionColor' Lens
createLabelOptionColorL :: Lens_' CreateLabelOption (Text)
createLabelOptionColorL f CreateLabelOption{..} = (\createLabelOptionColor -> CreateLabelOption { createLabelOptionColor, ..} ) <$> f createLabelOptionColor
{-# INLINE createLabelOptionColorL #-}

-- | 'createLabelOptionDescription' Lens
createLabelOptionDescriptionL :: Lens_' CreateLabelOption (Maybe Text)
createLabelOptionDescriptionL f CreateLabelOption{..} = (\createLabelOptionDescription -> CreateLabelOption { createLabelOptionDescription, ..} ) <$> f createLabelOptionDescription
{-# INLINE createLabelOptionDescriptionL #-}

-- | 'createLabelOptionExclusive' Lens
createLabelOptionExclusiveL :: Lens_' CreateLabelOption (Maybe Bool)
createLabelOptionExclusiveL f CreateLabelOption{..} = (\createLabelOptionExclusive -> CreateLabelOption { createLabelOptionExclusive, ..} ) <$> f createLabelOptionExclusive
{-# INLINE createLabelOptionExclusiveL #-}

-- | 'createLabelOptionName' Lens
createLabelOptionNameL :: Lens_' CreateLabelOption (Text)
createLabelOptionNameL f CreateLabelOption{..} = (\createLabelOptionName -> CreateLabelOption { createLabelOptionName, ..} ) <$> f createLabelOptionName
{-# INLINE createLabelOptionNameL #-}



-- * CreateMilestoneOption

-- | 'createMilestoneOptionDescription' Lens
createMilestoneOptionDescriptionL :: Lens_' CreateMilestoneOption (Maybe Text)
createMilestoneOptionDescriptionL f CreateMilestoneOption{..} = (\createMilestoneOptionDescription -> CreateMilestoneOption { createMilestoneOptionDescription, ..} ) <$> f createMilestoneOptionDescription
{-# INLINE createMilestoneOptionDescriptionL #-}

-- | 'createMilestoneOptionDueOn' Lens
createMilestoneOptionDueOnL :: Lens_' CreateMilestoneOption (Maybe DateTime)
createMilestoneOptionDueOnL f CreateMilestoneOption{..} = (\createMilestoneOptionDueOn -> CreateMilestoneOption { createMilestoneOptionDueOn, ..} ) <$> f createMilestoneOptionDueOn
{-# INLINE createMilestoneOptionDueOnL #-}

-- | 'createMilestoneOptionState' Lens
createMilestoneOptionStateL :: Lens_' CreateMilestoneOption (Maybe E'State)
createMilestoneOptionStateL f CreateMilestoneOption{..} = (\createMilestoneOptionState -> CreateMilestoneOption { createMilestoneOptionState, ..} ) <$> f createMilestoneOptionState
{-# INLINE createMilestoneOptionStateL #-}

-- | 'createMilestoneOptionTitle' Lens
createMilestoneOptionTitleL :: Lens_' CreateMilestoneOption (Maybe Text)
createMilestoneOptionTitleL f CreateMilestoneOption{..} = (\createMilestoneOptionTitle -> CreateMilestoneOption { createMilestoneOptionTitle, ..} ) <$> f createMilestoneOptionTitle
{-# INLINE createMilestoneOptionTitleL #-}



-- * CreateOAuth2ApplicationOptions

-- | 'createOAuth2ApplicationOptionsConfidentialClient' Lens
createOAuth2ApplicationOptionsConfidentialClientL :: Lens_' CreateOAuth2ApplicationOptions (Maybe Bool)
createOAuth2ApplicationOptionsConfidentialClientL f CreateOAuth2ApplicationOptions{..} = (\createOAuth2ApplicationOptionsConfidentialClient -> CreateOAuth2ApplicationOptions { createOAuth2ApplicationOptionsConfidentialClient, ..} ) <$> f createOAuth2ApplicationOptionsConfidentialClient
{-# INLINE createOAuth2ApplicationOptionsConfidentialClientL #-}

-- | 'createOAuth2ApplicationOptionsName' Lens
createOAuth2ApplicationOptionsNameL :: Lens_' CreateOAuth2ApplicationOptions (Maybe Text)
createOAuth2ApplicationOptionsNameL f CreateOAuth2ApplicationOptions{..} = (\createOAuth2ApplicationOptionsName -> CreateOAuth2ApplicationOptions { createOAuth2ApplicationOptionsName, ..} ) <$> f createOAuth2ApplicationOptionsName
{-# INLINE createOAuth2ApplicationOptionsNameL #-}

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



-- * CreateOrgOption

-- | 'createOrgOptionDescription' Lens
createOrgOptionDescriptionL :: Lens_' CreateOrgOption (Maybe Text)
createOrgOptionDescriptionL f CreateOrgOption{..} = (\createOrgOptionDescription -> CreateOrgOption { createOrgOptionDescription, ..} ) <$> f createOrgOptionDescription
{-# INLINE createOrgOptionDescriptionL #-}

-- | 'createOrgOptionFullName' Lens
createOrgOptionFullNameL :: Lens_' CreateOrgOption (Maybe Text)
createOrgOptionFullNameL f CreateOrgOption{..} = (\createOrgOptionFullName -> CreateOrgOption { createOrgOptionFullName, ..} ) <$> f createOrgOptionFullName
{-# INLINE createOrgOptionFullNameL #-}

-- | 'createOrgOptionLocation' Lens
createOrgOptionLocationL :: Lens_' CreateOrgOption (Maybe Text)
createOrgOptionLocationL f CreateOrgOption{..} = (\createOrgOptionLocation -> CreateOrgOption { createOrgOptionLocation, ..} ) <$> f createOrgOptionLocation
{-# INLINE createOrgOptionLocationL #-}

-- | 'createOrgOptionRepoAdminChangeTeamAccess' Lens
createOrgOptionRepoAdminChangeTeamAccessL :: Lens_' CreateOrgOption (Maybe Bool)
createOrgOptionRepoAdminChangeTeamAccessL f CreateOrgOption{..} = (\createOrgOptionRepoAdminChangeTeamAccess -> CreateOrgOption { createOrgOptionRepoAdminChangeTeamAccess, ..} ) <$> f createOrgOptionRepoAdminChangeTeamAccess
{-# INLINE createOrgOptionRepoAdminChangeTeamAccessL #-}

-- | 'createOrgOptionUsername' Lens
createOrgOptionUsernameL :: Lens_' CreateOrgOption (Text)
createOrgOptionUsernameL f CreateOrgOption{..} = (\createOrgOptionUsername -> CreateOrgOption { createOrgOptionUsername, ..} ) <$> f createOrgOptionUsername
{-# INLINE createOrgOptionUsernameL #-}

-- | 'createOrgOptionVisibility' Lens
createOrgOptionVisibilityL :: Lens_' CreateOrgOption (Maybe E'Visibility)
createOrgOptionVisibilityL f CreateOrgOption{..} = (\createOrgOptionVisibility -> CreateOrgOption { createOrgOptionVisibility, ..} ) <$> f createOrgOptionVisibility
{-# INLINE createOrgOptionVisibilityL #-}

-- | 'createOrgOptionWebsite' Lens
createOrgOptionWebsiteL :: Lens_' CreateOrgOption (Maybe Text)
createOrgOptionWebsiteL f CreateOrgOption{..} = (\createOrgOptionWebsite -> CreateOrgOption { createOrgOptionWebsite, ..} ) <$> f createOrgOptionWebsite
{-# INLINE createOrgOptionWebsiteL #-}



-- * CreatePullRequestOption

-- | 'createPullRequestOptionAssignee' Lens
createPullRequestOptionAssigneeL :: Lens_' CreatePullRequestOption (Maybe Text)
createPullRequestOptionAssigneeL f CreatePullRequestOption{..} = (\createPullRequestOptionAssignee -> CreatePullRequestOption { createPullRequestOptionAssignee, ..} ) <$> f createPullRequestOptionAssignee
{-# INLINE createPullRequestOptionAssigneeL #-}

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

-- | 'createPullRequestOptionBase' Lens
createPullRequestOptionBaseL :: Lens_' CreatePullRequestOption (Maybe Text)
createPullRequestOptionBaseL f CreatePullRequestOption{..} = (\createPullRequestOptionBase -> CreatePullRequestOption { createPullRequestOptionBase, ..} ) <$> f createPullRequestOptionBase
{-# INLINE createPullRequestOptionBaseL #-}

-- | 'createPullRequestOptionBody' Lens
createPullRequestOptionBodyL :: Lens_' CreatePullRequestOption (Maybe Text)
createPullRequestOptionBodyL f CreatePullRequestOption{..} = (\createPullRequestOptionBody -> CreatePullRequestOption { createPullRequestOptionBody, ..} ) <$> f createPullRequestOptionBody
{-# INLINE createPullRequestOptionBodyL #-}

-- | 'createPullRequestOptionDueDate' Lens
createPullRequestOptionDueDateL :: Lens_' CreatePullRequestOption (Maybe DateTime)
createPullRequestOptionDueDateL f CreatePullRequestOption{..} = (\createPullRequestOptionDueDate -> CreatePullRequestOption { createPullRequestOptionDueDate, ..} ) <$> f createPullRequestOptionDueDate
{-# INLINE createPullRequestOptionDueDateL #-}

-- | 'createPullRequestOptionHead' Lens
createPullRequestOptionHeadL :: Lens_' CreatePullRequestOption (Maybe Text)
createPullRequestOptionHeadL f CreatePullRequestOption{..} = (\createPullRequestOptionHead -> CreatePullRequestOption { createPullRequestOptionHead, ..} ) <$> f createPullRequestOptionHead
{-# INLINE createPullRequestOptionHeadL #-}

-- | 'createPullRequestOptionLabels' Lens
createPullRequestOptionLabelsL :: Lens_' CreatePullRequestOption (Maybe [Integer])
createPullRequestOptionLabelsL f CreatePullRequestOption{..} = (\createPullRequestOptionLabels -> CreatePullRequestOption { createPullRequestOptionLabels, ..} ) <$> f createPullRequestOptionLabels
{-# INLINE createPullRequestOptionLabelsL #-}

-- | 'createPullRequestOptionMilestone' Lens
createPullRequestOptionMilestoneL :: Lens_' CreatePullRequestOption (Maybe Integer)
createPullRequestOptionMilestoneL f CreatePullRequestOption{..} = (\createPullRequestOptionMilestone -> CreatePullRequestOption { createPullRequestOptionMilestone, ..} ) <$> f createPullRequestOptionMilestone
{-# INLINE createPullRequestOptionMilestoneL #-}

-- | 'createPullRequestOptionTitle' Lens
createPullRequestOptionTitleL :: Lens_' CreatePullRequestOption (Maybe Text)
createPullRequestOptionTitleL f CreatePullRequestOption{..} = (\createPullRequestOptionTitle -> CreatePullRequestOption { createPullRequestOptionTitle, ..} ) <$> f createPullRequestOptionTitle
{-# INLINE createPullRequestOptionTitleL #-}



-- * CreatePullReviewComment

-- | 'createPullReviewCommentBody' Lens
createPullReviewCommentBodyL :: Lens_' CreatePullReviewComment (Maybe Text)
createPullReviewCommentBodyL f CreatePullReviewComment{..} = (\createPullReviewCommentBody -> CreatePullReviewComment { createPullReviewCommentBody, ..} ) <$> f createPullReviewCommentBody
{-# INLINE createPullReviewCommentBodyL #-}

-- | 'createPullReviewCommentNewPosition' Lens
createPullReviewCommentNewPositionL :: Lens_' CreatePullReviewComment (Maybe Integer)
createPullReviewCommentNewPositionL f CreatePullReviewComment{..} = (\createPullReviewCommentNewPosition -> CreatePullReviewComment { createPullReviewCommentNewPosition, ..} ) <$> f createPullReviewCommentNewPosition
{-# INLINE createPullReviewCommentNewPositionL #-}

-- | 'createPullReviewCommentOldPosition' Lens
createPullReviewCommentOldPositionL :: Lens_' CreatePullReviewComment (Maybe Integer)
createPullReviewCommentOldPositionL f CreatePullReviewComment{..} = (\createPullReviewCommentOldPosition -> CreatePullReviewComment { createPullReviewCommentOldPosition, ..} ) <$> f createPullReviewCommentOldPosition
{-# INLINE createPullReviewCommentOldPositionL #-}

-- | 'createPullReviewCommentPath' Lens
createPullReviewCommentPathL :: Lens_' CreatePullReviewComment (Maybe Text)
createPullReviewCommentPathL f CreatePullReviewComment{..} = (\createPullReviewCommentPath -> CreatePullReviewComment { createPullReviewCommentPath, ..} ) <$> f createPullReviewCommentPath
{-# INLINE createPullReviewCommentPathL #-}



-- * CreatePullReviewOptions

-- | 'createPullReviewOptionsBody' Lens
createPullReviewOptionsBodyL :: Lens_' CreatePullReviewOptions (Maybe Text)
createPullReviewOptionsBodyL f CreatePullReviewOptions{..} = (\createPullReviewOptionsBody -> CreatePullReviewOptions { createPullReviewOptionsBody, ..} ) <$> f createPullReviewOptionsBody
{-# INLINE createPullReviewOptionsBodyL #-}

-- | 'createPullReviewOptionsComments' Lens
createPullReviewOptionsCommentsL :: Lens_' CreatePullReviewOptions (Maybe [CreatePullReviewComment])
createPullReviewOptionsCommentsL f CreatePullReviewOptions{..} = (\createPullReviewOptionsComments -> CreatePullReviewOptions { createPullReviewOptionsComments, ..} ) <$> f createPullReviewOptionsComments
{-# INLINE createPullReviewOptionsCommentsL #-}

-- | 'createPullReviewOptionsCommitId' Lens
createPullReviewOptionsCommitIdL :: Lens_' CreatePullReviewOptions (Maybe Text)
createPullReviewOptionsCommitIdL f CreatePullReviewOptions{..} = (\createPullReviewOptionsCommitId -> CreatePullReviewOptions { createPullReviewOptionsCommitId, ..} ) <$> f createPullReviewOptionsCommitId
{-# INLINE createPullReviewOptionsCommitIdL #-}

-- | 'createPullReviewOptionsEvent' Lens
createPullReviewOptionsEventL :: Lens_' CreatePullReviewOptions (Maybe Text)
createPullReviewOptionsEventL f CreatePullReviewOptions{..} = (\createPullReviewOptionsEvent -> CreatePullReviewOptions { createPullReviewOptionsEvent, ..} ) <$> f createPullReviewOptionsEvent
{-# INLINE createPullReviewOptionsEventL #-}



-- * CreatePushMirrorOption

-- | 'createPushMirrorOptionInterval' Lens
createPushMirrorOptionIntervalL :: Lens_' CreatePushMirrorOption (Maybe Text)
createPushMirrorOptionIntervalL f CreatePushMirrorOption{..} = (\createPushMirrorOptionInterval -> CreatePushMirrorOption { createPushMirrorOptionInterval, ..} ) <$> f createPushMirrorOptionInterval
{-# INLINE createPushMirrorOptionIntervalL #-}

-- | 'createPushMirrorOptionRemoteAddress' Lens
createPushMirrorOptionRemoteAddressL :: Lens_' CreatePushMirrorOption (Maybe Text)
createPushMirrorOptionRemoteAddressL f CreatePushMirrorOption{..} = (\createPushMirrorOptionRemoteAddress -> CreatePushMirrorOption { createPushMirrorOptionRemoteAddress, ..} ) <$> f createPushMirrorOptionRemoteAddress
{-# INLINE createPushMirrorOptionRemoteAddressL #-}

-- | 'createPushMirrorOptionRemotePassword' Lens
createPushMirrorOptionRemotePasswordL :: Lens_' CreatePushMirrorOption (Maybe Text)
createPushMirrorOptionRemotePasswordL f CreatePushMirrorOption{..} = (\createPushMirrorOptionRemotePassword -> CreatePushMirrorOption { createPushMirrorOptionRemotePassword, ..} ) <$> f createPushMirrorOptionRemotePassword
{-# INLINE createPushMirrorOptionRemotePasswordL #-}

-- | 'createPushMirrorOptionRemoteUsername' Lens
createPushMirrorOptionRemoteUsernameL :: Lens_' CreatePushMirrorOption (Maybe Text)
createPushMirrorOptionRemoteUsernameL f CreatePushMirrorOption{..} = (\createPushMirrorOptionRemoteUsername -> CreatePushMirrorOption { createPushMirrorOptionRemoteUsername, ..} ) <$> f createPushMirrorOptionRemoteUsername
{-# INLINE createPushMirrorOptionRemoteUsernameL #-}

-- | 'createPushMirrorOptionSyncOnCommit' Lens
createPushMirrorOptionSyncOnCommitL :: Lens_' CreatePushMirrorOption (Maybe Bool)
createPushMirrorOptionSyncOnCommitL f CreatePushMirrorOption{..} = (\createPushMirrorOptionSyncOnCommit -> CreatePushMirrorOption { createPushMirrorOptionSyncOnCommit, ..} ) <$> f createPushMirrorOptionSyncOnCommit
{-# INLINE createPushMirrorOptionSyncOnCommitL #-}



-- * CreateReleaseOption

-- | 'createReleaseOptionBody' Lens
createReleaseOptionBodyL :: Lens_' CreateReleaseOption (Maybe Text)
createReleaseOptionBodyL f CreateReleaseOption{..} = (\createReleaseOptionBody -> CreateReleaseOption { createReleaseOptionBody, ..} ) <$> f createReleaseOptionBody
{-# INLINE createReleaseOptionBodyL #-}

-- | 'createReleaseOptionDraft' Lens
createReleaseOptionDraftL :: Lens_' CreateReleaseOption (Maybe Bool)
createReleaseOptionDraftL f CreateReleaseOption{..} = (\createReleaseOptionDraft -> CreateReleaseOption { createReleaseOptionDraft, ..} ) <$> f createReleaseOptionDraft
{-# INLINE createReleaseOptionDraftL #-}

-- | 'createReleaseOptionName' Lens
createReleaseOptionNameL :: Lens_' CreateReleaseOption (Maybe Text)
createReleaseOptionNameL f CreateReleaseOption{..} = (\createReleaseOptionName -> CreateReleaseOption { createReleaseOptionName, ..} ) <$> f createReleaseOptionName
{-# INLINE createReleaseOptionNameL #-}

-- | 'createReleaseOptionPrerelease' Lens
createReleaseOptionPrereleaseL :: Lens_' CreateReleaseOption (Maybe Bool)
createReleaseOptionPrereleaseL f CreateReleaseOption{..} = (\createReleaseOptionPrerelease -> CreateReleaseOption { createReleaseOptionPrerelease, ..} ) <$> f createReleaseOptionPrerelease
{-# INLINE createReleaseOptionPrereleaseL #-}

-- | 'createReleaseOptionTagName' Lens
createReleaseOptionTagNameL :: Lens_' CreateReleaseOption (Text)
createReleaseOptionTagNameL f CreateReleaseOption{..} = (\createReleaseOptionTagName -> CreateReleaseOption { createReleaseOptionTagName, ..} ) <$> f createReleaseOptionTagName
{-# INLINE createReleaseOptionTagNameL #-}

-- | 'createReleaseOptionTargetCommitish' Lens
createReleaseOptionTargetCommitishL :: Lens_' CreateReleaseOption (Maybe Text)
createReleaseOptionTargetCommitishL f CreateReleaseOption{..} = (\createReleaseOptionTargetCommitish -> CreateReleaseOption { createReleaseOptionTargetCommitish, ..} ) <$> f createReleaseOptionTargetCommitish
{-# INLINE createReleaseOptionTargetCommitishL #-}



-- * CreateRepoOption

-- | 'createRepoOptionAutoInit' Lens
createRepoOptionAutoInitL :: Lens_' CreateRepoOption (Maybe Bool)
createRepoOptionAutoInitL f CreateRepoOption{..} = (\createRepoOptionAutoInit -> CreateRepoOption { createRepoOptionAutoInit, ..} ) <$> f createRepoOptionAutoInit
{-# INLINE createRepoOptionAutoInitL #-}

-- | 'createRepoOptionDefaultBranch' Lens
createRepoOptionDefaultBranchL :: Lens_' CreateRepoOption (Maybe Text)
createRepoOptionDefaultBranchL f CreateRepoOption{..} = (\createRepoOptionDefaultBranch -> CreateRepoOption { createRepoOptionDefaultBranch, ..} ) <$> f createRepoOptionDefaultBranch
{-# INLINE createRepoOptionDefaultBranchL #-}

-- | 'createRepoOptionDescription' Lens
createRepoOptionDescriptionL :: Lens_' CreateRepoOption (Maybe Text)
createRepoOptionDescriptionL f CreateRepoOption{..} = (\createRepoOptionDescription -> CreateRepoOption { createRepoOptionDescription, ..} ) <$> f createRepoOptionDescription
{-# INLINE createRepoOptionDescriptionL #-}

-- | 'createRepoOptionGitignores' Lens
createRepoOptionGitignoresL :: Lens_' CreateRepoOption (Maybe Text)
createRepoOptionGitignoresL f CreateRepoOption{..} = (\createRepoOptionGitignores -> CreateRepoOption { createRepoOptionGitignores, ..} ) <$> f createRepoOptionGitignores
{-# INLINE createRepoOptionGitignoresL #-}

-- | 'createRepoOptionIssueLabels' Lens
createRepoOptionIssueLabelsL :: Lens_' CreateRepoOption (Maybe Text)
createRepoOptionIssueLabelsL f CreateRepoOption{..} = (\createRepoOptionIssueLabels -> CreateRepoOption { createRepoOptionIssueLabels, ..} ) <$> f createRepoOptionIssueLabels
{-# INLINE createRepoOptionIssueLabelsL #-}

-- | 'createRepoOptionLicense' Lens
createRepoOptionLicenseL :: Lens_' CreateRepoOption (Maybe Text)
createRepoOptionLicenseL f CreateRepoOption{..} = (\createRepoOptionLicense -> CreateRepoOption { createRepoOptionLicense, ..} ) <$> f createRepoOptionLicense
{-# INLINE createRepoOptionLicenseL #-}

-- | 'createRepoOptionName' Lens
createRepoOptionNameL :: Lens_' CreateRepoOption (Text)
createRepoOptionNameL f CreateRepoOption{..} = (\createRepoOptionName -> CreateRepoOption { createRepoOptionName, ..} ) <$> f createRepoOptionName
{-# INLINE createRepoOptionNameL #-}

-- | 'createRepoOptionPrivate' Lens
createRepoOptionPrivateL :: Lens_' CreateRepoOption (Maybe Bool)
createRepoOptionPrivateL f CreateRepoOption{..} = (\createRepoOptionPrivate -> CreateRepoOption { createRepoOptionPrivate, ..} ) <$> f createRepoOptionPrivate
{-# INLINE createRepoOptionPrivateL #-}

-- | 'createRepoOptionReadme' Lens
createRepoOptionReadmeL :: Lens_' CreateRepoOption (Maybe Text)
createRepoOptionReadmeL f CreateRepoOption{..} = (\createRepoOptionReadme -> CreateRepoOption { createRepoOptionReadme, ..} ) <$> f createRepoOptionReadme
{-# INLINE createRepoOptionReadmeL #-}

-- | 'createRepoOptionTemplate' Lens
createRepoOptionTemplateL :: Lens_' CreateRepoOption (Maybe Bool)
createRepoOptionTemplateL f CreateRepoOption{..} = (\createRepoOptionTemplate -> CreateRepoOption { createRepoOptionTemplate, ..} ) <$> f createRepoOptionTemplate
{-# INLINE createRepoOptionTemplateL #-}

-- | 'createRepoOptionTrustModel' Lens
createRepoOptionTrustModelL :: Lens_' CreateRepoOption (Maybe E'TrustModel)
createRepoOptionTrustModelL f CreateRepoOption{..} = (\createRepoOptionTrustModel -> CreateRepoOption { createRepoOptionTrustModel, ..} ) <$> f createRepoOptionTrustModel
{-# INLINE createRepoOptionTrustModelL #-}



-- * CreateStatusOption

-- | 'createStatusOptionContext' Lens
createStatusOptionContextL :: Lens_' CreateStatusOption (Maybe Text)
createStatusOptionContextL f CreateStatusOption{..} = (\createStatusOptionContext -> CreateStatusOption { createStatusOptionContext, ..} ) <$> f createStatusOptionContext
{-# INLINE createStatusOptionContextL #-}

-- | 'createStatusOptionDescription' Lens
createStatusOptionDescriptionL :: Lens_' CreateStatusOption (Maybe Text)
createStatusOptionDescriptionL f CreateStatusOption{..} = (\createStatusOptionDescription -> CreateStatusOption { createStatusOptionDescription, ..} ) <$> f createStatusOptionDescription
{-# INLINE createStatusOptionDescriptionL #-}

-- | 'createStatusOptionState' Lens
createStatusOptionStateL :: Lens_' CreateStatusOption (Maybe Text)
createStatusOptionStateL f CreateStatusOption{..} = (\createStatusOptionState -> CreateStatusOption { createStatusOptionState, ..} ) <$> f createStatusOptionState
{-# INLINE createStatusOptionStateL #-}

-- | 'createStatusOptionTargetUrl' Lens
createStatusOptionTargetUrlL :: Lens_' CreateStatusOption (Maybe Text)
createStatusOptionTargetUrlL f CreateStatusOption{..} = (\createStatusOptionTargetUrl -> CreateStatusOption { createStatusOptionTargetUrl, ..} ) <$> f createStatusOptionTargetUrl
{-# INLINE createStatusOptionTargetUrlL #-}



-- * CreateTagOption

-- | 'createTagOptionMessage' Lens
createTagOptionMessageL :: Lens_' CreateTagOption (Maybe Text)
createTagOptionMessageL f CreateTagOption{..} = (\createTagOptionMessage -> CreateTagOption { createTagOptionMessage, ..} ) <$> f createTagOptionMessage
{-# INLINE createTagOptionMessageL #-}

-- | 'createTagOptionTagName' Lens
createTagOptionTagNameL :: Lens_' CreateTagOption (Text)
createTagOptionTagNameL f CreateTagOption{..} = (\createTagOptionTagName -> CreateTagOption { createTagOptionTagName, ..} ) <$> f createTagOptionTagName
{-# INLINE createTagOptionTagNameL #-}

-- | 'createTagOptionTarget' Lens
createTagOptionTargetL :: Lens_' CreateTagOption (Maybe Text)
createTagOptionTargetL f CreateTagOption{..} = (\createTagOptionTarget -> CreateTagOption { createTagOptionTarget, ..} ) <$> f createTagOptionTarget
{-# INLINE createTagOptionTargetL #-}



-- * CreateTeamOption

-- | 'createTeamOptionCanCreateOrgRepo' Lens
createTeamOptionCanCreateOrgRepoL :: Lens_' CreateTeamOption (Maybe Bool)
createTeamOptionCanCreateOrgRepoL f CreateTeamOption{..} = (\createTeamOptionCanCreateOrgRepo -> CreateTeamOption { createTeamOptionCanCreateOrgRepo, ..} ) <$> f createTeamOptionCanCreateOrgRepo
{-# INLINE createTeamOptionCanCreateOrgRepoL #-}

-- | 'createTeamOptionDescription' Lens
createTeamOptionDescriptionL :: Lens_' CreateTeamOption (Maybe Text)
createTeamOptionDescriptionL f CreateTeamOption{..} = (\createTeamOptionDescription -> CreateTeamOption { createTeamOptionDescription, ..} ) <$> f createTeamOptionDescription
{-# INLINE createTeamOptionDescriptionL #-}

-- | 'createTeamOptionIncludesAllRepositories' Lens
createTeamOptionIncludesAllRepositoriesL :: Lens_' CreateTeamOption (Maybe Bool)
createTeamOptionIncludesAllRepositoriesL f CreateTeamOption{..} = (\createTeamOptionIncludesAllRepositories -> CreateTeamOption { createTeamOptionIncludesAllRepositories, ..} ) <$> f createTeamOptionIncludesAllRepositories
{-# INLINE createTeamOptionIncludesAllRepositoriesL #-}

-- | 'createTeamOptionName' Lens
createTeamOptionNameL :: Lens_' CreateTeamOption (Text)
createTeamOptionNameL f CreateTeamOption{..} = (\createTeamOptionName -> CreateTeamOption { createTeamOptionName, ..} ) <$> f createTeamOptionName
{-# INLINE createTeamOptionNameL #-}

-- | 'createTeamOptionPermission' Lens
createTeamOptionPermissionL :: Lens_' CreateTeamOption (Maybe E'Permission)
createTeamOptionPermissionL f CreateTeamOption{..} = (\createTeamOptionPermission -> CreateTeamOption { createTeamOptionPermission, ..} ) <$> f createTeamOptionPermission
{-# INLINE createTeamOptionPermissionL #-}

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

-- | 'createTeamOptionUnitsMap' Lens
createTeamOptionUnitsMapL :: Lens_' CreateTeamOption (Maybe (Map.Map String Text))
createTeamOptionUnitsMapL f CreateTeamOption{..} = (\createTeamOptionUnitsMap -> CreateTeamOption { createTeamOptionUnitsMap, ..} ) <$> f createTeamOptionUnitsMap
{-# INLINE createTeamOptionUnitsMapL #-}



-- * CreateUserOption

-- | 'createUserOptionCreatedAt' Lens
createUserOptionCreatedAtL :: Lens_' CreateUserOption (Maybe DateTime)
createUserOptionCreatedAtL f CreateUserOption{..} = (\createUserOptionCreatedAt -> CreateUserOption { createUserOptionCreatedAt, ..} ) <$> f createUserOptionCreatedAt
{-# INLINE createUserOptionCreatedAtL #-}

-- | 'createUserOptionEmail' Lens
createUserOptionEmailL :: Lens_' CreateUserOption (Text)
createUserOptionEmailL f CreateUserOption{..} = (\createUserOptionEmail -> CreateUserOption { createUserOptionEmail, ..} ) <$> f createUserOptionEmail
{-# INLINE createUserOptionEmailL #-}

-- | 'createUserOptionFullName' Lens
createUserOptionFullNameL :: Lens_' CreateUserOption (Maybe Text)
createUserOptionFullNameL f CreateUserOption{..} = (\createUserOptionFullName -> CreateUserOption { createUserOptionFullName, ..} ) <$> f createUserOptionFullName
{-# INLINE createUserOptionFullNameL #-}

-- | 'createUserOptionLoginName' Lens
createUserOptionLoginNameL :: Lens_' CreateUserOption (Maybe Text)
createUserOptionLoginNameL f CreateUserOption{..} = (\createUserOptionLoginName -> CreateUserOption { createUserOptionLoginName, ..} ) <$> f createUserOptionLoginName
{-# INLINE createUserOptionLoginNameL #-}

-- | 'createUserOptionMustChangePassword' Lens
createUserOptionMustChangePasswordL :: Lens_' CreateUserOption (Maybe Bool)
createUserOptionMustChangePasswordL f CreateUserOption{..} = (\createUserOptionMustChangePassword -> CreateUserOption { createUserOptionMustChangePassword, ..} ) <$> f createUserOptionMustChangePassword
{-# INLINE createUserOptionMustChangePasswordL #-}

-- | 'createUserOptionPassword' Lens
createUserOptionPasswordL :: Lens_' CreateUserOption (Text)
createUserOptionPasswordL f CreateUserOption{..} = (\createUserOptionPassword -> CreateUserOption { createUserOptionPassword, ..} ) <$> f createUserOptionPassword
{-# INLINE createUserOptionPasswordL #-}

-- | 'createUserOptionRestricted' Lens
createUserOptionRestrictedL :: Lens_' CreateUserOption (Maybe Bool)
createUserOptionRestrictedL f CreateUserOption{..} = (\createUserOptionRestricted -> CreateUserOption { createUserOptionRestricted, ..} ) <$> f createUserOptionRestricted
{-# INLINE createUserOptionRestrictedL #-}

-- | 'createUserOptionSendNotify' Lens
createUserOptionSendNotifyL :: Lens_' CreateUserOption (Maybe Bool)
createUserOptionSendNotifyL f CreateUserOption{..} = (\createUserOptionSendNotify -> CreateUserOption { createUserOptionSendNotify, ..} ) <$> f createUserOptionSendNotify
{-# INLINE createUserOptionSendNotifyL #-}

-- | 'createUserOptionSourceId' Lens
createUserOptionSourceIdL :: Lens_' CreateUserOption (Maybe Integer)
createUserOptionSourceIdL f CreateUserOption{..} = (\createUserOptionSourceId -> CreateUserOption { createUserOptionSourceId, ..} ) <$> f createUserOptionSourceId
{-# INLINE createUserOptionSourceIdL #-}

-- | 'createUserOptionUsername' Lens
createUserOptionUsernameL :: Lens_' CreateUserOption (Text)
createUserOptionUsernameL f CreateUserOption{..} = (\createUserOptionUsername -> CreateUserOption { createUserOptionUsername, ..} ) <$> f createUserOptionUsername
{-# INLINE createUserOptionUsernameL #-}

-- | 'createUserOptionVisibility' Lens
createUserOptionVisibilityL :: Lens_' CreateUserOption (Maybe Text)
createUserOptionVisibilityL f CreateUserOption{..} = (\createUserOptionVisibility -> CreateUserOption { createUserOptionVisibility, ..} ) <$> f createUserOptionVisibility
{-# INLINE createUserOptionVisibilityL #-}



-- * CreateWikiPageOptions

-- | 'createWikiPageOptionsContentBase64' Lens
createWikiPageOptionsContentBase64L :: Lens_' CreateWikiPageOptions (Maybe Text)
createWikiPageOptionsContentBase64L f CreateWikiPageOptions{..} = (\createWikiPageOptionsContentBase64 -> CreateWikiPageOptions { createWikiPageOptionsContentBase64, ..} ) <$> f createWikiPageOptionsContentBase64
{-# INLINE createWikiPageOptionsContentBase64L #-}

-- | 'createWikiPageOptionsMessage' Lens
createWikiPageOptionsMessageL :: Lens_' CreateWikiPageOptions (Maybe Text)
createWikiPageOptionsMessageL f CreateWikiPageOptions{..} = (\createWikiPageOptionsMessage -> CreateWikiPageOptions { createWikiPageOptionsMessage, ..} ) <$> f createWikiPageOptionsMessage
{-# INLINE createWikiPageOptionsMessageL #-}

-- | 'createWikiPageOptionsTitle' Lens
createWikiPageOptionsTitleL :: Lens_' CreateWikiPageOptions (Maybe Text)
createWikiPageOptionsTitleL f CreateWikiPageOptions{..} = (\createWikiPageOptionsTitle -> CreateWikiPageOptions { createWikiPageOptionsTitle, ..} ) <$> f createWikiPageOptionsTitle
{-# INLINE createWikiPageOptionsTitleL #-}



-- * Cron

-- | 'cronExecTimes' Lens
cronExecTimesL :: Lens_' Cron (Maybe Integer)
cronExecTimesL f Cron{..} = (\cronExecTimes -> Cron { cronExecTimes, ..} ) <$> f cronExecTimes
{-# INLINE cronExecTimesL #-}

-- | 'cronName' Lens
cronNameL :: Lens_' Cron (Maybe Text)
cronNameL f Cron{..} = (\cronName -> Cron { cronName, ..} ) <$> f cronName
{-# INLINE cronNameL #-}

-- | 'cronNext' Lens
cronNextL :: Lens_' Cron (Maybe DateTime)
cronNextL f Cron{..} = (\cronNext -> Cron { cronNext, ..} ) <$> f cronNext
{-# INLINE cronNextL #-}

-- | 'cronPrev' Lens
cronPrevL :: Lens_' Cron (Maybe DateTime)
cronPrevL f Cron{..} = (\cronPrev -> Cron { cronPrev, ..} ) <$> f cronPrev
{-# INLINE cronPrevL #-}

-- | 'cronSchedule' Lens
cronScheduleL :: Lens_' Cron (Maybe Text)
cronScheduleL f Cron{..} = (\cronSchedule -> Cron { cronSchedule, ..} ) <$> f cronSchedule
{-# INLINE cronScheduleL #-}



-- * DeleteEmailOption

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



-- * DeleteFileOptions

-- | 'deleteFileOptionsAuthor' Lens
deleteFileOptionsAuthorL :: Lens_' DeleteFileOptions (Maybe Identity)
deleteFileOptionsAuthorL f DeleteFileOptions{..} = (\deleteFileOptionsAuthor -> DeleteFileOptions { deleteFileOptionsAuthor, ..} ) <$> f deleteFileOptionsAuthor
{-# INLINE deleteFileOptionsAuthorL #-}

-- | 'deleteFileOptionsBranch' Lens
deleteFileOptionsBranchL :: Lens_' DeleteFileOptions (Maybe Text)
deleteFileOptionsBranchL f DeleteFileOptions{..} = (\deleteFileOptionsBranch -> DeleteFileOptions { deleteFileOptionsBranch, ..} ) <$> f deleteFileOptionsBranch
{-# INLINE deleteFileOptionsBranchL #-}

-- | 'deleteFileOptionsCommitter' Lens
deleteFileOptionsCommitterL :: Lens_' DeleteFileOptions (Maybe Identity)
deleteFileOptionsCommitterL f DeleteFileOptions{..} = (\deleteFileOptionsCommitter -> DeleteFileOptions { deleteFileOptionsCommitter, ..} ) <$> f deleteFileOptionsCommitter
{-# INLINE deleteFileOptionsCommitterL #-}

-- | 'deleteFileOptionsDates' Lens
deleteFileOptionsDatesL :: Lens_' DeleteFileOptions (Maybe CommitDateOptions)
deleteFileOptionsDatesL f DeleteFileOptions{..} = (\deleteFileOptionsDates -> DeleteFileOptions { deleteFileOptionsDates, ..} ) <$> f deleteFileOptionsDates
{-# INLINE deleteFileOptionsDatesL #-}

-- | 'deleteFileOptionsMessage' Lens
deleteFileOptionsMessageL :: Lens_' DeleteFileOptions (Maybe Text)
deleteFileOptionsMessageL f DeleteFileOptions{..} = (\deleteFileOptionsMessage -> DeleteFileOptions { deleteFileOptionsMessage, ..} ) <$> f deleteFileOptionsMessage
{-# INLINE deleteFileOptionsMessageL #-}

-- | 'deleteFileOptionsNewBranch' Lens
deleteFileOptionsNewBranchL :: Lens_' DeleteFileOptions (Maybe Text)
deleteFileOptionsNewBranchL f DeleteFileOptions{..} = (\deleteFileOptionsNewBranch -> DeleteFileOptions { deleteFileOptionsNewBranch, ..} ) <$> f deleteFileOptionsNewBranch
{-# INLINE deleteFileOptionsNewBranchL #-}

-- | 'deleteFileOptionsSha' Lens
deleteFileOptionsShaL :: Lens_' DeleteFileOptions (Text)
deleteFileOptionsShaL f DeleteFileOptions{..} = (\deleteFileOptionsSha -> DeleteFileOptions { deleteFileOptionsSha, ..} ) <$> f deleteFileOptionsSha
{-# INLINE deleteFileOptionsShaL #-}

-- | 'deleteFileOptionsSignoff' Lens
deleteFileOptionsSignoffL :: Lens_' DeleteFileOptions (Maybe Bool)
deleteFileOptionsSignoffL f DeleteFileOptions{..} = (\deleteFileOptionsSignoff -> DeleteFileOptions { deleteFileOptionsSignoff, ..} ) <$> f deleteFileOptionsSignoff
{-# INLINE deleteFileOptionsSignoffL #-}



-- * DeployKey

-- | 'deployKeyCreatedAt' Lens
deployKeyCreatedAtL :: Lens_' DeployKey (Maybe DateTime)
deployKeyCreatedAtL f DeployKey{..} = (\deployKeyCreatedAt -> DeployKey { deployKeyCreatedAt, ..} ) <$> f deployKeyCreatedAt
{-# INLINE deployKeyCreatedAtL #-}

-- | 'deployKeyFingerprint' Lens
deployKeyFingerprintL :: Lens_' DeployKey (Maybe Text)
deployKeyFingerprintL f DeployKey{..} = (\deployKeyFingerprint -> DeployKey { deployKeyFingerprint, ..} ) <$> f deployKeyFingerprint
{-# INLINE deployKeyFingerprintL #-}

-- | 'deployKeyId' Lens
deployKeyIdL :: Lens_' DeployKey (Maybe Integer)
deployKeyIdL f DeployKey{..} = (\deployKeyId -> DeployKey { deployKeyId, ..} ) <$> f deployKeyId
{-# INLINE deployKeyIdL #-}

-- | 'deployKeyKey' Lens
deployKeyKeyL :: Lens_' DeployKey (Maybe Text)
deployKeyKeyL f DeployKey{..} = (\deployKeyKey -> DeployKey { deployKeyKey, ..} ) <$> f deployKeyKey
{-# INLINE deployKeyKeyL #-}

-- | 'deployKeyKeyId' Lens
deployKeyKeyIdL :: Lens_' DeployKey (Maybe Integer)
deployKeyKeyIdL f DeployKey{..} = (\deployKeyKeyId -> DeployKey { deployKeyKeyId, ..} ) <$> f deployKeyKeyId
{-# INLINE deployKeyKeyIdL #-}

-- | 'deployKeyReadOnly' Lens
deployKeyReadOnlyL :: Lens_' DeployKey (Maybe Bool)
deployKeyReadOnlyL f DeployKey{..} = (\deployKeyReadOnly -> DeployKey { deployKeyReadOnly, ..} ) <$> f deployKeyReadOnly
{-# INLINE deployKeyReadOnlyL #-}

-- | 'deployKeyRepository' Lens
deployKeyRepositoryL :: Lens_' DeployKey (Maybe Repository)
deployKeyRepositoryL f DeployKey{..} = (\deployKeyRepository -> DeployKey { deployKeyRepository, ..} ) <$> f deployKeyRepository
{-# INLINE deployKeyRepositoryL #-}

-- | 'deployKeyTitle' Lens
deployKeyTitleL :: Lens_' DeployKey (Maybe Text)
deployKeyTitleL f DeployKey{..} = (\deployKeyTitle -> DeployKey { deployKeyTitle, ..} ) <$> f deployKeyTitle
{-# INLINE deployKeyTitleL #-}

-- | 'deployKeyUrl' Lens
deployKeyUrlL :: Lens_' DeployKey (Maybe Text)
deployKeyUrlL f DeployKey{..} = (\deployKeyUrl -> DeployKey { deployKeyUrl, ..} ) <$> f deployKeyUrl
{-# INLINE deployKeyUrlL #-}



-- * DismissPullReviewOptions

-- | 'dismissPullReviewOptionsMessage' Lens
dismissPullReviewOptionsMessageL :: Lens_' DismissPullReviewOptions (Maybe Text)
dismissPullReviewOptionsMessageL f DismissPullReviewOptions{..} = (\dismissPullReviewOptionsMessage -> DismissPullReviewOptions { dismissPullReviewOptionsMessage, ..} ) <$> f dismissPullReviewOptionsMessage
{-# INLINE dismissPullReviewOptionsMessageL #-}

-- | 'dismissPullReviewOptionsPriors' Lens
dismissPullReviewOptionsPriorsL :: Lens_' DismissPullReviewOptions (Maybe Bool)
dismissPullReviewOptionsPriorsL f DismissPullReviewOptions{..} = (\dismissPullReviewOptionsPriors -> DismissPullReviewOptions { dismissPullReviewOptionsPriors, ..} ) <$> f dismissPullReviewOptionsPriors
{-# INLINE dismissPullReviewOptionsPriorsL #-}



-- * EditAttachmentOptions

-- | 'editAttachmentOptionsName' Lens
editAttachmentOptionsNameL :: Lens_' EditAttachmentOptions (Maybe Text)
editAttachmentOptionsNameL f EditAttachmentOptions{..} = (\editAttachmentOptionsName -> EditAttachmentOptions { editAttachmentOptionsName, ..} ) <$> f editAttachmentOptionsName
{-# INLINE editAttachmentOptionsNameL #-}



-- * EditBranchProtectionOption

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

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

-- | 'editBranchProtectionOptionBlockOnOfficialReviewRequests' Lens
editBranchProtectionOptionBlockOnOfficialReviewRequestsL :: Lens_' EditBranchProtectionOption (Maybe Bool)
editBranchProtectionOptionBlockOnOfficialReviewRequestsL f EditBranchProtectionOption{..} = (\editBranchProtectionOptionBlockOnOfficialReviewRequests -> EditBranchProtectionOption { editBranchProtectionOptionBlockOnOfficialReviewRequests, ..} ) <$> f editBranchProtectionOptionBlockOnOfficialReviewRequests
{-# INLINE editBranchProtectionOptionBlockOnOfficialReviewRequestsL #-}

-- | 'editBranchProtectionOptionBlockOnOutdatedBranch' Lens
editBranchProtectionOptionBlockOnOutdatedBranchL :: Lens_' EditBranchProtectionOption (Maybe Bool)
editBranchProtectionOptionBlockOnOutdatedBranchL f EditBranchProtectionOption{..} = (\editBranchProtectionOptionBlockOnOutdatedBranch -> EditBranchProtectionOption { editBranchProtectionOptionBlockOnOutdatedBranch, ..} ) <$> f editBranchProtectionOptionBlockOnOutdatedBranch
{-# INLINE editBranchProtectionOptionBlockOnOutdatedBranchL #-}

-- | 'editBranchProtectionOptionBlockOnRejectedReviews' Lens
editBranchProtectionOptionBlockOnRejectedReviewsL :: Lens_' EditBranchProtectionOption (Maybe Bool)
editBranchProtectionOptionBlockOnRejectedReviewsL f EditBranchProtectionOption{..} = (\editBranchProtectionOptionBlockOnRejectedReviews -> EditBranchProtectionOption { editBranchProtectionOptionBlockOnRejectedReviews, ..} ) <$> f editBranchProtectionOptionBlockOnRejectedReviews
{-# INLINE editBranchProtectionOptionBlockOnRejectedReviewsL #-}

-- | 'editBranchProtectionOptionDismissStaleApprovals' Lens
editBranchProtectionOptionDismissStaleApprovalsL :: Lens_' EditBranchProtectionOption (Maybe Bool)
editBranchProtectionOptionDismissStaleApprovalsL f EditBranchProtectionOption{..} = (\editBranchProtectionOptionDismissStaleApprovals -> EditBranchProtectionOption { editBranchProtectionOptionDismissStaleApprovals, ..} ) <$> f editBranchProtectionOptionDismissStaleApprovals
{-# INLINE editBranchProtectionOptionDismissStaleApprovalsL #-}

-- | 'editBranchProtectionOptionEnableApprovalsWhitelist' Lens
editBranchProtectionOptionEnableApprovalsWhitelistL :: Lens_' EditBranchProtectionOption (Maybe Bool)
editBranchProtectionOptionEnableApprovalsWhitelistL f EditBranchProtectionOption{..} = (\editBranchProtectionOptionEnableApprovalsWhitelist -> EditBranchProtectionOption { editBranchProtectionOptionEnableApprovalsWhitelist, ..} ) <$> f editBranchProtectionOptionEnableApprovalsWhitelist
{-# INLINE editBranchProtectionOptionEnableApprovalsWhitelistL #-}

-- | 'editBranchProtectionOptionEnableMergeWhitelist' Lens
editBranchProtectionOptionEnableMergeWhitelistL :: Lens_' EditBranchProtectionOption (Maybe Bool)
editBranchProtectionOptionEnableMergeWhitelistL f EditBranchProtectionOption{..} = (\editBranchProtectionOptionEnableMergeWhitelist -> EditBranchProtectionOption { editBranchProtectionOptionEnableMergeWhitelist, ..} ) <$> f editBranchProtectionOptionEnableMergeWhitelist
{-# INLINE editBranchProtectionOptionEnableMergeWhitelistL #-}

-- | 'editBranchProtectionOptionEnablePush' Lens
editBranchProtectionOptionEnablePushL :: Lens_' EditBranchProtectionOption (Maybe Bool)
editBranchProtectionOptionEnablePushL f EditBranchProtectionOption{..} = (\editBranchProtectionOptionEnablePush -> EditBranchProtectionOption { editBranchProtectionOptionEnablePush, ..} ) <$> f editBranchProtectionOptionEnablePush
{-# INLINE editBranchProtectionOptionEnablePushL #-}

-- | 'editBranchProtectionOptionEnablePushWhitelist' Lens
editBranchProtectionOptionEnablePushWhitelistL :: Lens_' EditBranchProtectionOption (Maybe Bool)
editBranchProtectionOptionEnablePushWhitelistL f EditBranchProtectionOption{..} = (\editBranchProtectionOptionEnablePushWhitelist -> EditBranchProtectionOption { editBranchProtectionOptionEnablePushWhitelist, ..} ) <$> f editBranchProtectionOptionEnablePushWhitelist
{-# INLINE editBranchProtectionOptionEnablePushWhitelistL #-}

-- | 'editBranchProtectionOptionEnableStatusCheck' Lens
editBranchProtectionOptionEnableStatusCheckL :: Lens_' EditBranchProtectionOption (Maybe Bool)
editBranchProtectionOptionEnableStatusCheckL f EditBranchProtectionOption{..} = (\editBranchProtectionOptionEnableStatusCheck -> EditBranchProtectionOption { editBranchProtectionOptionEnableStatusCheck, ..} ) <$> f editBranchProtectionOptionEnableStatusCheck
{-# INLINE editBranchProtectionOptionEnableStatusCheckL #-}

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

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

-- | 'editBranchProtectionOptionProtectedFilePatterns' Lens
editBranchProtectionOptionProtectedFilePatternsL :: Lens_' EditBranchProtectionOption (Maybe Text)
editBranchProtectionOptionProtectedFilePatternsL f EditBranchProtectionOption{..} = (\editBranchProtectionOptionProtectedFilePatterns -> EditBranchProtectionOption { editBranchProtectionOptionProtectedFilePatterns, ..} ) <$> f editBranchProtectionOptionProtectedFilePatterns
{-# INLINE editBranchProtectionOptionProtectedFilePatternsL #-}

-- | 'editBranchProtectionOptionPushWhitelistDeployKeys' Lens
editBranchProtectionOptionPushWhitelistDeployKeysL :: Lens_' EditBranchProtectionOption (Maybe Bool)
editBranchProtectionOptionPushWhitelistDeployKeysL f EditBranchProtectionOption{..} = (\editBranchProtectionOptionPushWhitelistDeployKeys -> EditBranchProtectionOption { editBranchProtectionOptionPushWhitelistDeployKeys, ..} ) <$> f editBranchProtectionOptionPushWhitelistDeployKeys
{-# INLINE editBranchProtectionOptionPushWhitelistDeployKeysL #-}

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

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

-- | 'editBranchProtectionOptionRequireSignedCommits' Lens
editBranchProtectionOptionRequireSignedCommitsL :: Lens_' EditBranchProtectionOption (Maybe Bool)
editBranchProtectionOptionRequireSignedCommitsL f EditBranchProtectionOption{..} = (\editBranchProtectionOptionRequireSignedCommits -> EditBranchProtectionOption { editBranchProtectionOptionRequireSignedCommits, ..} ) <$> f editBranchProtectionOptionRequireSignedCommits
{-# INLINE editBranchProtectionOptionRequireSignedCommitsL #-}

-- | 'editBranchProtectionOptionRequiredApprovals' Lens
editBranchProtectionOptionRequiredApprovalsL :: Lens_' EditBranchProtectionOption (Maybe Integer)
editBranchProtectionOptionRequiredApprovalsL f EditBranchProtectionOption{..} = (\editBranchProtectionOptionRequiredApprovals -> EditBranchProtectionOption { editBranchProtectionOptionRequiredApprovals, ..} ) <$> f editBranchProtectionOptionRequiredApprovals
{-# INLINE editBranchProtectionOptionRequiredApprovalsL #-}

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

-- | 'editBranchProtectionOptionUnprotectedFilePatterns' Lens
editBranchProtectionOptionUnprotectedFilePatternsL :: Lens_' EditBranchProtectionOption (Maybe Text)
editBranchProtectionOptionUnprotectedFilePatternsL f EditBranchProtectionOption{..} = (\editBranchProtectionOptionUnprotectedFilePatterns -> EditBranchProtectionOption { editBranchProtectionOptionUnprotectedFilePatterns, ..} ) <$> f editBranchProtectionOptionUnprotectedFilePatterns
{-# INLINE editBranchProtectionOptionUnprotectedFilePatternsL #-}



-- * EditDeadlineOption

-- | 'editDeadlineOptionDueDate' Lens
editDeadlineOptionDueDateL :: Lens_' EditDeadlineOption (DateTime)
editDeadlineOptionDueDateL f EditDeadlineOption{..} = (\editDeadlineOptionDueDate -> EditDeadlineOption { editDeadlineOptionDueDate, ..} ) <$> f editDeadlineOptionDueDate
{-# INLINE editDeadlineOptionDueDateL #-}



-- * EditGitHookOption

-- | 'editGitHookOptionContent' Lens
editGitHookOptionContentL :: Lens_' EditGitHookOption (Maybe Text)
editGitHookOptionContentL f EditGitHookOption{..} = (\editGitHookOptionContent -> EditGitHookOption { editGitHookOptionContent, ..} ) <$> f editGitHookOptionContent
{-# INLINE editGitHookOptionContentL #-}



-- * EditHookOption

-- | 'editHookOptionActive' Lens
editHookOptionActiveL :: Lens_' EditHookOption (Maybe Bool)
editHookOptionActiveL f EditHookOption{..} = (\editHookOptionActive -> EditHookOption { editHookOptionActive, ..} ) <$> f editHookOptionActive
{-# INLINE editHookOptionActiveL #-}

-- | 'editHookOptionAuthorizationHeader' Lens
editHookOptionAuthorizationHeaderL :: Lens_' EditHookOption (Maybe Text)
editHookOptionAuthorizationHeaderL f EditHookOption{..} = (\editHookOptionAuthorizationHeader -> EditHookOption { editHookOptionAuthorizationHeader, ..} ) <$> f editHookOptionAuthorizationHeader
{-# INLINE editHookOptionAuthorizationHeaderL #-}

-- | 'editHookOptionBranchFilter' Lens
editHookOptionBranchFilterL :: Lens_' EditHookOption (Maybe Text)
editHookOptionBranchFilterL f EditHookOption{..} = (\editHookOptionBranchFilter -> EditHookOption { editHookOptionBranchFilter, ..} ) <$> f editHookOptionBranchFilter
{-# INLINE editHookOptionBranchFilterL #-}

-- | 'editHookOptionConfig' Lens
editHookOptionConfigL :: Lens_' EditHookOption (Maybe (Map.Map String Text))
editHookOptionConfigL f EditHookOption{..} = (\editHookOptionConfig -> EditHookOption { editHookOptionConfig, ..} ) <$> f editHookOptionConfig
{-# INLINE editHookOptionConfigL #-}

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



-- * EditIssueCommentOption

-- | 'editIssueCommentOptionBody' Lens
editIssueCommentOptionBodyL :: Lens_' EditIssueCommentOption (Text)
editIssueCommentOptionBodyL f EditIssueCommentOption{..} = (\editIssueCommentOptionBody -> EditIssueCommentOption { editIssueCommentOptionBody, ..} ) <$> f editIssueCommentOptionBody
{-# INLINE editIssueCommentOptionBodyL #-}



-- * EditIssueOption

-- | 'editIssueOptionAssignee' Lens
editIssueOptionAssigneeL :: Lens_' EditIssueOption (Maybe Text)
editIssueOptionAssigneeL f EditIssueOption{..} = (\editIssueOptionAssignee -> EditIssueOption { editIssueOptionAssignee, ..} ) <$> f editIssueOptionAssignee
{-# INLINE editIssueOptionAssigneeL #-}

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

-- | 'editIssueOptionBody' Lens
editIssueOptionBodyL :: Lens_' EditIssueOption (Maybe Text)
editIssueOptionBodyL f EditIssueOption{..} = (\editIssueOptionBody -> EditIssueOption { editIssueOptionBody, ..} ) <$> f editIssueOptionBody
{-# INLINE editIssueOptionBodyL #-}

-- | 'editIssueOptionDueDate' Lens
editIssueOptionDueDateL :: Lens_' EditIssueOption (Maybe DateTime)
editIssueOptionDueDateL f EditIssueOption{..} = (\editIssueOptionDueDate -> EditIssueOption { editIssueOptionDueDate, ..} ) <$> f editIssueOptionDueDate
{-# INLINE editIssueOptionDueDateL #-}

-- | 'editIssueOptionMilestone' Lens
editIssueOptionMilestoneL :: Lens_' EditIssueOption (Maybe Integer)
editIssueOptionMilestoneL f EditIssueOption{..} = (\editIssueOptionMilestone -> EditIssueOption { editIssueOptionMilestone, ..} ) <$> f editIssueOptionMilestone
{-# INLINE editIssueOptionMilestoneL #-}

-- | 'editIssueOptionRef' Lens
editIssueOptionRefL :: Lens_' EditIssueOption (Maybe Text)
editIssueOptionRefL f EditIssueOption{..} = (\editIssueOptionRef -> EditIssueOption { editIssueOptionRef, ..} ) <$> f editIssueOptionRef
{-# INLINE editIssueOptionRefL #-}

-- | 'editIssueOptionState' Lens
editIssueOptionStateL :: Lens_' EditIssueOption (Maybe Text)
editIssueOptionStateL f EditIssueOption{..} = (\editIssueOptionState -> EditIssueOption { editIssueOptionState, ..} ) <$> f editIssueOptionState
{-# INLINE editIssueOptionStateL #-}

-- | 'editIssueOptionTitle' Lens
editIssueOptionTitleL :: Lens_' EditIssueOption (Maybe Text)
editIssueOptionTitleL f EditIssueOption{..} = (\editIssueOptionTitle -> EditIssueOption { editIssueOptionTitle, ..} ) <$> f editIssueOptionTitle
{-# INLINE editIssueOptionTitleL #-}

-- | 'editIssueOptionUnsetDueDate' Lens
editIssueOptionUnsetDueDateL :: Lens_' EditIssueOption (Maybe Bool)
editIssueOptionUnsetDueDateL f EditIssueOption{..} = (\editIssueOptionUnsetDueDate -> EditIssueOption { editIssueOptionUnsetDueDate, ..} ) <$> f editIssueOptionUnsetDueDate
{-# INLINE editIssueOptionUnsetDueDateL #-}



-- * EditLabelOption

-- | 'editLabelOptionColor' Lens
editLabelOptionColorL :: Lens_' EditLabelOption (Maybe Text)
editLabelOptionColorL f EditLabelOption{..} = (\editLabelOptionColor -> EditLabelOption { editLabelOptionColor, ..} ) <$> f editLabelOptionColor
{-# INLINE editLabelOptionColorL #-}

-- | 'editLabelOptionDescription' Lens
editLabelOptionDescriptionL :: Lens_' EditLabelOption (Maybe Text)
editLabelOptionDescriptionL f EditLabelOption{..} = (\editLabelOptionDescription -> EditLabelOption { editLabelOptionDescription, ..} ) <$> f editLabelOptionDescription
{-# INLINE editLabelOptionDescriptionL #-}

-- | 'editLabelOptionExclusive' Lens
editLabelOptionExclusiveL :: Lens_' EditLabelOption (Maybe Bool)
editLabelOptionExclusiveL f EditLabelOption{..} = (\editLabelOptionExclusive -> EditLabelOption { editLabelOptionExclusive, ..} ) <$> f editLabelOptionExclusive
{-# INLINE editLabelOptionExclusiveL #-}

-- | 'editLabelOptionName' Lens
editLabelOptionNameL :: Lens_' EditLabelOption (Maybe Text)
editLabelOptionNameL f EditLabelOption{..} = (\editLabelOptionName -> EditLabelOption { editLabelOptionName, ..} ) <$> f editLabelOptionName
{-# INLINE editLabelOptionNameL #-}



-- * EditMilestoneOption

-- | 'editMilestoneOptionDescription' Lens
editMilestoneOptionDescriptionL :: Lens_' EditMilestoneOption (Maybe Text)
editMilestoneOptionDescriptionL f EditMilestoneOption{..} = (\editMilestoneOptionDescription -> EditMilestoneOption { editMilestoneOptionDescription, ..} ) <$> f editMilestoneOptionDescription
{-# INLINE editMilestoneOptionDescriptionL #-}

-- | 'editMilestoneOptionDueOn' Lens
editMilestoneOptionDueOnL :: Lens_' EditMilestoneOption (Maybe DateTime)
editMilestoneOptionDueOnL f EditMilestoneOption{..} = (\editMilestoneOptionDueOn -> EditMilestoneOption { editMilestoneOptionDueOn, ..} ) <$> f editMilestoneOptionDueOn
{-# INLINE editMilestoneOptionDueOnL #-}

-- | 'editMilestoneOptionState' Lens
editMilestoneOptionStateL :: Lens_' EditMilestoneOption (Maybe Text)
editMilestoneOptionStateL f EditMilestoneOption{..} = (\editMilestoneOptionState -> EditMilestoneOption { editMilestoneOptionState, ..} ) <$> f editMilestoneOptionState
{-# INLINE editMilestoneOptionStateL #-}

-- | 'editMilestoneOptionTitle' Lens
editMilestoneOptionTitleL :: Lens_' EditMilestoneOption (Maybe Text)
editMilestoneOptionTitleL f EditMilestoneOption{..} = (\editMilestoneOptionTitle -> EditMilestoneOption { editMilestoneOptionTitle, ..} ) <$> f editMilestoneOptionTitle
{-# INLINE editMilestoneOptionTitleL #-}



-- * EditOrgOption

-- | 'editOrgOptionDescription' Lens
editOrgOptionDescriptionL :: Lens_' EditOrgOption (Maybe Text)
editOrgOptionDescriptionL f EditOrgOption{..} = (\editOrgOptionDescription -> EditOrgOption { editOrgOptionDescription, ..} ) <$> f editOrgOptionDescription
{-# INLINE editOrgOptionDescriptionL #-}

-- | 'editOrgOptionFullName' Lens
editOrgOptionFullNameL :: Lens_' EditOrgOption (Maybe Text)
editOrgOptionFullNameL f EditOrgOption{..} = (\editOrgOptionFullName -> EditOrgOption { editOrgOptionFullName, ..} ) <$> f editOrgOptionFullName
{-# INLINE editOrgOptionFullNameL #-}

-- | 'editOrgOptionLocation' Lens
editOrgOptionLocationL :: Lens_' EditOrgOption (Maybe Text)
editOrgOptionLocationL f EditOrgOption{..} = (\editOrgOptionLocation -> EditOrgOption { editOrgOptionLocation, ..} ) <$> f editOrgOptionLocation
{-# INLINE editOrgOptionLocationL #-}

-- | 'editOrgOptionRepoAdminChangeTeamAccess' Lens
editOrgOptionRepoAdminChangeTeamAccessL :: Lens_' EditOrgOption (Maybe Bool)
editOrgOptionRepoAdminChangeTeamAccessL f EditOrgOption{..} = (\editOrgOptionRepoAdminChangeTeamAccess -> EditOrgOption { editOrgOptionRepoAdminChangeTeamAccess, ..} ) <$> f editOrgOptionRepoAdminChangeTeamAccess
{-# INLINE editOrgOptionRepoAdminChangeTeamAccessL #-}

-- | 'editOrgOptionVisibility' Lens
editOrgOptionVisibilityL :: Lens_' EditOrgOption (Maybe E'Visibility)
editOrgOptionVisibilityL f EditOrgOption{..} = (\editOrgOptionVisibility -> EditOrgOption { editOrgOptionVisibility, ..} ) <$> f editOrgOptionVisibility
{-# INLINE editOrgOptionVisibilityL #-}

-- | 'editOrgOptionWebsite' Lens
editOrgOptionWebsiteL :: Lens_' EditOrgOption (Maybe Text)
editOrgOptionWebsiteL f EditOrgOption{..} = (\editOrgOptionWebsite -> EditOrgOption { editOrgOptionWebsite, ..} ) <$> f editOrgOptionWebsite
{-# INLINE editOrgOptionWebsiteL #-}



-- * EditPullRequestOption

-- | 'editPullRequestOptionAllowMaintainerEdit' Lens
editPullRequestOptionAllowMaintainerEditL :: Lens_' EditPullRequestOption (Maybe Bool)
editPullRequestOptionAllowMaintainerEditL f EditPullRequestOption{..} = (\editPullRequestOptionAllowMaintainerEdit -> EditPullRequestOption { editPullRequestOptionAllowMaintainerEdit, ..} ) <$> f editPullRequestOptionAllowMaintainerEdit
{-# INLINE editPullRequestOptionAllowMaintainerEditL #-}

-- | 'editPullRequestOptionAssignee' Lens
editPullRequestOptionAssigneeL :: Lens_' EditPullRequestOption (Maybe Text)
editPullRequestOptionAssigneeL f EditPullRequestOption{..} = (\editPullRequestOptionAssignee -> EditPullRequestOption { editPullRequestOptionAssignee, ..} ) <$> f editPullRequestOptionAssignee
{-# INLINE editPullRequestOptionAssigneeL #-}

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

-- | 'editPullRequestOptionBase' Lens
editPullRequestOptionBaseL :: Lens_' EditPullRequestOption (Maybe Text)
editPullRequestOptionBaseL f EditPullRequestOption{..} = (\editPullRequestOptionBase -> EditPullRequestOption { editPullRequestOptionBase, ..} ) <$> f editPullRequestOptionBase
{-# INLINE editPullRequestOptionBaseL #-}

-- | 'editPullRequestOptionBody' Lens
editPullRequestOptionBodyL :: Lens_' EditPullRequestOption (Maybe Text)
editPullRequestOptionBodyL f EditPullRequestOption{..} = (\editPullRequestOptionBody -> EditPullRequestOption { editPullRequestOptionBody, ..} ) <$> f editPullRequestOptionBody
{-# INLINE editPullRequestOptionBodyL #-}

-- | 'editPullRequestOptionDueDate' Lens
editPullRequestOptionDueDateL :: Lens_' EditPullRequestOption (Maybe DateTime)
editPullRequestOptionDueDateL f EditPullRequestOption{..} = (\editPullRequestOptionDueDate -> EditPullRequestOption { editPullRequestOptionDueDate, ..} ) <$> f editPullRequestOptionDueDate
{-# INLINE editPullRequestOptionDueDateL #-}

-- | 'editPullRequestOptionLabels' Lens
editPullRequestOptionLabelsL :: Lens_' EditPullRequestOption (Maybe [Integer])
editPullRequestOptionLabelsL f EditPullRequestOption{..} = (\editPullRequestOptionLabels -> EditPullRequestOption { editPullRequestOptionLabels, ..} ) <$> f editPullRequestOptionLabels
{-# INLINE editPullRequestOptionLabelsL #-}

-- | 'editPullRequestOptionMilestone' Lens
editPullRequestOptionMilestoneL :: Lens_' EditPullRequestOption (Maybe Integer)
editPullRequestOptionMilestoneL f EditPullRequestOption{..} = (\editPullRequestOptionMilestone -> EditPullRequestOption { editPullRequestOptionMilestone, ..} ) <$> f editPullRequestOptionMilestone
{-# INLINE editPullRequestOptionMilestoneL #-}

-- | 'editPullRequestOptionState' Lens
editPullRequestOptionStateL :: Lens_' EditPullRequestOption (Maybe Text)
editPullRequestOptionStateL f EditPullRequestOption{..} = (\editPullRequestOptionState -> EditPullRequestOption { editPullRequestOptionState, ..} ) <$> f editPullRequestOptionState
{-# INLINE editPullRequestOptionStateL #-}

-- | 'editPullRequestOptionTitle' Lens
editPullRequestOptionTitleL :: Lens_' EditPullRequestOption (Maybe Text)
editPullRequestOptionTitleL f EditPullRequestOption{..} = (\editPullRequestOptionTitle -> EditPullRequestOption { editPullRequestOptionTitle, ..} ) <$> f editPullRequestOptionTitle
{-# INLINE editPullRequestOptionTitleL #-}

-- | 'editPullRequestOptionUnsetDueDate' Lens
editPullRequestOptionUnsetDueDateL :: Lens_' EditPullRequestOption (Maybe Bool)
editPullRequestOptionUnsetDueDateL f EditPullRequestOption{..} = (\editPullRequestOptionUnsetDueDate -> EditPullRequestOption { editPullRequestOptionUnsetDueDate, ..} ) <$> f editPullRequestOptionUnsetDueDate
{-# INLINE editPullRequestOptionUnsetDueDateL #-}



-- * EditReactionOption

-- | 'editReactionOptionContent' Lens
editReactionOptionContentL :: Lens_' EditReactionOption (Maybe Text)
editReactionOptionContentL f EditReactionOption{..} = (\editReactionOptionContent -> EditReactionOption { editReactionOptionContent, ..} ) <$> f editReactionOptionContent
{-# INLINE editReactionOptionContentL #-}



-- * EditReleaseOption

-- | 'editReleaseOptionBody' Lens
editReleaseOptionBodyL :: Lens_' EditReleaseOption (Maybe Text)
editReleaseOptionBodyL f EditReleaseOption{..} = (\editReleaseOptionBody -> EditReleaseOption { editReleaseOptionBody, ..} ) <$> f editReleaseOptionBody
{-# INLINE editReleaseOptionBodyL #-}

-- | 'editReleaseOptionDraft' Lens
editReleaseOptionDraftL :: Lens_' EditReleaseOption (Maybe Bool)
editReleaseOptionDraftL f EditReleaseOption{..} = (\editReleaseOptionDraft -> EditReleaseOption { editReleaseOptionDraft, ..} ) <$> f editReleaseOptionDraft
{-# INLINE editReleaseOptionDraftL #-}

-- | 'editReleaseOptionName' Lens
editReleaseOptionNameL :: Lens_' EditReleaseOption (Maybe Text)
editReleaseOptionNameL f EditReleaseOption{..} = (\editReleaseOptionName -> EditReleaseOption { editReleaseOptionName, ..} ) <$> f editReleaseOptionName
{-# INLINE editReleaseOptionNameL #-}

-- | 'editReleaseOptionPrerelease' Lens
editReleaseOptionPrereleaseL :: Lens_' EditReleaseOption (Maybe Bool)
editReleaseOptionPrereleaseL f EditReleaseOption{..} = (\editReleaseOptionPrerelease -> EditReleaseOption { editReleaseOptionPrerelease, ..} ) <$> f editReleaseOptionPrerelease
{-# INLINE editReleaseOptionPrereleaseL #-}

-- | 'editReleaseOptionTagName' Lens
editReleaseOptionTagNameL :: Lens_' EditReleaseOption (Maybe Text)
editReleaseOptionTagNameL f EditReleaseOption{..} = (\editReleaseOptionTagName -> EditReleaseOption { editReleaseOptionTagName, ..} ) <$> f editReleaseOptionTagName
{-# INLINE editReleaseOptionTagNameL #-}

-- | 'editReleaseOptionTargetCommitish' Lens
editReleaseOptionTargetCommitishL :: Lens_' EditReleaseOption (Maybe Text)
editReleaseOptionTargetCommitishL f EditReleaseOption{..} = (\editReleaseOptionTargetCommitish -> EditReleaseOption { editReleaseOptionTargetCommitish, ..} ) <$> f editReleaseOptionTargetCommitish
{-# INLINE editReleaseOptionTargetCommitishL #-}



-- * EditRepoOption

-- | 'editRepoOptionAllowManualMerge' Lens
editRepoOptionAllowManualMergeL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionAllowManualMergeL f EditRepoOption{..} = (\editRepoOptionAllowManualMerge -> EditRepoOption { editRepoOptionAllowManualMerge, ..} ) <$> f editRepoOptionAllowManualMerge
{-# INLINE editRepoOptionAllowManualMergeL #-}

-- | 'editRepoOptionAllowMergeCommits' Lens
editRepoOptionAllowMergeCommitsL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionAllowMergeCommitsL f EditRepoOption{..} = (\editRepoOptionAllowMergeCommits -> EditRepoOption { editRepoOptionAllowMergeCommits, ..} ) <$> f editRepoOptionAllowMergeCommits
{-# INLINE editRepoOptionAllowMergeCommitsL #-}

-- | 'editRepoOptionAllowRebase' Lens
editRepoOptionAllowRebaseL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionAllowRebaseL f EditRepoOption{..} = (\editRepoOptionAllowRebase -> EditRepoOption { editRepoOptionAllowRebase, ..} ) <$> f editRepoOptionAllowRebase
{-# INLINE editRepoOptionAllowRebaseL #-}

-- | 'editRepoOptionAllowRebaseExplicit' Lens
editRepoOptionAllowRebaseExplicitL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionAllowRebaseExplicitL f EditRepoOption{..} = (\editRepoOptionAllowRebaseExplicit -> EditRepoOption { editRepoOptionAllowRebaseExplicit, ..} ) <$> f editRepoOptionAllowRebaseExplicit
{-# INLINE editRepoOptionAllowRebaseExplicitL #-}

-- | 'editRepoOptionAllowRebaseUpdate' Lens
editRepoOptionAllowRebaseUpdateL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionAllowRebaseUpdateL f EditRepoOption{..} = (\editRepoOptionAllowRebaseUpdate -> EditRepoOption { editRepoOptionAllowRebaseUpdate, ..} ) <$> f editRepoOptionAllowRebaseUpdate
{-# INLINE editRepoOptionAllowRebaseUpdateL #-}

-- | 'editRepoOptionAllowSquashMerge' Lens
editRepoOptionAllowSquashMergeL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionAllowSquashMergeL f EditRepoOption{..} = (\editRepoOptionAllowSquashMerge -> EditRepoOption { editRepoOptionAllowSquashMerge, ..} ) <$> f editRepoOptionAllowSquashMerge
{-# INLINE editRepoOptionAllowSquashMergeL #-}

-- | 'editRepoOptionArchived' Lens
editRepoOptionArchivedL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionArchivedL f EditRepoOption{..} = (\editRepoOptionArchived -> EditRepoOption { editRepoOptionArchived, ..} ) <$> f editRepoOptionArchived
{-# INLINE editRepoOptionArchivedL #-}

-- | 'editRepoOptionAutodetectManualMerge' Lens
editRepoOptionAutodetectManualMergeL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionAutodetectManualMergeL f EditRepoOption{..} = (\editRepoOptionAutodetectManualMerge -> EditRepoOption { editRepoOptionAutodetectManualMerge, ..} ) <$> f editRepoOptionAutodetectManualMerge
{-# INLINE editRepoOptionAutodetectManualMergeL #-}

-- | 'editRepoOptionDefaultAllowMaintainerEdit' Lens
editRepoOptionDefaultAllowMaintainerEditL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionDefaultAllowMaintainerEditL f EditRepoOption{..} = (\editRepoOptionDefaultAllowMaintainerEdit -> EditRepoOption { editRepoOptionDefaultAllowMaintainerEdit, ..} ) <$> f editRepoOptionDefaultAllowMaintainerEdit
{-# INLINE editRepoOptionDefaultAllowMaintainerEditL #-}

-- | 'editRepoOptionDefaultBranch' Lens
editRepoOptionDefaultBranchL :: Lens_' EditRepoOption (Maybe Text)
editRepoOptionDefaultBranchL f EditRepoOption{..} = (\editRepoOptionDefaultBranch -> EditRepoOption { editRepoOptionDefaultBranch, ..} ) <$> f editRepoOptionDefaultBranch
{-# INLINE editRepoOptionDefaultBranchL #-}

-- | 'editRepoOptionDefaultDeleteBranchAfterMerge' Lens
editRepoOptionDefaultDeleteBranchAfterMergeL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionDefaultDeleteBranchAfterMergeL f EditRepoOption{..} = (\editRepoOptionDefaultDeleteBranchAfterMerge -> EditRepoOption { editRepoOptionDefaultDeleteBranchAfterMerge, ..} ) <$> f editRepoOptionDefaultDeleteBranchAfterMerge
{-# INLINE editRepoOptionDefaultDeleteBranchAfterMergeL #-}

-- | 'editRepoOptionDefaultMergeStyle' Lens
editRepoOptionDefaultMergeStyleL :: Lens_' EditRepoOption (Maybe Text)
editRepoOptionDefaultMergeStyleL f EditRepoOption{..} = (\editRepoOptionDefaultMergeStyle -> EditRepoOption { editRepoOptionDefaultMergeStyle, ..} ) <$> f editRepoOptionDefaultMergeStyle
{-# INLINE editRepoOptionDefaultMergeStyleL #-}

-- | 'editRepoOptionDescription' Lens
editRepoOptionDescriptionL :: Lens_' EditRepoOption (Maybe Text)
editRepoOptionDescriptionL f EditRepoOption{..} = (\editRepoOptionDescription -> EditRepoOption { editRepoOptionDescription, ..} ) <$> f editRepoOptionDescription
{-# INLINE editRepoOptionDescriptionL #-}

-- | 'editRepoOptionEnablePrune' Lens
editRepoOptionEnablePruneL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionEnablePruneL f EditRepoOption{..} = (\editRepoOptionEnablePrune -> EditRepoOption { editRepoOptionEnablePrune, ..} ) <$> f editRepoOptionEnablePrune
{-# INLINE editRepoOptionEnablePruneL #-}

-- | 'editRepoOptionExternalTracker' Lens
editRepoOptionExternalTrackerL :: Lens_' EditRepoOption (Maybe ExternalTracker)
editRepoOptionExternalTrackerL f EditRepoOption{..} = (\editRepoOptionExternalTracker -> EditRepoOption { editRepoOptionExternalTracker, ..} ) <$> f editRepoOptionExternalTracker
{-# INLINE editRepoOptionExternalTrackerL #-}

-- | 'editRepoOptionExternalWiki' Lens
editRepoOptionExternalWikiL :: Lens_' EditRepoOption (Maybe ExternalWiki)
editRepoOptionExternalWikiL f EditRepoOption{..} = (\editRepoOptionExternalWiki -> EditRepoOption { editRepoOptionExternalWiki, ..} ) <$> f editRepoOptionExternalWiki
{-# INLINE editRepoOptionExternalWikiL #-}

-- | 'editRepoOptionHasActions' Lens
editRepoOptionHasActionsL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionHasActionsL f EditRepoOption{..} = (\editRepoOptionHasActions -> EditRepoOption { editRepoOptionHasActions, ..} ) <$> f editRepoOptionHasActions
{-# INLINE editRepoOptionHasActionsL #-}

-- | 'editRepoOptionHasIssues' Lens
editRepoOptionHasIssuesL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionHasIssuesL f EditRepoOption{..} = (\editRepoOptionHasIssues -> EditRepoOption { editRepoOptionHasIssues, ..} ) <$> f editRepoOptionHasIssues
{-# INLINE editRepoOptionHasIssuesL #-}

-- | 'editRepoOptionHasPackages' Lens
editRepoOptionHasPackagesL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionHasPackagesL f EditRepoOption{..} = (\editRepoOptionHasPackages -> EditRepoOption { editRepoOptionHasPackages, ..} ) <$> f editRepoOptionHasPackages
{-# INLINE editRepoOptionHasPackagesL #-}

-- | 'editRepoOptionHasProjects' Lens
editRepoOptionHasProjectsL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionHasProjectsL f EditRepoOption{..} = (\editRepoOptionHasProjects -> EditRepoOption { editRepoOptionHasProjects, ..} ) <$> f editRepoOptionHasProjects
{-# INLINE editRepoOptionHasProjectsL #-}

-- | 'editRepoOptionHasPullRequests' Lens
editRepoOptionHasPullRequestsL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionHasPullRequestsL f EditRepoOption{..} = (\editRepoOptionHasPullRequests -> EditRepoOption { editRepoOptionHasPullRequests, ..} ) <$> f editRepoOptionHasPullRequests
{-# INLINE editRepoOptionHasPullRequestsL #-}

-- | 'editRepoOptionHasReleases' Lens
editRepoOptionHasReleasesL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionHasReleasesL f EditRepoOption{..} = (\editRepoOptionHasReleases -> EditRepoOption { editRepoOptionHasReleases, ..} ) <$> f editRepoOptionHasReleases
{-# INLINE editRepoOptionHasReleasesL #-}

-- | 'editRepoOptionHasWiki' Lens
editRepoOptionHasWikiL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionHasWikiL f EditRepoOption{..} = (\editRepoOptionHasWiki -> EditRepoOption { editRepoOptionHasWiki, ..} ) <$> f editRepoOptionHasWiki
{-# INLINE editRepoOptionHasWikiL #-}

-- | 'editRepoOptionIgnoreWhitespaceConflicts' Lens
editRepoOptionIgnoreWhitespaceConflictsL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionIgnoreWhitespaceConflictsL f EditRepoOption{..} = (\editRepoOptionIgnoreWhitespaceConflicts -> EditRepoOption { editRepoOptionIgnoreWhitespaceConflicts, ..} ) <$> f editRepoOptionIgnoreWhitespaceConflicts
{-# INLINE editRepoOptionIgnoreWhitespaceConflictsL #-}

-- | 'editRepoOptionInternalTracker' Lens
editRepoOptionInternalTrackerL :: Lens_' EditRepoOption (Maybe InternalTracker)
editRepoOptionInternalTrackerL f EditRepoOption{..} = (\editRepoOptionInternalTracker -> EditRepoOption { editRepoOptionInternalTracker, ..} ) <$> f editRepoOptionInternalTracker
{-# INLINE editRepoOptionInternalTrackerL #-}

-- | 'editRepoOptionMirrorInterval' Lens
editRepoOptionMirrorIntervalL :: Lens_' EditRepoOption (Maybe Text)
editRepoOptionMirrorIntervalL f EditRepoOption{..} = (\editRepoOptionMirrorInterval -> EditRepoOption { editRepoOptionMirrorInterval, ..} ) <$> f editRepoOptionMirrorInterval
{-# INLINE editRepoOptionMirrorIntervalL #-}

-- | 'editRepoOptionName' Lens
editRepoOptionNameL :: Lens_' EditRepoOption (Maybe Text)
editRepoOptionNameL f EditRepoOption{..} = (\editRepoOptionName -> EditRepoOption { editRepoOptionName, ..} ) <$> f editRepoOptionName
{-# INLINE editRepoOptionNameL #-}

-- | 'editRepoOptionPrivate' Lens
editRepoOptionPrivateL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionPrivateL f EditRepoOption{..} = (\editRepoOptionPrivate -> EditRepoOption { editRepoOptionPrivate, ..} ) <$> f editRepoOptionPrivate
{-# INLINE editRepoOptionPrivateL #-}

-- | 'editRepoOptionTemplate' Lens
editRepoOptionTemplateL :: Lens_' EditRepoOption (Maybe Bool)
editRepoOptionTemplateL f EditRepoOption{..} = (\editRepoOptionTemplate -> EditRepoOption { editRepoOptionTemplate, ..} ) <$> f editRepoOptionTemplate
{-# INLINE editRepoOptionTemplateL #-}

-- | 'editRepoOptionWebsite' Lens
editRepoOptionWebsiteL :: Lens_' EditRepoOption (Maybe Text)
editRepoOptionWebsiteL f EditRepoOption{..} = (\editRepoOptionWebsite -> EditRepoOption { editRepoOptionWebsite, ..} ) <$> f editRepoOptionWebsite
{-# INLINE editRepoOptionWebsiteL #-}



-- * EditTeamOption

-- | 'editTeamOptionCanCreateOrgRepo' Lens
editTeamOptionCanCreateOrgRepoL :: Lens_' EditTeamOption (Maybe Bool)
editTeamOptionCanCreateOrgRepoL f EditTeamOption{..} = (\editTeamOptionCanCreateOrgRepo -> EditTeamOption { editTeamOptionCanCreateOrgRepo, ..} ) <$> f editTeamOptionCanCreateOrgRepo
{-# INLINE editTeamOptionCanCreateOrgRepoL #-}

-- | 'editTeamOptionDescription' Lens
editTeamOptionDescriptionL :: Lens_' EditTeamOption (Maybe Text)
editTeamOptionDescriptionL f EditTeamOption{..} = (\editTeamOptionDescription -> EditTeamOption { editTeamOptionDescription, ..} ) <$> f editTeamOptionDescription
{-# INLINE editTeamOptionDescriptionL #-}

-- | 'editTeamOptionIncludesAllRepositories' Lens
editTeamOptionIncludesAllRepositoriesL :: Lens_' EditTeamOption (Maybe Bool)
editTeamOptionIncludesAllRepositoriesL f EditTeamOption{..} = (\editTeamOptionIncludesAllRepositories -> EditTeamOption { editTeamOptionIncludesAllRepositories, ..} ) <$> f editTeamOptionIncludesAllRepositories
{-# INLINE editTeamOptionIncludesAllRepositoriesL #-}

-- | 'editTeamOptionName' Lens
editTeamOptionNameL :: Lens_' EditTeamOption (Text)
editTeamOptionNameL f EditTeamOption{..} = (\editTeamOptionName -> EditTeamOption { editTeamOptionName, ..} ) <$> f editTeamOptionName
{-# INLINE editTeamOptionNameL #-}

-- | 'editTeamOptionPermission' Lens
editTeamOptionPermissionL :: Lens_' EditTeamOption (Maybe E'Permission)
editTeamOptionPermissionL f EditTeamOption{..} = (\editTeamOptionPermission -> EditTeamOption { editTeamOptionPermission, ..} ) <$> f editTeamOptionPermission
{-# INLINE editTeamOptionPermissionL #-}

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

-- | 'editTeamOptionUnitsMap' Lens
editTeamOptionUnitsMapL :: Lens_' EditTeamOption (Maybe (Map.Map String Text))
editTeamOptionUnitsMapL f EditTeamOption{..} = (\editTeamOptionUnitsMap -> EditTeamOption { editTeamOptionUnitsMap, ..} ) <$> f editTeamOptionUnitsMap
{-# INLINE editTeamOptionUnitsMapL #-}



-- * EditUserOption

-- | 'editUserOptionActive' Lens
editUserOptionActiveL :: Lens_' EditUserOption (Maybe Bool)
editUserOptionActiveL f EditUserOption{..} = (\editUserOptionActive -> EditUserOption { editUserOptionActive, ..} ) <$> f editUserOptionActive
{-# INLINE editUserOptionActiveL #-}

-- | 'editUserOptionAdmin' Lens
editUserOptionAdminL :: Lens_' EditUserOption (Maybe Bool)
editUserOptionAdminL f EditUserOption{..} = (\editUserOptionAdmin -> EditUserOption { editUserOptionAdmin, ..} ) <$> f editUserOptionAdmin
{-# INLINE editUserOptionAdminL #-}

-- | 'editUserOptionAllowCreateOrganization' Lens
editUserOptionAllowCreateOrganizationL :: Lens_' EditUserOption (Maybe Bool)
editUserOptionAllowCreateOrganizationL f EditUserOption{..} = (\editUserOptionAllowCreateOrganization -> EditUserOption { editUserOptionAllowCreateOrganization, ..} ) <$> f editUserOptionAllowCreateOrganization
{-# INLINE editUserOptionAllowCreateOrganizationL #-}

-- | 'editUserOptionAllowGitHook' Lens
editUserOptionAllowGitHookL :: Lens_' EditUserOption (Maybe Bool)
editUserOptionAllowGitHookL f EditUserOption{..} = (\editUserOptionAllowGitHook -> EditUserOption { editUserOptionAllowGitHook, ..} ) <$> f editUserOptionAllowGitHook
{-# INLINE editUserOptionAllowGitHookL #-}

-- | 'editUserOptionAllowImportLocal' Lens
editUserOptionAllowImportLocalL :: Lens_' EditUserOption (Maybe Bool)
editUserOptionAllowImportLocalL f EditUserOption{..} = (\editUserOptionAllowImportLocal -> EditUserOption { editUserOptionAllowImportLocal, ..} ) <$> f editUserOptionAllowImportLocal
{-# INLINE editUserOptionAllowImportLocalL #-}

-- | 'editUserOptionDescription' Lens
editUserOptionDescriptionL :: Lens_' EditUserOption (Maybe Text)
editUserOptionDescriptionL f EditUserOption{..} = (\editUserOptionDescription -> EditUserOption { editUserOptionDescription, ..} ) <$> f editUserOptionDescription
{-# INLINE editUserOptionDescriptionL #-}

-- | 'editUserOptionEmail' Lens
editUserOptionEmailL :: Lens_' EditUserOption (Maybe Text)
editUserOptionEmailL f EditUserOption{..} = (\editUserOptionEmail -> EditUserOption { editUserOptionEmail, ..} ) <$> f editUserOptionEmail
{-# INLINE editUserOptionEmailL #-}

-- | 'editUserOptionFullName' Lens
editUserOptionFullNameL :: Lens_' EditUserOption (Maybe Text)
editUserOptionFullNameL f EditUserOption{..} = (\editUserOptionFullName -> EditUserOption { editUserOptionFullName, ..} ) <$> f editUserOptionFullName
{-# INLINE editUserOptionFullNameL #-}

-- | 'editUserOptionLocation' Lens
editUserOptionLocationL :: Lens_' EditUserOption (Maybe Text)
editUserOptionLocationL f EditUserOption{..} = (\editUserOptionLocation -> EditUserOption { editUserOptionLocation, ..} ) <$> f editUserOptionLocation
{-# INLINE editUserOptionLocationL #-}

-- | 'editUserOptionLoginName' Lens
editUserOptionLoginNameL :: Lens_' EditUserOption (Text)
editUserOptionLoginNameL f EditUserOption{..} = (\editUserOptionLoginName -> EditUserOption { editUserOptionLoginName, ..} ) <$> f editUserOptionLoginName
{-# INLINE editUserOptionLoginNameL #-}

-- | 'editUserOptionMaxRepoCreation' Lens
editUserOptionMaxRepoCreationL :: Lens_' EditUserOption (Maybe Integer)
editUserOptionMaxRepoCreationL f EditUserOption{..} = (\editUserOptionMaxRepoCreation -> EditUserOption { editUserOptionMaxRepoCreation, ..} ) <$> f editUserOptionMaxRepoCreation
{-# INLINE editUserOptionMaxRepoCreationL #-}

-- | 'editUserOptionMustChangePassword' Lens
editUserOptionMustChangePasswordL :: Lens_' EditUserOption (Maybe Bool)
editUserOptionMustChangePasswordL f EditUserOption{..} = (\editUserOptionMustChangePassword -> EditUserOption { editUserOptionMustChangePassword, ..} ) <$> f editUserOptionMustChangePassword
{-# INLINE editUserOptionMustChangePasswordL #-}

-- | 'editUserOptionPassword' Lens
editUserOptionPasswordL :: Lens_' EditUserOption (Maybe Text)
editUserOptionPasswordL f EditUserOption{..} = (\editUserOptionPassword -> EditUserOption { editUserOptionPassword, ..} ) <$> f editUserOptionPassword
{-# INLINE editUserOptionPasswordL #-}

-- | 'editUserOptionProhibitLogin' Lens
editUserOptionProhibitLoginL :: Lens_' EditUserOption (Maybe Bool)
editUserOptionProhibitLoginL f EditUserOption{..} = (\editUserOptionProhibitLogin -> EditUserOption { editUserOptionProhibitLogin, ..} ) <$> f editUserOptionProhibitLogin
{-# INLINE editUserOptionProhibitLoginL #-}

-- | 'editUserOptionRestricted' Lens
editUserOptionRestrictedL :: Lens_' EditUserOption (Maybe Bool)
editUserOptionRestrictedL f EditUserOption{..} = (\editUserOptionRestricted -> EditUserOption { editUserOptionRestricted, ..} ) <$> f editUserOptionRestricted
{-# INLINE editUserOptionRestrictedL #-}

-- | 'editUserOptionSourceId' Lens
editUserOptionSourceIdL :: Lens_' EditUserOption (Integer)
editUserOptionSourceIdL f EditUserOption{..} = (\editUserOptionSourceId -> EditUserOption { editUserOptionSourceId, ..} ) <$> f editUserOptionSourceId
{-# INLINE editUserOptionSourceIdL #-}

-- | 'editUserOptionVisibility' Lens
editUserOptionVisibilityL :: Lens_' EditUserOption (Maybe Text)
editUserOptionVisibilityL f EditUserOption{..} = (\editUserOptionVisibility -> EditUserOption { editUserOptionVisibility, ..} ) <$> f editUserOptionVisibility
{-# INLINE editUserOptionVisibilityL #-}

-- | 'editUserOptionWebsite' Lens
editUserOptionWebsiteL :: Lens_' EditUserOption (Maybe Text)
editUserOptionWebsiteL f EditUserOption{..} = (\editUserOptionWebsite -> EditUserOption { editUserOptionWebsite, ..} ) <$> f editUserOptionWebsite
{-# INLINE editUserOptionWebsiteL #-}



-- * Email

-- | 'emailEmail' Lens
emailEmailL :: Lens_' Email (Maybe Text)
emailEmailL f Email{..} = (\emailEmail -> Email { emailEmail, ..} ) <$> f emailEmail
{-# INLINE emailEmailL #-}

-- | 'emailPrimary' Lens
emailPrimaryL :: Lens_' Email (Maybe Bool)
emailPrimaryL f Email{..} = (\emailPrimary -> Email { emailPrimary, ..} ) <$> f emailPrimary
{-# INLINE emailPrimaryL #-}

-- | 'emailUserId' Lens
emailUserIdL :: Lens_' Email (Maybe Integer)
emailUserIdL f Email{..} = (\emailUserId -> Email { emailUserId, ..} ) <$> f emailUserId
{-# INLINE emailUserIdL #-}

-- | 'emailUsername' Lens
emailUsernameL :: Lens_' Email (Maybe Text)
emailUsernameL f Email{..} = (\emailUsername -> Email { emailUsername, ..} ) <$> f emailUsername
{-# INLINE emailUsernameL #-}

-- | 'emailVerified' Lens
emailVerifiedL :: Lens_' Email (Maybe Bool)
emailVerifiedL f Email{..} = (\emailVerified -> Email { emailVerified, ..} ) <$> f emailVerified
{-# INLINE emailVerifiedL #-}



-- * ExternalTracker

-- | 'externalTrackerExternalTrackerFormat' Lens
externalTrackerExternalTrackerFormatL :: Lens_' ExternalTracker (Maybe Text)
externalTrackerExternalTrackerFormatL f ExternalTracker{..} = (\externalTrackerExternalTrackerFormat -> ExternalTracker { externalTrackerExternalTrackerFormat, ..} ) <$> f externalTrackerExternalTrackerFormat
{-# INLINE externalTrackerExternalTrackerFormatL #-}

-- | 'externalTrackerExternalTrackerRegexpPattern' Lens
externalTrackerExternalTrackerRegexpPatternL :: Lens_' ExternalTracker (Maybe Text)
externalTrackerExternalTrackerRegexpPatternL f ExternalTracker{..} = (\externalTrackerExternalTrackerRegexpPattern -> ExternalTracker { externalTrackerExternalTrackerRegexpPattern, ..} ) <$> f externalTrackerExternalTrackerRegexpPattern
{-# INLINE externalTrackerExternalTrackerRegexpPatternL #-}

-- | 'externalTrackerExternalTrackerStyle' Lens
externalTrackerExternalTrackerStyleL :: Lens_' ExternalTracker (Maybe Text)
externalTrackerExternalTrackerStyleL f ExternalTracker{..} = (\externalTrackerExternalTrackerStyle -> ExternalTracker { externalTrackerExternalTrackerStyle, ..} ) <$> f externalTrackerExternalTrackerStyle
{-# INLINE externalTrackerExternalTrackerStyleL #-}

-- | 'externalTrackerExternalTrackerUrl' Lens
externalTrackerExternalTrackerUrlL :: Lens_' ExternalTracker (Maybe Text)
externalTrackerExternalTrackerUrlL f ExternalTracker{..} = (\externalTrackerExternalTrackerUrl -> ExternalTracker { externalTrackerExternalTrackerUrl, ..} ) <$> f externalTrackerExternalTrackerUrl
{-# INLINE externalTrackerExternalTrackerUrlL #-}



-- * ExternalWiki

-- | 'externalWikiExternalWikiUrl' Lens
externalWikiExternalWikiUrlL :: Lens_' ExternalWiki (Maybe Text)
externalWikiExternalWikiUrlL f ExternalWiki{..} = (\externalWikiExternalWikiUrl -> ExternalWiki { externalWikiExternalWikiUrl, ..} ) <$> f externalWikiExternalWikiUrl
{-# INLINE externalWikiExternalWikiUrlL #-}



-- * FileCommitResponse

-- | 'fileCommitResponseAuthor' Lens
fileCommitResponseAuthorL :: Lens_' FileCommitResponse (Maybe CommitUser)
fileCommitResponseAuthorL f FileCommitResponse{..} = (\fileCommitResponseAuthor -> FileCommitResponse { fileCommitResponseAuthor, ..} ) <$> f fileCommitResponseAuthor
{-# INLINE fileCommitResponseAuthorL #-}

-- | 'fileCommitResponseCommitter' Lens
fileCommitResponseCommitterL :: Lens_' FileCommitResponse (Maybe CommitUser)
fileCommitResponseCommitterL f FileCommitResponse{..} = (\fileCommitResponseCommitter -> FileCommitResponse { fileCommitResponseCommitter, ..} ) <$> f fileCommitResponseCommitter
{-# INLINE fileCommitResponseCommitterL #-}

-- | 'fileCommitResponseCreated' Lens
fileCommitResponseCreatedL :: Lens_' FileCommitResponse (Maybe DateTime)
fileCommitResponseCreatedL f FileCommitResponse{..} = (\fileCommitResponseCreated -> FileCommitResponse { fileCommitResponseCreated, ..} ) <$> f fileCommitResponseCreated
{-# INLINE fileCommitResponseCreatedL #-}

-- | 'fileCommitResponseHtmlUrl' Lens
fileCommitResponseHtmlUrlL :: Lens_' FileCommitResponse (Maybe Text)
fileCommitResponseHtmlUrlL f FileCommitResponse{..} = (\fileCommitResponseHtmlUrl -> FileCommitResponse { fileCommitResponseHtmlUrl, ..} ) <$> f fileCommitResponseHtmlUrl
{-# INLINE fileCommitResponseHtmlUrlL #-}

-- | 'fileCommitResponseMessage' Lens
fileCommitResponseMessageL :: Lens_' FileCommitResponse (Maybe Text)
fileCommitResponseMessageL f FileCommitResponse{..} = (\fileCommitResponseMessage -> FileCommitResponse { fileCommitResponseMessage, ..} ) <$> f fileCommitResponseMessage
{-# INLINE fileCommitResponseMessageL #-}

-- | 'fileCommitResponseParents' Lens
fileCommitResponseParentsL :: Lens_' FileCommitResponse (Maybe [CommitMeta])
fileCommitResponseParentsL f FileCommitResponse{..} = (\fileCommitResponseParents -> FileCommitResponse { fileCommitResponseParents, ..} ) <$> f fileCommitResponseParents
{-# INLINE fileCommitResponseParentsL #-}

-- | 'fileCommitResponseSha' Lens
fileCommitResponseShaL :: Lens_' FileCommitResponse (Maybe Text)
fileCommitResponseShaL f FileCommitResponse{..} = (\fileCommitResponseSha -> FileCommitResponse { fileCommitResponseSha, ..} ) <$> f fileCommitResponseSha
{-# INLINE fileCommitResponseShaL #-}

-- | 'fileCommitResponseTree' Lens
fileCommitResponseTreeL :: Lens_' FileCommitResponse (Maybe CommitMeta)
fileCommitResponseTreeL f FileCommitResponse{..} = (\fileCommitResponseTree -> FileCommitResponse { fileCommitResponseTree, ..} ) <$> f fileCommitResponseTree
{-# INLINE fileCommitResponseTreeL #-}

-- | 'fileCommitResponseUrl' Lens
fileCommitResponseUrlL :: Lens_' FileCommitResponse (Maybe Text)
fileCommitResponseUrlL f FileCommitResponse{..} = (\fileCommitResponseUrl -> FileCommitResponse { fileCommitResponseUrl, ..} ) <$> f fileCommitResponseUrl
{-# INLINE fileCommitResponseUrlL #-}



-- * FileDeleteResponse

-- | 'fileDeleteResponseCommit' Lens
fileDeleteResponseCommitL :: Lens_' FileDeleteResponse (Maybe FileCommitResponse)
fileDeleteResponseCommitL f FileDeleteResponse{..} = (\fileDeleteResponseCommit -> FileDeleteResponse { fileDeleteResponseCommit, ..} ) <$> f fileDeleteResponseCommit
{-# INLINE fileDeleteResponseCommitL #-}

-- | 'fileDeleteResponseContent' Lens
fileDeleteResponseContentL :: Lens_' FileDeleteResponse (Maybe A.Value)
fileDeleteResponseContentL f FileDeleteResponse{..} = (\fileDeleteResponseContent -> FileDeleteResponse { fileDeleteResponseContent, ..} ) <$> f fileDeleteResponseContent
{-# INLINE fileDeleteResponseContentL #-}

-- | 'fileDeleteResponseVerification' Lens
fileDeleteResponseVerificationL :: Lens_' FileDeleteResponse (Maybe PayloadCommitVerification)
fileDeleteResponseVerificationL f FileDeleteResponse{..} = (\fileDeleteResponseVerification -> FileDeleteResponse { fileDeleteResponseVerification, ..} ) <$> f fileDeleteResponseVerification
{-# INLINE fileDeleteResponseVerificationL #-}



-- * FileLinksResponse

-- | 'fileLinksResponseGit' Lens
fileLinksResponseGitL :: Lens_' FileLinksResponse (Maybe Text)
fileLinksResponseGitL f FileLinksResponse{..} = (\fileLinksResponseGit -> FileLinksResponse { fileLinksResponseGit, ..} ) <$> f fileLinksResponseGit
{-# INLINE fileLinksResponseGitL #-}

-- | 'fileLinksResponseHtml' Lens
fileLinksResponseHtmlL :: Lens_' FileLinksResponse (Maybe Text)
fileLinksResponseHtmlL f FileLinksResponse{..} = (\fileLinksResponseHtml -> FileLinksResponse { fileLinksResponseHtml, ..} ) <$> f fileLinksResponseHtml
{-# INLINE fileLinksResponseHtmlL #-}

-- | 'fileLinksResponseSelf' Lens
fileLinksResponseSelfL :: Lens_' FileLinksResponse (Maybe Text)
fileLinksResponseSelfL f FileLinksResponse{..} = (\fileLinksResponseSelf -> FileLinksResponse { fileLinksResponseSelf, ..} ) <$> f fileLinksResponseSelf
{-# INLINE fileLinksResponseSelfL #-}



-- * FileResponse

-- | 'fileResponseCommit' Lens
fileResponseCommitL :: Lens_' FileResponse (Maybe FileCommitResponse)
fileResponseCommitL f FileResponse{..} = (\fileResponseCommit -> FileResponse { fileResponseCommit, ..} ) <$> f fileResponseCommit
{-# INLINE fileResponseCommitL #-}

-- | 'fileResponseContent' Lens
fileResponseContentL :: Lens_' FileResponse (Maybe ContentsResponse)
fileResponseContentL f FileResponse{..} = (\fileResponseContent -> FileResponse { fileResponseContent, ..} ) <$> f fileResponseContent
{-# INLINE fileResponseContentL #-}

-- | 'fileResponseVerification' Lens
fileResponseVerificationL :: Lens_' FileResponse (Maybe PayloadCommitVerification)
fileResponseVerificationL f FileResponse{..} = (\fileResponseVerification -> FileResponse { fileResponseVerification, ..} ) <$> f fileResponseVerification
{-# INLINE fileResponseVerificationL #-}



-- * FilesResponse

-- | 'filesResponseCommit' Lens
filesResponseCommitL :: Lens_' FilesResponse (Maybe FileCommitResponse)
filesResponseCommitL f FilesResponse{..} = (\filesResponseCommit -> FilesResponse { filesResponseCommit, ..} ) <$> f filesResponseCommit
{-# INLINE filesResponseCommitL #-}

-- | 'filesResponseFiles' Lens
filesResponseFilesL :: Lens_' FilesResponse (Maybe [ContentsResponse])
filesResponseFilesL f FilesResponse{..} = (\filesResponseFiles -> FilesResponse { filesResponseFiles, ..} ) <$> f filesResponseFiles
{-# INLINE filesResponseFilesL #-}

-- | 'filesResponseVerification' Lens
filesResponseVerificationL :: Lens_' FilesResponse (Maybe PayloadCommitVerification)
filesResponseVerificationL f FilesResponse{..} = (\filesResponseVerification -> FilesResponse { filesResponseVerification, ..} ) <$> f filesResponseVerification
{-# INLINE filesResponseVerificationL #-}



-- * GPGKey

-- | 'gPGKeyCanCertify' Lens
gPGKeyCanCertifyL :: Lens_' GPGKey (Maybe Bool)
gPGKeyCanCertifyL f GPGKey{..} = (\gPGKeyCanCertify -> GPGKey { gPGKeyCanCertify, ..} ) <$> f gPGKeyCanCertify
{-# INLINE gPGKeyCanCertifyL #-}

-- | 'gPGKeyCanEncryptComms' Lens
gPGKeyCanEncryptCommsL :: Lens_' GPGKey (Maybe Bool)
gPGKeyCanEncryptCommsL f GPGKey{..} = (\gPGKeyCanEncryptComms -> GPGKey { gPGKeyCanEncryptComms, ..} ) <$> f gPGKeyCanEncryptComms
{-# INLINE gPGKeyCanEncryptCommsL #-}

-- | 'gPGKeyCanEncryptStorage' Lens
gPGKeyCanEncryptStorageL :: Lens_' GPGKey (Maybe Bool)
gPGKeyCanEncryptStorageL f GPGKey{..} = (\gPGKeyCanEncryptStorage -> GPGKey { gPGKeyCanEncryptStorage, ..} ) <$> f gPGKeyCanEncryptStorage
{-# INLINE gPGKeyCanEncryptStorageL #-}

-- | 'gPGKeyCanSign' Lens
gPGKeyCanSignL :: Lens_' GPGKey (Maybe Bool)
gPGKeyCanSignL f GPGKey{..} = (\gPGKeyCanSign -> GPGKey { gPGKeyCanSign, ..} ) <$> f gPGKeyCanSign
{-# INLINE gPGKeyCanSignL #-}

-- | 'gPGKeyCreatedAt' Lens
gPGKeyCreatedAtL :: Lens_' GPGKey (Maybe DateTime)
gPGKeyCreatedAtL f GPGKey{..} = (\gPGKeyCreatedAt -> GPGKey { gPGKeyCreatedAt, ..} ) <$> f gPGKeyCreatedAt
{-# INLINE gPGKeyCreatedAtL #-}

-- | 'gPGKeyEmails' Lens
gPGKeyEmailsL :: Lens_' GPGKey (Maybe [GPGKeyEmail])
gPGKeyEmailsL f GPGKey{..} = (\gPGKeyEmails -> GPGKey { gPGKeyEmails, ..} ) <$> f gPGKeyEmails
{-# INLINE gPGKeyEmailsL #-}

-- | 'gPGKeyExpiresAt' Lens
gPGKeyExpiresAtL :: Lens_' GPGKey (Maybe DateTime)
gPGKeyExpiresAtL f GPGKey{..} = (\gPGKeyExpiresAt -> GPGKey { gPGKeyExpiresAt, ..} ) <$> f gPGKeyExpiresAt
{-# INLINE gPGKeyExpiresAtL #-}

-- | 'gPGKeyId' Lens
gPGKeyIdL :: Lens_' GPGKey (Maybe Integer)
gPGKeyIdL f GPGKey{..} = (\gPGKeyId -> GPGKey { gPGKeyId, ..} ) <$> f gPGKeyId
{-# INLINE gPGKeyIdL #-}

-- | 'gPGKeyKeyId' Lens
gPGKeyKeyIdL :: Lens_' GPGKey (Maybe Text)
gPGKeyKeyIdL f GPGKey{..} = (\gPGKeyKeyId -> GPGKey { gPGKeyKeyId, ..} ) <$> f gPGKeyKeyId
{-# INLINE gPGKeyKeyIdL #-}

-- | 'gPGKeyPrimaryKeyId' Lens
gPGKeyPrimaryKeyIdL :: Lens_' GPGKey (Maybe Text)
gPGKeyPrimaryKeyIdL f GPGKey{..} = (\gPGKeyPrimaryKeyId -> GPGKey { gPGKeyPrimaryKeyId, ..} ) <$> f gPGKeyPrimaryKeyId
{-# INLINE gPGKeyPrimaryKeyIdL #-}

-- | 'gPGKeyPublicKey' Lens
gPGKeyPublicKeyL :: Lens_' GPGKey (Maybe Text)
gPGKeyPublicKeyL f GPGKey{..} = (\gPGKeyPublicKey -> GPGKey { gPGKeyPublicKey, ..} ) <$> f gPGKeyPublicKey
{-# INLINE gPGKeyPublicKeyL #-}

-- | 'gPGKeySubkeys' Lens
gPGKeySubkeysL :: Lens_' GPGKey (Maybe [GPGKey])
gPGKeySubkeysL f GPGKey{..} = (\gPGKeySubkeys -> GPGKey { gPGKeySubkeys, ..} ) <$> f gPGKeySubkeys
{-# INLINE gPGKeySubkeysL #-}

-- | 'gPGKeyVerified' Lens
gPGKeyVerifiedL :: Lens_' GPGKey (Maybe Bool)
gPGKeyVerifiedL f GPGKey{..} = (\gPGKeyVerified -> GPGKey { gPGKeyVerified, ..} ) <$> f gPGKeyVerified
{-# INLINE gPGKeyVerifiedL #-}



-- * GPGKeyEmail

-- | 'gPGKeyEmailEmail' Lens
gPGKeyEmailEmailL :: Lens_' GPGKeyEmail (Maybe Text)
gPGKeyEmailEmailL f GPGKeyEmail{..} = (\gPGKeyEmailEmail -> GPGKeyEmail { gPGKeyEmailEmail, ..} ) <$> f gPGKeyEmailEmail
{-# INLINE gPGKeyEmailEmailL #-}

-- | 'gPGKeyEmailVerified' Lens
gPGKeyEmailVerifiedL :: Lens_' GPGKeyEmail (Maybe Bool)
gPGKeyEmailVerifiedL f GPGKeyEmail{..} = (\gPGKeyEmailVerified -> GPGKeyEmail { gPGKeyEmailVerified, ..} ) <$> f gPGKeyEmailVerified
{-# INLINE gPGKeyEmailVerifiedL #-}



-- * GeneralAPISettings

-- | 'generalAPISettingsDefaultGitTreesPerPage' Lens
generalAPISettingsDefaultGitTreesPerPageL :: Lens_' GeneralAPISettings (Maybe Integer)
generalAPISettingsDefaultGitTreesPerPageL f GeneralAPISettings{..} = (\generalAPISettingsDefaultGitTreesPerPage -> GeneralAPISettings { generalAPISettingsDefaultGitTreesPerPage, ..} ) <$> f generalAPISettingsDefaultGitTreesPerPage
{-# INLINE generalAPISettingsDefaultGitTreesPerPageL #-}

-- | 'generalAPISettingsDefaultMaxBlobSize' Lens
generalAPISettingsDefaultMaxBlobSizeL :: Lens_' GeneralAPISettings (Maybe Integer)
generalAPISettingsDefaultMaxBlobSizeL f GeneralAPISettings{..} = (\generalAPISettingsDefaultMaxBlobSize -> GeneralAPISettings { generalAPISettingsDefaultMaxBlobSize, ..} ) <$> f generalAPISettingsDefaultMaxBlobSize
{-# INLINE generalAPISettingsDefaultMaxBlobSizeL #-}

-- | 'generalAPISettingsDefaultPagingNum' Lens
generalAPISettingsDefaultPagingNumL :: Lens_' GeneralAPISettings (Maybe Integer)
generalAPISettingsDefaultPagingNumL f GeneralAPISettings{..} = (\generalAPISettingsDefaultPagingNum -> GeneralAPISettings { generalAPISettingsDefaultPagingNum, ..} ) <$> f generalAPISettingsDefaultPagingNum
{-# INLINE generalAPISettingsDefaultPagingNumL #-}

-- | 'generalAPISettingsMaxResponseItems' Lens
generalAPISettingsMaxResponseItemsL :: Lens_' GeneralAPISettings (Maybe Integer)
generalAPISettingsMaxResponseItemsL f GeneralAPISettings{..} = (\generalAPISettingsMaxResponseItems -> GeneralAPISettings { generalAPISettingsMaxResponseItems, ..} ) <$> f generalAPISettingsMaxResponseItems
{-# INLINE generalAPISettingsMaxResponseItemsL #-}



-- * GeneralAttachmentSettings

-- | 'generalAttachmentSettingsAllowedTypes' Lens
generalAttachmentSettingsAllowedTypesL :: Lens_' GeneralAttachmentSettings (Maybe Text)
generalAttachmentSettingsAllowedTypesL f GeneralAttachmentSettings{..} = (\generalAttachmentSettingsAllowedTypes -> GeneralAttachmentSettings { generalAttachmentSettingsAllowedTypes, ..} ) <$> f generalAttachmentSettingsAllowedTypes
{-# INLINE generalAttachmentSettingsAllowedTypesL #-}

-- | 'generalAttachmentSettingsEnabled' Lens
generalAttachmentSettingsEnabledL :: Lens_' GeneralAttachmentSettings (Maybe Bool)
generalAttachmentSettingsEnabledL f GeneralAttachmentSettings{..} = (\generalAttachmentSettingsEnabled -> GeneralAttachmentSettings { generalAttachmentSettingsEnabled, ..} ) <$> f generalAttachmentSettingsEnabled
{-# INLINE generalAttachmentSettingsEnabledL #-}

-- | 'generalAttachmentSettingsMaxFiles' Lens
generalAttachmentSettingsMaxFilesL :: Lens_' GeneralAttachmentSettings (Maybe Integer)
generalAttachmentSettingsMaxFilesL f GeneralAttachmentSettings{..} = (\generalAttachmentSettingsMaxFiles -> GeneralAttachmentSettings { generalAttachmentSettingsMaxFiles, ..} ) <$> f generalAttachmentSettingsMaxFiles
{-# INLINE generalAttachmentSettingsMaxFilesL #-}

-- | 'generalAttachmentSettingsMaxSize' Lens
generalAttachmentSettingsMaxSizeL :: Lens_' GeneralAttachmentSettings (Maybe Integer)
generalAttachmentSettingsMaxSizeL f GeneralAttachmentSettings{..} = (\generalAttachmentSettingsMaxSize -> GeneralAttachmentSettings { generalAttachmentSettingsMaxSize, ..} ) <$> f generalAttachmentSettingsMaxSize
{-# INLINE generalAttachmentSettingsMaxSizeL #-}



-- * GeneralRepoSettings

-- | 'generalRepoSettingsHttpGitDisabled' Lens
generalRepoSettingsHttpGitDisabledL :: Lens_' GeneralRepoSettings (Maybe Bool)
generalRepoSettingsHttpGitDisabledL f GeneralRepoSettings{..} = (\generalRepoSettingsHttpGitDisabled -> GeneralRepoSettings { generalRepoSettingsHttpGitDisabled, ..} ) <$> f generalRepoSettingsHttpGitDisabled
{-# INLINE generalRepoSettingsHttpGitDisabledL #-}

-- | 'generalRepoSettingsLfsDisabled' Lens
generalRepoSettingsLfsDisabledL :: Lens_' GeneralRepoSettings (Maybe Bool)
generalRepoSettingsLfsDisabledL f GeneralRepoSettings{..} = (\generalRepoSettingsLfsDisabled -> GeneralRepoSettings { generalRepoSettingsLfsDisabled, ..} ) <$> f generalRepoSettingsLfsDisabled
{-# INLINE generalRepoSettingsLfsDisabledL #-}

-- | 'generalRepoSettingsMigrationsDisabled' Lens
generalRepoSettingsMigrationsDisabledL :: Lens_' GeneralRepoSettings (Maybe Bool)
generalRepoSettingsMigrationsDisabledL f GeneralRepoSettings{..} = (\generalRepoSettingsMigrationsDisabled -> GeneralRepoSettings { generalRepoSettingsMigrationsDisabled, ..} ) <$> f generalRepoSettingsMigrationsDisabled
{-# INLINE generalRepoSettingsMigrationsDisabledL #-}

-- | 'generalRepoSettingsMirrorsDisabled' Lens
generalRepoSettingsMirrorsDisabledL :: Lens_' GeneralRepoSettings (Maybe Bool)
generalRepoSettingsMirrorsDisabledL f GeneralRepoSettings{..} = (\generalRepoSettingsMirrorsDisabled -> GeneralRepoSettings { generalRepoSettingsMirrorsDisabled, ..} ) <$> f generalRepoSettingsMirrorsDisabled
{-# INLINE generalRepoSettingsMirrorsDisabledL #-}

-- | 'generalRepoSettingsStarsDisabled' Lens
generalRepoSettingsStarsDisabledL :: Lens_' GeneralRepoSettings (Maybe Bool)
generalRepoSettingsStarsDisabledL f GeneralRepoSettings{..} = (\generalRepoSettingsStarsDisabled -> GeneralRepoSettings { generalRepoSettingsStarsDisabled, ..} ) <$> f generalRepoSettingsStarsDisabled
{-# INLINE generalRepoSettingsStarsDisabledL #-}

-- | 'generalRepoSettingsTimeTrackingDisabled' Lens
generalRepoSettingsTimeTrackingDisabledL :: Lens_' GeneralRepoSettings (Maybe Bool)
generalRepoSettingsTimeTrackingDisabledL f GeneralRepoSettings{..} = (\generalRepoSettingsTimeTrackingDisabled -> GeneralRepoSettings { generalRepoSettingsTimeTrackingDisabled, ..} ) <$> f generalRepoSettingsTimeTrackingDisabled
{-# INLINE generalRepoSettingsTimeTrackingDisabledL #-}



-- * GeneralUISettings

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

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

-- | 'generalUISettingsDefaultTheme' Lens
generalUISettingsDefaultThemeL :: Lens_' GeneralUISettings (Maybe Text)
generalUISettingsDefaultThemeL f GeneralUISettings{..} = (\generalUISettingsDefaultTheme -> GeneralUISettings { generalUISettingsDefaultTheme, ..} ) <$> f generalUISettingsDefaultTheme
{-# INLINE generalUISettingsDefaultThemeL #-}



-- * GenerateRepoOption

-- | 'generateRepoOptionAvatar' Lens
generateRepoOptionAvatarL :: Lens_' GenerateRepoOption (Maybe Bool)
generateRepoOptionAvatarL f GenerateRepoOption{..} = (\generateRepoOptionAvatar -> GenerateRepoOption { generateRepoOptionAvatar, ..} ) <$> f generateRepoOptionAvatar
{-# INLINE generateRepoOptionAvatarL #-}

-- | 'generateRepoOptionDefaultBranch' Lens
generateRepoOptionDefaultBranchL :: Lens_' GenerateRepoOption (Maybe Text)
generateRepoOptionDefaultBranchL f GenerateRepoOption{..} = (\generateRepoOptionDefaultBranch -> GenerateRepoOption { generateRepoOptionDefaultBranch, ..} ) <$> f generateRepoOptionDefaultBranch
{-# INLINE generateRepoOptionDefaultBranchL #-}

-- | 'generateRepoOptionDescription' Lens
generateRepoOptionDescriptionL :: Lens_' GenerateRepoOption (Maybe Text)
generateRepoOptionDescriptionL f GenerateRepoOption{..} = (\generateRepoOptionDescription -> GenerateRepoOption { generateRepoOptionDescription, ..} ) <$> f generateRepoOptionDescription
{-# INLINE generateRepoOptionDescriptionL #-}

-- | 'generateRepoOptionGitContent' Lens
generateRepoOptionGitContentL :: Lens_' GenerateRepoOption (Maybe Bool)
generateRepoOptionGitContentL f GenerateRepoOption{..} = (\generateRepoOptionGitContent -> GenerateRepoOption { generateRepoOptionGitContent, ..} ) <$> f generateRepoOptionGitContent
{-# INLINE generateRepoOptionGitContentL #-}

-- | 'generateRepoOptionGitHooks' Lens
generateRepoOptionGitHooksL :: Lens_' GenerateRepoOption (Maybe Bool)
generateRepoOptionGitHooksL f GenerateRepoOption{..} = (\generateRepoOptionGitHooks -> GenerateRepoOption { generateRepoOptionGitHooks, ..} ) <$> f generateRepoOptionGitHooks
{-# INLINE generateRepoOptionGitHooksL #-}

-- | 'generateRepoOptionLabels' Lens
generateRepoOptionLabelsL :: Lens_' GenerateRepoOption (Maybe Bool)
generateRepoOptionLabelsL f GenerateRepoOption{..} = (\generateRepoOptionLabels -> GenerateRepoOption { generateRepoOptionLabels, ..} ) <$> f generateRepoOptionLabels
{-# INLINE generateRepoOptionLabelsL #-}

-- | 'generateRepoOptionName' Lens
generateRepoOptionNameL :: Lens_' GenerateRepoOption (Text)
generateRepoOptionNameL f GenerateRepoOption{..} = (\generateRepoOptionName -> GenerateRepoOption { generateRepoOptionName, ..} ) <$> f generateRepoOptionName
{-# INLINE generateRepoOptionNameL #-}

-- | 'generateRepoOptionOwner' Lens
generateRepoOptionOwnerL :: Lens_' GenerateRepoOption (Text)
generateRepoOptionOwnerL f GenerateRepoOption{..} = (\generateRepoOptionOwner -> GenerateRepoOption { generateRepoOptionOwner, ..} ) <$> f generateRepoOptionOwner
{-# INLINE generateRepoOptionOwnerL #-}

-- | 'generateRepoOptionPrivate' Lens
generateRepoOptionPrivateL :: Lens_' GenerateRepoOption (Maybe Bool)
generateRepoOptionPrivateL f GenerateRepoOption{..} = (\generateRepoOptionPrivate -> GenerateRepoOption { generateRepoOptionPrivate, ..} ) <$> f generateRepoOptionPrivate
{-# INLINE generateRepoOptionPrivateL #-}

-- | 'generateRepoOptionTopics' Lens
generateRepoOptionTopicsL :: Lens_' GenerateRepoOption (Maybe Bool)
generateRepoOptionTopicsL f GenerateRepoOption{..} = (\generateRepoOptionTopics -> GenerateRepoOption { generateRepoOptionTopics, ..} ) <$> f generateRepoOptionTopics
{-# INLINE generateRepoOptionTopicsL #-}

-- | 'generateRepoOptionWebhooks' Lens
generateRepoOptionWebhooksL :: Lens_' GenerateRepoOption (Maybe Bool)
generateRepoOptionWebhooksL f GenerateRepoOption{..} = (\generateRepoOptionWebhooks -> GenerateRepoOption { generateRepoOptionWebhooks, ..} ) <$> f generateRepoOptionWebhooks
{-# INLINE generateRepoOptionWebhooksL #-}



-- * GitBlobResponse

-- | 'gitBlobResponseContent' Lens
gitBlobResponseContentL :: Lens_' GitBlobResponse (Maybe Text)
gitBlobResponseContentL f GitBlobResponse{..} = (\gitBlobResponseContent -> GitBlobResponse { gitBlobResponseContent, ..} ) <$> f gitBlobResponseContent
{-# INLINE gitBlobResponseContentL #-}

-- | 'gitBlobResponseEncoding' Lens
gitBlobResponseEncodingL :: Lens_' GitBlobResponse (Maybe Text)
gitBlobResponseEncodingL f GitBlobResponse{..} = (\gitBlobResponseEncoding -> GitBlobResponse { gitBlobResponseEncoding, ..} ) <$> f gitBlobResponseEncoding
{-# INLINE gitBlobResponseEncodingL #-}

-- | 'gitBlobResponseSha' Lens
gitBlobResponseShaL :: Lens_' GitBlobResponse (Maybe Text)
gitBlobResponseShaL f GitBlobResponse{..} = (\gitBlobResponseSha -> GitBlobResponse { gitBlobResponseSha, ..} ) <$> f gitBlobResponseSha
{-# INLINE gitBlobResponseShaL #-}

-- | 'gitBlobResponseSize' Lens
gitBlobResponseSizeL :: Lens_' GitBlobResponse (Maybe Integer)
gitBlobResponseSizeL f GitBlobResponse{..} = (\gitBlobResponseSize -> GitBlobResponse { gitBlobResponseSize, ..} ) <$> f gitBlobResponseSize
{-# INLINE gitBlobResponseSizeL #-}

-- | 'gitBlobResponseUrl' Lens
gitBlobResponseUrlL :: Lens_' GitBlobResponse (Maybe Text)
gitBlobResponseUrlL f GitBlobResponse{..} = (\gitBlobResponseUrl -> GitBlobResponse { gitBlobResponseUrl, ..} ) <$> f gitBlobResponseUrl
{-# INLINE gitBlobResponseUrlL #-}



-- * GitEntry

-- | 'gitEntryMode' Lens
gitEntryModeL :: Lens_' GitEntry (Maybe Text)
gitEntryModeL f GitEntry{..} = (\gitEntryMode -> GitEntry { gitEntryMode, ..} ) <$> f gitEntryMode
{-# INLINE gitEntryModeL #-}

-- | 'gitEntryPath' Lens
gitEntryPathL :: Lens_' GitEntry (Maybe Text)
gitEntryPathL f GitEntry{..} = (\gitEntryPath -> GitEntry { gitEntryPath, ..} ) <$> f gitEntryPath
{-# INLINE gitEntryPathL #-}

-- | 'gitEntrySha' Lens
gitEntryShaL :: Lens_' GitEntry (Maybe Text)
gitEntryShaL f GitEntry{..} = (\gitEntrySha -> GitEntry { gitEntrySha, ..} ) <$> f gitEntrySha
{-# INLINE gitEntryShaL #-}

-- | 'gitEntrySize' Lens
gitEntrySizeL :: Lens_' GitEntry (Maybe Integer)
gitEntrySizeL f GitEntry{..} = (\gitEntrySize -> GitEntry { gitEntrySize, ..} ) <$> f gitEntrySize
{-# INLINE gitEntrySizeL #-}

-- | 'gitEntryType' Lens
gitEntryTypeL :: Lens_' GitEntry (Maybe Text)
gitEntryTypeL f GitEntry{..} = (\gitEntryType -> GitEntry { gitEntryType, ..} ) <$> f gitEntryType
{-# INLINE gitEntryTypeL #-}

-- | 'gitEntryUrl' Lens
gitEntryUrlL :: Lens_' GitEntry (Maybe Text)
gitEntryUrlL f GitEntry{..} = (\gitEntryUrl -> GitEntry { gitEntryUrl, ..} ) <$> f gitEntryUrl
{-# INLINE gitEntryUrlL #-}



-- * GitHook

-- | 'gitHookContent' Lens
gitHookContentL :: Lens_' GitHook (Maybe Text)
gitHookContentL f GitHook{..} = (\gitHookContent -> GitHook { gitHookContent, ..} ) <$> f gitHookContent
{-# INLINE gitHookContentL #-}

-- | 'gitHookIsActive' Lens
gitHookIsActiveL :: Lens_' GitHook (Maybe Bool)
gitHookIsActiveL f GitHook{..} = (\gitHookIsActive -> GitHook { gitHookIsActive, ..} ) <$> f gitHookIsActive
{-# INLINE gitHookIsActiveL #-}

-- | 'gitHookName' Lens
gitHookNameL :: Lens_' GitHook (Maybe Text)
gitHookNameL f GitHook{..} = (\gitHookName -> GitHook { gitHookName, ..} ) <$> f gitHookName
{-# INLINE gitHookNameL #-}



-- * GitObject

-- | 'gitObjectSha' Lens
gitObjectShaL :: Lens_' GitObject (Maybe Text)
gitObjectShaL f GitObject{..} = (\gitObjectSha -> GitObject { gitObjectSha, ..} ) <$> f gitObjectSha
{-# INLINE gitObjectShaL #-}

-- | 'gitObjectType' Lens
gitObjectTypeL :: Lens_' GitObject (Maybe Text)
gitObjectTypeL f GitObject{..} = (\gitObjectType -> GitObject { gitObjectType, ..} ) <$> f gitObjectType
{-# INLINE gitObjectTypeL #-}

-- | 'gitObjectUrl' Lens
gitObjectUrlL :: Lens_' GitObject (Maybe Text)
gitObjectUrlL f GitObject{..} = (\gitObjectUrl -> GitObject { gitObjectUrl, ..} ) <$> f gitObjectUrl
{-# INLINE gitObjectUrlL #-}



-- * GitTreeResponse

-- | 'gitTreeResponsePage' Lens
gitTreeResponsePageL :: Lens_' GitTreeResponse (Maybe Integer)
gitTreeResponsePageL f GitTreeResponse{..} = (\gitTreeResponsePage -> GitTreeResponse { gitTreeResponsePage, ..} ) <$> f gitTreeResponsePage
{-# INLINE gitTreeResponsePageL #-}

-- | 'gitTreeResponseSha' Lens
gitTreeResponseShaL :: Lens_' GitTreeResponse (Maybe Text)
gitTreeResponseShaL f GitTreeResponse{..} = (\gitTreeResponseSha -> GitTreeResponse { gitTreeResponseSha, ..} ) <$> f gitTreeResponseSha
{-# INLINE gitTreeResponseShaL #-}

-- | 'gitTreeResponseTotalCount' Lens
gitTreeResponseTotalCountL :: Lens_' GitTreeResponse (Maybe Integer)
gitTreeResponseTotalCountL f GitTreeResponse{..} = (\gitTreeResponseTotalCount -> GitTreeResponse { gitTreeResponseTotalCount, ..} ) <$> f gitTreeResponseTotalCount
{-# INLINE gitTreeResponseTotalCountL #-}

-- | 'gitTreeResponseTree' Lens
gitTreeResponseTreeL :: Lens_' GitTreeResponse (Maybe [GitEntry])
gitTreeResponseTreeL f GitTreeResponse{..} = (\gitTreeResponseTree -> GitTreeResponse { gitTreeResponseTree, ..} ) <$> f gitTreeResponseTree
{-# INLINE gitTreeResponseTreeL #-}

-- | 'gitTreeResponseTruncated' Lens
gitTreeResponseTruncatedL :: Lens_' GitTreeResponse (Maybe Bool)
gitTreeResponseTruncatedL f GitTreeResponse{..} = (\gitTreeResponseTruncated -> GitTreeResponse { gitTreeResponseTruncated, ..} ) <$> f gitTreeResponseTruncated
{-# INLINE gitTreeResponseTruncatedL #-}

-- | 'gitTreeResponseUrl' Lens
gitTreeResponseUrlL :: Lens_' GitTreeResponse (Maybe Text)
gitTreeResponseUrlL f GitTreeResponse{..} = (\gitTreeResponseUrl -> GitTreeResponse { gitTreeResponseUrl, ..} ) <$> f gitTreeResponseUrl
{-# INLINE gitTreeResponseUrlL #-}



-- * GitignoreTemplateInfo

-- | 'gitignoreTemplateInfoName' Lens
gitignoreTemplateInfoNameL :: Lens_' GitignoreTemplateInfo (Maybe Text)
gitignoreTemplateInfoNameL f GitignoreTemplateInfo{..} = (\gitignoreTemplateInfoName -> GitignoreTemplateInfo { gitignoreTemplateInfoName, ..} ) <$> f gitignoreTemplateInfoName
{-# INLINE gitignoreTemplateInfoNameL #-}

-- | 'gitignoreTemplateInfoSource' Lens
gitignoreTemplateInfoSourceL :: Lens_' GitignoreTemplateInfo (Maybe Text)
gitignoreTemplateInfoSourceL f GitignoreTemplateInfo{..} = (\gitignoreTemplateInfoSource -> GitignoreTemplateInfo { gitignoreTemplateInfoSource, ..} ) <$> f gitignoreTemplateInfoSource
{-# INLINE gitignoreTemplateInfoSourceL #-}



-- * Hook

-- | 'hookActive' Lens
hookActiveL :: Lens_' Hook (Maybe Bool)
hookActiveL f Hook{..} = (\hookActive -> Hook { hookActive, ..} ) <$> f hookActive
{-# INLINE hookActiveL #-}

-- | 'hookAuthorizationHeader' Lens
hookAuthorizationHeaderL :: Lens_' Hook (Maybe Text)
hookAuthorizationHeaderL f Hook{..} = (\hookAuthorizationHeader -> Hook { hookAuthorizationHeader, ..} ) <$> f hookAuthorizationHeader
{-# INLINE hookAuthorizationHeaderL #-}

-- | 'hookBranchFilter' Lens
hookBranchFilterL :: Lens_' Hook (Maybe Text)
hookBranchFilterL f Hook{..} = (\hookBranchFilter -> Hook { hookBranchFilter, ..} ) <$> f hookBranchFilter
{-# INLINE hookBranchFilterL #-}

-- | 'hookConfig' Lens
hookConfigL :: Lens_' Hook (Maybe (Map.Map String Text))
hookConfigL f Hook{..} = (\hookConfig -> Hook { hookConfig, ..} ) <$> f hookConfig
{-# INLINE hookConfigL #-}

-- | 'hookCreatedAt' Lens
hookCreatedAtL :: Lens_' Hook (Maybe DateTime)
hookCreatedAtL f Hook{..} = (\hookCreatedAt -> Hook { hookCreatedAt, ..} ) <$> f hookCreatedAt
{-# INLINE hookCreatedAtL #-}

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

-- | 'hookId' Lens
hookIdL :: Lens_' Hook (Maybe Integer)
hookIdL f Hook{..} = (\hookId -> Hook { hookId, ..} ) <$> f hookId
{-# INLINE hookIdL #-}

-- | 'hookType' Lens
hookTypeL :: Lens_' Hook (Maybe Text)
hookTypeL f Hook{..} = (\hookType -> Hook { hookType, ..} ) <$> f hookType
{-# INLINE hookTypeL #-}

-- | 'hookUpdatedAt' Lens
hookUpdatedAtL :: Lens_' Hook (Maybe DateTime)
hookUpdatedAtL f Hook{..} = (\hookUpdatedAt -> Hook { hookUpdatedAt, ..} ) <$> f hookUpdatedAt
{-# INLINE hookUpdatedAtL #-}



-- * Identity

-- | 'identityEmail' Lens
identityEmailL :: Lens_' Identity (Maybe Text)
identityEmailL f Identity{..} = (\identityEmail -> Identity { identityEmail, ..} ) <$> f identityEmail
{-# INLINE identityEmailL #-}

-- | 'identityName' Lens
identityNameL :: Lens_' Identity (Maybe Text)
identityNameL f Identity{..} = (\identityName -> Identity { identityName, ..} ) <$> f identityName
{-# INLINE identityNameL #-}



-- * InternalTracker

-- | 'internalTrackerAllowOnlyContributorsToTrackTime' Lens
internalTrackerAllowOnlyContributorsToTrackTimeL :: Lens_' InternalTracker (Maybe Bool)
internalTrackerAllowOnlyContributorsToTrackTimeL f InternalTracker{..} = (\internalTrackerAllowOnlyContributorsToTrackTime -> InternalTracker { internalTrackerAllowOnlyContributorsToTrackTime, ..} ) <$> f internalTrackerAllowOnlyContributorsToTrackTime
{-# INLINE internalTrackerAllowOnlyContributorsToTrackTimeL #-}

-- | 'internalTrackerEnableIssueDependencies' Lens
internalTrackerEnableIssueDependenciesL :: Lens_' InternalTracker (Maybe Bool)
internalTrackerEnableIssueDependenciesL f InternalTracker{..} = (\internalTrackerEnableIssueDependencies -> InternalTracker { internalTrackerEnableIssueDependencies, ..} ) <$> f internalTrackerEnableIssueDependencies
{-# INLINE internalTrackerEnableIssueDependenciesL #-}

-- | 'internalTrackerEnableTimeTracker' Lens
internalTrackerEnableTimeTrackerL :: Lens_' InternalTracker (Maybe Bool)
internalTrackerEnableTimeTrackerL f InternalTracker{..} = (\internalTrackerEnableTimeTracker -> InternalTracker { internalTrackerEnableTimeTracker, ..} ) <$> f internalTrackerEnableTimeTracker
{-# INLINE internalTrackerEnableTimeTrackerL #-}



-- * Issue

-- | 'issueAssets' Lens
issueAssetsL :: Lens_' Issue (Maybe [Attachment])
issueAssetsL f Issue{..} = (\issueAssets -> Issue { issueAssets, ..} ) <$> f issueAssets
{-# INLINE issueAssetsL #-}

-- | 'issueAssignee' Lens
issueAssigneeL :: Lens_' Issue (Maybe User)
issueAssigneeL f Issue{..} = (\issueAssignee -> Issue { issueAssignee, ..} ) <$> f issueAssignee
{-# INLINE issueAssigneeL #-}

-- | 'issueAssignees' Lens
issueAssigneesL :: Lens_' Issue (Maybe [User])
issueAssigneesL f Issue{..} = (\issueAssignees -> Issue { issueAssignees, ..} ) <$> f issueAssignees
{-# INLINE issueAssigneesL #-}

-- | 'issueBody' Lens
issueBodyL :: Lens_' Issue (Maybe Text)
issueBodyL f Issue{..} = (\issueBody -> Issue { issueBody, ..} ) <$> f issueBody
{-# INLINE issueBodyL #-}

-- | 'issueClosedAt' Lens
issueClosedAtL :: Lens_' Issue (Maybe DateTime)
issueClosedAtL f Issue{..} = (\issueClosedAt -> Issue { issueClosedAt, ..} ) <$> f issueClosedAt
{-# INLINE issueClosedAtL #-}

-- | 'issueComments' Lens
issueCommentsL :: Lens_' Issue (Maybe Integer)
issueCommentsL f Issue{..} = (\issueComments -> Issue { issueComments, ..} ) <$> f issueComments
{-# INLINE issueCommentsL #-}

-- | 'issueCreatedAt' Lens
issueCreatedAtL :: Lens_' Issue (Maybe DateTime)
issueCreatedAtL f Issue{..} = (\issueCreatedAt -> Issue { issueCreatedAt, ..} ) <$> f issueCreatedAt
{-# INLINE issueCreatedAtL #-}

-- | 'issueDueDate' Lens
issueDueDateL :: Lens_' Issue (Maybe DateTime)
issueDueDateL f Issue{..} = (\issueDueDate -> Issue { issueDueDate, ..} ) <$> f issueDueDate
{-# INLINE issueDueDateL #-}

-- | 'issueHtmlUrl' Lens
issueHtmlUrlL :: Lens_' Issue (Maybe Text)
issueHtmlUrlL f Issue{..} = (\issueHtmlUrl -> Issue { issueHtmlUrl, ..} ) <$> f issueHtmlUrl
{-# INLINE issueHtmlUrlL #-}

-- | 'issueId' Lens
issueIdL :: Lens_' Issue (Maybe Integer)
issueIdL f Issue{..} = (\issueId -> Issue { issueId, ..} ) <$> f issueId
{-# INLINE issueIdL #-}

-- | 'issueIsLocked' Lens
issueIsLockedL :: Lens_' Issue (Maybe Bool)
issueIsLockedL f Issue{..} = (\issueIsLocked -> Issue { issueIsLocked, ..} ) <$> f issueIsLocked
{-# INLINE issueIsLockedL #-}

-- | 'issueLabels' Lens
issueLabelsL :: Lens_' Issue (Maybe [Label])
issueLabelsL f Issue{..} = (\issueLabels -> Issue { issueLabels, ..} ) <$> f issueLabels
{-# INLINE issueLabelsL #-}

-- | 'issueMilestone' Lens
issueMilestoneL :: Lens_' Issue (Maybe Milestone)
issueMilestoneL f Issue{..} = (\issueMilestone -> Issue { issueMilestone, ..} ) <$> f issueMilestone
{-# INLINE issueMilestoneL #-}

-- | 'issueNumber' Lens
issueNumberL :: Lens_' Issue (Maybe Integer)
issueNumberL f Issue{..} = (\issueNumber -> Issue { issueNumber, ..} ) <$> f issueNumber
{-# INLINE issueNumberL #-}

-- | 'issueOriginalAuthor' Lens
issueOriginalAuthorL :: Lens_' Issue (Maybe Text)
issueOriginalAuthorL f Issue{..} = (\issueOriginalAuthor -> Issue { issueOriginalAuthor, ..} ) <$> f issueOriginalAuthor
{-# INLINE issueOriginalAuthorL #-}

-- | 'issueOriginalAuthorId' Lens
issueOriginalAuthorIdL :: Lens_' Issue (Maybe Integer)
issueOriginalAuthorIdL f Issue{..} = (\issueOriginalAuthorId -> Issue { issueOriginalAuthorId, ..} ) <$> f issueOriginalAuthorId
{-# INLINE issueOriginalAuthorIdL #-}

-- | 'issuePinOrder' Lens
issuePinOrderL :: Lens_' Issue (Maybe Integer)
issuePinOrderL f Issue{..} = (\issuePinOrder -> Issue { issuePinOrder, ..} ) <$> f issuePinOrder
{-# INLINE issuePinOrderL #-}

-- | 'issuePullRequest' Lens
issuePullRequestL :: Lens_' Issue (Maybe PullRequestMeta)
issuePullRequestL f Issue{..} = (\issuePullRequest -> Issue { issuePullRequest, ..} ) <$> f issuePullRequest
{-# INLINE issuePullRequestL #-}

-- | 'issueRef' Lens
issueRefL :: Lens_' Issue (Maybe Text)
issueRefL f Issue{..} = (\issueRef -> Issue { issueRef, ..} ) <$> f issueRef
{-# INLINE issueRefL #-}

-- | 'issueRepository' Lens
issueRepositoryL :: Lens_' Issue (Maybe RepositoryMeta)
issueRepositoryL f Issue{..} = (\issueRepository -> Issue { issueRepository, ..} ) <$> f issueRepository
{-# INLINE issueRepositoryL #-}

-- | 'issueState' Lens
issueStateL :: Lens_' Issue (Maybe Text)
issueStateL f Issue{..} = (\issueState -> Issue { issueState, ..} ) <$> f issueState
{-# INLINE issueStateL #-}

-- | 'issueTitle' Lens
issueTitleL :: Lens_' Issue (Maybe Text)
issueTitleL f Issue{..} = (\issueTitle -> Issue { issueTitle, ..} ) <$> f issueTitle
{-# INLINE issueTitleL #-}

-- | 'issueUpdatedAt' Lens
issueUpdatedAtL :: Lens_' Issue (Maybe DateTime)
issueUpdatedAtL f Issue{..} = (\issueUpdatedAt -> Issue { issueUpdatedAt, ..} ) <$> f issueUpdatedAt
{-# INLINE issueUpdatedAtL #-}

-- | 'issueUrl' Lens
issueUrlL :: Lens_' Issue (Maybe Text)
issueUrlL f Issue{..} = (\issueUrl -> Issue { issueUrl, ..} ) <$> f issueUrl
{-# INLINE issueUrlL #-}

-- | 'issueUser' Lens
issueUserL :: Lens_' Issue (Maybe User)
issueUserL f Issue{..} = (\issueUser -> Issue { issueUser, ..} ) <$> f issueUser
{-# INLINE issueUserL #-}



-- * IssueConfig

-- | 'issueConfigBlankIssuesEnabled' Lens
issueConfigBlankIssuesEnabledL :: Lens_' IssueConfig (Maybe Bool)
issueConfigBlankIssuesEnabledL f IssueConfig{..} = (\issueConfigBlankIssuesEnabled -> IssueConfig { issueConfigBlankIssuesEnabled, ..} ) <$> f issueConfigBlankIssuesEnabled
{-# INLINE issueConfigBlankIssuesEnabledL #-}

-- | 'issueConfigContactLinks' Lens
issueConfigContactLinksL :: Lens_' IssueConfig (Maybe [IssueConfigContactLink])
issueConfigContactLinksL f IssueConfig{..} = (\issueConfigContactLinks -> IssueConfig { issueConfigContactLinks, ..} ) <$> f issueConfigContactLinks
{-# INLINE issueConfigContactLinksL #-}



-- * IssueConfigContactLink

-- | 'issueConfigContactLinkAbout' Lens
issueConfigContactLinkAboutL :: Lens_' IssueConfigContactLink (Maybe Text)
issueConfigContactLinkAboutL f IssueConfigContactLink{..} = (\issueConfigContactLinkAbout -> IssueConfigContactLink { issueConfigContactLinkAbout, ..} ) <$> f issueConfigContactLinkAbout
{-# INLINE issueConfigContactLinkAboutL #-}

-- | 'issueConfigContactLinkName' Lens
issueConfigContactLinkNameL :: Lens_' IssueConfigContactLink (Maybe Text)
issueConfigContactLinkNameL f IssueConfigContactLink{..} = (\issueConfigContactLinkName -> IssueConfigContactLink { issueConfigContactLinkName, ..} ) <$> f issueConfigContactLinkName
{-# INLINE issueConfigContactLinkNameL #-}

-- | 'issueConfigContactLinkUrl' Lens
issueConfigContactLinkUrlL :: Lens_' IssueConfigContactLink (Maybe Text)
issueConfigContactLinkUrlL f IssueConfigContactLink{..} = (\issueConfigContactLinkUrl -> IssueConfigContactLink { issueConfigContactLinkUrl, ..} ) <$> f issueConfigContactLinkUrl
{-# INLINE issueConfigContactLinkUrlL #-}



-- * IssueConfigValidation

-- | 'issueConfigValidationMessage' Lens
issueConfigValidationMessageL :: Lens_' IssueConfigValidation (Maybe Text)
issueConfigValidationMessageL f IssueConfigValidation{..} = (\issueConfigValidationMessage -> IssueConfigValidation { issueConfigValidationMessage, ..} ) <$> f issueConfigValidationMessage
{-# INLINE issueConfigValidationMessageL #-}

-- | 'issueConfigValidationValid' Lens
issueConfigValidationValidL :: Lens_' IssueConfigValidation (Maybe Bool)
issueConfigValidationValidL f IssueConfigValidation{..} = (\issueConfigValidationValid -> IssueConfigValidation { issueConfigValidationValid, ..} ) <$> f issueConfigValidationValid
{-# INLINE issueConfigValidationValidL #-}



-- * IssueDeadline

-- | 'issueDeadlineDueDate' Lens
issueDeadlineDueDateL :: Lens_' IssueDeadline (Maybe DateTime)
issueDeadlineDueDateL f IssueDeadline{..} = (\issueDeadlineDueDate -> IssueDeadline { issueDeadlineDueDate, ..} ) <$> f issueDeadlineDueDate
{-# INLINE issueDeadlineDueDateL #-}



-- * IssueFormField

-- | 'issueFormFieldAttributes' Lens
issueFormFieldAttributesL :: Lens_' IssueFormField (Maybe (Map.Map String A.Value))
issueFormFieldAttributesL f IssueFormField{..} = (\issueFormFieldAttributes -> IssueFormField { issueFormFieldAttributes, ..} ) <$> f issueFormFieldAttributes
{-# INLINE issueFormFieldAttributesL #-}

-- | 'issueFormFieldId' Lens
issueFormFieldIdL :: Lens_' IssueFormField (Maybe Text)
issueFormFieldIdL f IssueFormField{..} = (\issueFormFieldId -> IssueFormField { issueFormFieldId, ..} ) <$> f issueFormFieldId
{-# INLINE issueFormFieldIdL #-}

-- | 'issueFormFieldType' Lens
issueFormFieldTypeL :: Lens_' IssueFormField (Maybe Text)
issueFormFieldTypeL f IssueFormField{..} = (\issueFormFieldType -> IssueFormField { issueFormFieldType, ..} ) <$> f issueFormFieldType
{-# INLINE issueFormFieldTypeL #-}

-- | 'issueFormFieldValidations' Lens
issueFormFieldValidationsL :: Lens_' IssueFormField (Maybe (Map.Map String A.Value))
issueFormFieldValidationsL f IssueFormField{..} = (\issueFormFieldValidations -> IssueFormField { issueFormFieldValidations, ..} ) <$> f issueFormFieldValidations
{-# INLINE issueFormFieldValidationsL #-}



-- * IssueLabelsOption

-- | 'issueLabelsOptionLabels' Lens
issueLabelsOptionLabelsL :: Lens_' IssueLabelsOption (Maybe [Integer])
issueLabelsOptionLabelsL f IssueLabelsOption{..} = (\issueLabelsOptionLabels -> IssueLabelsOption { issueLabelsOptionLabels, ..} ) <$> f issueLabelsOptionLabels
{-# INLINE issueLabelsOptionLabelsL #-}



-- * IssueMeta

-- | 'issueMetaIndex' Lens
issueMetaIndexL :: Lens_' IssueMeta (Maybe Integer)
issueMetaIndexL f IssueMeta{..} = (\issueMetaIndex -> IssueMeta { issueMetaIndex, ..} ) <$> f issueMetaIndex
{-# INLINE issueMetaIndexL #-}

-- | 'issueMetaOwner' Lens
issueMetaOwnerL :: Lens_' IssueMeta (Maybe Text)
issueMetaOwnerL f IssueMeta{..} = (\issueMetaOwner -> IssueMeta { issueMetaOwner, ..} ) <$> f issueMetaOwner
{-# INLINE issueMetaOwnerL #-}

-- | 'issueMetaRepo' Lens
issueMetaRepoL :: Lens_' IssueMeta (Maybe Text)
issueMetaRepoL f IssueMeta{..} = (\issueMetaRepo -> IssueMeta { issueMetaRepo, ..} ) <$> f issueMetaRepo
{-# INLINE issueMetaRepoL #-}



-- * IssueTemplate

-- | 'issueTemplateAbout' Lens
issueTemplateAboutL :: Lens_' IssueTemplate (Maybe Text)
issueTemplateAboutL f IssueTemplate{..} = (\issueTemplateAbout -> IssueTemplate { issueTemplateAbout, ..} ) <$> f issueTemplateAbout
{-# INLINE issueTemplateAboutL #-}

-- | 'issueTemplateBody' Lens
issueTemplateBodyL :: Lens_' IssueTemplate (Maybe [IssueFormField])
issueTemplateBodyL f IssueTemplate{..} = (\issueTemplateBody -> IssueTemplate { issueTemplateBody, ..} ) <$> f issueTemplateBody
{-# INLINE issueTemplateBodyL #-}

-- | 'issueTemplateContent' Lens
issueTemplateContentL :: Lens_' IssueTemplate (Maybe Text)
issueTemplateContentL f IssueTemplate{..} = (\issueTemplateContent -> IssueTemplate { issueTemplateContent, ..} ) <$> f issueTemplateContent
{-# INLINE issueTemplateContentL #-}

-- | 'issueTemplateFileName' Lens
issueTemplateFileNameL :: Lens_' IssueTemplate (Maybe Text)
issueTemplateFileNameL f IssueTemplate{..} = (\issueTemplateFileName -> IssueTemplate { issueTemplateFileName, ..} ) <$> f issueTemplateFileName
{-# INLINE issueTemplateFileNameL #-}

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

-- | 'issueTemplateName' Lens
issueTemplateNameL :: Lens_' IssueTemplate (Maybe Text)
issueTemplateNameL f IssueTemplate{..} = (\issueTemplateName -> IssueTemplate { issueTemplateName, ..} ) <$> f issueTemplateName
{-# INLINE issueTemplateNameL #-}

-- | 'issueTemplateRef' Lens
issueTemplateRefL :: Lens_' IssueTemplate (Maybe Text)
issueTemplateRefL f IssueTemplate{..} = (\issueTemplateRef -> IssueTemplate { issueTemplateRef, ..} ) <$> f issueTemplateRef
{-# INLINE issueTemplateRefL #-}

-- | 'issueTemplateTitle' Lens
issueTemplateTitleL :: Lens_' IssueTemplate (Maybe Text)
issueTemplateTitleL f IssueTemplate{..} = (\issueTemplateTitle -> IssueTemplate { issueTemplateTitle, ..} ) <$> f issueTemplateTitle
{-# INLINE issueTemplateTitleL #-}



-- * Label

-- | 'labelColor' Lens
labelColorL :: Lens_' Label (Maybe Text)
labelColorL f Label{..} = (\labelColor -> Label { labelColor, ..} ) <$> f labelColor
{-# INLINE labelColorL #-}

-- | 'labelDescription' Lens
labelDescriptionL :: Lens_' Label (Maybe Text)
labelDescriptionL f Label{..} = (\labelDescription -> Label { labelDescription, ..} ) <$> f labelDescription
{-# INLINE labelDescriptionL #-}

-- | 'labelExclusive' Lens
labelExclusiveL :: Lens_' Label (Maybe Bool)
labelExclusiveL f Label{..} = (\labelExclusive -> Label { labelExclusive, ..} ) <$> f labelExclusive
{-# INLINE labelExclusiveL #-}

-- | 'labelId' Lens
labelIdL :: Lens_' Label (Maybe Integer)
labelIdL f Label{..} = (\labelId -> Label { labelId, ..} ) <$> f labelId
{-# INLINE labelIdL #-}

-- | 'labelName' Lens
labelNameL :: Lens_' Label (Maybe Text)
labelNameL f Label{..} = (\labelName -> Label { labelName, ..} ) <$> f labelName
{-# INLINE labelNameL #-}

-- | 'labelUrl' Lens
labelUrlL :: Lens_' Label (Maybe Text)
labelUrlL f Label{..} = (\labelUrl -> Label { labelUrl, ..} ) <$> f labelUrl
{-# INLINE labelUrlL #-}



-- * LabelTemplate

-- | 'labelTemplateColor' Lens
labelTemplateColorL :: Lens_' LabelTemplate (Maybe Text)
labelTemplateColorL f LabelTemplate{..} = (\labelTemplateColor -> LabelTemplate { labelTemplateColor, ..} ) <$> f labelTemplateColor
{-# INLINE labelTemplateColorL #-}

-- | 'labelTemplateDescription' Lens
labelTemplateDescriptionL :: Lens_' LabelTemplate (Maybe Text)
labelTemplateDescriptionL f LabelTemplate{..} = (\labelTemplateDescription -> LabelTemplate { labelTemplateDescription, ..} ) <$> f labelTemplateDescription
{-# INLINE labelTemplateDescriptionL #-}

-- | 'labelTemplateExclusive' Lens
labelTemplateExclusiveL :: Lens_' LabelTemplate (Maybe Bool)
labelTemplateExclusiveL f LabelTemplate{..} = (\labelTemplateExclusive -> LabelTemplate { labelTemplateExclusive, ..} ) <$> f labelTemplateExclusive
{-# INLINE labelTemplateExclusiveL #-}

-- | 'labelTemplateName' Lens
labelTemplateNameL :: Lens_' LabelTemplate (Maybe Text)
labelTemplateNameL f LabelTemplate{..} = (\labelTemplateName -> LabelTemplate { labelTemplateName, ..} ) <$> f labelTemplateName
{-# INLINE labelTemplateNameL #-}



-- * LicenseTemplateInfo

-- | 'licenseTemplateInfoBody' Lens
licenseTemplateInfoBodyL :: Lens_' LicenseTemplateInfo (Maybe Text)
licenseTemplateInfoBodyL f LicenseTemplateInfo{..} = (\licenseTemplateInfoBody -> LicenseTemplateInfo { licenseTemplateInfoBody, ..} ) <$> f licenseTemplateInfoBody
{-# INLINE licenseTemplateInfoBodyL #-}

-- | 'licenseTemplateInfoImplementation' Lens
licenseTemplateInfoImplementationL :: Lens_' LicenseTemplateInfo (Maybe Text)
licenseTemplateInfoImplementationL f LicenseTemplateInfo{..} = (\licenseTemplateInfoImplementation -> LicenseTemplateInfo { licenseTemplateInfoImplementation, ..} ) <$> f licenseTemplateInfoImplementation
{-# INLINE licenseTemplateInfoImplementationL #-}

-- | 'licenseTemplateInfoKey' Lens
licenseTemplateInfoKeyL :: Lens_' LicenseTemplateInfo (Maybe Text)
licenseTemplateInfoKeyL f LicenseTemplateInfo{..} = (\licenseTemplateInfoKey -> LicenseTemplateInfo { licenseTemplateInfoKey, ..} ) <$> f licenseTemplateInfoKey
{-# INLINE licenseTemplateInfoKeyL #-}

-- | 'licenseTemplateInfoName' Lens
licenseTemplateInfoNameL :: Lens_' LicenseTemplateInfo (Maybe Text)
licenseTemplateInfoNameL f LicenseTemplateInfo{..} = (\licenseTemplateInfoName -> LicenseTemplateInfo { licenseTemplateInfoName, ..} ) <$> f licenseTemplateInfoName
{-# INLINE licenseTemplateInfoNameL #-}

-- | 'licenseTemplateInfoUrl' Lens
licenseTemplateInfoUrlL :: Lens_' LicenseTemplateInfo (Maybe Text)
licenseTemplateInfoUrlL f LicenseTemplateInfo{..} = (\licenseTemplateInfoUrl -> LicenseTemplateInfo { licenseTemplateInfoUrl, ..} ) <$> f licenseTemplateInfoUrl
{-# INLINE licenseTemplateInfoUrlL #-}



-- * LicensesTemplateListEntry

-- | 'licensesTemplateListEntryKey' Lens
licensesTemplateListEntryKeyL :: Lens_' LicensesTemplateListEntry (Maybe Text)
licensesTemplateListEntryKeyL f LicensesTemplateListEntry{..} = (\licensesTemplateListEntryKey -> LicensesTemplateListEntry { licensesTemplateListEntryKey, ..} ) <$> f licensesTemplateListEntryKey
{-# INLINE licensesTemplateListEntryKeyL #-}

-- | 'licensesTemplateListEntryName' Lens
licensesTemplateListEntryNameL :: Lens_' LicensesTemplateListEntry (Maybe Text)
licensesTemplateListEntryNameL f LicensesTemplateListEntry{..} = (\licensesTemplateListEntryName -> LicensesTemplateListEntry { licensesTemplateListEntryName, ..} ) <$> f licensesTemplateListEntryName
{-# INLINE licensesTemplateListEntryNameL #-}

-- | 'licensesTemplateListEntryUrl' Lens
licensesTemplateListEntryUrlL :: Lens_' LicensesTemplateListEntry (Maybe Text)
licensesTemplateListEntryUrlL f LicensesTemplateListEntry{..} = (\licensesTemplateListEntryUrl -> LicensesTemplateListEntry { licensesTemplateListEntryUrl, ..} ) <$> f licensesTemplateListEntryUrl
{-# INLINE licensesTemplateListEntryUrlL #-}



-- * MarkdownOption

-- | 'markdownOptionContext' Lens
markdownOptionContextL :: Lens_' MarkdownOption (Maybe Text)
markdownOptionContextL f MarkdownOption{..} = (\markdownOptionContext -> MarkdownOption { markdownOptionContext, ..} ) <$> f markdownOptionContext
{-# INLINE markdownOptionContextL #-}

-- | 'markdownOptionMode' Lens
markdownOptionModeL :: Lens_' MarkdownOption (Maybe Text)
markdownOptionModeL f MarkdownOption{..} = (\markdownOptionMode -> MarkdownOption { markdownOptionMode, ..} ) <$> f markdownOptionMode
{-# INLINE markdownOptionModeL #-}

-- | 'markdownOptionText' Lens
markdownOptionTextL :: Lens_' MarkdownOption (Maybe Text)
markdownOptionTextL f MarkdownOption{..} = (\markdownOptionText -> MarkdownOption { markdownOptionText, ..} ) <$> f markdownOptionText
{-# INLINE markdownOptionTextL #-}

-- | 'markdownOptionWiki' Lens
markdownOptionWikiL :: Lens_' MarkdownOption (Maybe Bool)
markdownOptionWikiL f MarkdownOption{..} = (\markdownOptionWiki -> MarkdownOption { markdownOptionWiki, ..} ) <$> f markdownOptionWiki
{-# INLINE markdownOptionWikiL #-}



-- * MarkupOption

-- | 'markupOptionContext' Lens
markupOptionContextL :: Lens_' MarkupOption (Maybe Text)
markupOptionContextL f MarkupOption{..} = (\markupOptionContext -> MarkupOption { markupOptionContext, ..} ) <$> f markupOptionContext
{-# INLINE markupOptionContextL #-}

-- | 'markupOptionFilePath' Lens
markupOptionFilePathL :: Lens_' MarkupOption (Maybe Text)
markupOptionFilePathL f MarkupOption{..} = (\markupOptionFilePath -> MarkupOption { markupOptionFilePath, ..} ) <$> f markupOptionFilePath
{-# INLINE markupOptionFilePathL #-}

-- | 'markupOptionMode' Lens
markupOptionModeL :: Lens_' MarkupOption (Maybe Text)
markupOptionModeL f MarkupOption{..} = (\markupOptionMode -> MarkupOption { markupOptionMode, ..} ) <$> f markupOptionMode
{-# INLINE markupOptionModeL #-}

-- | 'markupOptionText' Lens
markupOptionTextL :: Lens_' MarkupOption (Maybe Text)
markupOptionTextL f MarkupOption{..} = (\markupOptionText -> MarkupOption { markupOptionText, ..} ) <$> f markupOptionText
{-# INLINE markupOptionTextL #-}

-- | 'markupOptionWiki' Lens
markupOptionWikiL :: Lens_' MarkupOption (Maybe Bool)
markupOptionWikiL f MarkupOption{..} = (\markupOptionWiki -> MarkupOption { markupOptionWiki, ..} ) <$> f markupOptionWiki
{-# INLINE markupOptionWikiL #-}



-- * MergePullRequestOption

-- | 'mergePullRequestOptionDo' Lens
mergePullRequestOptionDoL :: Lens_' MergePullRequestOption (E'Do)
mergePullRequestOptionDoL f MergePullRequestOption{..} = (\mergePullRequestOptionDo -> MergePullRequestOption { mergePullRequestOptionDo, ..} ) <$> f mergePullRequestOptionDo
{-# INLINE mergePullRequestOptionDoL #-}

-- | 'mergePullRequestOptionMergeCommitId' Lens
mergePullRequestOptionMergeCommitIdL :: Lens_' MergePullRequestOption (Maybe Text)
mergePullRequestOptionMergeCommitIdL f MergePullRequestOption{..} = (\mergePullRequestOptionMergeCommitId -> MergePullRequestOption { mergePullRequestOptionMergeCommitId, ..} ) <$> f mergePullRequestOptionMergeCommitId
{-# INLINE mergePullRequestOptionMergeCommitIdL #-}

-- | 'mergePullRequestOptionMergeMessageField' Lens
mergePullRequestOptionMergeMessageFieldL :: Lens_' MergePullRequestOption (Maybe Text)
mergePullRequestOptionMergeMessageFieldL f MergePullRequestOption{..} = (\mergePullRequestOptionMergeMessageField -> MergePullRequestOption { mergePullRequestOptionMergeMessageField, ..} ) <$> f mergePullRequestOptionMergeMessageField
{-# INLINE mergePullRequestOptionMergeMessageFieldL #-}

-- | 'mergePullRequestOptionMergeTitleField' Lens
mergePullRequestOptionMergeTitleFieldL :: Lens_' MergePullRequestOption (Maybe Text)
mergePullRequestOptionMergeTitleFieldL f MergePullRequestOption{..} = (\mergePullRequestOptionMergeTitleField -> MergePullRequestOption { mergePullRequestOptionMergeTitleField, ..} ) <$> f mergePullRequestOptionMergeTitleField
{-# INLINE mergePullRequestOptionMergeTitleFieldL #-}

-- | 'mergePullRequestOptionDeleteBranchAfterMerge' Lens
mergePullRequestOptionDeleteBranchAfterMergeL :: Lens_' MergePullRequestOption (Maybe Bool)
mergePullRequestOptionDeleteBranchAfterMergeL f MergePullRequestOption{..} = (\mergePullRequestOptionDeleteBranchAfterMerge -> MergePullRequestOption { mergePullRequestOptionDeleteBranchAfterMerge, ..} ) <$> f mergePullRequestOptionDeleteBranchAfterMerge
{-# INLINE mergePullRequestOptionDeleteBranchAfterMergeL #-}

-- | 'mergePullRequestOptionForceMerge' Lens
mergePullRequestOptionForceMergeL :: Lens_' MergePullRequestOption (Maybe Bool)
mergePullRequestOptionForceMergeL f MergePullRequestOption{..} = (\mergePullRequestOptionForceMerge -> MergePullRequestOption { mergePullRequestOptionForceMerge, ..} ) <$> f mergePullRequestOptionForceMerge
{-# INLINE mergePullRequestOptionForceMergeL #-}

-- | 'mergePullRequestOptionHeadCommitId' Lens
mergePullRequestOptionHeadCommitIdL :: Lens_' MergePullRequestOption (Maybe Text)
mergePullRequestOptionHeadCommitIdL f MergePullRequestOption{..} = (\mergePullRequestOptionHeadCommitId -> MergePullRequestOption { mergePullRequestOptionHeadCommitId, ..} ) <$> f mergePullRequestOptionHeadCommitId
{-# INLINE mergePullRequestOptionHeadCommitIdL #-}

-- | 'mergePullRequestOptionMergeWhenChecksSucceed' Lens
mergePullRequestOptionMergeWhenChecksSucceedL :: Lens_' MergePullRequestOption (Maybe Bool)
mergePullRequestOptionMergeWhenChecksSucceedL f MergePullRequestOption{..} = (\mergePullRequestOptionMergeWhenChecksSucceed -> MergePullRequestOption { mergePullRequestOptionMergeWhenChecksSucceed, ..} ) <$> f mergePullRequestOptionMergeWhenChecksSucceed
{-# INLINE mergePullRequestOptionMergeWhenChecksSucceedL #-}



-- * MigrateRepoOptions

-- | 'migrateRepoOptionsAuthPassword' Lens
migrateRepoOptionsAuthPasswordL :: Lens_' MigrateRepoOptions (Maybe Text)
migrateRepoOptionsAuthPasswordL f MigrateRepoOptions{..} = (\migrateRepoOptionsAuthPassword -> MigrateRepoOptions { migrateRepoOptionsAuthPassword, ..} ) <$> f migrateRepoOptionsAuthPassword
{-# INLINE migrateRepoOptionsAuthPasswordL #-}

-- | 'migrateRepoOptionsAuthToken' Lens
migrateRepoOptionsAuthTokenL :: Lens_' MigrateRepoOptions (Maybe Text)
migrateRepoOptionsAuthTokenL f MigrateRepoOptions{..} = (\migrateRepoOptionsAuthToken -> MigrateRepoOptions { migrateRepoOptionsAuthToken, ..} ) <$> f migrateRepoOptionsAuthToken
{-# INLINE migrateRepoOptionsAuthTokenL #-}

-- | 'migrateRepoOptionsAuthUsername' Lens
migrateRepoOptionsAuthUsernameL :: Lens_' MigrateRepoOptions (Maybe Text)
migrateRepoOptionsAuthUsernameL f MigrateRepoOptions{..} = (\migrateRepoOptionsAuthUsername -> MigrateRepoOptions { migrateRepoOptionsAuthUsername, ..} ) <$> f migrateRepoOptionsAuthUsername
{-# INLINE migrateRepoOptionsAuthUsernameL #-}

-- | 'migrateRepoOptionsCloneAddr' Lens
migrateRepoOptionsCloneAddrL :: Lens_' MigrateRepoOptions (Text)
migrateRepoOptionsCloneAddrL f MigrateRepoOptions{..} = (\migrateRepoOptionsCloneAddr -> MigrateRepoOptions { migrateRepoOptionsCloneAddr, ..} ) <$> f migrateRepoOptionsCloneAddr
{-# INLINE migrateRepoOptionsCloneAddrL #-}

-- | 'migrateRepoOptionsDescription' Lens
migrateRepoOptionsDescriptionL :: Lens_' MigrateRepoOptions (Maybe Text)
migrateRepoOptionsDescriptionL f MigrateRepoOptions{..} = (\migrateRepoOptionsDescription -> MigrateRepoOptions { migrateRepoOptionsDescription, ..} ) <$> f migrateRepoOptionsDescription
{-# INLINE migrateRepoOptionsDescriptionL #-}

-- | 'migrateRepoOptionsIssues' Lens
migrateRepoOptionsIssuesL :: Lens_' MigrateRepoOptions (Maybe Bool)
migrateRepoOptionsIssuesL f MigrateRepoOptions{..} = (\migrateRepoOptionsIssues -> MigrateRepoOptions { migrateRepoOptionsIssues, ..} ) <$> f migrateRepoOptionsIssues
{-# INLINE migrateRepoOptionsIssuesL #-}

-- | 'migrateRepoOptionsLabels' Lens
migrateRepoOptionsLabelsL :: Lens_' MigrateRepoOptions (Maybe Bool)
migrateRepoOptionsLabelsL f MigrateRepoOptions{..} = (\migrateRepoOptionsLabels -> MigrateRepoOptions { migrateRepoOptionsLabels, ..} ) <$> f migrateRepoOptionsLabels
{-# INLINE migrateRepoOptionsLabelsL #-}

-- | 'migrateRepoOptionsLfs' Lens
migrateRepoOptionsLfsL :: Lens_' MigrateRepoOptions (Maybe Bool)
migrateRepoOptionsLfsL f MigrateRepoOptions{..} = (\migrateRepoOptionsLfs -> MigrateRepoOptions { migrateRepoOptionsLfs, ..} ) <$> f migrateRepoOptionsLfs
{-# INLINE migrateRepoOptionsLfsL #-}

-- | 'migrateRepoOptionsLfsEndpoint' Lens
migrateRepoOptionsLfsEndpointL :: Lens_' MigrateRepoOptions (Maybe Text)
migrateRepoOptionsLfsEndpointL f MigrateRepoOptions{..} = (\migrateRepoOptionsLfsEndpoint -> MigrateRepoOptions { migrateRepoOptionsLfsEndpoint, ..} ) <$> f migrateRepoOptionsLfsEndpoint
{-# INLINE migrateRepoOptionsLfsEndpointL #-}

-- | 'migrateRepoOptionsMilestones' Lens
migrateRepoOptionsMilestonesL :: Lens_' MigrateRepoOptions (Maybe Bool)
migrateRepoOptionsMilestonesL f MigrateRepoOptions{..} = (\migrateRepoOptionsMilestones -> MigrateRepoOptions { migrateRepoOptionsMilestones, ..} ) <$> f migrateRepoOptionsMilestones
{-# INLINE migrateRepoOptionsMilestonesL #-}

-- | 'migrateRepoOptionsMirror' Lens
migrateRepoOptionsMirrorL :: Lens_' MigrateRepoOptions (Maybe Bool)
migrateRepoOptionsMirrorL f MigrateRepoOptions{..} = (\migrateRepoOptionsMirror -> MigrateRepoOptions { migrateRepoOptionsMirror, ..} ) <$> f migrateRepoOptionsMirror
{-# INLINE migrateRepoOptionsMirrorL #-}

-- | 'migrateRepoOptionsMirrorInterval' Lens
migrateRepoOptionsMirrorIntervalL :: Lens_' MigrateRepoOptions (Maybe Text)
migrateRepoOptionsMirrorIntervalL f MigrateRepoOptions{..} = (\migrateRepoOptionsMirrorInterval -> MigrateRepoOptions { migrateRepoOptionsMirrorInterval, ..} ) <$> f migrateRepoOptionsMirrorInterval
{-# INLINE migrateRepoOptionsMirrorIntervalL #-}

-- | 'migrateRepoOptionsPrivate' Lens
migrateRepoOptionsPrivateL :: Lens_' MigrateRepoOptions (Maybe Bool)
migrateRepoOptionsPrivateL f MigrateRepoOptions{..} = (\migrateRepoOptionsPrivate -> MigrateRepoOptions { migrateRepoOptionsPrivate, ..} ) <$> f migrateRepoOptionsPrivate
{-# INLINE migrateRepoOptionsPrivateL #-}

-- | 'migrateRepoOptionsPullRequests' Lens
migrateRepoOptionsPullRequestsL :: Lens_' MigrateRepoOptions (Maybe Bool)
migrateRepoOptionsPullRequestsL f MigrateRepoOptions{..} = (\migrateRepoOptionsPullRequests -> MigrateRepoOptions { migrateRepoOptionsPullRequests, ..} ) <$> f migrateRepoOptionsPullRequests
{-# INLINE migrateRepoOptionsPullRequestsL #-}

-- | 'migrateRepoOptionsReleases' Lens
migrateRepoOptionsReleasesL :: Lens_' MigrateRepoOptions (Maybe Bool)
migrateRepoOptionsReleasesL f MigrateRepoOptions{..} = (\migrateRepoOptionsReleases -> MigrateRepoOptions { migrateRepoOptionsReleases, ..} ) <$> f migrateRepoOptionsReleases
{-# INLINE migrateRepoOptionsReleasesL #-}

-- | 'migrateRepoOptionsRepoName' Lens
migrateRepoOptionsRepoNameL :: Lens_' MigrateRepoOptions (Text)
migrateRepoOptionsRepoNameL f MigrateRepoOptions{..} = (\migrateRepoOptionsRepoName -> MigrateRepoOptions { migrateRepoOptionsRepoName, ..} ) <$> f migrateRepoOptionsRepoName
{-# INLINE migrateRepoOptionsRepoNameL #-}

-- | 'migrateRepoOptionsRepoOwner' Lens
migrateRepoOptionsRepoOwnerL :: Lens_' MigrateRepoOptions (Maybe Text)
migrateRepoOptionsRepoOwnerL f MigrateRepoOptions{..} = (\migrateRepoOptionsRepoOwner -> MigrateRepoOptions { migrateRepoOptionsRepoOwner, ..} ) <$> f migrateRepoOptionsRepoOwner
{-# INLINE migrateRepoOptionsRepoOwnerL #-}

-- | 'migrateRepoOptionsService' Lens
migrateRepoOptionsServiceL :: Lens_' MigrateRepoOptions (Maybe E'Service)
migrateRepoOptionsServiceL f MigrateRepoOptions{..} = (\migrateRepoOptionsService -> MigrateRepoOptions { migrateRepoOptionsService, ..} ) <$> f migrateRepoOptionsService
{-# INLINE migrateRepoOptionsServiceL #-}

-- | 'migrateRepoOptionsUid' Lens
migrateRepoOptionsUidL :: Lens_' MigrateRepoOptions (Maybe Integer)
migrateRepoOptionsUidL f MigrateRepoOptions{..} = (\migrateRepoOptionsUid -> MigrateRepoOptions { migrateRepoOptionsUid, ..} ) <$> f migrateRepoOptionsUid
{-# INLINE migrateRepoOptionsUidL #-}

-- | 'migrateRepoOptionsWiki' Lens
migrateRepoOptionsWikiL :: Lens_' MigrateRepoOptions (Maybe Bool)
migrateRepoOptionsWikiL f MigrateRepoOptions{..} = (\migrateRepoOptionsWiki -> MigrateRepoOptions { migrateRepoOptionsWiki, ..} ) <$> f migrateRepoOptionsWiki
{-# INLINE migrateRepoOptionsWikiL #-}



-- * Milestone

-- | 'milestoneClosedAt' Lens
milestoneClosedAtL :: Lens_' Milestone (Maybe DateTime)
milestoneClosedAtL f Milestone{..} = (\milestoneClosedAt -> Milestone { milestoneClosedAt, ..} ) <$> f milestoneClosedAt
{-# INLINE milestoneClosedAtL #-}

-- | 'milestoneClosedIssues' Lens
milestoneClosedIssuesL :: Lens_' Milestone (Maybe Integer)
milestoneClosedIssuesL f Milestone{..} = (\milestoneClosedIssues -> Milestone { milestoneClosedIssues, ..} ) <$> f milestoneClosedIssues
{-# INLINE milestoneClosedIssuesL #-}

-- | 'milestoneCreatedAt' Lens
milestoneCreatedAtL :: Lens_' Milestone (Maybe DateTime)
milestoneCreatedAtL f Milestone{..} = (\milestoneCreatedAt -> Milestone { milestoneCreatedAt, ..} ) <$> f milestoneCreatedAt
{-# INLINE milestoneCreatedAtL #-}

-- | 'milestoneDescription' Lens
milestoneDescriptionL :: Lens_' Milestone (Maybe Text)
milestoneDescriptionL f Milestone{..} = (\milestoneDescription -> Milestone { milestoneDescription, ..} ) <$> f milestoneDescription
{-# INLINE milestoneDescriptionL #-}

-- | 'milestoneDueOn' Lens
milestoneDueOnL :: Lens_' Milestone (Maybe DateTime)
milestoneDueOnL f Milestone{..} = (\milestoneDueOn -> Milestone { milestoneDueOn, ..} ) <$> f milestoneDueOn
{-# INLINE milestoneDueOnL #-}

-- | 'milestoneId' Lens
milestoneIdL :: Lens_' Milestone (Maybe Integer)
milestoneIdL f Milestone{..} = (\milestoneId -> Milestone { milestoneId, ..} ) <$> f milestoneId
{-# INLINE milestoneIdL #-}

-- | 'milestoneOpenIssues' Lens
milestoneOpenIssuesL :: Lens_' Milestone (Maybe Integer)
milestoneOpenIssuesL f Milestone{..} = (\milestoneOpenIssues -> Milestone { milestoneOpenIssues, ..} ) <$> f milestoneOpenIssues
{-# INLINE milestoneOpenIssuesL #-}

-- | 'milestoneState' Lens
milestoneStateL :: Lens_' Milestone (Maybe Text)
milestoneStateL f Milestone{..} = (\milestoneState -> Milestone { milestoneState, ..} ) <$> f milestoneState
{-# INLINE milestoneStateL #-}

-- | 'milestoneTitle' Lens
milestoneTitleL :: Lens_' Milestone (Maybe Text)
milestoneTitleL f Milestone{..} = (\milestoneTitle -> Milestone { milestoneTitle, ..} ) <$> f milestoneTitle
{-# INLINE milestoneTitleL #-}

-- | 'milestoneUpdatedAt' Lens
milestoneUpdatedAtL :: Lens_' Milestone (Maybe DateTime)
milestoneUpdatedAtL f Milestone{..} = (\milestoneUpdatedAt -> Milestone { milestoneUpdatedAt, ..} ) <$> f milestoneUpdatedAt
{-# INLINE milestoneUpdatedAtL #-}



-- * NewIssuePinsAllowed

-- | 'newIssuePinsAllowedIssues' Lens
newIssuePinsAllowedIssuesL :: Lens_' NewIssuePinsAllowed (Maybe Bool)
newIssuePinsAllowedIssuesL f NewIssuePinsAllowed{..} = (\newIssuePinsAllowedIssues -> NewIssuePinsAllowed { newIssuePinsAllowedIssues, ..} ) <$> f newIssuePinsAllowedIssues
{-# INLINE newIssuePinsAllowedIssuesL #-}

-- | 'newIssuePinsAllowedPullRequests' Lens
newIssuePinsAllowedPullRequestsL :: Lens_' NewIssuePinsAllowed (Maybe Bool)
newIssuePinsAllowedPullRequestsL f NewIssuePinsAllowed{..} = (\newIssuePinsAllowedPullRequests -> NewIssuePinsAllowed { newIssuePinsAllowedPullRequests, ..} ) <$> f newIssuePinsAllowedPullRequests
{-# INLINE newIssuePinsAllowedPullRequestsL #-}



-- * NodeInfo

-- | 'nodeInfoMetadata' Lens
nodeInfoMetadataL :: Lens_' NodeInfo (Maybe A.Value)
nodeInfoMetadataL f NodeInfo{..} = (\nodeInfoMetadata -> NodeInfo { nodeInfoMetadata, ..} ) <$> f nodeInfoMetadata
{-# INLINE nodeInfoMetadataL #-}

-- | 'nodeInfoOpenRegistrations' Lens
nodeInfoOpenRegistrationsL :: Lens_' NodeInfo (Maybe Bool)
nodeInfoOpenRegistrationsL f NodeInfo{..} = (\nodeInfoOpenRegistrations -> NodeInfo { nodeInfoOpenRegistrations, ..} ) <$> f nodeInfoOpenRegistrations
{-# INLINE nodeInfoOpenRegistrationsL #-}

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

-- | 'nodeInfoServices' Lens
nodeInfoServicesL :: Lens_' NodeInfo (Maybe NodeInfoServices)
nodeInfoServicesL f NodeInfo{..} = (\nodeInfoServices -> NodeInfo { nodeInfoServices, ..} ) <$> f nodeInfoServices
{-# INLINE nodeInfoServicesL #-}

-- | 'nodeInfoSoftware' Lens
nodeInfoSoftwareL :: Lens_' NodeInfo (Maybe NodeInfoSoftware)
nodeInfoSoftwareL f NodeInfo{..} = (\nodeInfoSoftware -> NodeInfo { nodeInfoSoftware, ..} ) <$> f nodeInfoSoftware
{-# INLINE nodeInfoSoftwareL #-}

-- | 'nodeInfoUsage' Lens
nodeInfoUsageL :: Lens_' NodeInfo (Maybe NodeInfoUsage)
nodeInfoUsageL f NodeInfo{..} = (\nodeInfoUsage -> NodeInfo { nodeInfoUsage, ..} ) <$> f nodeInfoUsage
{-# INLINE nodeInfoUsageL #-}

-- | 'nodeInfoVersion' Lens
nodeInfoVersionL :: Lens_' NodeInfo (Maybe Text)
nodeInfoVersionL f NodeInfo{..} = (\nodeInfoVersion -> NodeInfo { nodeInfoVersion, ..} ) <$> f nodeInfoVersion
{-# INLINE nodeInfoVersionL #-}



-- * NodeInfoServices

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

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



-- * NodeInfoSoftware

-- | 'nodeInfoSoftwareHomepage' Lens
nodeInfoSoftwareHomepageL :: Lens_' NodeInfoSoftware (Maybe Text)
nodeInfoSoftwareHomepageL f NodeInfoSoftware{..} = (\nodeInfoSoftwareHomepage -> NodeInfoSoftware { nodeInfoSoftwareHomepage, ..} ) <$> f nodeInfoSoftwareHomepage
{-# INLINE nodeInfoSoftwareHomepageL #-}

-- | 'nodeInfoSoftwareName' Lens
nodeInfoSoftwareNameL :: Lens_' NodeInfoSoftware (Maybe Text)
nodeInfoSoftwareNameL f NodeInfoSoftware{..} = (\nodeInfoSoftwareName -> NodeInfoSoftware { nodeInfoSoftwareName, ..} ) <$> f nodeInfoSoftwareName
{-# INLINE nodeInfoSoftwareNameL #-}

-- | 'nodeInfoSoftwareRepository' Lens
nodeInfoSoftwareRepositoryL :: Lens_' NodeInfoSoftware (Maybe Text)
nodeInfoSoftwareRepositoryL f NodeInfoSoftware{..} = (\nodeInfoSoftwareRepository -> NodeInfoSoftware { nodeInfoSoftwareRepository, ..} ) <$> f nodeInfoSoftwareRepository
{-# INLINE nodeInfoSoftwareRepositoryL #-}

-- | 'nodeInfoSoftwareVersion' Lens
nodeInfoSoftwareVersionL :: Lens_' NodeInfoSoftware (Maybe Text)
nodeInfoSoftwareVersionL f NodeInfoSoftware{..} = (\nodeInfoSoftwareVersion -> NodeInfoSoftware { nodeInfoSoftwareVersion, ..} ) <$> f nodeInfoSoftwareVersion
{-# INLINE nodeInfoSoftwareVersionL #-}



-- * NodeInfoUsage

-- | 'nodeInfoUsageLocalComments' Lens
nodeInfoUsageLocalCommentsL :: Lens_' NodeInfoUsage (Maybe Integer)
nodeInfoUsageLocalCommentsL f NodeInfoUsage{..} = (\nodeInfoUsageLocalComments -> NodeInfoUsage { nodeInfoUsageLocalComments, ..} ) <$> f nodeInfoUsageLocalComments
{-# INLINE nodeInfoUsageLocalCommentsL #-}

-- | 'nodeInfoUsageLocalPosts' Lens
nodeInfoUsageLocalPostsL :: Lens_' NodeInfoUsage (Maybe Integer)
nodeInfoUsageLocalPostsL f NodeInfoUsage{..} = (\nodeInfoUsageLocalPosts -> NodeInfoUsage { nodeInfoUsageLocalPosts, ..} ) <$> f nodeInfoUsageLocalPosts
{-# INLINE nodeInfoUsageLocalPostsL #-}

-- | 'nodeInfoUsageUsers' Lens
nodeInfoUsageUsersL :: Lens_' NodeInfoUsage (Maybe NodeInfoUsageUsers)
nodeInfoUsageUsersL f NodeInfoUsage{..} = (\nodeInfoUsageUsers -> NodeInfoUsage { nodeInfoUsageUsers, ..} ) <$> f nodeInfoUsageUsers
{-# INLINE nodeInfoUsageUsersL #-}



-- * NodeInfoUsageUsers

-- | 'nodeInfoUsageUsersActiveHalfyear' Lens
nodeInfoUsageUsersActiveHalfyearL :: Lens_' NodeInfoUsageUsers (Maybe Integer)
nodeInfoUsageUsersActiveHalfyearL f NodeInfoUsageUsers{..} = (\nodeInfoUsageUsersActiveHalfyear -> NodeInfoUsageUsers { nodeInfoUsageUsersActiveHalfyear, ..} ) <$> f nodeInfoUsageUsersActiveHalfyear
{-# INLINE nodeInfoUsageUsersActiveHalfyearL #-}

-- | 'nodeInfoUsageUsersActiveMonth' Lens
nodeInfoUsageUsersActiveMonthL :: Lens_' NodeInfoUsageUsers (Maybe Integer)
nodeInfoUsageUsersActiveMonthL f NodeInfoUsageUsers{..} = (\nodeInfoUsageUsersActiveMonth -> NodeInfoUsageUsers { nodeInfoUsageUsersActiveMonth, ..} ) <$> f nodeInfoUsageUsersActiveMonth
{-# INLINE nodeInfoUsageUsersActiveMonthL #-}

-- | 'nodeInfoUsageUsersTotal' Lens
nodeInfoUsageUsersTotalL :: Lens_' NodeInfoUsageUsers (Maybe Integer)
nodeInfoUsageUsersTotalL f NodeInfoUsageUsers{..} = (\nodeInfoUsageUsersTotal -> NodeInfoUsageUsers { nodeInfoUsageUsersTotal, ..} ) <$> f nodeInfoUsageUsersTotal
{-# INLINE nodeInfoUsageUsersTotalL #-}



-- * Note

-- | 'noteCommit' Lens
noteCommitL :: Lens_' Note (Maybe Commit)
noteCommitL f Note{..} = (\noteCommit -> Note { noteCommit, ..} ) <$> f noteCommit
{-# INLINE noteCommitL #-}

-- | 'noteMessage' Lens
noteMessageL :: Lens_' Note (Maybe Text)
noteMessageL f Note{..} = (\noteMessage -> Note { noteMessage, ..} ) <$> f noteMessage
{-# INLINE noteMessageL #-}



-- * NotificationCount

-- | 'notificationCountNew' Lens
notificationCountNewL :: Lens_' NotificationCount (Maybe Integer)
notificationCountNewL f NotificationCount{..} = (\notificationCountNew -> NotificationCount { notificationCountNew, ..} ) <$> f notificationCountNew
{-# INLINE notificationCountNewL #-}



-- * NotificationSubject

-- | 'notificationSubjectHtmlUrl' Lens
notificationSubjectHtmlUrlL :: Lens_' NotificationSubject (Maybe Text)
notificationSubjectHtmlUrlL f NotificationSubject{..} = (\notificationSubjectHtmlUrl -> NotificationSubject { notificationSubjectHtmlUrl, ..} ) <$> f notificationSubjectHtmlUrl
{-# INLINE notificationSubjectHtmlUrlL #-}

-- | 'notificationSubjectLatestCommentHtmlUrl' Lens
notificationSubjectLatestCommentHtmlUrlL :: Lens_' NotificationSubject (Maybe Text)
notificationSubjectLatestCommentHtmlUrlL f NotificationSubject{..} = (\notificationSubjectLatestCommentHtmlUrl -> NotificationSubject { notificationSubjectLatestCommentHtmlUrl, ..} ) <$> f notificationSubjectLatestCommentHtmlUrl
{-# INLINE notificationSubjectLatestCommentHtmlUrlL #-}

-- | 'notificationSubjectLatestCommentUrl' Lens
notificationSubjectLatestCommentUrlL :: Lens_' NotificationSubject (Maybe Text)
notificationSubjectLatestCommentUrlL f NotificationSubject{..} = (\notificationSubjectLatestCommentUrl -> NotificationSubject { notificationSubjectLatestCommentUrl, ..} ) <$> f notificationSubjectLatestCommentUrl
{-# INLINE notificationSubjectLatestCommentUrlL #-}

-- | 'notificationSubjectState' Lens
notificationSubjectStateL :: Lens_' NotificationSubject (Maybe Text)
notificationSubjectStateL f NotificationSubject{..} = (\notificationSubjectState -> NotificationSubject { notificationSubjectState, ..} ) <$> f notificationSubjectState
{-# INLINE notificationSubjectStateL #-}

-- | 'notificationSubjectTitle' Lens
notificationSubjectTitleL :: Lens_' NotificationSubject (Maybe Text)
notificationSubjectTitleL f NotificationSubject{..} = (\notificationSubjectTitle -> NotificationSubject { notificationSubjectTitle, ..} ) <$> f notificationSubjectTitle
{-# INLINE notificationSubjectTitleL #-}

-- | 'notificationSubjectType' Lens
notificationSubjectTypeL :: Lens_' NotificationSubject (Maybe Text)
notificationSubjectTypeL f NotificationSubject{..} = (\notificationSubjectType -> NotificationSubject { notificationSubjectType, ..} ) <$> f notificationSubjectType
{-# INLINE notificationSubjectTypeL #-}

-- | 'notificationSubjectUrl' Lens
notificationSubjectUrlL :: Lens_' NotificationSubject (Maybe Text)
notificationSubjectUrlL f NotificationSubject{..} = (\notificationSubjectUrl -> NotificationSubject { notificationSubjectUrl, ..} ) <$> f notificationSubjectUrl
{-# INLINE notificationSubjectUrlL #-}



-- * NotificationThread

-- | 'notificationThreadId' Lens
notificationThreadIdL :: Lens_' NotificationThread (Maybe Integer)
notificationThreadIdL f NotificationThread{..} = (\notificationThreadId -> NotificationThread { notificationThreadId, ..} ) <$> f notificationThreadId
{-# INLINE notificationThreadIdL #-}

-- | 'notificationThreadPinned' Lens
notificationThreadPinnedL :: Lens_' NotificationThread (Maybe Bool)
notificationThreadPinnedL f NotificationThread{..} = (\notificationThreadPinned -> NotificationThread { notificationThreadPinned, ..} ) <$> f notificationThreadPinned
{-# INLINE notificationThreadPinnedL #-}

-- | 'notificationThreadRepository' Lens
notificationThreadRepositoryL :: Lens_' NotificationThread (Maybe Repository)
notificationThreadRepositoryL f NotificationThread{..} = (\notificationThreadRepository -> NotificationThread { notificationThreadRepository, ..} ) <$> f notificationThreadRepository
{-# INLINE notificationThreadRepositoryL #-}

-- | 'notificationThreadSubject' Lens
notificationThreadSubjectL :: Lens_' NotificationThread (Maybe NotificationSubject)
notificationThreadSubjectL f NotificationThread{..} = (\notificationThreadSubject -> NotificationThread { notificationThreadSubject, ..} ) <$> f notificationThreadSubject
{-# INLINE notificationThreadSubjectL #-}

-- | 'notificationThreadUnread' Lens
notificationThreadUnreadL :: Lens_' NotificationThread (Maybe Bool)
notificationThreadUnreadL f NotificationThread{..} = (\notificationThreadUnread -> NotificationThread { notificationThreadUnread, ..} ) <$> f notificationThreadUnread
{-# INLINE notificationThreadUnreadL #-}

-- | 'notificationThreadUpdatedAt' Lens
notificationThreadUpdatedAtL :: Lens_' NotificationThread (Maybe DateTime)
notificationThreadUpdatedAtL f NotificationThread{..} = (\notificationThreadUpdatedAt -> NotificationThread { notificationThreadUpdatedAt, ..} ) <$> f notificationThreadUpdatedAt
{-# INLINE notificationThreadUpdatedAtL #-}

-- | 'notificationThreadUrl' Lens
notificationThreadUrlL :: Lens_' NotificationThread (Maybe Text)
notificationThreadUrlL f NotificationThread{..} = (\notificationThreadUrl -> NotificationThread { notificationThreadUrl, ..} ) <$> f notificationThreadUrl
{-# INLINE notificationThreadUrlL #-}



-- * OAuth2Application

-- | 'oAuth2ApplicationClientId' Lens
oAuth2ApplicationClientIdL :: Lens_' OAuth2Application (Maybe Text)
oAuth2ApplicationClientIdL f OAuth2Application{..} = (\oAuth2ApplicationClientId -> OAuth2Application { oAuth2ApplicationClientId, ..} ) <$> f oAuth2ApplicationClientId
{-# INLINE oAuth2ApplicationClientIdL #-}

-- | 'oAuth2ApplicationClientSecret' Lens
oAuth2ApplicationClientSecretL :: Lens_' OAuth2Application (Maybe Text)
oAuth2ApplicationClientSecretL f OAuth2Application{..} = (\oAuth2ApplicationClientSecret -> OAuth2Application { oAuth2ApplicationClientSecret, ..} ) <$> f oAuth2ApplicationClientSecret
{-# INLINE oAuth2ApplicationClientSecretL #-}

-- | 'oAuth2ApplicationConfidentialClient' Lens
oAuth2ApplicationConfidentialClientL :: Lens_' OAuth2Application (Maybe Bool)
oAuth2ApplicationConfidentialClientL f OAuth2Application{..} = (\oAuth2ApplicationConfidentialClient -> OAuth2Application { oAuth2ApplicationConfidentialClient, ..} ) <$> f oAuth2ApplicationConfidentialClient
{-# INLINE oAuth2ApplicationConfidentialClientL #-}

-- | 'oAuth2ApplicationCreated' Lens
oAuth2ApplicationCreatedL :: Lens_' OAuth2Application (Maybe DateTime)
oAuth2ApplicationCreatedL f OAuth2Application{..} = (\oAuth2ApplicationCreated -> OAuth2Application { oAuth2ApplicationCreated, ..} ) <$> f oAuth2ApplicationCreated
{-# INLINE oAuth2ApplicationCreatedL #-}

-- | 'oAuth2ApplicationId' Lens
oAuth2ApplicationIdL :: Lens_' OAuth2Application (Maybe Integer)
oAuth2ApplicationIdL f OAuth2Application{..} = (\oAuth2ApplicationId -> OAuth2Application { oAuth2ApplicationId, ..} ) <$> f oAuth2ApplicationId
{-# INLINE oAuth2ApplicationIdL #-}

-- | 'oAuth2ApplicationName' Lens
oAuth2ApplicationNameL :: Lens_' OAuth2Application (Maybe Text)
oAuth2ApplicationNameL f OAuth2Application{..} = (\oAuth2ApplicationName -> OAuth2Application { oAuth2ApplicationName, ..} ) <$> f oAuth2ApplicationName
{-# INLINE oAuth2ApplicationNameL #-}

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



-- * Organization

-- | 'organizationAvatarUrl' Lens
organizationAvatarUrlL :: Lens_' Organization (Maybe Text)
organizationAvatarUrlL f Organization{..} = (\organizationAvatarUrl -> Organization { organizationAvatarUrl, ..} ) <$> f organizationAvatarUrl
{-# INLINE organizationAvatarUrlL #-}

-- | 'organizationDescription' Lens
organizationDescriptionL :: Lens_' Organization (Maybe Text)
organizationDescriptionL f Organization{..} = (\organizationDescription -> Organization { organizationDescription, ..} ) <$> f organizationDescription
{-# INLINE organizationDescriptionL #-}

-- | 'organizationFullName' Lens
organizationFullNameL :: Lens_' Organization (Maybe Text)
organizationFullNameL f Organization{..} = (\organizationFullName -> Organization { organizationFullName, ..} ) <$> f organizationFullName
{-# INLINE organizationFullNameL #-}

-- | 'organizationId' Lens
organizationIdL :: Lens_' Organization (Maybe Integer)
organizationIdL f Organization{..} = (\organizationId -> Organization { organizationId, ..} ) <$> f organizationId
{-# INLINE organizationIdL #-}

-- | 'organizationLocation' Lens
organizationLocationL :: Lens_' Organization (Maybe Text)
organizationLocationL f Organization{..} = (\organizationLocation -> Organization { organizationLocation, ..} ) <$> f organizationLocation
{-# INLINE organizationLocationL #-}

-- | 'organizationName' Lens
organizationNameL :: Lens_' Organization (Maybe Text)
organizationNameL f Organization{..} = (\organizationName -> Organization { organizationName, ..} ) <$> f organizationName
{-# INLINE organizationNameL #-}

-- | 'organizationRepoAdminChangeTeamAccess' Lens
organizationRepoAdminChangeTeamAccessL :: Lens_' Organization (Maybe Bool)
organizationRepoAdminChangeTeamAccessL f Organization{..} = (\organizationRepoAdminChangeTeamAccess -> Organization { organizationRepoAdminChangeTeamAccess, ..} ) <$> f organizationRepoAdminChangeTeamAccess
{-# INLINE organizationRepoAdminChangeTeamAccessL #-}

-- | 'organizationUsername' Lens
organizationUsernameL :: Lens_' Organization (Maybe Text)
organizationUsernameL f Organization{..} = (\organizationUsername -> Organization { organizationUsername, ..} ) <$> f organizationUsername
{-# INLINE organizationUsernameL #-}

-- | 'organizationVisibility' Lens
organizationVisibilityL :: Lens_' Organization (Maybe Text)
organizationVisibilityL f Organization{..} = (\organizationVisibility -> Organization { organizationVisibility, ..} ) <$> f organizationVisibility
{-# INLINE organizationVisibilityL #-}

-- | 'organizationWebsite' Lens
organizationWebsiteL :: Lens_' Organization (Maybe Text)
organizationWebsiteL f Organization{..} = (\organizationWebsite -> Organization { organizationWebsite, ..} ) <$> f organizationWebsite
{-# INLINE organizationWebsiteL #-}



-- * OrganizationPermissions

-- | 'organizationPermissionsCanCreateRepository' Lens
organizationPermissionsCanCreateRepositoryL :: Lens_' OrganizationPermissions (Maybe Bool)
organizationPermissionsCanCreateRepositoryL f OrganizationPermissions{..} = (\organizationPermissionsCanCreateRepository -> OrganizationPermissions { organizationPermissionsCanCreateRepository, ..} ) <$> f organizationPermissionsCanCreateRepository
{-# INLINE organizationPermissionsCanCreateRepositoryL #-}

-- | 'organizationPermissionsCanRead' Lens
organizationPermissionsCanReadL :: Lens_' OrganizationPermissions (Maybe Bool)
organizationPermissionsCanReadL f OrganizationPermissions{..} = (\organizationPermissionsCanRead -> OrganizationPermissions { organizationPermissionsCanRead, ..} ) <$> f organizationPermissionsCanRead
{-# INLINE organizationPermissionsCanReadL #-}

-- | 'organizationPermissionsCanWrite' Lens
organizationPermissionsCanWriteL :: Lens_' OrganizationPermissions (Maybe Bool)
organizationPermissionsCanWriteL f OrganizationPermissions{..} = (\organizationPermissionsCanWrite -> OrganizationPermissions { organizationPermissionsCanWrite, ..} ) <$> f organizationPermissionsCanWrite
{-# INLINE organizationPermissionsCanWriteL #-}

-- | 'organizationPermissionsIsAdmin' Lens
organizationPermissionsIsAdminL :: Lens_' OrganizationPermissions (Maybe Bool)
organizationPermissionsIsAdminL f OrganizationPermissions{..} = (\organizationPermissionsIsAdmin -> OrganizationPermissions { organizationPermissionsIsAdmin, ..} ) <$> f organizationPermissionsIsAdmin
{-# INLINE organizationPermissionsIsAdminL #-}

-- | 'organizationPermissionsIsOwner' Lens
organizationPermissionsIsOwnerL :: Lens_' OrganizationPermissions (Maybe Bool)
organizationPermissionsIsOwnerL f OrganizationPermissions{..} = (\organizationPermissionsIsOwner -> OrganizationPermissions { organizationPermissionsIsOwner, ..} ) <$> f organizationPermissionsIsOwner
{-# INLINE organizationPermissionsIsOwnerL #-}



-- * PRBranchInfo

-- | 'pRBranchInfoLabel' Lens
pRBranchInfoLabelL :: Lens_' PRBranchInfo (Maybe Text)
pRBranchInfoLabelL f PRBranchInfo{..} = (\pRBranchInfoLabel -> PRBranchInfo { pRBranchInfoLabel, ..} ) <$> f pRBranchInfoLabel
{-# INLINE pRBranchInfoLabelL #-}

-- | 'pRBranchInfoRef' Lens
pRBranchInfoRefL :: Lens_' PRBranchInfo (Maybe Text)
pRBranchInfoRefL f PRBranchInfo{..} = (\pRBranchInfoRef -> PRBranchInfo { pRBranchInfoRef, ..} ) <$> f pRBranchInfoRef
{-# INLINE pRBranchInfoRefL #-}

-- | 'pRBranchInfoRepo' Lens
pRBranchInfoRepoL :: Lens_' PRBranchInfo (Maybe Repository)
pRBranchInfoRepoL f PRBranchInfo{..} = (\pRBranchInfoRepo -> PRBranchInfo { pRBranchInfoRepo, ..} ) <$> f pRBranchInfoRepo
{-# INLINE pRBranchInfoRepoL #-}

-- | 'pRBranchInfoRepoId' Lens
pRBranchInfoRepoIdL :: Lens_' PRBranchInfo (Maybe Integer)
pRBranchInfoRepoIdL f PRBranchInfo{..} = (\pRBranchInfoRepoId -> PRBranchInfo { pRBranchInfoRepoId, ..} ) <$> f pRBranchInfoRepoId
{-# INLINE pRBranchInfoRepoIdL #-}

-- | 'pRBranchInfoSha' Lens
pRBranchInfoShaL :: Lens_' PRBranchInfo (Maybe Text)
pRBranchInfoShaL f PRBranchInfo{..} = (\pRBranchInfoSha -> PRBranchInfo { pRBranchInfoSha, ..} ) <$> f pRBranchInfoSha
{-# INLINE pRBranchInfoShaL #-}



-- * Package

-- | 'packageCreatedAt' Lens
packageCreatedAtL :: Lens_' Package (Maybe DateTime)
packageCreatedAtL f Package{..} = (\packageCreatedAt -> Package { packageCreatedAt, ..} ) <$> f packageCreatedAt
{-# INLINE packageCreatedAtL #-}

-- | 'packageCreator' Lens
packageCreatorL :: Lens_' Package (Maybe User)
packageCreatorL f Package{..} = (\packageCreator -> Package { packageCreator, ..} ) <$> f packageCreator
{-# INLINE packageCreatorL #-}

-- | 'packageHtmlUrl' Lens
packageHtmlUrlL :: Lens_' Package (Maybe Text)
packageHtmlUrlL f Package{..} = (\packageHtmlUrl -> Package { packageHtmlUrl, ..} ) <$> f packageHtmlUrl
{-# INLINE packageHtmlUrlL #-}

-- | 'packageId' Lens
packageIdL :: Lens_' Package (Maybe Integer)
packageIdL f Package{..} = (\packageId -> Package { packageId, ..} ) <$> f packageId
{-# INLINE packageIdL #-}

-- | 'packageName' Lens
packageNameL :: Lens_' Package (Maybe Text)
packageNameL f Package{..} = (\packageName -> Package { packageName, ..} ) <$> f packageName
{-# INLINE packageNameL #-}

-- | 'packageOwner' Lens
packageOwnerL :: Lens_' Package (Maybe User)
packageOwnerL f Package{..} = (\packageOwner -> Package { packageOwner, ..} ) <$> f packageOwner
{-# INLINE packageOwnerL #-}

-- | 'packageRepository' Lens
packageRepositoryL :: Lens_' Package (Maybe Repository)
packageRepositoryL f Package{..} = (\packageRepository -> Package { packageRepository, ..} ) <$> f packageRepository
{-# INLINE packageRepositoryL #-}

-- | 'packageType' Lens
packageTypeL :: Lens_' Package (Maybe Text)
packageTypeL f Package{..} = (\packageType -> Package { packageType, ..} ) <$> f packageType
{-# INLINE packageTypeL #-}

-- | 'packageVersion' Lens
packageVersionL :: Lens_' Package (Maybe Text)
packageVersionL f Package{..} = (\packageVersion -> Package { packageVersion, ..} ) <$> f packageVersion
{-# INLINE packageVersionL #-}



-- * PackageFile

-- | 'packageFileSize' Lens
packageFileSizeL :: Lens_' PackageFile (Maybe Integer)
packageFileSizeL f PackageFile{..} = (\packageFileSize -> PackageFile { packageFileSize, ..} ) <$> f packageFileSize
{-# INLINE packageFileSizeL #-}

-- | 'packageFileId' Lens
packageFileIdL :: Lens_' PackageFile (Maybe Integer)
packageFileIdL f PackageFile{..} = (\packageFileId -> PackageFile { packageFileId, ..} ) <$> f packageFileId
{-# INLINE packageFileIdL #-}

-- | 'packageFileMd5' Lens
packageFileMd5L :: Lens_' PackageFile (Maybe Text)
packageFileMd5L f PackageFile{..} = (\packageFileMd5 -> PackageFile { packageFileMd5, ..} ) <$> f packageFileMd5
{-# INLINE packageFileMd5L #-}

-- | 'packageFileName' Lens
packageFileNameL :: Lens_' PackageFile (Maybe Text)
packageFileNameL f PackageFile{..} = (\packageFileName -> PackageFile { packageFileName, ..} ) <$> f packageFileName
{-# INLINE packageFileNameL #-}

-- | 'packageFileSha1' Lens
packageFileSha1L :: Lens_' PackageFile (Maybe Text)
packageFileSha1L f PackageFile{..} = (\packageFileSha1 -> PackageFile { packageFileSha1, ..} ) <$> f packageFileSha1
{-# INLINE packageFileSha1L #-}

-- | 'packageFileSha256' Lens
packageFileSha256L :: Lens_' PackageFile (Maybe Text)
packageFileSha256L f PackageFile{..} = (\packageFileSha256 -> PackageFile { packageFileSha256, ..} ) <$> f packageFileSha256
{-# INLINE packageFileSha256L #-}

-- | 'packageFileSha512' Lens
packageFileSha512L :: Lens_' PackageFile (Maybe Text)
packageFileSha512L f PackageFile{..} = (\packageFileSha512 -> PackageFile { packageFileSha512, ..} ) <$> f packageFileSha512
{-# INLINE packageFileSha512L #-}



-- * PayloadCommit

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

-- | 'payloadCommitAuthor' Lens
payloadCommitAuthorL :: Lens_' PayloadCommit (Maybe PayloadUser)
payloadCommitAuthorL f PayloadCommit{..} = (\payloadCommitAuthor -> PayloadCommit { payloadCommitAuthor, ..} ) <$> f payloadCommitAuthor
{-# INLINE payloadCommitAuthorL #-}

-- | 'payloadCommitCommitter' Lens
payloadCommitCommitterL :: Lens_' PayloadCommit (Maybe PayloadUser)
payloadCommitCommitterL f PayloadCommit{..} = (\payloadCommitCommitter -> PayloadCommit { payloadCommitCommitter, ..} ) <$> f payloadCommitCommitter
{-# INLINE payloadCommitCommitterL #-}

-- | 'payloadCommitId' Lens
payloadCommitIdL :: Lens_' PayloadCommit (Maybe Text)
payloadCommitIdL f PayloadCommit{..} = (\payloadCommitId -> PayloadCommit { payloadCommitId, ..} ) <$> f payloadCommitId
{-# INLINE payloadCommitIdL #-}

-- | 'payloadCommitMessage' Lens
payloadCommitMessageL :: Lens_' PayloadCommit (Maybe Text)
payloadCommitMessageL f PayloadCommit{..} = (\payloadCommitMessage -> PayloadCommit { payloadCommitMessage, ..} ) <$> f payloadCommitMessage
{-# INLINE payloadCommitMessageL #-}

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

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

-- | 'payloadCommitTimestamp' Lens
payloadCommitTimestampL :: Lens_' PayloadCommit (Maybe DateTime)
payloadCommitTimestampL f PayloadCommit{..} = (\payloadCommitTimestamp -> PayloadCommit { payloadCommitTimestamp, ..} ) <$> f payloadCommitTimestamp
{-# INLINE payloadCommitTimestampL #-}

-- | 'payloadCommitUrl' Lens
payloadCommitUrlL :: Lens_' PayloadCommit (Maybe Text)
payloadCommitUrlL f PayloadCommit{..} = (\payloadCommitUrl -> PayloadCommit { payloadCommitUrl, ..} ) <$> f payloadCommitUrl
{-# INLINE payloadCommitUrlL #-}

-- | 'payloadCommitVerification' Lens
payloadCommitVerificationL :: Lens_' PayloadCommit (Maybe PayloadCommitVerification)
payloadCommitVerificationL f PayloadCommit{..} = (\payloadCommitVerification -> PayloadCommit { payloadCommitVerification, ..} ) <$> f payloadCommitVerification
{-# INLINE payloadCommitVerificationL #-}



-- * PayloadCommitVerification

-- | 'payloadCommitVerificationPayload' Lens
payloadCommitVerificationPayloadL :: Lens_' PayloadCommitVerification (Maybe Text)
payloadCommitVerificationPayloadL f PayloadCommitVerification{..} = (\payloadCommitVerificationPayload -> PayloadCommitVerification { payloadCommitVerificationPayload, ..} ) <$> f payloadCommitVerificationPayload
{-# INLINE payloadCommitVerificationPayloadL #-}

-- | 'payloadCommitVerificationReason' Lens
payloadCommitVerificationReasonL :: Lens_' PayloadCommitVerification (Maybe Text)
payloadCommitVerificationReasonL f PayloadCommitVerification{..} = (\payloadCommitVerificationReason -> PayloadCommitVerification { payloadCommitVerificationReason, ..} ) <$> f payloadCommitVerificationReason
{-# INLINE payloadCommitVerificationReasonL #-}

-- | 'payloadCommitVerificationSignature' Lens
payloadCommitVerificationSignatureL :: Lens_' PayloadCommitVerification (Maybe Text)
payloadCommitVerificationSignatureL f PayloadCommitVerification{..} = (\payloadCommitVerificationSignature -> PayloadCommitVerification { payloadCommitVerificationSignature, ..} ) <$> f payloadCommitVerificationSignature
{-# INLINE payloadCommitVerificationSignatureL #-}

-- | 'payloadCommitVerificationSigner' Lens
payloadCommitVerificationSignerL :: Lens_' PayloadCommitVerification (Maybe PayloadUser)
payloadCommitVerificationSignerL f PayloadCommitVerification{..} = (\payloadCommitVerificationSigner -> PayloadCommitVerification { payloadCommitVerificationSigner, ..} ) <$> f payloadCommitVerificationSigner
{-# INLINE payloadCommitVerificationSignerL #-}

-- | 'payloadCommitVerificationVerified' Lens
payloadCommitVerificationVerifiedL :: Lens_' PayloadCommitVerification (Maybe Bool)
payloadCommitVerificationVerifiedL f PayloadCommitVerification{..} = (\payloadCommitVerificationVerified -> PayloadCommitVerification { payloadCommitVerificationVerified, ..} ) <$> f payloadCommitVerificationVerified
{-# INLINE payloadCommitVerificationVerifiedL #-}



-- * PayloadUser

-- | 'payloadUserEmail' Lens
payloadUserEmailL :: Lens_' PayloadUser (Maybe Text)
payloadUserEmailL f PayloadUser{..} = (\payloadUserEmail -> PayloadUser { payloadUserEmail, ..} ) <$> f payloadUserEmail
{-# INLINE payloadUserEmailL #-}

-- | 'payloadUserName' Lens
payloadUserNameL :: Lens_' PayloadUser (Maybe Text)
payloadUserNameL f PayloadUser{..} = (\payloadUserName -> PayloadUser { payloadUserName, ..} ) <$> f payloadUserName
{-# INLINE payloadUserNameL #-}

-- | 'payloadUserUsername' Lens
payloadUserUsernameL :: Lens_' PayloadUser (Maybe Text)
payloadUserUsernameL f PayloadUser{..} = (\payloadUserUsername -> PayloadUser { payloadUserUsername, ..} ) <$> f payloadUserUsername
{-# INLINE payloadUserUsernameL #-}



-- * Permission

-- | 'permissionAdmin' Lens
permissionAdminL :: Lens_' Permission (Maybe Bool)
permissionAdminL f Permission{..} = (\permissionAdmin -> Permission { permissionAdmin, ..} ) <$> f permissionAdmin
{-# INLINE permissionAdminL #-}

-- | 'permissionPull' Lens
permissionPullL :: Lens_' Permission (Maybe Bool)
permissionPullL f Permission{..} = (\permissionPull -> Permission { permissionPull, ..} ) <$> f permissionPull
{-# INLINE permissionPullL #-}

-- | 'permissionPush' Lens
permissionPushL :: Lens_' Permission (Maybe Bool)
permissionPushL f Permission{..} = (\permissionPush -> Permission { permissionPush, ..} ) <$> f permissionPush
{-# INLINE permissionPushL #-}



-- * PublicKey

-- | 'publicKeyCreatedAt' Lens
publicKeyCreatedAtL :: Lens_' PublicKey (Maybe DateTime)
publicKeyCreatedAtL f PublicKey{..} = (\publicKeyCreatedAt -> PublicKey { publicKeyCreatedAt, ..} ) <$> f publicKeyCreatedAt
{-# INLINE publicKeyCreatedAtL #-}

-- | 'publicKeyFingerprint' Lens
publicKeyFingerprintL :: Lens_' PublicKey (Maybe Text)
publicKeyFingerprintL f PublicKey{..} = (\publicKeyFingerprint -> PublicKey { publicKeyFingerprint, ..} ) <$> f publicKeyFingerprint
{-# INLINE publicKeyFingerprintL #-}

-- | 'publicKeyId' Lens
publicKeyIdL :: Lens_' PublicKey (Maybe Integer)
publicKeyIdL f PublicKey{..} = (\publicKeyId -> PublicKey { publicKeyId, ..} ) <$> f publicKeyId
{-# INLINE publicKeyIdL #-}

-- | 'publicKeyKey' Lens
publicKeyKeyL :: Lens_' PublicKey (Maybe Text)
publicKeyKeyL f PublicKey{..} = (\publicKeyKey -> PublicKey { publicKeyKey, ..} ) <$> f publicKeyKey
{-# INLINE publicKeyKeyL #-}

-- | 'publicKeyKeyType' Lens
publicKeyKeyTypeL :: Lens_' PublicKey (Maybe Text)
publicKeyKeyTypeL f PublicKey{..} = (\publicKeyKeyType -> PublicKey { publicKeyKeyType, ..} ) <$> f publicKeyKeyType
{-# INLINE publicKeyKeyTypeL #-}

-- | 'publicKeyReadOnly' Lens
publicKeyReadOnlyL :: Lens_' PublicKey (Maybe Bool)
publicKeyReadOnlyL f PublicKey{..} = (\publicKeyReadOnly -> PublicKey { publicKeyReadOnly, ..} ) <$> f publicKeyReadOnly
{-# INLINE publicKeyReadOnlyL #-}

-- | 'publicKeyTitle' Lens
publicKeyTitleL :: Lens_' PublicKey (Maybe Text)
publicKeyTitleL f PublicKey{..} = (\publicKeyTitle -> PublicKey { publicKeyTitle, ..} ) <$> f publicKeyTitle
{-# INLINE publicKeyTitleL #-}

-- | 'publicKeyUrl' Lens
publicKeyUrlL :: Lens_' PublicKey (Maybe Text)
publicKeyUrlL f PublicKey{..} = (\publicKeyUrl -> PublicKey { publicKeyUrl, ..} ) <$> f publicKeyUrl
{-# INLINE publicKeyUrlL #-}

-- | 'publicKeyUser' Lens
publicKeyUserL :: Lens_' PublicKey (Maybe User)
publicKeyUserL f PublicKey{..} = (\publicKeyUser -> PublicKey { publicKeyUser, ..} ) <$> f publicKeyUser
{-# INLINE publicKeyUserL #-}



-- * PullRequest

-- | 'pullRequestAllowMaintainerEdit' Lens
pullRequestAllowMaintainerEditL :: Lens_' PullRequest (Maybe Bool)
pullRequestAllowMaintainerEditL f PullRequest{..} = (\pullRequestAllowMaintainerEdit -> PullRequest { pullRequestAllowMaintainerEdit, ..} ) <$> f pullRequestAllowMaintainerEdit
{-# INLINE pullRequestAllowMaintainerEditL #-}

-- | 'pullRequestAssignee' Lens
pullRequestAssigneeL :: Lens_' PullRequest (Maybe User)
pullRequestAssigneeL f PullRequest{..} = (\pullRequestAssignee -> PullRequest { pullRequestAssignee, ..} ) <$> f pullRequestAssignee
{-# INLINE pullRequestAssigneeL #-}

-- | 'pullRequestAssignees' Lens
pullRequestAssigneesL :: Lens_' PullRequest (Maybe [User])
pullRequestAssigneesL f PullRequest{..} = (\pullRequestAssignees -> PullRequest { pullRequestAssignees, ..} ) <$> f pullRequestAssignees
{-# INLINE pullRequestAssigneesL #-}

-- | 'pullRequestBase' Lens
pullRequestBaseL :: Lens_' PullRequest (Maybe PRBranchInfo)
pullRequestBaseL f PullRequest{..} = (\pullRequestBase -> PullRequest { pullRequestBase, ..} ) <$> f pullRequestBase
{-# INLINE pullRequestBaseL #-}

-- | 'pullRequestBody' Lens
pullRequestBodyL :: Lens_' PullRequest (Maybe Text)
pullRequestBodyL f PullRequest{..} = (\pullRequestBody -> PullRequest { pullRequestBody, ..} ) <$> f pullRequestBody
{-# INLINE pullRequestBodyL #-}

-- | 'pullRequestClosedAt' Lens
pullRequestClosedAtL :: Lens_' PullRequest (Maybe DateTime)
pullRequestClosedAtL f PullRequest{..} = (\pullRequestClosedAt -> PullRequest { pullRequestClosedAt, ..} ) <$> f pullRequestClosedAt
{-# INLINE pullRequestClosedAtL #-}

-- | 'pullRequestComments' Lens
pullRequestCommentsL :: Lens_' PullRequest (Maybe Integer)
pullRequestCommentsL f PullRequest{..} = (\pullRequestComments -> PullRequest { pullRequestComments, ..} ) <$> f pullRequestComments
{-# INLINE pullRequestCommentsL #-}

-- | 'pullRequestCreatedAt' Lens
pullRequestCreatedAtL :: Lens_' PullRequest (Maybe DateTime)
pullRequestCreatedAtL f PullRequest{..} = (\pullRequestCreatedAt -> PullRequest { pullRequestCreatedAt, ..} ) <$> f pullRequestCreatedAt
{-# INLINE pullRequestCreatedAtL #-}

-- | 'pullRequestDiffUrl' Lens
pullRequestDiffUrlL :: Lens_' PullRequest (Maybe Text)
pullRequestDiffUrlL f PullRequest{..} = (\pullRequestDiffUrl -> PullRequest { pullRequestDiffUrl, ..} ) <$> f pullRequestDiffUrl
{-# INLINE pullRequestDiffUrlL #-}

-- | 'pullRequestDueDate' Lens
pullRequestDueDateL :: Lens_' PullRequest (Maybe DateTime)
pullRequestDueDateL f PullRequest{..} = (\pullRequestDueDate -> PullRequest { pullRequestDueDate, ..} ) <$> f pullRequestDueDate
{-# INLINE pullRequestDueDateL #-}

-- | 'pullRequestHead' Lens
pullRequestHeadL :: Lens_' PullRequest (Maybe PRBranchInfo)
pullRequestHeadL f PullRequest{..} = (\pullRequestHead -> PullRequest { pullRequestHead, ..} ) <$> f pullRequestHead
{-# INLINE pullRequestHeadL #-}

-- | 'pullRequestHtmlUrl' Lens
pullRequestHtmlUrlL :: Lens_' PullRequest (Maybe Text)
pullRequestHtmlUrlL f PullRequest{..} = (\pullRequestHtmlUrl -> PullRequest { pullRequestHtmlUrl, ..} ) <$> f pullRequestHtmlUrl
{-# INLINE pullRequestHtmlUrlL #-}

-- | 'pullRequestId' Lens
pullRequestIdL :: Lens_' PullRequest (Maybe Integer)
pullRequestIdL f PullRequest{..} = (\pullRequestId -> PullRequest { pullRequestId, ..} ) <$> f pullRequestId
{-# INLINE pullRequestIdL #-}

-- | 'pullRequestIsLocked' Lens
pullRequestIsLockedL :: Lens_' PullRequest (Maybe Bool)
pullRequestIsLockedL f PullRequest{..} = (\pullRequestIsLocked -> PullRequest { pullRequestIsLocked, ..} ) <$> f pullRequestIsLocked
{-# INLINE pullRequestIsLockedL #-}

-- | 'pullRequestLabels' Lens
pullRequestLabelsL :: Lens_' PullRequest (Maybe [Label])
pullRequestLabelsL f PullRequest{..} = (\pullRequestLabels -> PullRequest { pullRequestLabels, ..} ) <$> f pullRequestLabels
{-# INLINE pullRequestLabelsL #-}

-- | 'pullRequestMergeBase' Lens
pullRequestMergeBaseL :: Lens_' PullRequest (Maybe Text)
pullRequestMergeBaseL f PullRequest{..} = (\pullRequestMergeBase -> PullRequest { pullRequestMergeBase, ..} ) <$> f pullRequestMergeBase
{-# INLINE pullRequestMergeBaseL #-}

-- | 'pullRequestMergeCommitSha' Lens
pullRequestMergeCommitShaL :: Lens_' PullRequest (Maybe Text)
pullRequestMergeCommitShaL f PullRequest{..} = (\pullRequestMergeCommitSha -> PullRequest { pullRequestMergeCommitSha, ..} ) <$> f pullRequestMergeCommitSha
{-# INLINE pullRequestMergeCommitShaL #-}

-- | 'pullRequestMergeable' Lens
pullRequestMergeableL :: Lens_' PullRequest (Maybe Bool)
pullRequestMergeableL f PullRequest{..} = (\pullRequestMergeable -> PullRequest { pullRequestMergeable, ..} ) <$> f pullRequestMergeable
{-# INLINE pullRequestMergeableL #-}

-- | 'pullRequestMerged' Lens
pullRequestMergedL :: Lens_' PullRequest (Maybe Bool)
pullRequestMergedL f PullRequest{..} = (\pullRequestMerged -> PullRequest { pullRequestMerged, ..} ) <$> f pullRequestMerged
{-# INLINE pullRequestMergedL #-}

-- | 'pullRequestMergedAt' Lens
pullRequestMergedAtL :: Lens_' PullRequest (Maybe DateTime)
pullRequestMergedAtL f PullRequest{..} = (\pullRequestMergedAt -> PullRequest { pullRequestMergedAt, ..} ) <$> f pullRequestMergedAt
{-# INLINE pullRequestMergedAtL #-}

-- | 'pullRequestMergedBy' Lens
pullRequestMergedByL :: Lens_' PullRequest (Maybe User)
pullRequestMergedByL f PullRequest{..} = (\pullRequestMergedBy -> PullRequest { pullRequestMergedBy, ..} ) <$> f pullRequestMergedBy
{-# INLINE pullRequestMergedByL #-}

-- | 'pullRequestMilestone' Lens
pullRequestMilestoneL :: Lens_' PullRequest (Maybe Milestone)
pullRequestMilestoneL f PullRequest{..} = (\pullRequestMilestone -> PullRequest { pullRequestMilestone, ..} ) <$> f pullRequestMilestone
{-# INLINE pullRequestMilestoneL #-}

-- | 'pullRequestNumber' Lens
pullRequestNumberL :: Lens_' PullRequest (Maybe Integer)
pullRequestNumberL f PullRequest{..} = (\pullRequestNumber -> PullRequest { pullRequestNumber, ..} ) <$> f pullRequestNumber
{-# INLINE pullRequestNumberL #-}

-- | 'pullRequestPatchUrl' Lens
pullRequestPatchUrlL :: Lens_' PullRequest (Maybe Text)
pullRequestPatchUrlL f PullRequest{..} = (\pullRequestPatchUrl -> PullRequest { pullRequestPatchUrl, ..} ) <$> f pullRequestPatchUrl
{-# INLINE pullRequestPatchUrlL #-}

-- | 'pullRequestPinOrder' Lens
pullRequestPinOrderL :: Lens_' PullRequest (Maybe Integer)
pullRequestPinOrderL f PullRequest{..} = (\pullRequestPinOrder -> PullRequest { pullRequestPinOrder, ..} ) <$> f pullRequestPinOrder
{-# INLINE pullRequestPinOrderL #-}

-- | 'pullRequestRequestedReviewers' Lens
pullRequestRequestedReviewersL :: Lens_' PullRequest (Maybe [User])
pullRequestRequestedReviewersL f PullRequest{..} = (\pullRequestRequestedReviewers -> PullRequest { pullRequestRequestedReviewers, ..} ) <$> f pullRequestRequestedReviewers
{-# INLINE pullRequestRequestedReviewersL #-}

-- | 'pullRequestState' Lens
pullRequestStateL :: Lens_' PullRequest (Maybe Text)
pullRequestStateL f PullRequest{..} = (\pullRequestState -> PullRequest { pullRequestState, ..} ) <$> f pullRequestState
{-# INLINE pullRequestStateL #-}

-- | 'pullRequestTitle' Lens
pullRequestTitleL :: Lens_' PullRequest (Maybe Text)
pullRequestTitleL f PullRequest{..} = (\pullRequestTitle -> PullRequest { pullRequestTitle, ..} ) <$> f pullRequestTitle
{-# INLINE pullRequestTitleL #-}

-- | 'pullRequestUpdatedAt' Lens
pullRequestUpdatedAtL :: Lens_' PullRequest (Maybe DateTime)
pullRequestUpdatedAtL f PullRequest{..} = (\pullRequestUpdatedAt -> PullRequest { pullRequestUpdatedAt, ..} ) <$> f pullRequestUpdatedAt
{-# INLINE pullRequestUpdatedAtL #-}

-- | 'pullRequestUrl' Lens
pullRequestUrlL :: Lens_' PullRequest (Maybe Text)
pullRequestUrlL f PullRequest{..} = (\pullRequestUrl -> PullRequest { pullRequestUrl, ..} ) <$> f pullRequestUrl
{-# INLINE pullRequestUrlL #-}

-- | 'pullRequestUser' Lens
pullRequestUserL :: Lens_' PullRequest (Maybe User)
pullRequestUserL f PullRequest{..} = (\pullRequestUser -> PullRequest { pullRequestUser, ..} ) <$> f pullRequestUser
{-# INLINE pullRequestUserL #-}



-- * PullRequestMeta

-- | 'pullRequestMetaMerged' Lens
pullRequestMetaMergedL :: Lens_' PullRequestMeta (Maybe Bool)
pullRequestMetaMergedL f PullRequestMeta{..} = (\pullRequestMetaMerged -> PullRequestMeta { pullRequestMetaMerged, ..} ) <$> f pullRequestMetaMerged
{-# INLINE pullRequestMetaMergedL #-}

-- | 'pullRequestMetaMergedAt' Lens
pullRequestMetaMergedAtL :: Lens_' PullRequestMeta (Maybe DateTime)
pullRequestMetaMergedAtL f PullRequestMeta{..} = (\pullRequestMetaMergedAt -> PullRequestMeta { pullRequestMetaMergedAt, ..} ) <$> f pullRequestMetaMergedAt
{-# INLINE pullRequestMetaMergedAtL #-}



-- * PullReview

-- | 'pullReviewBody' Lens
pullReviewBodyL :: Lens_' PullReview (Maybe Text)
pullReviewBodyL f PullReview{..} = (\pullReviewBody -> PullReview { pullReviewBody, ..} ) <$> f pullReviewBody
{-# INLINE pullReviewBodyL #-}

-- | 'pullReviewCommentsCount' Lens
pullReviewCommentsCountL :: Lens_' PullReview (Maybe Integer)
pullReviewCommentsCountL f PullReview{..} = (\pullReviewCommentsCount -> PullReview { pullReviewCommentsCount, ..} ) <$> f pullReviewCommentsCount
{-# INLINE pullReviewCommentsCountL #-}

-- | 'pullReviewCommitId' Lens
pullReviewCommitIdL :: Lens_' PullReview (Maybe Text)
pullReviewCommitIdL f PullReview{..} = (\pullReviewCommitId -> PullReview { pullReviewCommitId, ..} ) <$> f pullReviewCommitId
{-# INLINE pullReviewCommitIdL #-}

-- | 'pullReviewDismissed' Lens
pullReviewDismissedL :: Lens_' PullReview (Maybe Bool)
pullReviewDismissedL f PullReview{..} = (\pullReviewDismissed -> PullReview { pullReviewDismissed, ..} ) <$> f pullReviewDismissed
{-# INLINE pullReviewDismissedL #-}

-- | 'pullReviewHtmlUrl' Lens
pullReviewHtmlUrlL :: Lens_' PullReview (Maybe Text)
pullReviewHtmlUrlL f PullReview{..} = (\pullReviewHtmlUrl -> PullReview { pullReviewHtmlUrl, ..} ) <$> f pullReviewHtmlUrl
{-# INLINE pullReviewHtmlUrlL #-}

-- | 'pullReviewId' Lens
pullReviewIdL :: Lens_' PullReview (Maybe Integer)
pullReviewIdL f PullReview{..} = (\pullReviewId -> PullReview { pullReviewId, ..} ) <$> f pullReviewId
{-# INLINE pullReviewIdL #-}

-- | 'pullReviewOfficial' Lens
pullReviewOfficialL :: Lens_' PullReview (Maybe Bool)
pullReviewOfficialL f PullReview{..} = (\pullReviewOfficial -> PullReview { pullReviewOfficial, ..} ) <$> f pullReviewOfficial
{-# INLINE pullReviewOfficialL #-}

-- | 'pullReviewPullRequestUrl' Lens
pullReviewPullRequestUrlL :: Lens_' PullReview (Maybe Text)
pullReviewPullRequestUrlL f PullReview{..} = (\pullReviewPullRequestUrl -> PullReview { pullReviewPullRequestUrl, ..} ) <$> f pullReviewPullRequestUrl
{-# INLINE pullReviewPullRequestUrlL #-}

-- | 'pullReviewStale' Lens
pullReviewStaleL :: Lens_' PullReview (Maybe Bool)
pullReviewStaleL f PullReview{..} = (\pullReviewStale -> PullReview { pullReviewStale, ..} ) <$> f pullReviewStale
{-# INLINE pullReviewStaleL #-}

-- | 'pullReviewState' Lens
pullReviewStateL :: Lens_' PullReview (Maybe Text)
pullReviewStateL f PullReview{..} = (\pullReviewState -> PullReview { pullReviewState, ..} ) <$> f pullReviewState
{-# INLINE pullReviewStateL #-}

-- | 'pullReviewSubmittedAt' Lens
pullReviewSubmittedAtL :: Lens_' PullReview (Maybe DateTime)
pullReviewSubmittedAtL f PullReview{..} = (\pullReviewSubmittedAt -> PullReview { pullReviewSubmittedAt, ..} ) <$> f pullReviewSubmittedAt
{-# INLINE pullReviewSubmittedAtL #-}

-- | 'pullReviewTeam' Lens
pullReviewTeamL :: Lens_' PullReview (Maybe Team)
pullReviewTeamL f PullReview{..} = (\pullReviewTeam -> PullReview { pullReviewTeam, ..} ) <$> f pullReviewTeam
{-# INLINE pullReviewTeamL #-}

-- | 'pullReviewUpdatedAt' Lens
pullReviewUpdatedAtL :: Lens_' PullReview (Maybe DateTime)
pullReviewUpdatedAtL f PullReview{..} = (\pullReviewUpdatedAt -> PullReview { pullReviewUpdatedAt, ..} ) <$> f pullReviewUpdatedAt
{-# INLINE pullReviewUpdatedAtL #-}

-- | 'pullReviewUser' Lens
pullReviewUserL :: Lens_' PullReview (Maybe User)
pullReviewUserL f PullReview{..} = (\pullReviewUser -> PullReview { pullReviewUser, ..} ) <$> f pullReviewUser
{-# INLINE pullReviewUserL #-}



-- * PullReviewComment

-- | 'pullReviewCommentBody' Lens
pullReviewCommentBodyL :: Lens_' PullReviewComment (Maybe Text)
pullReviewCommentBodyL f PullReviewComment{..} = (\pullReviewCommentBody -> PullReviewComment { pullReviewCommentBody, ..} ) <$> f pullReviewCommentBody
{-# INLINE pullReviewCommentBodyL #-}

-- | 'pullReviewCommentCommitId' Lens
pullReviewCommentCommitIdL :: Lens_' PullReviewComment (Maybe Text)
pullReviewCommentCommitIdL f PullReviewComment{..} = (\pullReviewCommentCommitId -> PullReviewComment { pullReviewCommentCommitId, ..} ) <$> f pullReviewCommentCommitId
{-# INLINE pullReviewCommentCommitIdL #-}

-- | 'pullReviewCommentCreatedAt' Lens
pullReviewCommentCreatedAtL :: Lens_' PullReviewComment (Maybe DateTime)
pullReviewCommentCreatedAtL f PullReviewComment{..} = (\pullReviewCommentCreatedAt -> PullReviewComment { pullReviewCommentCreatedAt, ..} ) <$> f pullReviewCommentCreatedAt
{-# INLINE pullReviewCommentCreatedAtL #-}

-- | 'pullReviewCommentDiffHunk' Lens
pullReviewCommentDiffHunkL :: Lens_' PullReviewComment (Maybe Text)
pullReviewCommentDiffHunkL f PullReviewComment{..} = (\pullReviewCommentDiffHunk -> PullReviewComment { pullReviewCommentDiffHunk, ..} ) <$> f pullReviewCommentDiffHunk
{-# INLINE pullReviewCommentDiffHunkL #-}

-- | 'pullReviewCommentHtmlUrl' Lens
pullReviewCommentHtmlUrlL :: Lens_' PullReviewComment (Maybe Text)
pullReviewCommentHtmlUrlL f PullReviewComment{..} = (\pullReviewCommentHtmlUrl -> PullReviewComment { pullReviewCommentHtmlUrl, ..} ) <$> f pullReviewCommentHtmlUrl
{-# INLINE pullReviewCommentHtmlUrlL #-}

-- | 'pullReviewCommentId' Lens
pullReviewCommentIdL :: Lens_' PullReviewComment (Maybe Integer)
pullReviewCommentIdL f PullReviewComment{..} = (\pullReviewCommentId -> PullReviewComment { pullReviewCommentId, ..} ) <$> f pullReviewCommentId
{-# INLINE pullReviewCommentIdL #-}

-- | 'pullReviewCommentOriginalCommitId' Lens
pullReviewCommentOriginalCommitIdL :: Lens_' PullReviewComment (Maybe Text)
pullReviewCommentOriginalCommitIdL f PullReviewComment{..} = (\pullReviewCommentOriginalCommitId -> PullReviewComment { pullReviewCommentOriginalCommitId, ..} ) <$> f pullReviewCommentOriginalCommitId
{-# INLINE pullReviewCommentOriginalCommitIdL #-}

-- | 'pullReviewCommentOriginalPosition' Lens
pullReviewCommentOriginalPositionL :: Lens_' PullReviewComment (Maybe Int)
pullReviewCommentOriginalPositionL f PullReviewComment{..} = (\pullReviewCommentOriginalPosition -> PullReviewComment { pullReviewCommentOriginalPosition, ..} ) <$> f pullReviewCommentOriginalPosition
{-# INLINE pullReviewCommentOriginalPositionL #-}

-- | 'pullReviewCommentPath' Lens
pullReviewCommentPathL :: Lens_' PullReviewComment (Maybe Text)
pullReviewCommentPathL f PullReviewComment{..} = (\pullReviewCommentPath -> PullReviewComment { pullReviewCommentPath, ..} ) <$> f pullReviewCommentPath
{-# INLINE pullReviewCommentPathL #-}

-- | 'pullReviewCommentPosition' Lens
pullReviewCommentPositionL :: Lens_' PullReviewComment (Maybe Int)
pullReviewCommentPositionL f PullReviewComment{..} = (\pullReviewCommentPosition -> PullReviewComment { pullReviewCommentPosition, ..} ) <$> f pullReviewCommentPosition
{-# INLINE pullReviewCommentPositionL #-}

-- | 'pullReviewCommentPullRequestReviewId' Lens
pullReviewCommentPullRequestReviewIdL :: Lens_' PullReviewComment (Maybe Integer)
pullReviewCommentPullRequestReviewIdL f PullReviewComment{..} = (\pullReviewCommentPullRequestReviewId -> PullReviewComment { pullReviewCommentPullRequestReviewId, ..} ) <$> f pullReviewCommentPullRequestReviewId
{-# INLINE pullReviewCommentPullRequestReviewIdL #-}

-- | 'pullReviewCommentPullRequestUrl' Lens
pullReviewCommentPullRequestUrlL :: Lens_' PullReviewComment (Maybe Text)
pullReviewCommentPullRequestUrlL f PullReviewComment{..} = (\pullReviewCommentPullRequestUrl -> PullReviewComment { pullReviewCommentPullRequestUrl, ..} ) <$> f pullReviewCommentPullRequestUrl
{-# INLINE pullReviewCommentPullRequestUrlL #-}

-- | 'pullReviewCommentResolver' Lens
pullReviewCommentResolverL :: Lens_' PullReviewComment (Maybe User)
pullReviewCommentResolverL f PullReviewComment{..} = (\pullReviewCommentResolver -> PullReviewComment { pullReviewCommentResolver, ..} ) <$> f pullReviewCommentResolver
{-# INLINE pullReviewCommentResolverL #-}

-- | 'pullReviewCommentUpdatedAt' Lens
pullReviewCommentUpdatedAtL :: Lens_' PullReviewComment (Maybe DateTime)
pullReviewCommentUpdatedAtL f PullReviewComment{..} = (\pullReviewCommentUpdatedAt -> PullReviewComment { pullReviewCommentUpdatedAt, ..} ) <$> f pullReviewCommentUpdatedAt
{-# INLINE pullReviewCommentUpdatedAtL #-}

-- | 'pullReviewCommentUser' Lens
pullReviewCommentUserL :: Lens_' PullReviewComment (Maybe User)
pullReviewCommentUserL f PullReviewComment{..} = (\pullReviewCommentUser -> PullReviewComment { pullReviewCommentUser, ..} ) <$> f pullReviewCommentUser
{-# INLINE pullReviewCommentUserL #-}



-- * PullReviewRequestOptions

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

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



-- * PushMirror

-- | 'pushMirrorCreated' Lens
pushMirrorCreatedL :: Lens_' PushMirror (Maybe Text)
pushMirrorCreatedL f PushMirror{..} = (\pushMirrorCreated -> PushMirror { pushMirrorCreated, ..} ) <$> f pushMirrorCreated
{-# INLINE pushMirrorCreatedL #-}

-- | 'pushMirrorInterval' Lens
pushMirrorIntervalL :: Lens_' PushMirror (Maybe Text)
pushMirrorIntervalL f PushMirror{..} = (\pushMirrorInterval -> PushMirror { pushMirrorInterval, ..} ) <$> f pushMirrorInterval
{-# INLINE pushMirrorIntervalL #-}

-- | 'pushMirrorLastError' Lens
pushMirrorLastErrorL :: Lens_' PushMirror (Maybe Text)
pushMirrorLastErrorL f PushMirror{..} = (\pushMirrorLastError -> PushMirror { pushMirrorLastError, ..} ) <$> f pushMirrorLastError
{-# INLINE pushMirrorLastErrorL #-}

-- | 'pushMirrorLastUpdate' Lens
pushMirrorLastUpdateL :: Lens_' PushMirror (Maybe Text)
pushMirrorLastUpdateL f PushMirror{..} = (\pushMirrorLastUpdate -> PushMirror { pushMirrorLastUpdate, ..} ) <$> f pushMirrorLastUpdate
{-# INLINE pushMirrorLastUpdateL #-}

-- | 'pushMirrorRemoteAddress' Lens
pushMirrorRemoteAddressL :: Lens_' PushMirror (Maybe Text)
pushMirrorRemoteAddressL f PushMirror{..} = (\pushMirrorRemoteAddress -> PushMirror { pushMirrorRemoteAddress, ..} ) <$> f pushMirrorRemoteAddress
{-# INLINE pushMirrorRemoteAddressL #-}

-- | 'pushMirrorRemoteName' Lens
pushMirrorRemoteNameL :: Lens_' PushMirror (Maybe Text)
pushMirrorRemoteNameL f PushMirror{..} = (\pushMirrorRemoteName -> PushMirror { pushMirrorRemoteName, ..} ) <$> f pushMirrorRemoteName
{-# INLINE pushMirrorRemoteNameL #-}

-- | 'pushMirrorRepoName' Lens
pushMirrorRepoNameL :: Lens_' PushMirror (Maybe Text)
pushMirrorRepoNameL f PushMirror{..} = (\pushMirrorRepoName -> PushMirror { pushMirrorRepoName, ..} ) <$> f pushMirrorRepoName
{-# INLINE pushMirrorRepoNameL #-}

-- | 'pushMirrorSyncOnCommit' Lens
pushMirrorSyncOnCommitL :: Lens_' PushMirror (Maybe Bool)
pushMirrorSyncOnCommitL f PushMirror{..} = (\pushMirrorSyncOnCommit -> PushMirror { pushMirrorSyncOnCommit, ..} ) <$> f pushMirrorSyncOnCommit
{-# INLINE pushMirrorSyncOnCommitL #-}



-- * Reaction

-- | 'reactionContent' Lens
reactionContentL :: Lens_' Reaction (Maybe Text)
reactionContentL f Reaction{..} = (\reactionContent -> Reaction { reactionContent, ..} ) <$> f reactionContent
{-# INLINE reactionContentL #-}

-- | 'reactionCreatedAt' Lens
reactionCreatedAtL :: Lens_' Reaction (Maybe DateTime)
reactionCreatedAtL f Reaction{..} = (\reactionCreatedAt -> Reaction { reactionCreatedAt, ..} ) <$> f reactionCreatedAt
{-# INLINE reactionCreatedAtL #-}

-- | 'reactionUser' Lens
reactionUserL :: Lens_' Reaction (Maybe User)
reactionUserL f Reaction{..} = (\reactionUser -> Reaction { reactionUser, ..} ) <$> f reactionUser
{-# INLINE reactionUserL #-}



-- * Reference

-- | 'referenceObject' Lens
referenceObjectL :: Lens_' Reference (Maybe GitObject)
referenceObjectL f Reference{..} = (\referenceObject -> Reference { referenceObject, ..} ) <$> f referenceObject
{-# INLINE referenceObjectL #-}

-- | 'referenceRef' Lens
referenceRefL :: Lens_' Reference (Maybe Text)
referenceRefL f Reference{..} = (\referenceRef -> Reference { referenceRef, ..} ) <$> f referenceRef
{-# INLINE referenceRefL #-}

-- | 'referenceUrl' Lens
referenceUrlL :: Lens_' Reference (Maybe Text)
referenceUrlL f Reference{..} = (\referenceUrl -> Reference { referenceUrl, ..} ) <$> f referenceUrl
{-# INLINE referenceUrlL #-}



-- * Release

-- | 'releaseAssets' Lens
releaseAssetsL :: Lens_' Release (Maybe [Attachment])
releaseAssetsL f Release{..} = (\releaseAssets -> Release { releaseAssets, ..} ) <$> f releaseAssets
{-# INLINE releaseAssetsL #-}

-- | 'releaseAuthor' Lens
releaseAuthorL :: Lens_' Release (Maybe User)
releaseAuthorL f Release{..} = (\releaseAuthor -> Release { releaseAuthor, ..} ) <$> f releaseAuthor
{-# INLINE releaseAuthorL #-}

-- | 'releaseBody' Lens
releaseBodyL :: Lens_' Release (Maybe Text)
releaseBodyL f Release{..} = (\releaseBody -> Release { releaseBody, ..} ) <$> f releaseBody
{-# INLINE releaseBodyL #-}

-- | 'releaseCreatedAt' Lens
releaseCreatedAtL :: Lens_' Release (Maybe DateTime)
releaseCreatedAtL f Release{..} = (\releaseCreatedAt -> Release { releaseCreatedAt, ..} ) <$> f releaseCreatedAt
{-# INLINE releaseCreatedAtL #-}

-- | 'releaseDraft' Lens
releaseDraftL :: Lens_' Release (Maybe Bool)
releaseDraftL f Release{..} = (\releaseDraft -> Release { releaseDraft, ..} ) <$> f releaseDraft
{-# INLINE releaseDraftL #-}

-- | 'releaseHtmlUrl' Lens
releaseHtmlUrlL :: Lens_' Release (Maybe Text)
releaseHtmlUrlL f Release{..} = (\releaseHtmlUrl -> Release { releaseHtmlUrl, ..} ) <$> f releaseHtmlUrl
{-# INLINE releaseHtmlUrlL #-}

-- | 'releaseId' Lens
releaseIdL :: Lens_' Release (Maybe Integer)
releaseIdL f Release{..} = (\releaseId -> Release { releaseId, ..} ) <$> f releaseId
{-# INLINE releaseIdL #-}

-- | 'releaseName' Lens
releaseNameL :: Lens_' Release (Maybe Text)
releaseNameL f Release{..} = (\releaseName -> Release { releaseName, ..} ) <$> f releaseName
{-# INLINE releaseNameL #-}

-- | 'releasePrerelease' Lens
releasePrereleaseL :: Lens_' Release (Maybe Bool)
releasePrereleaseL f Release{..} = (\releasePrerelease -> Release { releasePrerelease, ..} ) <$> f releasePrerelease
{-# INLINE releasePrereleaseL #-}

-- | 'releasePublishedAt' Lens
releasePublishedAtL :: Lens_' Release (Maybe DateTime)
releasePublishedAtL f Release{..} = (\releasePublishedAt -> Release { releasePublishedAt, ..} ) <$> f releasePublishedAt
{-# INLINE releasePublishedAtL #-}

-- | 'releaseTagName' Lens
releaseTagNameL :: Lens_' Release (Maybe Text)
releaseTagNameL f Release{..} = (\releaseTagName -> Release { releaseTagName, ..} ) <$> f releaseTagName
{-# INLINE releaseTagNameL #-}

-- | 'releaseTarballUrl' Lens
releaseTarballUrlL :: Lens_' Release (Maybe Text)
releaseTarballUrlL f Release{..} = (\releaseTarballUrl -> Release { releaseTarballUrl, ..} ) <$> f releaseTarballUrl
{-# INLINE releaseTarballUrlL #-}

-- | 'releaseTargetCommitish' Lens
releaseTargetCommitishL :: Lens_' Release (Maybe Text)
releaseTargetCommitishL f Release{..} = (\releaseTargetCommitish -> Release { releaseTargetCommitish, ..} ) <$> f releaseTargetCommitish
{-# INLINE releaseTargetCommitishL #-}

-- | 'releaseUrl' Lens
releaseUrlL :: Lens_' Release (Maybe Text)
releaseUrlL f Release{..} = (\releaseUrl -> Release { releaseUrl, ..} ) <$> f releaseUrl
{-# INLINE releaseUrlL #-}

-- | 'releaseZipballUrl' Lens
releaseZipballUrlL :: Lens_' Release (Maybe Text)
releaseZipballUrlL f Release{..} = (\releaseZipballUrl -> Release { releaseZipballUrl, ..} ) <$> f releaseZipballUrl
{-# INLINE releaseZipballUrlL #-}



-- * RenameUserOption

-- | 'renameUserOptionNewUsername' Lens
renameUserOptionNewUsernameL :: Lens_' RenameUserOption (Text)
renameUserOptionNewUsernameL f RenameUserOption{..} = (\renameUserOptionNewUsername -> RenameUserOption { renameUserOptionNewUsername, ..} ) <$> f renameUserOptionNewUsername
{-# INLINE renameUserOptionNewUsernameL #-}



-- * RepoCollaboratorPermission

-- | 'repoCollaboratorPermissionPermission' Lens
repoCollaboratorPermissionPermissionL :: Lens_' RepoCollaboratorPermission (Maybe Text)
repoCollaboratorPermissionPermissionL f RepoCollaboratorPermission{..} = (\repoCollaboratorPermissionPermission -> RepoCollaboratorPermission { repoCollaboratorPermissionPermission, ..} ) <$> f repoCollaboratorPermissionPermission
{-# INLINE repoCollaboratorPermissionPermissionL #-}

-- | 'repoCollaboratorPermissionRoleName' Lens
repoCollaboratorPermissionRoleNameL :: Lens_' RepoCollaboratorPermission (Maybe Text)
repoCollaboratorPermissionRoleNameL f RepoCollaboratorPermission{..} = (\repoCollaboratorPermissionRoleName -> RepoCollaboratorPermission { repoCollaboratorPermissionRoleName, ..} ) <$> f repoCollaboratorPermissionRoleName
{-# INLINE repoCollaboratorPermissionRoleNameL #-}

-- | 'repoCollaboratorPermissionUser' Lens
repoCollaboratorPermissionUserL :: Lens_' RepoCollaboratorPermission (Maybe User)
repoCollaboratorPermissionUserL f RepoCollaboratorPermission{..} = (\repoCollaboratorPermissionUser -> RepoCollaboratorPermission { repoCollaboratorPermissionUser, ..} ) <$> f repoCollaboratorPermissionUser
{-# INLINE repoCollaboratorPermissionUserL #-}



-- * RepoCommit

-- | 'repoCommitAuthor' Lens
repoCommitAuthorL :: Lens_' RepoCommit (Maybe CommitUser)
repoCommitAuthorL f RepoCommit{..} = (\repoCommitAuthor -> RepoCommit { repoCommitAuthor, ..} ) <$> f repoCommitAuthor
{-# INLINE repoCommitAuthorL #-}

-- | 'repoCommitCommitter' Lens
repoCommitCommitterL :: Lens_' RepoCommit (Maybe CommitUser)
repoCommitCommitterL f RepoCommit{..} = (\repoCommitCommitter -> RepoCommit { repoCommitCommitter, ..} ) <$> f repoCommitCommitter
{-# INLINE repoCommitCommitterL #-}

-- | 'repoCommitMessage' Lens
repoCommitMessageL :: Lens_' RepoCommit (Maybe Text)
repoCommitMessageL f RepoCommit{..} = (\repoCommitMessage -> RepoCommit { repoCommitMessage, ..} ) <$> f repoCommitMessage
{-# INLINE repoCommitMessageL #-}

-- | 'repoCommitTree' Lens
repoCommitTreeL :: Lens_' RepoCommit (Maybe CommitMeta)
repoCommitTreeL f RepoCommit{..} = (\repoCommitTree -> RepoCommit { repoCommitTree, ..} ) <$> f repoCommitTree
{-# INLINE repoCommitTreeL #-}

-- | 'repoCommitUrl' Lens
repoCommitUrlL :: Lens_' RepoCommit (Maybe Text)
repoCommitUrlL f RepoCommit{..} = (\repoCommitUrl -> RepoCommit { repoCommitUrl, ..} ) <$> f repoCommitUrl
{-# INLINE repoCommitUrlL #-}

-- | 'repoCommitVerification' Lens
repoCommitVerificationL :: Lens_' RepoCommit (Maybe PayloadCommitVerification)
repoCommitVerificationL f RepoCommit{..} = (\repoCommitVerification -> RepoCommit { repoCommitVerification, ..} ) <$> f repoCommitVerification
{-# INLINE repoCommitVerificationL #-}



-- * RepoTopicOptions

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



-- * RepoTransfer

-- | 'repoTransferDoer' Lens
repoTransferDoerL :: Lens_' RepoTransfer (Maybe User)
repoTransferDoerL f RepoTransfer{..} = (\repoTransferDoer -> RepoTransfer { repoTransferDoer, ..} ) <$> f repoTransferDoer
{-# INLINE repoTransferDoerL #-}

-- | 'repoTransferRecipient' Lens
repoTransferRecipientL :: Lens_' RepoTransfer (Maybe User)
repoTransferRecipientL f RepoTransfer{..} = (\repoTransferRecipient -> RepoTransfer { repoTransferRecipient, ..} ) <$> f repoTransferRecipient
{-# INLINE repoTransferRecipientL #-}

-- | 'repoTransferTeams' Lens
repoTransferTeamsL :: Lens_' RepoTransfer (Maybe [Team])
repoTransferTeamsL f RepoTransfer{..} = (\repoTransferTeams -> RepoTransfer { repoTransferTeams, ..} ) <$> f repoTransferTeams
{-# INLINE repoTransferTeamsL #-}



-- * Repository

-- | 'repositoryAllowMergeCommits' Lens
repositoryAllowMergeCommitsL :: Lens_' Repository (Maybe Bool)
repositoryAllowMergeCommitsL f Repository{..} = (\repositoryAllowMergeCommits -> Repository { repositoryAllowMergeCommits, ..} ) <$> f repositoryAllowMergeCommits
{-# INLINE repositoryAllowMergeCommitsL #-}

-- | 'repositoryAllowRebase' Lens
repositoryAllowRebaseL :: Lens_' Repository (Maybe Bool)
repositoryAllowRebaseL f Repository{..} = (\repositoryAllowRebase -> Repository { repositoryAllowRebase, ..} ) <$> f repositoryAllowRebase
{-# INLINE repositoryAllowRebaseL #-}

-- | 'repositoryAllowRebaseExplicit' Lens
repositoryAllowRebaseExplicitL :: Lens_' Repository (Maybe Bool)
repositoryAllowRebaseExplicitL f Repository{..} = (\repositoryAllowRebaseExplicit -> Repository { repositoryAllowRebaseExplicit, ..} ) <$> f repositoryAllowRebaseExplicit
{-# INLINE repositoryAllowRebaseExplicitL #-}

-- | 'repositoryAllowRebaseUpdate' Lens
repositoryAllowRebaseUpdateL :: Lens_' Repository (Maybe Bool)
repositoryAllowRebaseUpdateL f Repository{..} = (\repositoryAllowRebaseUpdate -> Repository { repositoryAllowRebaseUpdate, ..} ) <$> f repositoryAllowRebaseUpdate
{-# INLINE repositoryAllowRebaseUpdateL #-}

-- | 'repositoryAllowSquashMerge' Lens
repositoryAllowSquashMergeL :: Lens_' Repository (Maybe Bool)
repositoryAllowSquashMergeL f Repository{..} = (\repositoryAllowSquashMerge -> Repository { repositoryAllowSquashMerge, ..} ) <$> f repositoryAllowSquashMerge
{-# INLINE repositoryAllowSquashMergeL #-}

-- | 'repositoryArchived' Lens
repositoryArchivedL :: Lens_' Repository (Maybe Bool)
repositoryArchivedL f Repository{..} = (\repositoryArchived -> Repository { repositoryArchived, ..} ) <$> f repositoryArchived
{-# INLINE repositoryArchivedL #-}

-- | 'repositoryArchivedAt' Lens
repositoryArchivedAtL :: Lens_' Repository (Maybe DateTime)
repositoryArchivedAtL f Repository{..} = (\repositoryArchivedAt -> Repository { repositoryArchivedAt, ..} ) <$> f repositoryArchivedAt
{-# INLINE repositoryArchivedAtL #-}

-- | 'repositoryAvatarUrl' Lens
repositoryAvatarUrlL :: Lens_' Repository (Maybe Text)
repositoryAvatarUrlL f Repository{..} = (\repositoryAvatarUrl -> Repository { repositoryAvatarUrl, ..} ) <$> f repositoryAvatarUrl
{-# INLINE repositoryAvatarUrlL #-}

-- | 'repositoryCloneUrl' Lens
repositoryCloneUrlL :: Lens_' Repository (Maybe Text)
repositoryCloneUrlL f Repository{..} = (\repositoryCloneUrl -> Repository { repositoryCloneUrl, ..} ) <$> f repositoryCloneUrl
{-# INLINE repositoryCloneUrlL #-}

-- | 'repositoryCreatedAt' Lens
repositoryCreatedAtL :: Lens_' Repository (Maybe DateTime)
repositoryCreatedAtL f Repository{..} = (\repositoryCreatedAt -> Repository { repositoryCreatedAt, ..} ) <$> f repositoryCreatedAt
{-# INLINE repositoryCreatedAtL #-}

-- | 'repositoryDefaultAllowMaintainerEdit' Lens
repositoryDefaultAllowMaintainerEditL :: Lens_' Repository (Maybe Bool)
repositoryDefaultAllowMaintainerEditL f Repository{..} = (\repositoryDefaultAllowMaintainerEdit -> Repository { repositoryDefaultAllowMaintainerEdit, ..} ) <$> f repositoryDefaultAllowMaintainerEdit
{-# INLINE repositoryDefaultAllowMaintainerEditL #-}

-- | 'repositoryDefaultBranch' Lens
repositoryDefaultBranchL :: Lens_' Repository (Maybe Text)
repositoryDefaultBranchL f Repository{..} = (\repositoryDefaultBranch -> Repository { repositoryDefaultBranch, ..} ) <$> f repositoryDefaultBranch
{-# INLINE repositoryDefaultBranchL #-}

-- | 'repositoryDefaultDeleteBranchAfterMerge' Lens
repositoryDefaultDeleteBranchAfterMergeL :: Lens_' Repository (Maybe Bool)
repositoryDefaultDeleteBranchAfterMergeL f Repository{..} = (\repositoryDefaultDeleteBranchAfterMerge -> Repository { repositoryDefaultDeleteBranchAfterMerge, ..} ) <$> f repositoryDefaultDeleteBranchAfterMerge
{-# INLINE repositoryDefaultDeleteBranchAfterMergeL #-}

-- | 'repositoryDefaultMergeStyle' Lens
repositoryDefaultMergeStyleL :: Lens_' Repository (Maybe Text)
repositoryDefaultMergeStyleL f Repository{..} = (\repositoryDefaultMergeStyle -> Repository { repositoryDefaultMergeStyle, ..} ) <$> f repositoryDefaultMergeStyle
{-# INLINE repositoryDefaultMergeStyleL #-}

-- | 'repositoryDescription' Lens
repositoryDescriptionL :: Lens_' Repository (Maybe Text)
repositoryDescriptionL f Repository{..} = (\repositoryDescription -> Repository { repositoryDescription, ..} ) <$> f repositoryDescription
{-# INLINE repositoryDescriptionL #-}

-- | 'repositoryEmpty' Lens
repositoryEmptyL :: Lens_' Repository (Maybe Bool)
repositoryEmptyL f Repository{..} = (\repositoryEmpty -> Repository { repositoryEmpty, ..} ) <$> f repositoryEmpty
{-# INLINE repositoryEmptyL #-}

-- | 'repositoryExternalTracker' Lens
repositoryExternalTrackerL :: Lens_' Repository (Maybe ExternalTracker)
repositoryExternalTrackerL f Repository{..} = (\repositoryExternalTracker -> Repository { repositoryExternalTracker, ..} ) <$> f repositoryExternalTracker
{-# INLINE repositoryExternalTrackerL #-}

-- | 'repositoryExternalWiki' Lens
repositoryExternalWikiL :: Lens_' Repository (Maybe ExternalWiki)
repositoryExternalWikiL f Repository{..} = (\repositoryExternalWiki -> Repository { repositoryExternalWiki, ..} ) <$> f repositoryExternalWiki
{-# INLINE repositoryExternalWikiL #-}

-- | 'repositoryFork' Lens
repositoryForkL :: Lens_' Repository (Maybe Bool)
repositoryForkL f Repository{..} = (\repositoryFork -> Repository { repositoryFork, ..} ) <$> f repositoryFork
{-# INLINE repositoryForkL #-}

-- | 'repositoryForksCount' Lens
repositoryForksCountL :: Lens_' Repository (Maybe Integer)
repositoryForksCountL f Repository{..} = (\repositoryForksCount -> Repository { repositoryForksCount, ..} ) <$> f repositoryForksCount
{-# INLINE repositoryForksCountL #-}

-- | 'repositoryFullName' Lens
repositoryFullNameL :: Lens_' Repository (Maybe Text)
repositoryFullNameL f Repository{..} = (\repositoryFullName -> Repository { repositoryFullName, ..} ) <$> f repositoryFullName
{-# INLINE repositoryFullNameL #-}

-- | 'repositoryHasActions' Lens
repositoryHasActionsL :: Lens_' Repository (Maybe Bool)
repositoryHasActionsL f Repository{..} = (\repositoryHasActions -> Repository { repositoryHasActions, ..} ) <$> f repositoryHasActions
{-# INLINE repositoryHasActionsL #-}

-- | 'repositoryHasIssues' Lens
repositoryHasIssuesL :: Lens_' Repository (Maybe Bool)
repositoryHasIssuesL f Repository{..} = (\repositoryHasIssues -> Repository { repositoryHasIssues, ..} ) <$> f repositoryHasIssues
{-# INLINE repositoryHasIssuesL #-}

-- | 'repositoryHasPackages' Lens
repositoryHasPackagesL :: Lens_' Repository (Maybe Bool)
repositoryHasPackagesL f Repository{..} = (\repositoryHasPackages -> Repository { repositoryHasPackages, ..} ) <$> f repositoryHasPackages
{-# INLINE repositoryHasPackagesL #-}

-- | 'repositoryHasProjects' Lens
repositoryHasProjectsL :: Lens_' Repository (Maybe Bool)
repositoryHasProjectsL f Repository{..} = (\repositoryHasProjects -> Repository { repositoryHasProjects, ..} ) <$> f repositoryHasProjects
{-# INLINE repositoryHasProjectsL #-}

-- | 'repositoryHasPullRequests' Lens
repositoryHasPullRequestsL :: Lens_' Repository (Maybe Bool)
repositoryHasPullRequestsL f Repository{..} = (\repositoryHasPullRequests -> Repository { repositoryHasPullRequests, ..} ) <$> f repositoryHasPullRequests
{-# INLINE repositoryHasPullRequestsL #-}

-- | 'repositoryHasReleases' Lens
repositoryHasReleasesL :: Lens_' Repository (Maybe Bool)
repositoryHasReleasesL f Repository{..} = (\repositoryHasReleases -> Repository { repositoryHasReleases, ..} ) <$> f repositoryHasReleases
{-# INLINE repositoryHasReleasesL #-}

-- | 'repositoryHasWiki' Lens
repositoryHasWikiL :: Lens_' Repository (Maybe Bool)
repositoryHasWikiL f Repository{..} = (\repositoryHasWiki -> Repository { repositoryHasWiki, ..} ) <$> f repositoryHasWiki
{-# INLINE repositoryHasWikiL #-}

-- | 'repositoryHtmlUrl' Lens
repositoryHtmlUrlL :: Lens_' Repository (Maybe Text)
repositoryHtmlUrlL f Repository{..} = (\repositoryHtmlUrl -> Repository { repositoryHtmlUrl, ..} ) <$> f repositoryHtmlUrl
{-# INLINE repositoryHtmlUrlL #-}

-- | 'repositoryId' Lens
repositoryIdL :: Lens_' Repository (Maybe Integer)
repositoryIdL f Repository{..} = (\repositoryId -> Repository { repositoryId, ..} ) <$> f repositoryId
{-# INLINE repositoryIdL #-}

-- | 'repositoryIgnoreWhitespaceConflicts' Lens
repositoryIgnoreWhitespaceConflictsL :: Lens_' Repository (Maybe Bool)
repositoryIgnoreWhitespaceConflictsL f Repository{..} = (\repositoryIgnoreWhitespaceConflicts -> Repository { repositoryIgnoreWhitespaceConflicts, ..} ) <$> f repositoryIgnoreWhitespaceConflicts
{-# INLINE repositoryIgnoreWhitespaceConflictsL #-}

-- | 'repositoryInternal' Lens
repositoryInternalL :: Lens_' Repository (Maybe Bool)
repositoryInternalL f Repository{..} = (\repositoryInternal -> Repository { repositoryInternal, ..} ) <$> f repositoryInternal
{-# INLINE repositoryInternalL #-}

-- | 'repositoryInternalTracker' Lens
repositoryInternalTrackerL :: Lens_' Repository (Maybe InternalTracker)
repositoryInternalTrackerL f Repository{..} = (\repositoryInternalTracker -> Repository { repositoryInternalTracker, ..} ) <$> f repositoryInternalTracker
{-# INLINE repositoryInternalTrackerL #-}

-- | 'repositoryLanguage' Lens
repositoryLanguageL :: Lens_' Repository (Maybe Text)
repositoryLanguageL f Repository{..} = (\repositoryLanguage -> Repository { repositoryLanguage, ..} ) <$> f repositoryLanguage
{-# INLINE repositoryLanguageL #-}

-- | 'repositoryLanguagesUrl' Lens
repositoryLanguagesUrlL :: Lens_' Repository (Maybe Text)
repositoryLanguagesUrlL f Repository{..} = (\repositoryLanguagesUrl -> Repository { repositoryLanguagesUrl, ..} ) <$> f repositoryLanguagesUrl
{-# INLINE repositoryLanguagesUrlL #-}

-- | 'repositoryLink' Lens
repositoryLinkL :: Lens_' Repository (Maybe Text)
repositoryLinkL f Repository{..} = (\repositoryLink -> Repository { repositoryLink, ..} ) <$> f repositoryLink
{-# INLINE repositoryLinkL #-}

-- | 'repositoryMirror' Lens
repositoryMirrorL :: Lens_' Repository (Maybe Bool)
repositoryMirrorL f Repository{..} = (\repositoryMirror -> Repository { repositoryMirror, ..} ) <$> f repositoryMirror
{-# INLINE repositoryMirrorL #-}

-- | 'repositoryMirrorInterval' Lens
repositoryMirrorIntervalL :: Lens_' Repository (Maybe Text)
repositoryMirrorIntervalL f Repository{..} = (\repositoryMirrorInterval -> Repository { repositoryMirrorInterval, ..} ) <$> f repositoryMirrorInterval
{-# INLINE repositoryMirrorIntervalL #-}

-- | 'repositoryMirrorUpdated' Lens
repositoryMirrorUpdatedL :: Lens_' Repository (Maybe DateTime)
repositoryMirrorUpdatedL f Repository{..} = (\repositoryMirrorUpdated -> Repository { repositoryMirrorUpdated, ..} ) <$> f repositoryMirrorUpdated
{-# INLINE repositoryMirrorUpdatedL #-}

-- | 'repositoryName' Lens
repositoryNameL :: Lens_' Repository (Maybe Text)
repositoryNameL f Repository{..} = (\repositoryName -> Repository { repositoryName, ..} ) <$> f repositoryName
{-# INLINE repositoryNameL #-}

-- | 'repositoryOpenIssuesCount' Lens
repositoryOpenIssuesCountL :: Lens_' Repository (Maybe Integer)
repositoryOpenIssuesCountL f Repository{..} = (\repositoryOpenIssuesCount -> Repository { repositoryOpenIssuesCount, ..} ) <$> f repositoryOpenIssuesCount
{-# INLINE repositoryOpenIssuesCountL #-}

-- | 'repositoryOpenPrCounter' Lens
repositoryOpenPrCounterL :: Lens_' Repository (Maybe Integer)
repositoryOpenPrCounterL f Repository{..} = (\repositoryOpenPrCounter -> Repository { repositoryOpenPrCounter, ..} ) <$> f repositoryOpenPrCounter
{-# INLINE repositoryOpenPrCounterL #-}

-- | 'repositoryOriginalUrl' Lens
repositoryOriginalUrlL :: Lens_' Repository (Maybe Text)
repositoryOriginalUrlL f Repository{..} = (\repositoryOriginalUrl -> Repository { repositoryOriginalUrl, ..} ) <$> f repositoryOriginalUrl
{-# INLINE repositoryOriginalUrlL #-}

-- | 'repositoryOwner' Lens
repositoryOwnerL :: Lens_' Repository (Maybe User)
repositoryOwnerL f Repository{..} = (\repositoryOwner -> Repository { repositoryOwner, ..} ) <$> f repositoryOwner
{-# INLINE repositoryOwnerL #-}

-- | 'repositoryParent' Lens
repositoryParentL :: Lens_' Repository (Maybe Repository)
repositoryParentL f Repository{..} = (\repositoryParent -> Repository { repositoryParent, ..} ) <$> f repositoryParent
{-# INLINE repositoryParentL #-}

-- | 'repositoryPermissions' Lens
repositoryPermissionsL :: Lens_' Repository (Maybe Permission)
repositoryPermissionsL f Repository{..} = (\repositoryPermissions -> Repository { repositoryPermissions, ..} ) <$> f repositoryPermissions
{-# INLINE repositoryPermissionsL #-}

-- | 'repositoryPrivate' Lens
repositoryPrivateL :: Lens_' Repository (Maybe Bool)
repositoryPrivateL f Repository{..} = (\repositoryPrivate -> Repository { repositoryPrivate, ..} ) <$> f repositoryPrivate
{-# INLINE repositoryPrivateL #-}

-- | 'repositoryReleaseCounter' Lens
repositoryReleaseCounterL :: Lens_' Repository (Maybe Integer)
repositoryReleaseCounterL f Repository{..} = (\repositoryReleaseCounter -> Repository { repositoryReleaseCounter, ..} ) <$> f repositoryReleaseCounter
{-# INLINE repositoryReleaseCounterL #-}

-- | 'repositoryRepoTransfer' Lens
repositoryRepoTransferL :: Lens_' Repository (Maybe RepoTransfer)
repositoryRepoTransferL f Repository{..} = (\repositoryRepoTransfer -> Repository { repositoryRepoTransfer, ..} ) <$> f repositoryRepoTransfer
{-# INLINE repositoryRepoTransferL #-}

-- | 'repositorySize' Lens
repositorySizeL :: Lens_' Repository (Maybe Integer)
repositorySizeL f Repository{..} = (\repositorySize -> Repository { repositorySize, ..} ) <$> f repositorySize
{-# INLINE repositorySizeL #-}

-- | 'repositorySshUrl' Lens
repositorySshUrlL :: Lens_' Repository (Maybe Text)
repositorySshUrlL f Repository{..} = (\repositorySshUrl -> Repository { repositorySshUrl, ..} ) <$> f repositorySshUrl
{-# INLINE repositorySshUrlL #-}

-- | 'repositoryStarsCount' Lens
repositoryStarsCountL :: Lens_' Repository (Maybe Integer)
repositoryStarsCountL f Repository{..} = (\repositoryStarsCount -> Repository { repositoryStarsCount, ..} ) <$> f repositoryStarsCount
{-# INLINE repositoryStarsCountL #-}

-- | 'repositoryTemplate' Lens
repositoryTemplateL :: Lens_' Repository (Maybe Bool)
repositoryTemplateL f Repository{..} = (\repositoryTemplate -> Repository { repositoryTemplate, ..} ) <$> f repositoryTemplate
{-# INLINE repositoryTemplateL #-}

-- | 'repositoryUpdatedAt' Lens
repositoryUpdatedAtL :: Lens_' Repository (Maybe DateTime)
repositoryUpdatedAtL f Repository{..} = (\repositoryUpdatedAt -> Repository { repositoryUpdatedAt, ..} ) <$> f repositoryUpdatedAt
{-# INLINE repositoryUpdatedAtL #-}

-- | 'repositoryUrl' Lens
repositoryUrlL :: Lens_' Repository (Maybe Text)
repositoryUrlL f Repository{..} = (\repositoryUrl -> Repository { repositoryUrl, ..} ) <$> f repositoryUrl
{-# INLINE repositoryUrlL #-}

-- | 'repositoryWatchersCount' Lens
repositoryWatchersCountL :: Lens_' Repository (Maybe Integer)
repositoryWatchersCountL f Repository{..} = (\repositoryWatchersCount -> Repository { repositoryWatchersCount, ..} ) <$> f repositoryWatchersCount
{-# INLINE repositoryWatchersCountL #-}

-- | 'repositoryWebsite' Lens
repositoryWebsiteL :: Lens_' Repository (Maybe Text)
repositoryWebsiteL f Repository{..} = (\repositoryWebsite -> Repository { repositoryWebsite, ..} ) <$> f repositoryWebsite
{-# INLINE repositoryWebsiteL #-}



-- * RepositoryMeta

-- | 'repositoryMetaFullName' Lens
repositoryMetaFullNameL :: Lens_' RepositoryMeta (Maybe Text)
repositoryMetaFullNameL f RepositoryMeta{..} = (\repositoryMetaFullName -> RepositoryMeta { repositoryMetaFullName, ..} ) <$> f repositoryMetaFullName
{-# INLINE repositoryMetaFullNameL #-}

-- | 'repositoryMetaId' Lens
repositoryMetaIdL :: Lens_' RepositoryMeta (Maybe Integer)
repositoryMetaIdL f RepositoryMeta{..} = (\repositoryMetaId -> RepositoryMeta { repositoryMetaId, ..} ) <$> f repositoryMetaId
{-# INLINE repositoryMetaIdL #-}

-- | 'repositoryMetaName' Lens
repositoryMetaNameL :: Lens_' RepositoryMeta (Maybe Text)
repositoryMetaNameL f RepositoryMeta{..} = (\repositoryMetaName -> RepositoryMeta { repositoryMetaName, ..} ) <$> f repositoryMetaName
{-# INLINE repositoryMetaNameL #-}

-- | 'repositoryMetaOwner' Lens
repositoryMetaOwnerL :: Lens_' RepositoryMeta (Maybe Text)
repositoryMetaOwnerL f RepositoryMeta{..} = (\repositoryMetaOwner -> RepositoryMeta { repositoryMetaOwner, ..} ) <$> f repositoryMetaOwner
{-# INLINE repositoryMetaOwnerL #-}



-- * SearchResults

-- | 'searchResultsData' Lens
searchResultsDataL :: Lens_' SearchResults (Maybe [Repository])
searchResultsDataL f SearchResults{..} = (\searchResultsData -> SearchResults { searchResultsData, ..} ) <$> f searchResultsData
{-# INLINE searchResultsDataL #-}

-- | 'searchResultsOk' Lens
searchResultsOkL :: Lens_' SearchResults (Maybe Bool)
searchResultsOkL f SearchResults{..} = (\searchResultsOk -> SearchResults { searchResultsOk, ..} ) <$> f searchResultsOk
{-# INLINE searchResultsOkL #-}



-- * ServerVersion

-- | 'serverVersionVersion' Lens
serverVersionVersionL :: Lens_' ServerVersion (Maybe Text)
serverVersionVersionL f ServerVersion{..} = (\serverVersionVersion -> ServerVersion { serverVersionVersion, ..} ) <$> f serverVersionVersion
{-# INLINE serverVersionVersionL #-}



-- * StopWatch

-- | 'stopWatchCreated' Lens
stopWatchCreatedL :: Lens_' StopWatch (Maybe DateTime)
stopWatchCreatedL f StopWatch{..} = (\stopWatchCreated -> StopWatch { stopWatchCreated, ..} ) <$> f stopWatchCreated
{-# INLINE stopWatchCreatedL #-}

-- | 'stopWatchDuration' Lens
stopWatchDurationL :: Lens_' StopWatch (Maybe Text)
stopWatchDurationL f StopWatch{..} = (\stopWatchDuration -> StopWatch { stopWatchDuration, ..} ) <$> f stopWatchDuration
{-# INLINE stopWatchDurationL #-}

-- | 'stopWatchIssueIndex' Lens
stopWatchIssueIndexL :: Lens_' StopWatch (Maybe Integer)
stopWatchIssueIndexL f StopWatch{..} = (\stopWatchIssueIndex -> StopWatch { stopWatchIssueIndex, ..} ) <$> f stopWatchIssueIndex
{-# INLINE stopWatchIssueIndexL #-}

-- | 'stopWatchIssueTitle' Lens
stopWatchIssueTitleL :: Lens_' StopWatch (Maybe Text)
stopWatchIssueTitleL f StopWatch{..} = (\stopWatchIssueTitle -> StopWatch { stopWatchIssueTitle, ..} ) <$> f stopWatchIssueTitle
{-# INLINE stopWatchIssueTitleL #-}

-- | 'stopWatchRepoName' Lens
stopWatchRepoNameL :: Lens_' StopWatch (Maybe Text)
stopWatchRepoNameL f StopWatch{..} = (\stopWatchRepoName -> StopWatch { stopWatchRepoName, ..} ) <$> f stopWatchRepoName
{-# INLINE stopWatchRepoNameL #-}

-- | 'stopWatchRepoOwnerName' Lens
stopWatchRepoOwnerNameL :: Lens_' StopWatch (Maybe Text)
stopWatchRepoOwnerNameL f StopWatch{..} = (\stopWatchRepoOwnerName -> StopWatch { stopWatchRepoOwnerName, ..} ) <$> f stopWatchRepoOwnerName
{-# INLINE stopWatchRepoOwnerNameL #-}

-- | 'stopWatchSeconds' Lens
stopWatchSecondsL :: Lens_' StopWatch (Maybe Integer)
stopWatchSecondsL f StopWatch{..} = (\stopWatchSeconds -> StopWatch { stopWatchSeconds, ..} ) <$> f stopWatchSeconds
{-# INLINE stopWatchSecondsL #-}



-- * SubmitPullReviewOptions

-- | 'submitPullReviewOptionsBody' Lens
submitPullReviewOptionsBodyL :: Lens_' SubmitPullReviewOptions (Maybe Text)
submitPullReviewOptionsBodyL f SubmitPullReviewOptions{..} = (\submitPullReviewOptionsBody -> SubmitPullReviewOptions { submitPullReviewOptionsBody, ..} ) <$> f submitPullReviewOptionsBody
{-# INLINE submitPullReviewOptionsBodyL #-}

-- | 'submitPullReviewOptionsEvent' Lens
submitPullReviewOptionsEventL :: Lens_' SubmitPullReviewOptions (Maybe Text)
submitPullReviewOptionsEventL f SubmitPullReviewOptions{..} = (\submitPullReviewOptionsEvent -> SubmitPullReviewOptions { submitPullReviewOptionsEvent, ..} ) <$> f submitPullReviewOptionsEvent
{-# INLINE submitPullReviewOptionsEventL #-}



-- * Tag

-- | 'tagCommit' Lens
tagCommitL :: Lens_' Tag (Maybe CommitMeta)
tagCommitL f Tag{..} = (\tagCommit -> Tag { tagCommit, ..} ) <$> f tagCommit
{-# INLINE tagCommitL #-}

-- | 'tagId' Lens
tagIdL :: Lens_' Tag (Maybe Text)
tagIdL f Tag{..} = (\tagId -> Tag { tagId, ..} ) <$> f tagId
{-# INLINE tagIdL #-}

-- | 'tagMessage' Lens
tagMessageL :: Lens_' Tag (Maybe Text)
tagMessageL f Tag{..} = (\tagMessage -> Tag { tagMessage, ..} ) <$> f tagMessage
{-# INLINE tagMessageL #-}

-- | 'tagName' Lens
tagNameL :: Lens_' Tag (Maybe Text)
tagNameL f Tag{..} = (\tagName -> Tag { tagName, ..} ) <$> f tagName
{-# INLINE tagNameL #-}

-- | 'tagTarballUrl' Lens
tagTarballUrlL :: Lens_' Tag (Maybe Text)
tagTarballUrlL f Tag{..} = (\tagTarballUrl -> Tag { tagTarballUrl, ..} ) <$> f tagTarballUrl
{-# INLINE tagTarballUrlL #-}

-- | 'tagZipballUrl' Lens
tagZipballUrlL :: Lens_' Tag (Maybe Text)
tagZipballUrlL f Tag{..} = (\tagZipballUrl -> Tag { tagZipballUrl, ..} ) <$> f tagZipballUrl
{-# INLINE tagZipballUrlL #-}



-- * Team

-- | 'teamCanCreateOrgRepo' Lens
teamCanCreateOrgRepoL :: Lens_' Team (Maybe Bool)
teamCanCreateOrgRepoL f Team{..} = (\teamCanCreateOrgRepo -> Team { teamCanCreateOrgRepo, ..} ) <$> f teamCanCreateOrgRepo
{-# INLINE teamCanCreateOrgRepoL #-}

-- | 'teamDescription' Lens
teamDescriptionL :: Lens_' Team (Maybe Text)
teamDescriptionL f Team{..} = (\teamDescription -> Team { teamDescription, ..} ) <$> f teamDescription
{-# INLINE teamDescriptionL #-}

-- | 'teamId' Lens
teamIdL :: Lens_' Team (Maybe Integer)
teamIdL f Team{..} = (\teamId -> Team { teamId, ..} ) <$> f teamId
{-# INLINE teamIdL #-}

-- | 'teamIncludesAllRepositories' Lens
teamIncludesAllRepositoriesL :: Lens_' Team (Maybe Bool)
teamIncludesAllRepositoriesL f Team{..} = (\teamIncludesAllRepositories -> Team { teamIncludesAllRepositories, ..} ) <$> f teamIncludesAllRepositories
{-# INLINE teamIncludesAllRepositoriesL #-}

-- | 'teamName' Lens
teamNameL :: Lens_' Team (Maybe Text)
teamNameL f Team{..} = (\teamName -> Team { teamName, ..} ) <$> f teamName
{-# INLINE teamNameL #-}

-- | 'teamOrganization' Lens
teamOrganizationL :: Lens_' Team (Maybe Organization)
teamOrganizationL f Team{..} = (\teamOrganization -> Team { teamOrganization, ..} ) <$> f teamOrganization
{-# INLINE teamOrganizationL #-}

-- | 'teamPermission' Lens
teamPermissionL :: Lens_' Team (Maybe E'Permission2)
teamPermissionL f Team{..} = (\teamPermission -> Team { teamPermission, ..} ) <$> f teamPermission
{-# INLINE teamPermissionL #-}

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

-- | 'teamUnitsMap' Lens
teamUnitsMapL :: Lens_' Team (Maybe (Map.Map String Text))
teamUnitsMapL f Team{..} = (\teamUnitsMap -> Team { teamUnitsMap, ..} ) <$> f teamUnitsMap
{-# INLINE teamUnitsMapL #-}



-- * TeamSearch200Response

-- | 'teamSearch200ResponseData' Lens
teamSearch200ResponseDataL :: Lens_' TeamSearch200Response (Maybe [Team])
teamSearch200ResponseDataL f TeamSearch200Response{..} = (\teamSearch200ResponseData -> TeamSearch200Response { teamSearch200ResponseData, ..} ) <$> f teamSearch200ResponseData
{-# INLINE teamSearch200ResponseDataL #-}

-- | 'teamSearch200ResponseOk' Lens
teamSearch200ResponseOkL :: Lens_' TeamSearch200Response (Maybe Bool)
teamSearch200ResponseOkL f TeamSearch200Response{..} = (\teamSearch200ResponseOk -> TeamSearch200Response { teamSearch200ResponseOk, ..} ) <$> f teamSearch200ResponseOk
{-# INLINE teamSearch200ResponseOkL #-}



-- * TimelineComment

-- | 'timelineCommentAssignee' Lens
timelineCommentAssigneeL :: Lens_' TimelineComment (Maybe User)
timelineCommentAssigneeL f TimelineComment{..} = (\timelineCommentAssignee -> TimelineComment { timelineCommentAssignee, ..} ) <$> f timelineCommentAssignee
{-# INLINE timelineCommentAssigneeL #-}

-- | 'timelineCommentAssigneeTeam' Lens
timelineCommentAssigneeTeamL :: Lens_' TimelineComment (Maybe Team)
timelineCommentAssigneeTeamL f TimelineComment{..} = (\timelineCommentAssigneeTeam -> TimelineComment { timelineCommentAssigneeTeam, ..} ) <$> f timelineCommentAssigneeTeam
{-# INLINE timelineCommentAssigneeTeamL #-}

-- | 'timelineCommentBody' Lens
timelineCommentBodyL :: Lens_' TimelineComment (Maybe Text)
timelineCommentBodyL f TimelineComment{..} = (\timelineCommentBody -> TimelineComment { timelineCommentBody, ..} ) <$> f timelineCommentBody
{-# INLINE timelineCommentBodyL #-}

-- | 'timelineCommentCreatedAt' Lens
timelineCommentCreatedAtL :: Lens_' TimelineComment (Maybe DateTime)
timelineCommentCreatedAtL f TimelineComment{..} = (\timelineCommentCreatedAt -> TimelineComment { timelineCommentCreatedAt, ..} ) <$> f timelineCommentCreatedAt
{-# INLINE timelineCommentCreatedAtL #-}

-- | 'timelineCommentDependentIssue' Lens
timelineCommentDependentIssueL :: Lens_' TimelineComment (Maybe Issue)
timelineCommentDependentIssueL f TimelineComment{..} = (\timelineCommentDependentIssue -> TimelineComment { timelineCommentDependentIssue, ..} ) <$> f timelineCommentDependentIssue
{-# INLINE timelineCommentDependentIssueL #-}

-- | 'timelineCommentHtmlUrl' Lens
timelineCommentHtmlUrlL :: Lens_' TimelineComment (Maybe Text)
timelineCommentHtmlUrlL f TimelineComment{..} = (\timelineCommentHtmlUrl -> TimelineComment { timelineCommentHtmlUrl, ..} ) <$> f timelineCommentHtmlUrl
{-# INLINE timelineCommentHtmlUrlL #-}

-- | 'timelineCommentId' Lens
timelineCommentIdL :: Lens_' TimelineComment (Maybe Integer)
timelineCommentIdL f TimelineComment{..} = (\timelineCommentId -> TimelineComment { timelineCommentId, ..} ) <$> f timelineCommentId
{-# INLINE timelineCommentIdL #-}

-- | 'timelineCommentIssueUrl' Lens
timelineCommentIssueUrlL :: Lens_' TimelineComment (Maybe Text)
timelineCommentIssueUrlL f TimelineComment{..} = (\timelineCommentIssueUrl -> TimelineComment { timelineCommentIssueUrl, ..} ) <$> f timelineCommentIssueUrl
{-# INLINE timelineCommentIssueUrlL #-}

-- | 'timelineCommentLabel' Lens
timelineCommentLabelL :: Lens_' TimelineComment (Maybe Label)
timelineCommentLabelL f TimelineComment{..} = (\timelineCommentLabel -> TimelineComment { timelineCommentLabel, ..} ) <$> f timelineCommentLabel
{-# INLINE timelineCommentLabelL #-}

-- | 'timelineCommentMilestone' Lens
timelineCommentMilestoneL :: Lens_' TimelineComment (Maybe Milestone)
timelineCommentMilestoneL f TimelineComment{..} = (\timelineCommentMilestone -> TimelineComment { timelineCommentMilestone, ..} ) <$> f timelineCommentMilestone
{-# INLINE timelineCommentMilestoneL #-}

-- | 'timelineCommentNewRef' Lens
timelineCommentNewRefL :: Lens_' TimelineComment (Maybe Text)
timelineCommentNewRefL f TimelineComment{..} = (\timelineCommentNewRef -> TimelineComment { timelineCommentNewRef, ..} ) <$> f timelineCommentNewRef
{-# INLINE timelineCommentNewRefL #-}

-- | 'timelineCommentNewTitle' Lens
timelineCommentNewTitleL :: Lens_' TimelineComment (Maybe Text)
timelineCommentNewTitleL f TimelineComment{..} = (\timelineCommentNewTitle -> TimelineComment { timelineCommentNewTitle, ..} ) <$> f timelineCommentNewTitle
{-# INLINE timelineCommentNewTitleL #-}

-- | 'timelineCommentOldMilestone' Lens
timelineCommentOldMilestoneL :: Lens_' TimelineComment (Maybe Milestone)
timelineCommentOldMilestoneL f TimelineComment{..} = (\timelineCommentOldMilestone -> TimelineComment { timelineCommentOldMilestone, ..} ) <$> f timelineCommentOldMilestone
{-# INLINE timelineCommentOldMilestoneL #-}

-- | 'timelineCommentOldProjectId' Lens
timelineCommentOldProjectIdL :: Lens_' TimelineComment (Maybe Integer)
timelineCommentOldProjectIdL f TimelineComment{..} = (\timelineCommentOldProjectId -> TimelineComment { timelineCommentOldProjectId, ..} ) <$> f timelineCommentOldProjectId
{-# INLINE timelineCommentOldProjectIdL #-}

-- | 'timelineCommentOldRef' Lens
timelineCommentOldRefL :: Lens_' TimelineComment (Maybe Text)
timelineCommentOldRefL f TimelineComment{..} = (\timelineCommentOldRef -> TimelineComment { timelineCommentOldRef, ..} ) <$> f timelineCommentOldRef
{-# INLINE timelineCommentOldRefL #-}

-- | 'timelineCommentOldTitle' Lens
timelineCommentOldTitleL :: Lens_' TimelineComment (Maybe Text)
timelineCommentOldTitleL f TimelineComment{..} = (\timelineCommentOldTitle -> TimelineComment { timelineCommentOldTitle, ..} ) <$> f timelineCommentOldTitle
{-# INLINE timelineCommentOldTitleL #-}

-- | 'timelineCommentProjectId' Lens
timelineCommentProjectIdL :: Lens_' TimelineComment (Maybe Integer)
timelineCommentProjectIdL f TimelineComment{..} = (\timelineCommentProjectId -> TimelineComment { timelineCommentProjectId, ..} ) <$> f timelineCommentProjectId
{-# INLINE timelineCommentProjectIdL #-}

-- | 'timelineCommentPullRequestUrl' Lens
timelineCommentPullRequestUrlL :: Lens_' TimelineComment (Maybe Text)
timelineCommentPullRequestUrlL f TimelineComment{..} = (\timelineCommentPullRequestUrl -> TimelineComment { timelineCommentPullRequestUrl, ..} ) <$> f timelineCommentPullRequestUrl
{-# INLINE timelineCommentPullRequestUrlL #-}

-- | 'timelineCommentRefAction' Lens
timelineCommentRefActionL :: Lens_' TimelineComment (Maybe Text)
timelineCommentRefActionL f TimelineComment{..} = (\timelineCommentRefAction -> TimelineComment { timelineCommentRefAction, ..} ) <$> f timelineCommentRefAction
{-# INLINE timelineCommentRefActionL #-}

-- | 'timelineCommentRefComment' Lens
timelineCommentRefCommentL :: Lens_' TimelineComment (Maybe Comment)
timelineCommentRefCommentL f TimelineComment{..} = (\timelineCommentRefComment -> TimelineComment { timelineCommentRefComment, ..} ) <$> f timelineCommentRefComment
{-# INLINE timelineCommentRefCommentL #-}

-- | 'timelineCommentRefCommitSha' Lens
timelineCommentRefCommitShaL :: Lens_' TimelineComment (Maybe Text)
timelineCommentRefCommitShaL f TimelineComment{..} = (\timelineCommentRefCommitSha -> TimelineComment { timelineCommentRefCommitSha, ..} ) <$> f timelineCommentRefCommitSha
{-# INLINE timelineCommentRefCommitShaL #-}

-- | 'timelineCommentRefIssue' Lens
timelineCommentRefIssueL :: Lens_' TimelineComment (Maybe Issue)
timelineCommentRefIssueL f TimelineComment{..} = (\timelineCommentRefIssue -> TimelineComment { timelineCommentRefIssue, ..} ) <$> f timelineCommentRefIssue
{-# INLINE timelineCommentRefIssueL #-}

-- | 'timelineCommentRemovedAssignee' Lens
timelineCommentRemovedAssigneeL :: Lens_' TimelineComment (Maybe Bool)
timelineCommentRemovedAssigneeL f TimelineComment{..} = (\timelineCommentRemovedAssignee -> TimelineComment { timelineCommentRemovedAssignee, ..} ) <$> f timelineCommentRemovedAssignee
{-# INLINE timelineCommentRemovedAssigneeL #-}

-- | 'timelineCommentResolveDoer' Lens
timelineCommentResolveDoerL :: Lens_' TimelineComment (Maybe User)
timelineCommentResolveDoerL f TimelineComment{..} = (\timelineCommentResolveDoer -> TimelineComment { timelineCommentResolveDoer, ..} ) <$> f timelineCommentResolveDoer
{-# INLINE timelineCommentResolveDoerL #-}

-- | 'timelineCommentReviewId' Lens
timelineCommentReviewIdL :: Lens_' TimelineComment (Maybe Integer)
timelineCommentReviewIdL f TimelineComment{..} = (\timelineCommentReviewId -> TimelineComment { timelineCommentReviewId, ..} ) <$> f timelineCommentReviewId
{-# INLINE timelineCommentReviewIdL #-}

-- | 'timelineCommentTrackedTime' Lens
timelineCommentTrackedTimeL :: Lens_' TimelineComment (Maybe TrackedTime)
timelineCommentTrackedTimeL f TimelineComment{..} = (\timelineCommentTrackedTime -> TimelineComment { timelineCommentTrackedTime, ..} ) <$> f timelineCommentTrackedTime
{-# INLINE timelineCommentTrackedTimeL #-}

-- | 'timelineCommentType' Lens
timelineCommentTypeL :: Lens_' TimelineComment (Maybe Text)
timelineCommentTypeL f TimelineComment{..} = (\timelineCommentType -> TimelineComment { timelineCommentType, ..} ) <$> f timelineCommentType
{-# INLINE timelineCommentTypeL #-}

-- | 'timelineCommentUpdatedAt' Lens
timelineCommentUpdatedAtL :: Lens_' TimelineComment (Maybe DateTime)
timelineCommentUpdatedAtL f TimelineComment{..} = (\timelineCommentUpdatedAt -> TimelineComment { timelineCommentUpdatedAt, ..} ) <$> f timelineCommentUpdatedAt
{-# INLINE timelineCommentUpdatedAtL #-}

-- | 'timelineCommentUser' Lens
timelineCommentUserL :: Lens_' TimelineComment (Maybe User)
timelineCommentUserL f TimelineComment{..} = (\timelineCommentUser -> TimelineComment { timelineCommentUser, ..} ) <$> f timelineCommentUser
{-# INLINE timelineCommentUserL #-}



-- * TopicName

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



-- * TopicResponse

-- | 'topicResponseCreated' Lens
topicResponseCreatedL :: Lens_' TopicResponse (Maybe DateTime)
topicResponseCreatedL f TopicResponse{..} = (\topicResponseCreated -> TopicResponse { topicResponseCreated, ..} ) <$> f topicResponseCreated
{-# INLINE topicResponseCreatedL #-}

-- | 'topicResponseId' Lens
topicResponseIdL :: Lens_' TopicResponse (Maybe Integer)
topicResponseIdL f TopicResponse{..} = (\topicResponseId -> TopicResponse { topicResponseId, ..} ) <$> f topicResponseId
{-# INLINE topicResponseIdL #-}

-- | 'topicResponseRepoCount' Lens
topicResponseRepoCountL :: Lens_' TopicResponse (Maybe Integer)
topicResponseRepoCountL f TopicResponse{..} = (\topicResponseRepoCount -> TopicResponse { topicResponseRepoCount, ..} ) <$> f topicResponseRepoCount
{-# INLINE topicResponseRepoCountL #-}

-- | 'topicResponseTopicName' Lens
topicResponseTopicNameL :: Lens_' TopicResponse (Maybe Text)
topicResponseTopicNameL f TopicResponse{..} = (\topicResponseTopicName -> TopicResponse { topicResponseTopicName, ..} ) <$> f topicResponseTopicName
{-# INLINE topicResponseTopicNameL #-}

-- | 'topicResponseUpdated' Lens
topicResponseUpdatedL :: Lens_' TopicResponse (Maybe DateTime)
topicResponseUpdatedL f TopicResponse{..} = (\topicResponseUpdated -> TopicResponse { topicResponseUpdated, ..} ) <$> f topicResponseUpdated
{-# INLINE topicResponseUpdatedL #-}



-- * TrackedTime

-- | 'trackedTimeCreated' Lens
trackedTimeCreatedL :: Lens_' TrackedTime (Maybe DateTime)
trackedTimeCreatedL f TrackedTime{..} = (\trackedTimeCreated -> TrackedTime { trackedTimeCreated, ..} ) <$> f trackedTimeCreated
{-# INLINE trackedTimeCreatedL #-}

-- | 'trackedTimeId' Lens
trackedTimeIdL :: Lens_' TrackedTime (Maybe Integer)
trackedTimeIdL f TrackedTime{..} = (\trackedTimeId -> TrackedTime { trackedTimeId, ..} ) <$> f trackedTimeId
{-# INLINE trackedTimeIdL #-}

-- | 'trackedTimeIssue' Lens
trackedTimeIssueL :: Lens_' TrackedTime (Maybe Issue)
trackedTimeIssueL f TrackedTime{..} = (\trackedTimeIssue -> TrackedTime { trackedTimeIssue, ..} ) <$> f trackedTimeIssue
{-# INLINE trackedTimeIssueL #-}

-- | 'trackedTimeIssueId' Lens
trackedTimeIssueIdL :: Lens_' TrackedTime (Maybe Integer)
trackedTimeIssueIdL f TrackedTime{..} = (\trackedTimeIssueId -> TrackedTime { trackedTimeIssueId, ..} ) <$> f trackedTimeIssueId
{-# INLINE trackedTimeIssueIdL #-}

-- | 'trackedTimeTime' Lens
trackedTimeTimeL :: Lens_' TrackedTime (Maybe Integer)
trackedTimeTimeL f TrackedTime{..} = (\trackedTimeTime -> TrackedTime { trackedTimeTime, ..} ) <$> f trackedTimeTime
{-# INLINE trackedTimeTimeL #-}

-- | 'trackedTimeUserId' Lens
trackedTimeUserIdL :: Lens_' TrackedTime (Maybe Integer)
trackedTimeUserIdL f TrackedTime{..} = (\trackedTimeUserId -> TrackedTime { trackedTimeUserId, ..} ) <$> f trackedTimeUserId
{-# INLINE trackedTimeUserIdL #-}

-- | 'trackedTimeUserName' Lens
trackedTimeUserNameL :: Lens_' TrackedTime (Maybe Text)
trackedTimeUserNameL f TrackedTime{..} = (\trackedTimeUserName -> TrackedTime { trackedTimeUserName, ..} ) <$> f trackedTimeUserName
{-# INLINE trackedTimeUserNameL #-}



-- * TransferRepoOption

-- | 'transferRepoOptionNewOwner' Lens
transferRepoOptionNewOwnerL :: Lens_' TransferRepoOption (Text)
transferRepoOptionNewOwnerL f TransferRepoOption{..} = (\transferRepoOptionNewOwner -> TransferRepoOption { transferRepoOptionNewOwner, ..} ) <$> f transferRepoOptionNewOwner
{-# INLINE transferRepoOptionNewOwnerL #-}

-- | 'transferRepoOptionTeamIds' Lens
transferRepoOptionTeamIdsL :: Lens_' TransferRepoOption (Maybe [Integer])
transferRepoOptionTeamIdsL f TransferRepoOption{..} = (\transferRepoOptionTeamIds -> TransferRepoOption { transferRepoOptionTeamIds, ..} ) <$> f transferRepoOptionTeamIds
{-# INLINE transferRepoOptionTeamIdsL #-}



-- * UpdateFileOptions

-- | 'updateFileOptionsAuthor' Lens
updateFileOptionsAuthorL :: Lens_' UpdateFileOptions (Maybe Identity)
updateFileOptionsAuthorL f UpdateFileOptions{..} = (\updateFileOptionsAuthor -> UpdateFileOptions { updateFileOptionsAuthor, ..} ) <$> f updateFileOptionsAuthor
{-# INLINE updateFileOptionsAuthorL #-}

-- | 'updateFileOptionsBranch' Lens
updateFileOptionsBranchL :: Lens_' UpdateFileOptions (Maybe Text)
updateFileOptionsBranchL f UpdateFileOptions{..} = (\updateFileOptionsBranch -> UpdateFileOptions { updateFileOptionsBranch, ..} ) <$> f updateFileOptionsBranch
{-# INLINE updateFileOptionsBranchL #-}

-- | 'updateFileOptionsCommitter' Lens
updateFileOptionsCommitterL :: Lens_' UpdateFileOptions (Maybe Identity)
updateFileOptionsCommitterL f UpdateFileOptions{..} = (\updateFileOptionsCommitter -> UpdateFileOptions { updateFileOptionsCommitter, ..} ) <$> f updateFileOptionsCommitter
{-# INLINE updateFileOptionsCommitterL #-}

-- | 'updateFileOptionsContent' Lens
updateFileOptionsContentL :: Lens_' UpdateFileOptions (Text)
updateFileOptionsContentL f UpdateFileOptions{..} = (\updateFileOptionsContent -> UpdateFileOptions { updateFileOptionsContent, ..} ) <$> f updateFileOptionsContent
{-# INLINE updateFileOptionsContentL #-}

-- | 'updateFileOptionsDates' Lens
updateFileOptionsDatesL :: Lens_' UpdateFileOptions (Maybe CommitDateOptions)
updateFileOptionsDatesL f UpdateFileOptions{..} = (\updateFileOptionsDates -> UpdateFileOptions { updateFileOptionsDates, ..} ) <$> f updateFileOptionsDates
{-# INLINE updateFileOptionsDatesL #-}

-- | 'updateFileOptionsFromPath' Lens
updateFileOptionsFromPathL :: Lens_' UpdateFileOptions (Maybe Text)
updateFileOptionsFromPathL f UpdateFileOptions{..} = (\updateFileOptionsFromPath -> UpdateFileOptions { updateFileOptionsFromPath, ..} ) <$> f updateFileOptionsFromPath
{-# INLINE updateFileOptionsFromPathL #-}

-- | 'updateFileOptionsMessage' Lens
updateFileOptionsMessageL :: Lens_' UpdateFileOptions (Maybe Text)
updateFileOptionsMessageL f UpdateFileOptions{..} = (\updateFileOptionsMessage -> UpdateFileOptions { updateFileOptionsMessage, ..} ) <$> f updateFileOptionsMessage
{-# INLINE updateFileOptionsMessageL #-}

-- | 'updateFileOptionsNewBranch' Lens
updateFileOptionsNewBranchL :: Lens_' UpdateFileOptions (Maybe Text)
updateFileOptionsNewBranchL f UpdateFileOptions{..} = (\updateFileOptionsNewBranch -> UpdateFileOptions { updateFileOptionsNewBranch, ..} ) <$> f updateFileOptionsNewBranch
{-# INLINE updateFileOptionsNewBranchL #-}

-- | 'updateFileOptionsSha' Lens
updateFileOptionsShaL :: Lens_' UpdateFileOptions (Text)
updateFileOptionsShaL f UpdateFileOptions{..} = (\updateFileOptionsSha -> UpdateFileOptions { updateFileOptionsSha, ..} ) <$> f updateFileOptionsSha
{-# INLINE updateFileOptionsShaL #-}

-- | 'updateFileOptionsSignoff' Lens
updateFileOptionsSignoffL :: Lens_' UpdateFileOptions (Maybe Bool)
updateFileOptionsSignoffL f UpdateFileOptions{..} = (\updateFileOptionsSignoff -> UpdateFileOptions { updateFileOptionsSignoff, ..} ) <$> f updateFileOptionsSignoff
{-# INLINE updateFileOptionsSignoffL #-}



-- * User

-- | 'userActive' Lens
userActiveL :: Lens_' User (Maybe Bool)
userActiveL f User{..} = (\userActive -> User { userActive, ..} ) <$> f userActive
{-# INLINE userActiveL #-}

-- | 'userAvatarUrl' Lens
userAvatarUrlL :: Lens_' User (Maybe Text)
userAvatarUrlL f User{..} = (\userAvatarUrl -> User { userAvatarUrl, ..} ) <$> f userAvatarUrl
{-# INLINE userAvatarUrlL #-}

-- | 'userCreated' Lens
userCreatedL :: Lens_' User (Maybe DateTime)
userCreatedL f User{..} = (\userCreated -> User { userCreated, ..} ) <$> f userCreated
{-# INLINE userCreatedL #-}

-- | 'userDescription' Lens
userDescriptionL :: Lens_' User (Maybe Text)
userDescriptionL f User{..} = (\userDescription -> User { userDescription, ..} ) <$> f userDescription
{-# INLINE userDescriptionL #-}

-- | 'userEmail' Lens
userEmailL :: Lens_' User (Maybe Text)
userEmailL f User{..} = (\userEmail -> User { userEmail, ..} ) <$> f userEmail
{-# INLINE userEmailL #-}

-- | 'userFollowersCount' Lens
userFollowersCountL :: Lens_' User (Maybe Integer)
userFollowersCountL f User{..} = (\userFollowersCount -> User { userFollowersCount, ..} ) <$> f userFollowersCount
{-# INLINE userFollowersCountL #-}

-- | 'userFollowingCount' Lens
userFollowingCountL :: Lens_' User (Maybe Integer)
userFollowingCountL f User{..} = (\userFollowingCount -> User { userFollowingCount, ..} ) <$> f userFollowingCount
{-# INLINE userFollowingCountL #-}

-- | 'userFullName' Lens
userFullNameL :: Lens_' User (Maybe Text)
userFullNameL f User{..} = (\userFullName -> User { userFullName, ..} ) <$> f userFullName
{-# INLINE userFullNameL #-}

-- | 'userId' Lens
userIdL :: Lens_' User (Maybe Integer)
userIdL f User{..} = (\userId -> User { userId, ..} ) <$> f userId
{-# INLINE userIdL #-}

-- | 'userIsAdmin' Lens
userIsAdminL :: Lens_' User (Maybe Bool)
userIsAdminL f User{..} = (\userIsAdmin -> User { userIsAdmin, ..} ) <$> f userIsAdmin
{-# INLINE userIsAdminL #-}

-- | 'userLanguage' Lens
userLanguageL :: Lens_' User (Maybe Text)
userLanguageL f User{..} = (\userLanguage -> User { userLanguage, ..} ) <$> f userLanguage
{-# INLINE userLanguageL #-}

-- | 'userLastLogin' Lens
userLastLoginL :: Lens_' User (Maybe DateTime)
userLastLoginL f User{..} = (\userLastLogin -> User { userLastLogin, ..} ) <$> f userLastLogin
{-# INLINE userLastLoginL #-}

-- | 'userLocation' Lens
userLocationL :: Lens_' User (Maybe Text)
userLocationL f User{..} = (\userLocation -> User { userLocation, ..} ) <$> f userLocation
{-# INLINE userLocationL #-}

-- | 'userLogin' Lens
userLoginL :: Lens_' User (Maybe Text)
userLoginL f User{..} = (\userLogin -> User { userLogin, ..} ) <$> f userLogin
{-# INLINE userLoginL #-}

-- | 'userLoginName' Lens
userLoginNameL :: Lens_' User (Maybe Text)
userLoginNameL f User{..} = (\userLoginName -> User { userLoginName, ..} ) <$> f userLoginName
{-# INLINE userLoginNameL #-}

-- | 'userProhibitLogin' Lens
userProhibitLoginL :: Lens_' User (Maybe Bool)
userProhibitLoginL f User{..} = (\userProhibitLogin -> User { userProhibitLogin, ..} ) <$> f userProhibitLogin
{-# INLINE userProhibitLoginL #-}

-- | 'userRestricted' Lens
userRestrictedL :: Lens_' User (Maybe Bool)
userRestrictedL f User{..} = (\userRestricted -> User { userRestricted, ..} ) <$> f userRestricted
{-# INLINE userRestrictedL #-}

-- | 'userStarredReposCount' Lens
userStarredReposCountL :: Lens_' User (Maybe Integer)
userStarredReposCountL f User{..} = (\userStarredReposCount -> User { userStarredReposCount, ..} ) <$> f userStarredReposCount
{-# INLINE userStarredReposCountL #-}

-- | 'userVisibility' Lens
userVisibilityL :: Lens_' User (Maybe Text)
userVisibilityL f User{..} = (\userVisibility -> User { userVisibility, ..} ) <$> f userVisibility
{-# INLINE userVisibilityL #-}

-- | 'userWebsite' Lens
userWebsiteL :: Lens_' User (Maybe Text)
userWebsiteL f User{..} = (\userWebsite -> User { userWebsite, ..} ) <$> f userWebsite
{-# INLINE userWebsiteL #-}



-- * UserHeatmapData

-- | 'userHeatmapDataContributions' Lens
userHeatmapDataContributionsL :: Lens_' UserHeatmapData (Maybe Integer)
userHeatmapDataContributionsL f UserHeatmapData{..} = (\userHeatmapDataContributions -> UserHeatmapData { userHeatmapDataContributions, ..} ) <$> f userHeatmapDataContributions
{-# INLINE userHeatmapDataContributionsL #-}

-- | 'userHeatmapDataTimestamp' Lens
userHeatmapDataTimestampL :: Lens_' UserHeatmapData (Maybe Integer)
userHeatmapDataTimestampL f UserHeatmapData{..} = (\userHeatmapDataTimestamp -> UserHeatmapData { userHeatmapDataTimestamp, ..} ) <$> f userHeatmapDataTimestamp
{-# INLINE userHeatmapDataTimestampL #-}



-- * UserSearch200Response

-- | 'userSearch200ResponseData' Lens
userSearch200ResponseDataL :: Lens_' UserSearch200Response (Maybe [User])
userSearch200ResponseDataL f UserSearch200Response{..} = (\userSearch200ResponseData -> UserSearch200Response { userSearch200ResponseData, ..} ) <$> f userSearch200ResponseData
{-# INLINE userSearch200ResponseDataL #-}

-- | 'userSearch200ResponseOk' Lens
userSearch200ResponseOkL :: Lens_' UserSearch200Response (Maybe Bool)
userSearch200ResponseOkL f UserSearch200Response{..} = (\userSearch200ResponseOk -> UserSearch200Response { userSearch200ResponseOk, ..} ) <$> f userSearch200ResponseOk
{-# INLINE userSearch200ResponseOkL #-}



-- * UserSettings

-- | 'userSettingsDescription' Lens
userSettingsDescriptionL :: Lens_' UserSettings (Maybe Text)
userSettingsDescriptionL f UserSettings{..} = (\userSettingsDescription -> UserSettings { userSettingsDescription, ..} ) <$> f userSettingsDescription
{-# INLINE userSettingsDescriptionL #-}

-- | 'userSettingsDiffViewStyle' Lens
userSettingsDiffViewStyleL :: Lens_' UserSettings (Maybe Text)
userSettingsDiffViewStyleL f UserSettings{..} = (\userSettingsDiffViewStyle -> UserSettings { userSettingsDiffViewStyle, ..} ) <$> f userSettingsDiffViewStyle
{-# INLINE userSettingsDiffViewStyleL #-}

-- | 'userSettingsFullName' Lens
userSettingsFullNameL :: Lens_' UserSettings (Maybe Text)
userSettingsFullNameL f UserSettings{..} = (\userSettingsFullName -> UserSettings { userSettingsFullName, ..} ) <$> f userSettingsFullName
{-# INLINE userSettingsFullNameL #-}

-- | 'userSettingsHideActivity' Lens
userSettingsHideActivityL :: Lens_' UserSettings (Maybe Bool)
userSettingsHideActivityL f UserSettings{..} = (\userSettingsHideActivity -> UserSettings { userSettingsHideActivity, ..} ) <$> f userSettingsHideActivity
{-# INLINE userSettingsHideActivityL #-}

-- | 'userSettingsHideEmail' Lens
userSettingsHideEmailL :: Lens_' UserSettings (Maybe Bool)
userSettingsHideEmailL f UserSettings{..} = (\userSettingsHideEmail -> UserSettings { userSettingsHideEmail, ..} ) <$> f userSettingsHideEmail
{-# INLINE userSettingsHideEmailL #-}

-- | 'userSettingsLanguage' Lens
userSettingsLanguageL :: Lens_' UserSettings (Maybe Text)
userSettingsLanguageL f UserSettings{..} = (\userSettingsLanguage -> UserSettings { userSettingsLanguage, ..} ) <$> f userSettingsLanguage
{-# INLINE userSettingsLanguageL #-}

-- | 'userSettingsLocation' Lens
userSettingsLocationL :: Lens_' UserSettings (Maybe Text)
userSettingsLocationL f UserSettings{..} = (\userSettingsLocation -> UserSettings { userSettingsLocation, ..} ) <$> f userSettingsLocation
{-# INLINE userSettingsLocationL #-}

-- | 'userSettingsTheme' Lens
userSettingsThemeL :: Lens_' UserSettings (Maybe Text)
userSettingsThemeL f UserSettings{..} = (\userSettingsTheme -> UserSettings { userSettingsTheme, ..} ) <$> f userSettingsTheme
{-# INLINE userSettingsThemeL #-}

-- | 'userSettingsWebsite' Lens
userSettingsWebsiteL :: Lens_' UserSettings (Maybe Text)
userSettingsWebsiteL f UserSettings{..} = (\userSettingsWebsite -> UserSettings { userSettingsWebsite, ..} ) <$> f userSettingsWebsite
{-# INLINE userSettingsWebsiteL #-}



-- * UserSettingsOptions

-- | 'userSettingsOptionsDescription' Lens
userSettingsOptionsDescriptionL :: Lens_' UserSettingsOptions (Maybe Text)
userSettingsOptionsDescriptionL f UserSettingsOptions{..} = (\userSettingsOptionsDescription -> UserSettingsOptions { userSettingsOptionsDescription, ..} ) <$> f userSettingsOptionsDescription
{-# INLINE userSettingsOptionsDescriptionL #-}

-- | 'userSettingsOptionsDiffViewStyle' Lens
userSettingsOptionsDiffViewStyleL :: Lens_' UserSettingsOptions (Maybe Text)
userSettingsOptionsDiffViewStyleL f UserSettingsOptions{..} = (\userSettingsOptionsDiffViewStyle -> UserSettingsOptions { userSettingsOptionsDiffViewStyle, ..} ) <$> f userSettingsOptionsDiffViewStyle
{-# INLINE userSettingsOptionsDiffViewStyleL #-}

-- | 'userSettingsOptionsFullName' Lens
userSettingsOptionsFullNameL :: Lens_' UserSettingsOptions (Maybe Text)
userSettingsOptionsFullNameL f UserSettingsOptions{..} = (\userSettingsOptionsFullName -> UserSettingsOptions { userSettingsOptionsFullName, ..} ) <$> f userSettingsOptionsFullName
{-# INLINE userSettingsOptionsFullNameL #-}

-- | 'userSettingsOptionsHideActivity' Lens
userSettingsOptionsHideActivityL :: Lens_' UserSettingsOptions (Maybe Bool)
userSettingsOptionsHideActivityL f UserSettingsOptions{..} = (\userSettingsOptionsHideActivity -> UserSettingsOptions { userSettingsOptionsHideActivity, ..} ) <$> f userSettingsOptionsHideActivity
{-# INLINE userSettingsOptionsHideActivityL #-}

-- | 'userSettingsOptionsHideEmail' Lens
userSettingsOptionsHideEmailL :: Lens_' UserSettingsOptions (Maybe Bool)
userSettingsOptionsHideEmailL f UserSettingsOptions{..} = (\userSettingsOptionsHideEmail -> UserSettingsOptions { userSettingsOptionsHideEmail, ..} ) <$> f userSettingsOptionsHideEmail
{-# INLINE userSettingsOptionsHideEmailL #-}

-- | 'userSettingsOptionsLanguage' Lens
userSettingsOptionsLanguageL :: Lens_' UserSettingsOptions (Maybe Text)
userSettingsOptionsLanguageL f UserSettingsOptions{..} = (\userSettingsOptionsLanguage -> UserSettingsOptions { userSettingsOptionsLanguage, ..} ) <$> f userSettingsOptionsLanguage
{-# INLINE userSettingsOptionsLanguageL #-}

-- | 'userSettingsOptionsLocation' Lens
userSettingsOptionsLocationL :: Lens_' UserSettingsOptions (Maybe Text)
userSettingsOptionsLocationL f UserSettingsOptions{..} = (\userSettingsOptionsLocation -> UserSettingsOptions { userSettingsOptionsLocation, ..} ) <$> f userSettingsOptionsLocation
{-# INLINE userSettingsOptionsLocationL #-}

-- | 'userSettingsOptionsTheme' Lens
userSettingsOptionsThemeL :: Lens_' UserSettingsOptions (Maybe Text)
userSettingsOptionsThemeL f UserSettingsOptions{..} = (\userSettingsOptionsTheme -> UserSettingsOptions { userSettingsOptionsTheme, ..} ) <$> f userSettingsOptionsTheme
{-# INLINE userSettingsOptionsThemeL #-}

-- | 'userSettingsOptionsWebsite' Lens
userSettingsOptionsWebsiteL :: Lens_' UserSettingsOptions (Maybe Text)
userSettingsOptionsWebsiteL f UserSettingsOptions{..} = (\userSettingsOptionsWebsite -> UserSettingsOptions { userSettingsOptionsWebsite, ..} ) <$> f userSettingsOptionsWebsite
{-# INLINE userSettingsOptionsWebsiteL #-}



-- * WatchInfo

-- | 'watchInfoCreatedAt' Lens
watchInfoCreatedAtL :: Lens_' WatchInfo (Maybe DateTime)
watchInfoCreatedAtL f WatchInfo{..} = (\watchInfoCreatedAt -> WatchInfo { watchInfoCreatedAt, ..} ) <$> f watchInfoCreatedAt
{-# INLINE watchInfoCreatedAtL #-}

-- | 'watchInfoIgnored' Lens
watchInfoIgnoredL :: Lens_' WatchInfo (Maybe Bool)
watchInfoIgnoredL f WatchInfo{..} = (\watchInfoIgnored -> WatchInfo { watchInfoIgnored, ..} ) <$> f watchInfoIgnored
{-# INLINE watchInfoIgnoredL #-}

-- | 'watchInfoReason' Lens
watchInfoReasonL :: Lens_' WatchInfo (Maybe A.Value)
watchInfoReasonL f WatchInfo{..} = (\watchInfoReason -> WatchInfo { watchInfoReason, ..} ) <$> f watchInfoReason
{-# INLINE watchInfoReasonL #-}

-- | 'watchInfoRepositoryUrl' Lens
watchInfoRepositoryUrlL :: Lens_' WatchInfo (Maybe Text)
watchInfoRepositoryUrlL f WatchInfo{..} = (\watchInfoRepositoryUrl -> WatchInfo { watchInfoRepositoryUrl, ..} ) <$> f watchInfoRepositoryUrl
{-# INLINE watchInfoRepositoryUrlL #-}

-- | 'watchInfoSubscribed' Lens
watchInfoSubscribedL :: Lens_' WatchInfo (Maybe Bool)
watchInfoSubscribedL f WatchInfo{..} = (\watchInfoSubscribed -> WatchInfo { watchInfoSubscribed, ..} ) <$> f watchInfoSubscribed
{-# INLINE watchInfoSubscribedL #-}

-- | 'watchInfoUrl' Lens
watchInfoUrlL :: Lens_' WatchInfo (Maybe Text)
watchInfoUrlL f WatchInfo{..} = (\watchInfoUrl -> WatchInfo { watchInfoUrl, ..} ) <$> f watchInfoUrl
{-# INLINE watchInfoUrlL #-}



-- * WikiCommit

-- | 'wikiCommitAuthor' Lens
wikiCommitAuthorL :: Lens_' WikiCommit (Maybe CommitUser)
wikiCommitAuthorL f WikiCommit{..} = (\wikiCommitAuthor -> WikiCommit { wikiCommitAuthor, ..} ) <$> f wikiCommitAuthor
{-# INLINE wikiCommitAuthorL #-}

-- | 'wikiCommitCommiter' Lens
wikiCommitCommiterL :: Lens_' WikiCommit (Maybe CommitUser)
wikiCommitCommiterL f WikiCommit{..} = (\wikiCommitCommiter -> WikiCommit { wikiCommitCommiter, ..} ) <$> f wikiCommitCommiter
{-# INLINE wikiCommitCommiterL #-}

-- | 'wikiCommitMessage' Lens
wikiCommitMessageL :: Lens_' WikiCommit (Maybe Text)
wikiCommitMessageL f WikiCommit{..} = (\wikiCommitMessage -> WikiCommit { wikiCommitMessage, ..} ) <$> f wikiCommitMessage
{-# INLINE wikiCommitMessageL #-}

-- | 'wikiCommitSha' Lens
wikiCommitShaL :: Lens_' WikiCommit (Maybe Text)
wikiCommitShaL f WikiCommit{..} = (\wikiCommitSha -> WikiCommit { wikiCommitSha, ..} ) <$> f wikiCommitSha
{-# INLINE wikiCommitShaL #-}



-- * WikiCommitList

-- | 'wikiCommitListCommits' Lens
wikiCommitListCommitsL :: Lens_' WikiCommitList (Maybe [WikiCommit])
wikiCommitListCommitsL f WikiCommitList{..} = (\wikiCommitListCommits -> WikiCommitList { wikiCommitListCommits, ..} ) <$> f wikiCommitListCommits
{-# INLINE wikiCommitListCommitsL #-}

-- | 'wikiCommitListCount' Lens
wikiCommitListCountL :: Lens_' WikiCommitList (Maybe Integer)
wikiCommitListCountL f WikiCommitList{..} = (\wikiCommitListCount -> WikiCommitList { wikiCommitListCount, ..} ) <$> f wikiCommitListCount
{-# INLINE wikiCommitListCountL #-}



-- * WikiPage

-- | 'wikiPageCommitCount' Lens
wikiPageCommitCountL :: Lens_' WikiPage (Maybe Integer)
wikiPageCommitCountL f WikiPage{..} = (\wikiPageCommitCount -> WikiPage { wikiPageCommitCount, ..} ) <$> f wikiPageCommitCount
{-# INLINE wikiPageCommitCountL #-}

-- | 'wikiPageContentBase64' Lens
wikiPageContentBase64L :: Lens_' WikiPage (Maybe Text)
wikiPageContentBase64L f WikiPage{..} = (\wikiPageContentBase64 -> WikiPage { wikiPageContentBase64, ..} ) <$> f wikiPageContentBase64
{-# INLINE wikiPageContentBase64L #-}

-- | 'wikiPageFooter' Lens
wikiPageFooterL :: Lens_' WikiPage (Maybe Text)
wikiPageFooterL f WikiPage{..} = (\wikiPageFooter -> WikiPage { wikiPageFooter, ..} ) <$> f wikiPageFooter
{-# INLINE wikiPageFooterL #-}

-- | 'wikiPageHtmlUrl' Lens
wikiPageHtmlUrlL :: Lens_' WikiPage (Maybe Text)
wikiPageHtmlUrlL f WikiPage{..} = (\wikiPageHtmlUrl -> WikiPage { wikiPageHtmlUrl, ..} ) <$> f wikiPageHtmlUrl
{-# INLINE wikiPageHtmlUrlL #-}

-- | 'wikiPageLastCommit' Lens
wikiPageLastCommitL :: Lens_' WikiPage (Maybe WikiCommit)
wikiPageLastCommitL f WikiPage{..} = (\wikiPageLastCommit -> WikiPage { wikiPageLastCommit, ..} ) <$> f wikiPageLastCommit
{-# INLINE wikiPageLastCommitL #-}

-- | 'wikiPageSidebar' Lens
wikiPageSidebarL :: Lens_' WikiPage (Maybe Text)
wikiPageSidebarL f WikiPage{..} = (\wikiPageSidebar -> WikiPage { wikiPageSidebar, ..} ) <$> f wikiPageSidebar
{-# INLINE wikiPageSidebarL #-}

-- | 'wikiPageSubUrl' Lens
wikiPageSubUrlL :: Lens_' WikiPage (Maybe Text)
wikiPageSubUrlL f WikiPage{..} = (\wikiPageSubUrl -> WikiPage { wikiPageSubUrl, ..} ) <$> f wikiPageSubUrl
{-# INLINE wikiPageSubUrlL #-}

-- | 'wikiPageTitle' Lens
wikiPageTitleL :: Lens_' WikiPage (Maybe Text)
wikiPageTitleL f WikiPage{..} = (\wikiPageTitle -> WikiPage { wikiPageTitle, ..} ) <$> f wikiPageTitle
{-# INLINE wikiPageTitleL #-}



-- * WikiPageMetaData

-- | 'wikiPageMetaDataHtmlUrl' Lens
wikiPageMetaDataHtmlUrlL :: Lens_' WikiPageMetaData (Maybe Text)
wikiPageMetaDataHtmlUrlL f WikiPageMetaData{..} = (\wikiPageMetaDataHtmlUrl -> WikiPageMetaData { wikiPageMetaDataHtmlUrl, ..} ) <$> f wikiPageMetaDataHtmlUrl
{-# INLINE wikiPageMetaDataHtmlUrlL #-}

-- | 'wikiPageMetaDataLastCommit' Lens
wikiPageMetaDataLastCommitL :: Lens_' WikiPageMetaData (Maybe WikiCommit)
wikiPageMetaDataLastCommitL f WikiPageMetaData{..} = (\wikiPageMetaDataLastCommit -> WikiPageMetaData { wikiPageMetaDataLastCommit, ..} ) <$> f wikiPageMetaDataLastCommit
{-# INLINE wikiPageMetaDataLastCommitL #-}

-- | 'wikiPageMetaDataSubUrl' Lens
wikiPageMetaDataSubUrlL :: Lens_' WikiPageMetaData (Maybe Text)
wikiPageMetaDataSubUrlL f WikiPageMetaData{..} = (\wikiPageMetaDataSubUrl -> WikiPageMetaData { wikiPageMetaDataSubUrl, ..} ) <$> f wikiPageMetaDataSubUrl
{-# INLINE wikiPageMetaDataSubUrlL #-}

-- | 'wikiPageMetaDataTitle' Lens
wikiPageMetaDataTitleL :: Lens_' WikiPageMetaData (Maybe Text)
wikiPageMetaDataTitleL f WikiPageMetaData{..} = (\wikiPageMetaDataTitle -> WikiPageMetaData { wikiPageMetaDataTitle, ..} ) <$> f wikiPageMetaDataTitle
{-# INLINE wikiPageMetaDataTitleL #-}