{-
   Kubernetes

   No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)

   OpenAPI Version: 3.0.1
   Kubernetes API version: release-1.23
   Generated by OpenAPI Generator (https://openapi-generator.tech)
-}

{-|
Module : Kubernetes.OpenAPI.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 Kubernetes.OpenAPI.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 Kubernetes.OpenAPI.Model
import Kubernetes.OpenAPI.Core


-- * AdmissionregistrationV1ServiceReference

-- | 'admissionregistrationV1ServiceReferenceName' Lens
admissionregistrationV1ServiceReferenceNameL :: Lens_' AdmissionregistrationV1ServiceReference (Text)
admissionregistrationV1ServiceReferenceNameL f AdmissionregistrationV1ServiceReference{..} = (\admissionregistrationV1ServiceReferenceName -> AdmissionregistrationV1ServiceReference { admissionregistrationV1ServiceReferenceName, ..} ) <$> f admissionregistrationV1ServiceReferenceName
{-# INLINE admissionregistrationV1ServiceReferenceNameL #-}

-- | 'admissionregistrationV1ServiceReferenceNamespace' Lens
admissionregistrationV1ServiceReferenceNamespaceL :: Lens_' AdmissionregistrationV1ServiceReference (Text)
admissionregistrationV1ServiceReferenceNamespaceL f AdmissionregistrationV1ServiceReference{..} = (\admissionregistrationV1ServiceReferenceNamespace -> AdmissionregistrationV1ServiceReference { admissionregistrationV1ServiceReferenceNamespace, ..} ) <$> f admissionregistrationV1ServiceReferenceNamespace
{-# INLINE admissionregistrationV1ServiceReferenceNamespaceL #-}

-- | 'admissionregistrationV1ServiceReferencePath' Lens
admissionregistrationV1ServiceReferencePathL :: Lens_' AdmissionregistrationV1ServiceReference (Maybe Text)
admissionregistrationV1ServiceReferencePathL f AdmissionregistrationV1ServiceReference{..} = (\admissionregistrationV1ServiceReferencePath -> AdmissionregistrationV1ServiceReference { admissionregistrationV1ServiceReferencePath, ..} ) <$> f admissionregistrationV1ServiceReferencePath
{-# INLINE admissionregistrationV1ServiceReferencePathL #-}

-- | 'admissionregistrationV1ServiceReferencePort' Lens
admissionregistrationV1ServiceReferencePortL :: Lens_' AdmissionregistrationV1ServiceReference (Maybe Int)
admissionregistrationV1ServiceReferencePortL f AdmissionregistrationV1ServiceReference{..} = (\admissionregistrationV1ServiceReferencePort -> AdmissionregistrationV1ServiceReference { admissionregistrationV1ServiceReferencePort, ..} ) <$> f admissionregistrationV1ServiceReferencePort
{-# INLINE admissionregistrationV1ServiceReferencePortL #-}



-- * AdmissionregistrationV1WebhookClientConfig

-- | 'admissionregistrationV1WebhookClientConfigCaBundle' Lens
admissionregistrationV1WebhookClientConfigCaBundleL :: Lens_' AdmissionregistrationV1WebhookClientConfig (Maybe ByteArray)
admissionregistrationV1WebhookClientConfigCaBundleL f AdmissionregistrationV1WebhookClientConfig{..} = (\admissionregistrationV1WebhookClientConfigCaBundle -> AdmissionregistrationV1WebhookClientConfig { admissionregistrationV1WebhookClientConfigCaBundle, ..} ) <$> f admissionregistrationV1WebhookClientConfigCaBundle
{-# INLINE admissionregistrationV1WebhookClientConfigCaBundleL #-}

-- | 'admissionregistrationV1WebhookClientConfigService' Lens
admissionregistrationV1WebhookClientConfigServiceL :: Lens_' AdmissionregistrationV1WebhookClientConfig (Maybe AdmissionregistrationV1ServiceReference)
admissionregistrationV1WebhookClientConfigServiceL f AdmissionregistrationV1WebhookClientConfig{..} = (\admissionregistrationV1WebhookClientConfigService -> AdmissionregistrationV1WebhookClientConfig { admissionregistrationV1WebhookClientConfigService, ..} ) <$> f admissionregistrationV1WebhookClientConfigService
{-# INLINE admissionregistrationV1WebhookClientConfigServiceL #-}

-- | 'admissionregistrationV1WebhookClientConfigUrl' Lens
admissionregistrationV1WebhookClientConfigUrlL :: Lens_' AdmissionregistrationV1WebhookClientConfig (Maybe Text)
admissionregistrationV1WebhookClientConfigUrlL f AdmissionregistrationV1WebhookClientConfig{..} = (\admissionregistrationV1WebhookClientConfigUrl -> AdmissionregistrationV1WebhookClientConfig { admissionregistrationV1WebhookClientConfigUrl, ..} ) <$> f admissionregistrationV1WebhookClientConfigUrl
{-# INLINE admissionregistrationV1WebhookClientConfigUrlL #-}



-- * ApiextensionsV1ServiceReference

-- | 'apiextensionsV1ServiceReferenceName' Lens
apiextensionsV1ServiceReferenceNameL :: Lens_' ApiextensionsV1ServiceReference (Text)
apiextensionsV1ServiceReferenceNameL f ApiextensionsV1ServiceReference{..} = (\apiextensionsV1ServiceReferenceName -> ApiextensionsV1ServiceReference { apiextensionsV1ServiceReferenceName, ..} ) <$> f apiextensionsV1ServiceReferenceName
{-# INLINE apiextensionsV1ServiceReferenceNameL #-}

-- | 'apiextensionsV1ServiceReferenceNamespace' Lens
apiextensionsV1ServiceReferenceNamespaceL :: Lens_' ApiextensionsV1ServiceReference (Text)
apiextensionsV1ServiceReferenceNamespaceL f ApiextensionsV1ServiceReference{..} = (\apiextensionsV1ServiceReferenceNamespace -> ApiextensionsV1ServiceReference { apiextensionsV1ServiceReferenceNamespace, ..} ) <$> f apiextensionsV1ServiceReferenceNamespace
{-# INLINE apiextensionsV1ServiceReferenceNamespaceL #-}

-- | 'apiextensionsV1ServiceReferencePath' Lens
apiextensionsV1ServiceReferencePathL :: Lens_' ApiextensionsV1ServiceReference (Maybe Text)
apiextensionsV1ServiceReferencePathL f ApiextensionsV1ServiceReference{..} = (\apiextensionsV1ServiceReferencePath -> ApiextensionsV1ServiceReference { apiextensionsV1ServiceReferencePath, ..} ) <$> f apiextensionsV1ServiceReferencePath
{-# INLINE apiextensionsV1ServiceReferencePathL #-}

-- | 'apiextensionsV1ServiceReferencePort' Lens
apiextensionsV1ServiceReferencePortL :: Lens_' ApiextensionsV1ServiceReference (Maybe Int)
apiextensionsV1ServiceReferencePortL f ApiextensionsV1ServiceReference{..} = (\apiextensionsV1ServiceReferencePort -> ApiextensionsV1ServiceReference { apiextensionsV1ServiceReferencePort, ..} ) <$> f apiextensionsV1ServiceReferencePort
{-# INLINE apiextensionsV1ServiceReferencePortL #-}



-- * ApiextensionsV1WebhookClientConfig

-- | 'apiextensionsV1WebhookClientConfigCaBundle' Lens
apiextensionsV1WebhookClientConfigCaBundleL :: Lens_' ApiextensionsV1WebhookClientConfig (Maybe ByteArray)
apiextensionsV1WebhookClientConfigCaBundleL f ApiextensionsV1WebhookClientConfig{..} = (\apiextensionsV1WebhookClientConfigCaBundle -> ApiextensionsV1WebhookClientConfig { apiextensionsV1WebhookClientConfigCaBundle, ..} ) <$> f apiextensionsV1WebhookClientConfigCaBundle
{-# INLINE apiextensionsV1WebhookClientConfigCaBundleL #-}

-- | 'apiextensionsV1WebhookClientConfigService' Lens
apiextensionsV1WebhookClientConfigServiceL :: Lens_' ApiextensionsV1WebhookClientConfig (Maybe ApiextensionsV1ServiceReference)
apiextensionsV1WebhookClientConfigServiceL f ApiextensionsV1WebhookClientConfig{..} = (\apiextensionsV1WebhookClientConfigService -> ApiextensionsV1WebhookClientConfig { apiextensionsV1WebhookClientConfigService, ..} ) <$> f apiextensionsV1WebhookClientConfigService
{-# INLINE apiextensionsV1WebhookClientConfigServiceL #-}

-- | 'apiextensionsV1WebhookClientConfigUrl' Lens
apiextensionsV1WebhookClientConfigUrlL :: Lens_' ApiextensionsV1WebhookClientConfig (Maybe Text)
apiextensionsV1WebhookClientConfigUrlL f ApiextensionsV1WebhookClientConfig{..} = (\apiextensionsV1WebhookClientConfigUrl -> ApiextensionsV1WebhookClientConfig { apiextensionsV1WebhookClientConfigUrl, ..} ) <$> f apiextensionsV1WebhookClientConfigUrl
{-# INLINE apiextensionsV1WebhookClientConfigUrlL #-}



-- * ApiregistrationV1ServiceReference

-- | 'apiregistrationV1ServiceReferenceName' Lens
apiregistrationV1ServiceReferenceNameL :: Lens_' ApiregistrationV1ServiceReference (Maybe Text)
apiregistrationV1ServiceReferenceNameL f ApiregistrationV1ServiceReference{..} = (\apiregistrationV1ServiceReferenceName -> ApiregistrationV1ServiceReference { apiregistrationV1ServiceReferenceName, ..} ) <$> f apiregistrationV1ServiceReferenceName
{-# INLINE apiregistrationV1ServiceReferenceNameL #-}

-- | 'apiregistrationV1ServiceReferenceNamespace' Lens
apiregistrationV1ServiceReferenceNamespaceL :: Lens_' ApiregistrationV1ServiceReference (Maybe Text)
apiregistrationV1ServiceReferenceNamespaceL f ApiregistrationV1ServiceReference{..} = (\apiregistrationV1ServiceReferenceNamespace -> ApiregistrationV1ServiceReference { apiregistrationV1ServiceReferenceNamespace, ..} ) <$> f apiregistrationV1ServiceReferenceNamespace
{-# INLINE apiregistrationV1ServiceReferenceNamespaceL #-}

-- | 'apiregistrationV1ServiceReferencePort' Lens
apiregistrationV1ServiceReferencePortL :: Lens_' ApiregistrationV1ServiceReference (Maybe Int)
apiregistrationV1ServiceReferencePortL f ApiregistrationV1ServiceReference{..} = (\apiregistrationV1ServiceReferencePort -> ApiregistrationV1ServiceReference { apiregistrationV1ServiceReferencePort, ..} ) <$> f apiregistrationV1ServiceReferencePort
{-# INLINE apiregistrationV1ServiceReferencePortL #-}



-- * AuthenticationV1TokenRequest

-- | 'authenticationV1TokenRequestApiVersion' Lens
authenticationV1TokenRequestApiVersionL :: Lens_' AuthenticationV1TokenRequest (Maybe Text)
authenticationV1TokenRequestApiVersionL f AuthenticationV1TokenRequest{..} = (\authenticationV1TokenRequestApiVersion -> AuthenticationV1TokenRequest { authenticationV1TokenRequestApiVersion, ..} ) <$> f authenticationV1TokenRequestApiVersion
{-# INLINE authenticationV1TokenRequestApiVersionL #-}

-- | 'authenticationV1TokenRequestKind' Lens
authenticationV1TokenRequestKindL :: Lens_' AuthenticationV1TokenRequest (Maybe Text)
authenticationV1TokenRequestKindL f AuthenticationV1TokenRequest{..} = (\authenticationV1TokenRequestKind -> AuthenticationV1TokenRequest { authenticationV1TokenRequestKind, ..} ) <$> f authenticationV1TokenRequestKind
{-# INLINE authenticationV1TokenRequestKindL #-}

-- | 'authenticationV1TokenRequestMetadata' Lens
authenticationV1TokenRequestMetadataL :: Lens_' AuthenticationV1TokenRequest (Maybe V1ObjectMeta)
authenticationV1TokenRequestMetadataL f AuthenticationV1TokenRequest{..} = (\authenticationV1TokenRequestMetadata -> AuthenticationV1TokenRequest { authenticationV1TokenRequestMetadata, ..} ) <$> f authenticationV1TokenRequestMetadata
{-# INLINE authenticationV1TokenRequestMetadataL #-}

-- | 'authenticationV1TokenRequestSpec' Lens
authenticationV1TokenRequestSpecL :: Lens_' AuthenticationV1TokenRequest (V1TokenRequestSpec)
authenticationV1TokenRequestSpecL f AuthenticationV1TokenRequest{..} = (\authenticationV1TokenRequestSpec -> AuthenticationV1TokenRequest { authenticationV1TokenRequestSpec, ..} ) <$> f authenticationV1TokenRequestSpec
{-# INLINE authenticationV1TokenRequestSpecL #-}

-- | 'authenticationV1TokenRequestStatus' Lens
authenticationV1TokenRequestStatusL :: Lens_' AuthenticationV1TokenRequest (Maybe V1TokenRequestStatus)
authenticationV1TokenRequestStatusL f AuthenticationV1TokenRequest{..} = (\authenticationV1TokenRequestStatus -> AuthenticationV1TokenRequest { authenticationV1TokenRequestStatus, ..} ) <$> f authenticationV1TokenRequestStatus
{-# INLINE authenticationV1TokenRequestStatusL #-}



-- * CoreV1EndpointPort

-- | 'coreV1EndpointPortAppProtocol' Lens
coreV1EndpointPortAppProtocolL :: Lens_' CoreV1EndpointPort (Maybe Text)
coreV1EndpointPortAppProtocolL f CoreV1EndpointPort{..} = (\coreV1EndpointPortAppProtocol -> CoreV1EndpointPort { coreV1EndpointPortAppProtocol, ..} ) <$> f coreV1EndpointPortAppProtocol
{-# INLINE coreV1EndpointPortAppProtocolL #-}

-- | 'coreV1EndpointPortName' Lens
coreV1EndpointPortNameL :: Lens_' CoreV1EndpointPort (Maybe Text)
coreV1EndpointPortNameL f CoreV1EndpointPort{..} = (\coreV1EndpointPortName -> CoreV1EndpointPort { coreV1EndpointPortName, ..} ) <$> f coreV1EndpointPortName
{-# INLINE coreV1EndpointPortNameL #-}

-- | 'coreV1EndpointPortPort' Lens
coreV1EndpointPortPortL :: Lens_' CoreV1EndpointPort (Int)
coreV1EndpointPortPortL f CoreV1EndpointPort{..} = (\coreV1EndpointPortPort -> CoreV1EndpointPort { coreV1EndpointPortPort, ..} ) <$> f coreV1EndpointPortPort
{-# INLINE coreV1EndpointPortPortL #-}

-- | 'coreV1EndpointPortProtocol' Lens
coreV1EndpointPortProtocolL :: Lens_' CoreV1EndpointPort (Maybe Text)
coreV1EndpointPortProtocolL f CoreV1EndpointPort{..} = (\coreV1EndpointPortProtocol -> CoreV1EndpointPort { coreV1EndpointPortProtocol, ..} ) <$> f coreV1EndpointPortProtocol
{-# INLINE coreV1EndpointPortProtocolL #-}



-- * CoreV1Event

-- | 'coreV1EventAction' Lens
coreV1EventActionL :: Lens_' CoreV1Event (Maybe Text)
coreV1EventActionL f CoreV1Event{..} = (\coreV1EventAction -> CoreV1Event { coreV1EventAction, ..} ) <$> f coreV1EventAction
{-# INLINE coreV1EventActionL #-}

-- | 'coreV1EventApiVersion' Lens
coreV1EventApiVersionL :: Lens_' CoreV1Event (Maybe Text)
coreV1EventApiVersionL f CoreV1Event{..} = (\coreV1EventApiVersion -> CoreV1Event { coreV1EventApiVersion, ..} ) <$> f coreV1EventApiVersion
{-# INLINE coreV1EventApiVersionL #-}

-- | 'coreV1EventCount' Lens
coreV1EventCountL :: Lens_' CoreV1Event (Maybe Int)
coreV1EventCountL f CoreV1Event{..} = (\coreV1EventCount -> CoreV1Event { coreV1EventCount, ..} ) <$> f coreV1EventCount
{-# INLINE coreV1EventCountL #-}

-- | 'coreV1EventEventTime' Lens
coreV1EventEventTimeL :: Lens_' CoreV1Event (Maybe DateTime)
coreV1EventEventTimeL f CoreV1Event{..} = (\coreV1EventEventTime -> CoreV1Event { coreV1EventEventTime, ..} ) <$> f coreV1EventEventTime
{-# INLINE coreV1EventEventTimeL #-}

-- | 'coreV1EventFirstTimestamp' Lens
coreV1EventFirstTimestampL :: Lens_' CoreV1Event (Maybe DateTime)
coreV1EventFirstTimestampL f CoreV1Event{..} = (\coreV1EventFirstTimestamp -> CoreV1Event { coreV1EventFirstTimestamp, ..} ) <$> f coreV1EventFirstTimestamp
{-# INLINE coreV1EventFirstTimestampL #-}

-- | 'coreV1EventInvolvedObject' Lens
coreV1EventInvolvedObjectL :: Lens_' CoreV1Event (V1ObjectReference)
coreV1EventInvolvedObjectL f CoreV1Event{..} = (\coreV1EventInvolvedObject -> CoreV1Event { coreV1EventInvolvedObject, ..} ) <$> f coreV1EventInvolvedObject
{-# INLINE coreV1EventInvolvedObjectL #-}

-- | 'coreV1EventKind' Lens
coreV1EventKindL :: Lens_' CoreV1Event (Maybe Text)
coreV1EventKindL f CoreV1Event{..} = (\coreV1EventKind -> CoreV1Event { coreV1EventKind, ..} ) <$> f coreV1EventKind
{-# INLINE coreV1EventKindL #-}

-- | 'coreV1EventLastTimestamp' Lens
coreV1EventLastTimestampL :: Lens_' CoreV1Event (Maybe DateTime)
coreV1EventLastTimestampL f CoreV1Event{..} = (\coreV1EventLastTimestamp -> CoreV1Event { coreV1EventLastTimestamp, ..} ) <$> f coreV1EventLastTimestamp
{-# INLINE coreV1EventLastTimestampL #-}

-- | 'coreV1EventMessage' Lens
coreV1EventMessageL :: Lens_' CoreV1Event (Maybe Text)
coreV1EventMessageL f CoreV1Event{..} = (\coreV1EventMessage -> CoreV1Event { coreV1EventMessage, ..} ) <$> f coreV1EventMessage
{-# INLINE coreV1EventMessageL #-}

-- | 'coreV1EventMetadata' Lens
coreV1EventMetadataL :: Lens_' CoreV1Event (V1ObjectMeta)
coreV1EventMetadataL f CoreV1Event{..} = (\coreV1EventMetadata -> CoreV1Event { coreV1EventMetadata, ..} ) <$> f coreV1EventMetadata
{-# INLINE coreV1EventMetadataL #-}

-- | 'coreV1EventReason' Lens
coreV1EventReasonL :: Lens_' CoreV1Event (Maybe Text)
coreV1EventReasonL f CoreV1Event{..} = (\coreV1EventReason -> CoreV1Event { coreV1EventReason, ..} ) <$> f coreV1EventReason
{-# INLINE coreV1EventReasonL #-}

-- | 'coreV1EventRelated' Lens
coreV1EventRelatedL :: Lens_' CoreV1Event (Maybe V1ObjectReference)
coreV1EventRelatedL f CoreV1Event{..} = (\coreV1EventRelated -> CoreV1Event { coreV1EventRelated, ..} ) <$> f coreV1EventRelated
{-# INLINE coreV1EventRelatedL #-}

-- | 'coreV1EventReportingComponent' Lens
coreV1EventReportingComponentL :: Lens_' CoreV1Event (Maybe Text)
coreV1EventReportingComponentL f CoreV1Event{..} = (\coreV1EventReportingComponent -> CoreV1Event { coreV1EventReportingComponent, ..} ) <$> f coreV1EventReportingComponent
{-# INLINE coreV1EventReportingComponentL #-}

-- | 'coreV1EventReportingInstance' Lens
coreV1EventReportingInstanceL :: Lens_' CoreV1Event (Maybe Text)
coreV1EventReportingInstanceL f CoreV1Event{..} = (\coreV1EventReportingInstance -> CoreV1Event { coreV1EventReportingInstance, ..} ) <$> f coreV1EventReportingInstance
{-# INLINE coreV1EventReportingInstanceL #-}

-- | 'coreV1EventSeries' Lens
coreV1EventSeriesL :: Lens_' CoreV1Event (Maybe CoreV1EventSeries)
coreV1EventSeriesL f CoreV1Event{..} = (\coreV1EventSeries -> CoreV1Event { coreV1EventSeries, ..} ) <$> f coreV1EventSeries
{-# INLINE coreV1EventSeriesL #-}

-- | 'coreV1EventSource' Lens
coreV1EventSourceL :: Lens_' CoreV1Event (Maybe V1EventSource)
coreV1EventSourceL f CoreV1Event{..} = (\coreV1EventSource -> CoreV1Event { coreV1EventSource, ..} ) <$> f coreV1EventSource
{-# INLINE coreV1EventSourceL #-}

-- | 'coreV1EventType' Lens
coreV1EventTypeL :: Lens_' CoreV1Event (Maybe Text)
coreV1EventTypeL f CoreV1Event{..} = (\coreV1EventType -> CoreV1Event { coreV1EventType, ..} ) <$> f coreV1EventType
{-# INLINE coreV1EventTypeL #-}



-- * CoreV1EventList

-- | 'coreV1EventListApiVersion' Lens
coreV1EventListApiVersionL :: Lens_' CoreV1EventList (Maybe Text)
coreV1EventListApiVersionL f CoreV1EventList{..} = (\coreV1EventListApiVersion -> CoreV1EventList { coreV1EventListApiVersion, ..} ) <$> f coreV1EventListApiVersion
{-# INLINE coreV1EventListApiVersionL #-}

-- | 'coreV1EventListItems' Lens
coreV1EventListItemsL :: Lens_' CoreV1EventList ([CoreV1Event])
coreV1EventListItemsL f CoreV1EventList{..} = (\coreV1EventListItems -> CoreV1EventList { coreV1EventListItems, ..} ) <$> f coreV1EventListItems
{-# INLINE coreV1EventListItemsL #-}

-- | 'coreV1EventListKind' Lens
coreV1EventListKindL :: Lens_' CoreV1EventList (Maybe Text)
coreV1EventListKindL f CoreV1EventList{..} = (\coreV1EventListKind -> CoreV1EventList { coreV1EventListKind, ..} ) <$> f coreV1EventListKind
{-# INLINE coreV1EventListKindL #-}

-- | 'coreV1EventListMetadata' Lens
coreV1EventListMetadataL :: Lens_' CoreV1EventList (Maybe V1ListMeta)
coreV1EventListMetadataL f CoreV1EventList{..} = (\coreV1EventListMetadata -> CoreV1EventList { coreV1EventListMetadata, ..} ) <$> f coreV1EventListMetadata
{-# INLINE coreV1EventListMetadataL #-}



-- * CoreV1EventSeries

-- | 'coreV1EventSeriesCount' Lens
coreV1EventSeriesCountL :: Lens_' CoreV1EventSeries (Maybe Int)
coreV1EventSeriesCountL f CoreV1EventSeries{..} = (\coreV1EventSeriesCount -> CoreV1EventSeries { coreV1EventSeriesCount, ..} ) <$> f coreV1EventSeriesCount
{-# INLINE coreV1EventSeriesCountL #-}

-- | 'coreV1EventSeriesLastObservedTime' Lens
coreV1EventSeriesLastObservedTimeL :: Lens_' CoreV1EventSeries (Maybe DateTime)
coreV1EventSeriesLastObservedTimeL f CoreV1EventSeries{..} = (\coreV1EventSeriesLastObservedTime -> CoreV1EventSeries { coreV1EventSeriesLastObservedTime, ..} ) <$> f coreV1EventSeriesLastObservedTime
{-# INLINE coreV1EventSeriesLastObservedTimeL #-}



-- * DiscoveryV1EndpointPort

-- | 'discoveryV1EndpointPortAppProtocol' Lens
discoveryV1EndpointPortAppProtocolL :: Lens_' DiscoveryV1EndpointPort (Maybe Text)
discoveryV1EndpointPortAppProtocolL f DiscoveryV1EndpointPort{..} = (\discoveryV1EndpointPortAppProtocol -> DiscoveryV1EndpointPort { discoveryV1EndpointPortAppProtocol, ..} ) <$> f discoveryV1EndpointPortAppProtocol
{-# INLINE discoveryV1EndpointPortAppProtocolL #-}

-- | 'discoveryV1EndpointPortName' Lens
discoveryV1EndpointPortNameL :: Lens_' DiscoveryV1EndpointPort (Maybe Text)
discoveryV1EndpointPortNameL f DiscoveryV1EndpointPort{..} = (\discoveryV1EndpointPortName -> DiscoveryV1EndpointPort { discoveryV1EndpointPortName, ..} ) <$> f discoveryV1EndpointPortName
{-# INLINE discoveryV1EndpointPortNameL #-}

-- | 'discoveryV1EndpointPortPort' Lens
discoveryV1EndpointPortPortL :: Lens_' DiscoveryV1EndpointPort (Maybe Int)
discoveryV1EndpointPortPortL f DiscoveryV1EndpointPort{..} = (\discoveryV1EndpointPortPort -> DiscoveryV1EndpointPort { discoveryV1EndpointPortPort, ..} ) <$> f discoveryV1EndpointPortPort
{-# INLINE discoveryV1EndpointPortPortL #-}

-- | 'discoveryV1EndpointPortProtocol' Lens
discoveryV1EndpointPortProtocolL :: Lens_' DiscoveryV1EndpointPort (Maybe Text)
discoveryV1EndpointPortProtocolL f DiscoveryV1EndpointPort{..} = (\discoveryV1EndpointPortProtocol -> DiscoveryV1EndpointPort { discoveryV1EndpointPortProtocol, ..} ) <$> f discoveryV1EndpointPortProtocol
{-# INLINE discoveryV1EndpointPortProtocolL #-}



-- * EventsV1Event

-- | 'eventsV1EventAction' Lens
eventsV1EventActionL :: Lens_' EventsV1Event (Maybe Text)
eventsV1EventActionL f EventsV1Event{..} = (\eventsV1EventAction -> EventsV1Event { eventsV1EventAction, ..} ) <$> f eventsV1EventAction
{-# INLINE eventsV1EventActionL #-}

-- | 'eventsV1EventApiVersion' Lens
eventsV1EventApiVersionL :: Lens_' EventsV1Event (Maybe Text)
eventsV1EventApiVersionL f EventsV1Event{..} = (\eventsV1EventApiVersion -> EventsV1Event { eventsV1EventApiVersion, ..} ) <$> f eventsV1EventApiVersion
{-# INLINE eventsV1EventApiVersionL #-}

-- | 'eventsV1EventDeprecatedCount' Lens
eventsV1EventDeprecatedCountL :: Lens_' EventsV1Event (Maybe Int)
eventsV1EventDeprecatedCountL f EventsV1Event{..} = (\eventsV1EventDeprecatedCount -> EventsV1Event { eventsV1EventDeprecatedCount, ..} ) <$> f eventsV1EventDeprecatedCount
{-# INLINE eventsV1EventDeprecatedCountL #-}

-- | 'eventsV1EventDeprecatedFirstTimestamp' Lens
eventsV1EventDeprecatedFirstTimestampL :: Lens_' EventsV1Event (Maybe DateTime)
eventsV1EventDeprecatedFirstTimestampL f EventsV1Event{..} = (\eventsV1EventDeprecatedFirstTimestamp -> EventsV1Event { eventsV1EventDeprecatedFirstTimestamp, ..} ) <$> f eventsV1EventDeprecatedFirstTimestamp
{-# INLINE eventsV1EventDeprecatedFirstTimestampL #-}

-- | 'eventsV1EventDeprecatedLastTimestamp' Lens
eventsV1EventDeprecatedLastTimestampL :: Lens_' EventsV1Event (Maybe DateTime)
eventsV1EventDeprecatedLastTimestampL f EventsV1Event{..} = (\eventsV1EventDeprecatedLastTimestamp -> EventsV1Event { eventsV1EventDeprecatedLastTimestamp, ..} ) <$> f eventsV1EventDeprecatedLastTimestamp
{-# INLINE eventsV1EventDeprecatedLastTimestampL #-}

-- | 'eventsV1EventDeprecatedSource' Lens
eventsV1EventDeprecatedSourceL :: Lens_' EventsV1Event (Maybe V1EventSource)
eventsV1EventDeprecatedSourceL f EventsV1Event{..} = (\eventsV1EventDeprecatedSource -> EventsV1Event { eventsV1EventDeprecatedSource, ..} ) <$> f eventsV1EventDeprecatedSource
{-# INLINE eventsV1EventDeprecatedSourceL #-}

-- | 'eventsV1EventEventTime' Lens
eventsV1EventEventTimeL :: Lens_' EventsV1Event (DateTime)
eventsV1EventEventTimeL f EventsV1Event{..} = (\eventsV1EventEventTime -> EventsV1Event { eventsV1EventEventTime, ..} ) <$> f eventsV1EventEventTime
{-# INLINE eventsV1EventEventTimeL #-}

-- | 'eventsV1EventKind' Lens
eventsV1EventKindL :: Lens_' EventsV1Event (Maybe Text)
eventsV1EventKindL f EventsV1Event{..} = (\eventsV1EventKind -> EventsV1Event { eventsV1EventKind, ..} ) <$> f eventsV1EventKind
{-# INLINE eventsV1EventKindL #-}

-- | 'eventsV1EventMetadata' Lens
eventsV1EventMetadataL :: Lens_' EventsV1Event (Maybe V1ObjectMeta)
eventsV1EventMetadataL f EventsV1Event{..} = (\eventsV1EventMetadata -> EventsV1Event { eventsV1EventMetadata, ..} ) <$> f eventsV1EventMetadata
{-# INLINE eventsV1EventMetadataL #-}

-- | 'eventsV1EventNote' Lens
eventsV1EventNoteL :: Lens_' EventsV1Event (Maybe Text)
eventsV1EventNoteL f EventsV1Event{..} = (\eventsV1EventNote -> EventsV1Event { eventsV1EventNote, ..} ) <$> f eventsV1EventNote
{-# INLINE eventsV1EventNoteL #-}

-- | 'eventsV1EventReason' Lens
eventsV1EventReasonL :: Lens_' EventsV1Event (Maybe Text)
eventsV1EventReasonL f EventsV1Event{..} = (\eventsV1EventReason -> EventsV1Event { eventsV1EventReason, ..} ) <$> f eventsV1EventReason
{-# INLINE eventsV1EventReasonL #-}

-- | 'eventsV1EventRegarding' Lens
eventsV1EventRegardingL :: Lens_' EventsV1Event (Maybe V1ObjectReference)
eventsV1EventRegardingL f EventsV1Event{..} = (\eventsV1EventRegarding -> EventsV1Event { eventsV1EventRegarding, ..} ) <$> f eventsV1EventRegarding
{-# INLINE eventsV1EventRegardingL #-}

-- | 'eventsV1EventRelated' Lens
eventsV1EventRelatedL :: Lens_' EventsV1Event (Maybe V1ObjectReference)
eventsV1EventRelatedL f EventsV1Event{..} = (\eventsV1EventRelated -> EventsV1Event { eventsV1EventRelated, ..} ) <$> f eventsV1EventRelated
{-# INLINE eventsV1EventRelatedL #-}

-- | 'eventsV1EventReportingController' Lens
eventsV1EventReportingControllerL :: Lens_' EventsV1Event (Maybe Text)
eventsV1EventReportingControllerL f EventsV1Event{..} = (\eventsV1EventReportingController -> EventsV1Event { eventsV1EventReportingController, ..} ) <$> f eventsV1EventReportingController
{-# INLINE eventsV1EventReportingControllerL #-}

-- | 'eventsV1EventReportingInstance' Lens
eventsV1EventReportingInstanceL :: Lens_' EventsV1Event (Maybe Text)
eventsV1EventReportingInstanceL f EventsV1Event{..} = (\eventsV1EventReportingInstance -> EventsV1Event { eventsV1EventReportingInstance, ..} ) <$> f eventsV1EventReportingInstance
{-# INLINE eventsV1EventReportingInstanceL #-}

-- | 'eventsV1EventSeries' Lens
eventsV1EventSeriesL :: Lens_' EventsV1Event (Maybe EventsV1EventSeries)
eventsV1EventSeriesL f EventsV1Event{..} = (\eventsV1EventSeries -> EventsV1Event { eventsV1EventSeries, ..} ) <$> f eventsV1EventSeries
{-# INLINE eventsV1EventSeriesL #-}

-- | 'eventsV1EventType' Lens
eventsV1EventTypeL :: Lens_' EventsV1Event (Maybe Text)
eventsV1EventTypeL f EventsV1Event{..} = (\eventsV1EventType -> EventsV1Event { eventsV1EventType, ..} ) <$> f eventsV1EventType
{-# INLINE eventsV1EventTypeL #-}



-- * EventsV1EventList

-- | 'eventsV1EventListApiVersion' Lens
eventsV1EventListApiVersionL :: Lens_' EventsV1EventList (Maybe Text)
eventsV1EventListApiVersionL f EventsV1EventList{..} = (\eventsV1EventListApiVersion -> EventsV1EventList { eventsV1EventListApiVersion, ..} ) <$> f eventsV1EventListApiVersion
{-# INLINE eventsV1EventListApiVersionL #-}

-- | 'eventsV1EventListItems' Lens
eventsV1EventListItemsL :: Lens_' EventsV1EventList ([EventsV1Event])
eventsV1EventListItemsL f EventsV1EventList{..} = (\eventsV1EventListItems -> EventsV1EventList { eventsV1EventListItems, ..} ) <$> f eventsV1EventListItems
{-# INLINE eventsV1EventListItemsL #-}

-- | 'eventsV1EventListKind' Lens
eventsV1EventListKindL :: Lens_' EventsV1EventList (Maybe Text)
eventsV1EventListKindL f EventsV1EventList{..} = (\eventsV1EventListKind -> EventsV1EventList { eventsV1EventListKind, ..} ) <$> f eventsV1EventListKind
{-# INLINE eventsV1EventListKindL #-}

-- | 'eventsV1EventListMetadata' Lens
eventsV1EventListMetadataL :: Lens_' EventsV1EventList (Maybe V1ListMeta)
eventsV1EventListMetadataL f EventsV1EventList{..} = (\eventsV1EventListMetadata -> EventsV1EventList { eventsV1EventListMetadata, ..} ) <$> f eventsV1EventListMetadata
{-# INLINE eventsV1EventListMetadataL #-}



-- * EventsV1EventSeries

-- | 'eventsV1EventSeriesCount' Lens
eventsV1EventSeriesCountL :: Lens_' EventsV1EventSeries (Int)
eventsV1EventSeriesCountL f EventsV1EventSeries{..} = (\eventsV1EventSeriesCount -> EventsV1EventSeries { eventsV1EventSeriesCount, ..} ) <$> f eventsV1EventSeriesCount
{-# INLINE eventsV1EventSeriesCountL #-}

-- | 'eventsV1EventSeriesLastObservedTime' Lens
eventsV1EventSeriesLastObservedTimeL :: Lens_' EventsV1EventSeries (DateTime)
eventsV1EventSeriesLastObservedTimeL f EventsV1EventSeries{..} = (\eventsV1EventSeriesLastObservedTime -> EventsV1EventSeries { eventsV1EventSeriesLastObservedTime, ..} ) <$> f eventsV1EventSeriesLastObservedTime
{-# INLINE eventsV1EventSeriesLastObservedTimeL #-}



-- * StorageV1TokenRequest

-- | 'storageV1TokenRequestAudience' Lens
storageV1TokenRequestAudienceL :: Lens_' StorageV1TokenRequest (Text)
storageV1TokenRequestAudienceL f StorageV1TokenRequest{..} = (\storageV1TokenRequestAudience -> StorageV1TokenRequest { storageV1TokenRequestAudience, ..} ) <$> f storageV1TokenRequestAudience
{-# INLINE storageV1TokenRequestAudienceL #-}

-- | 'storageV1TokenRequestExpirationSeconds' Lens
storageV1TokenRequestExpirationSecondsL :: Lens_' StorageV1TokenRequest (Maybe Integer)
storageV1TokenRequestExpirationSecondsL f StorageV1TokenRequest{..} = (\storageV1TokenRequestExpirationSeconds -> StorageV1TokenRequest { storageV1TokenRequestExpirationSeconds, ..} ) <$> f storageV1TokenRequestExpirationSeconds
{-# INLINE storageV1TokenRequestExpirationSecondsL #-}



-- * V1APIGroup

-- | 'v1APIGroupApiVersion' Lens
v1APIGroupApiVersionL :: Lens_' V1APIGroup (Maybe Text)
v1APIGroupApiVersionL f V1APIGroup{..} = (\v1APIGroupApiVersion -> V1APIGroup { v1APIGroupApiVersion, ..} ) <$> f v1APIGroupApiVersion
{-# INLINE v1APIGroupApiVersionL #-}

-- | 'v1APIGroupKind' Lens
v1APIGroupKindL :: Lens_' V1APIGroup (Maybe Text)
v1APIGroupKindL f V1APIGroup{..} = (\v1APIGroupKind -> V1APIGroup { v1APIGroupKind, ..} ) <$> f v1APIGroupKind
{-# INLINE v1APIGroupKindL #-}

-- | 'v1APIGroupName' Lens
v1APIGroupNameL :: Lens_' V1APIGroup (Text)
v1APIGroupNameL f V1APIGroup{..} = (\v1APIGroupName -> V1APIGroup { v1APIGroupName, ..} ) <$> f v1APIGroupName
{-# INLINE v1APIGroupNameL #-}

-- | 'v1APIGroupPreferredVersion' Lens
v1APIGroupPreferredVersionL :: Lens_' V1APIGroup (Maybe V1GroupVersionForDiscovery)
v1APIGroupPreferredVersionL f V1APIGroup{..} = (\v1APIGroupPreferredVersion -> V1APIGroup { v1APIGroupPreferredVersion, ..} ) <$> f v1APIGroupPreferredVersion
{-# INLINE v1APIGroupPreferredVersionL #-}

-- | 'v1APIGroupServerAddressByClientCidrs' Lens
v1APIGroupServerAddressByClientCidrsL :: Lens_' V1APIGroup (Maybe [V1ServerAddressByClientCIDR])
v1APIGroupServerAddressByClientCidrsL f V1APIGroup{..} = (\v1APIGroupServerAddressByClientCidrs -> V1APIGroup { v1APIGroupServerAddressByClientCidrs, ..} ) <$> f v1APIGroupServerAddressByClientCidrs
{-# INLINE v1APIGroupServerAddressByClientCidrsL #-}

-- | 'v1APIGroupVersions' Lens
v1APIGroupVersionsL :: Lens_' V1APIGroup ([V1GroupVersionForDiscovery])
v1APIGroupVersionsL f V1APIGroup{..} = (\v1APIGroupVersions -> V1APIGroup { v1APIGroupVersions, ..} ) <$> f v1APIGroupVersions
{-# INLINE v1APIGroupVersionsL #-}



-- * V1APIGroupList

-- | 'v1APIGroupListApiVersion' Lens
v1APIGroupListApiVersionL :: Lens_' V1APIGroupList (Maybe Text)
v1APIGroupListApiVersionL f V1APIGroupList{..} = (\v1APIGroupListApiVersion -> V1APIGroupList { v1APIGroupListApiVersion, ..} ) <$> f v1APIGroupListApiVersion
{-# INLINE v1APIGroupListApiVersionL #-}

-- | 'v1APIGroupListGroups' Lens
v1APIGroupListGroupsL :: Lens_' V1APIGroupList ([V1APIGroup])
v1APIGroupListGroupsL f V1APIGroupList{..} = (\v1APIGroupListGroups -> V1APIGroupList { v1APIGroupListGroups, ..} ) <$> f v1APIGroupListGroups
{-# INLINE v1APIGroupListGroupsL #-}

-- | 'v1APIGroupListKind' Lens
v1APIGroupListKindL :: Lens_' V1APIGroupList (Maybe Text)
v1APIGroupListKindL f V1APIGroupList{..} = (\v1APIGroupListKind -> V1APIGroupList { v1APIGroupListKind, ..} ) <$> f v1APIGroupListKind
{-# INLINE v1APIGroupListKindL #-}



-- * V1APIResource

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

-- | 'v1APIResourceGroup' Lens
v1APIResourceGroupL :: Lens_' V1APIResource (Maybe Text)
v1APIResourceGroupL f V1APIResource{..} = (\v1APIResourceGroup -> V1APIResource { v1APIResourceGroup, ..} ) <$> f v1APIResourceGroup
{-# INLINE v1APIResourceGroupL #-}

-- | 'v1APIResourceKind' Lens
v1APIResourceKindL :: Lens_' V1APIResource (Text)
v1APIResourceKindL f V1APIResource{..} = (\v1APIResourceKind -> V1APIResource { v1APIResourceKind, ..} ) <$> f v1APIResourceKind
{-# INLINE v1APIResourceKindL #-}

-- | 'v1APIResourceName' Lens
v1APIResourceNameL :: Lens_' V1APIResource (Text)
v1APIResourceNameL f V1APIResource{..} = (\v1APIResourceName -> V1APIResource { v1APIResourceName, ..} ) <$> f v1APIResourceName
{-# INLINE v1APIResourceNameL #-}

-- | 'v1APIResourceNamespaced' Lens
v1APIResourceNamespacedL :: Lens_' V1APIResource (Bool)
v1APIResourceNamespacedL f V1APIResource{..} = (\v1APIResourceNamespaced -> V1APIResource { v1APIResourceNamespaced, ..} ) <$> f v1APIResourceNamespaced
{-# INLINE v1APIResourceNamespacedL #-}

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

-- | 'v1APIResourceSingularName' Lens
v1APIResourceSingularNameL :: Lens_' V1APIResource (Text)
v1APIResourceSingularNameL f V1APIResource{..} = (\v1APIResourceSingularName -> V1APIResource { v1APIResourceSingularName, ..} ) <$> f v1APIResourceSingularName
{-# INLINE v1APIResourceSingularNameL #-}

-- | 'v1APIResourceStorageVersionHash' Lens
v1APIResourceStorageVersionHashL :: Lens_' V1APIResource (Maybe Text)
v1APIResourceStorageVersionHashL f V1APIResource{..} = (\v1APIResourceStorageVersionHash -> V1APIResource { v1APIResourceStorageVersionHash, ..} ) <$> f v1APIResourceStorageVersionHash
{-# INLINE v1APIResourceStorageVersionHashL #-}

-- | 'v1APIResourceVerbs' Lens
v1APIResourceVerbsL :: Lens_' V1APIResource ([Text])
v1APIResourceVerbsL f V1APIResource{..} = (\v1APIResourceVerbs -> V1APIResource { v1APIResourceVerbs, ..} ) <$> f v1APIResourceVerbs
{-# INLINE v1APIResourceVerbsL #-}

-- | 'v1APIResourceVersion' Lens
v1APIResourceVersionL :: Lens_' V1APIResource (Maybe Text)
v1APIResourceVersionL f V1APIResource{..} = (\v1APIResourceVersion -> V1APIResource { v1APIResourceVersion, ..} ) <$> f v1APIResourceVersion
{-# INLINE v1APIResourceVersionL #-}



-- * V1APIResourceList

-- | 'v1APIResourceListApiVersion' Lens
v1APIResourceListApiVersionL :: Lens_' V1APIResourceList (Maybe Text)
v1APIResourceListApiVersionL f V1APIResourceList{..} = (\v1APIResourceListApiVersion -> V1APIResourceList { v1APIResourceListApiVersion, ..} ) <$> f v1APIResourceListApiVersion
{-# INLINE v1APIResourceListApiVersionL #-}

-- | 'v1APIResourceListGroupVersion' Lens
v1APIResourceListGroupVersionL :: Lens_' V1APIResourceList (Text)
v1APIResourceListGroupVersionL f V1APIResourceList{..} = (\v1APIResourceListGroupVersion -> V1APIResourceList { v1APIResourceListGroupVersion, ..} ) <$> f v1APIResourceListGroupVersion
{-# INLINE v1APIResourceListGroupVersionL #-}

-- | 'v1APIResourceListKind' Lens
v1APIResourceListKindL :: Lens_' V1APIResourceList (Maybe Text)
v1APIResourceListKindL f V1APIResourceList{..} = (\v1APIResourceListKind -> V1APIResourceList { v1APIResourceListKind, ..} ) <$> f v1APIResourceListKind
{-# INLINE v1APIResourceListKindL #-}

-- | 'v1APIResourceListResources' Lens
v1APIResourceListResourcesL :: Lens_' V1APIResourceList ([V1APIResource])
v1APIResourceListResourcesL f V1APIResourceList{..} = (\v1APIResourceListResources -> V1APIResourceList { v1APIResourceListResources, ..} ) <$> f v1APIResourceListResources
{-# INLINE v1APIResourceListResourcesL #-}



-- * V1APIService

-- | 'v1APIServiceApiVersion' Lens
v1APIServiceApiVersionL :: Lens_' V1APIService (Maybe Text)
v1APIServiceApiVersionL f V1APIService{..} = (\v1APIServiceApiVersion -> V1APIService { v1APIServiceApiVersion, ..} ) <$> f v1APIServiceApiVersion
{-# INLINE v1APIServiceApiVersionL #-}

-- | 'v1APIServiceKind' Lens
v1APIServiceKindL :: Lens_' V1APIService (Maybe Text)
v1APIServiceKindL f V1APIService{..} = (\v1APIServiceKind -> V1APIService { v1APIServiceKind, ..} ) <$> f v1APIServiceKind
{-# INLINE v1APIServiceKindL #-}

-- | 'v1APIServiceMetadata' Lens
v1APIServiceMetadataL :: Lens_' V1APIService (Maybe V1ObjectMeta)
v1APIServiceMetadataL f V1APIService{..} = (\v1APIServiceMetadata -> V1APIService { v1APIServiceMetadata, ..} ) <$> f v1APIServiceMetadata
{-# INLINE v1APIServiceMetadataL #-}

-- | 'v1APIServiceSpec' Lens
v1APIServiceSpecL :: Lens_' V1APIService (Maybe V1APIServiceSpec)
v1APIServiceSpecL f V1APIService{..} = (\v1APIServiceSpec -> V1APIService { v1APIServiceSpec, ..} ) <$> f v1APIServiceSpec
{-# INLINE v1APIServiceSpecL #-}

-- | 'v1APIServiceStatus' Lens
v1APIServiceStatusL :: Lens_' V1APIService (Maybe V1APIServiceStatus)
v1APIServiceStatusL f V1APIService{..} = (\v1APIServiceStatus -> V1APIService { v1APIServiceStatus, ..} ) <$> f v1APIServiceStatus
{-# INLINE v1APIServiceStatusL #-}



-- * V1APIServiceCondition

-- | 'v1APIServiceConditionLastTransitionTime' Lens
v1APIServiceConditionLastTransitionTimeL :: Lens_' V1APIServiceCondition (Maybe DateTime)
v1APIServiceConditionLastTransitionTimeL f V1APIServiceCondition{..} = (\v1APIServiceConditionLastTransitionTime -> V1APIServiceCondition { v1APIServiceConditionLastTransitionTime, ..} ) <$> f v1APIServiceConditionLastTransitionTime
{-# INLINE v1APIServiceConditionLastTransitionTimeL #-}

-- | 'v1APIServiceConditionMessage' Lens
v1APIServiceConditionMessageL :: Lens_' V1APIServiceCondition (Maybe Text)
v1APIServiceConditionMessageL f V1APIServiceCondition{..} = (\v1APIServiceConditionMessage -> V1APIServiceCondition { v1APIServiceConditionMessage, ..} ) <$> f v1APIServiceConditionMessage
{-# INLINE v1APIServiceConditionMessageL #-}

-- | 'v1APIServiceConditionReason' Lens
v1APIServiceConditionReasonL :: Lens_' V1APIServiceCondition (Maybe Text)
v1APIServiceConditionReasonL f V1APIServiceCondition{..} = (\v1APIServiceConditionReason -> V1APIServiceCondition { v1APIServiceConditionReason, ..} ) <$> f v1APIServiceConditionReason
{-# INLINE v1APIServiceConditionReasonL #-}

-- | 'v1APIServiceConditionStatus' Lens
v1APIServiceConditionStatusL :: Lens_' V1APIServiceCondition (Text)
v1APIServiceConditionStatusL f V1APIServiceCondition{..} = (\v1APIServiceConditionStatus -> V1APIServiceCondition { v1APIServiceConditionStatus, ..} ) <$> f v1APIServiceConditionStatus
{-# INLINE v1APIServiceConditionStatusL #-}

-- | 'v1APIServiceConditionType' Lens
v1APIServiceConditionTypeL :: Lens_' V1APIServiceCondition (Text)
v1APIServiceConditionTypeL f V1APIServiceCondition{..} = (\v1APIServiceConditionType -> V1APIServiceCondition { v1APIServiceConditionType, ..} ) <$> f v1APIServiceConditionType
{-# INLINE v1APIServiceConditionTypeL #-}



-- * V1APIServiceList

-- | 'v1APIServiceListApiVersion' Lens
v1APIServiceListApiVersionL :: Lens_' V1APIServiceList (Maybe Text)
v1APIServiceListApiVersionL f V1APIServiceList{..} = (\v1APIServiceListApiVersion -> V1APIServiceList { v1APIServiceListApiVersion, ..} ) <$> f v1APIServiceListApiVersion
{-# INLINE v1APIServiceListApiVersionL #-}

-- | 'v1APIServiceListItems' Lens
v1APIServiceListItemsL :: Lens_' V1APIServiceList ([V1APIService])
v1APIServiceListItemsL f V1APIServiceList{..} = (\v1APIServiceListItems -> V1APIServiceList { v1APIServiceListItems, ..} ) <$> f v1APIServiceListItems
{-# INLINE v1APIServiceListItemsL #-}

-- | 'v1APIServiceListKind' Lens
v1APIServiceListKindL :: Lens_' V1APIServiceList (Maybe Text)
v1APIServiceListKindL f V1APIServiceList{..} = (\v1APIServiceListKind -> V1APIServiceList { v1APIServiceListKind, ..} ) <$> f v1APIServiceListKind
{-# INLINE v1APIServiceListKindL #-}

-- | 'v1APIServiceListMetadata' Lens
v1APIServiceListMetadataL :: Lens_' V1APIServiceList (Maybe V1ListMeta)
v1APIServiceListMetadataL f V1APIServiceList{..} = (\v1APIServiceListMetadata -> V1APIServiceList { v1APIServiceListMetadata, ..} ) <$> f v1APIServiceListMetadata
{-# INLINE v1APIServiceListMetadataL #-}



-- * V1APIServiceSpec

-- | 'v1APIServiceSpecCaBundle' Lens
v1APIServiceSpecCaBundleL :: Lens_' V1APIServiceSpec (Maybe ByteArray)
v1APIServiceSpecCaBundleL f V1APIServiceSpec{..} = (\v1APIServiceSpecCaBundle -> V1APIServiceSpec { v1APIServiceSpecCaBundle, ..} ) <$> f v1APIServiceSpecCaBundle
{-# INLINE v1APIServiceSpecCaBundleL #-}

-- | 'v1APIServiceSpecGroup' Lens
v1APIServiceSpecGroupL :: Lens_' V1APIServiceSpec (Maybe Text)
v1APIServiceSpecGroupL f V1APIServiceSpec{..} = (\v1APIServiceSpecGroup -> V1APIServiceSpec { v1APIServiceSpecGroup, ..} ) <$> f v1APIServiceSpecGroup
{-# INLINE v1APIServiceSpecGroupL #-}

-- | 'v1APIServiceSpecGroupPriorityMinimum' Lens
v1APIServiceSpecGroupPriorityMinimumL :: Lens_' V1APIServiceSpec (Int)
v1APIServiceSpecGroupPriorityMinimumL f V1APIServiceSpec{..} = (\v1APIServiceSpecGroupPriorityMinimum -> V1APIServiceSpec { v1APIServiceSpecGroupPriorityMinimum, ..} ) <$> f v1APIServiceSpecGroupPriorityMinimum
{-# INLINE v1APIServiceSpecGroupPriorityMinimumL #-}

-- | 'v1APIServiceSpecInsecureSkipTlsVerify' Lens
v1APIServiceSpecInsecureSkipTlsVerifyL :: Lens_' V1APIServiceSpec (Maybe Bool)
v1APIServiceSpecInsecureSkipTlsVerifyL f V1APIServiceSpec{..} = (\v1APIServiceSpecInsecureSkipTlsVerify -> V1APIServiceSpec { v1APIServiceSpecInsecureSkipTlsVerify, ..} ) <$> f v1APIServiceSpecInsecureSkipTlsVerify
{-# INLINE v1APIServiceSpecInsecureSkipTlsVerifyL #-}

-- | 'v1APIServiceSpecService' Lens
v1APIServiceSpecServiceL :: Lens_' V1APIServiceSpec (Maybe ApiregistrationV1ServiceReference)
v1APIServiceSpecServiceL f V1APIServiceSpec{..} = (\v1APIServiceSpecService -> V1APIServiceSpec { v1APIServiceSpecService, ..} ) <$> f v1APIServiceSpecService
{-# INLINE v1APIServiceSpecServiceL #-}

-- | 'v1APIServiceSpecVersion' Lens
v1APIServiceSpecVersionL :: Lens_' V1APIServiceSpec (Maybe Text)
v1APIServiceSpecVersionL f V1APIServiceSpec{..} = (\v1APIServiceSpecVersion -> V1APIServiceSpec { v1APIServiceSpecVersion, ..} ) <$> f v1APIServiceSpecVersion
{-# INLINE v1APIServiceSpecVersionL #-}

-- | 'v1APIServiceSpecVersionPriority' Lens
v1APIServiceSpecVersionPriorityL :: Lens_' V1APIServiceSpec (Int)
v1APIServiceSpecVersionPriorityL f V1APIServiceSpec{..} = (\v1APIServiceSpecVersionPriority -> V1APIServiceSpec { v1APIServiceSpecVersionPriority, ..} ) <$> f v1APIServiceSpecVersionPriority
{-# INLINE v1APIServiceSpecVersionPriorityL #-}



-- * V1APIServiceStatus

-- | 'v1APIServiceStatusConditions' Lens
v1APIServiceStatusConditionsL :: Lens_' V1APIServiceStatus (Maybe [V1APIServiceCondition])
v1APIServiceStatusConditionsL f V1APIServiceStatus{..} = (\v1APIServiceStatusConditions -> V1APIServiceStatus { v1APIServiceStatusConditions, ..} ) <$> f v1APIServiceStatusConditions
{-# INLINE v1APIServiceStatusConditionsL #-}



-- * V1APIVersions

-- | 'v1APIVersionsApiVersion' Lens
v1APIVersionsApiVersionL :: Lens_' V1APIVersions (Maybe Text)
v1APIVersionsApiVersionL f V1APIVersions{..} = (\v1APIVersionsApiVersion -> V1APIVersions { v1APIVersionsApiVersion, ..} ) <$> f v1APIVersionsApiVersion
{-# INLINE v1APIVersionsApiVersionL #-}

-- | 'v1APIVersionsKind' Lens
v1APIVersionsKindL :: Lens_' V1APIVersions (Maybe Text)
v1APIVersionsKindL f V1APIVersions{..} = (\v1APIVersionsKind -> V1APIVersions { v1APIVersionsKind, ..} ) <$> f v1APIVersionsKind
{-# INLINE v1APIVersionsKindL #-}

-- | 'v1APIVersionsServerAddressByClientCidrs' Lens
v1APIVersionsServerAddressByClientCidrsL :: Lens_' V1APIVersions ([V1ServerAddressByClientCIDR])
v1APIVersionsServerAddressByClientCidrsL f V1APIVersions{..} = (\v1APIVersionsServerAddressByClientCidrs -> V1APIVersions { v1APIVersionsServerAddressByClientCidrs, ..} ) <$> f v1APIVersionsServerAddressByClientCidrs
{-# INLINE v1APIVersionsServerAddressByClientCidrsL #-}

-- | 'v1APIVersionsVersions' Lens
v1APIVersionsVersionsL :: Lens_' V1APIVersions ([Text])
v1APIVersionsVersionsL f V1APIVersions{..} = (\v1APIVersionsVersions -> V1APIVersions { v1APIVersionsVersions, ..} ) <$> f v1APIVersionsVersions
{-# INLINE v1APIVersionsVersionsL #-}



-- * V1AWSElasticBlockStoreVolumeSource

-- | 'v1AWSElasticBlockStoreVolumeSourceFsType' Lens
v1AWSElasticBlockStoreVolumeSourceFsTypeL :: Lens_' V1AWSElasticBlockStoreVolumeSource (Maybe Text)
v1AWSElasticBlockStoreVolumeSourceFsTypeL f V1AWSElasticBlockStoreVolumeSource{..} = (\v1AWSElasticBlockStoreVolumeSourceFsType -> V1AWSElasticBlockStoreVolumeSource { v1AWSElasticBlockStoreVolumeSourceFsType, ..} ) <$> f v1AWSElasticBlockStoreVolumeSourceFsType
{-# INLINE v1AWSElasticBlockStoreVolumeSourceFsTypeL #-}

-- | 'v1AWSElasticBlockStoreVolumeSourcePartition' Lens
v1AWSElasticBlockStoreVolumeSourcePartitionL :: Lens_' V1AWSElasticBlockStoreVolumeSource (Maybe Int)
v1AWSElasticBlockStoreVolumeSourcePartitionL f V1AWSElasticBlockStoreVolumeSource{..} = (\v1AWSElasticBlockStoreVolumeSourcePartition -> V1AWSElasticBlockStoreVolumeSource { v1AWSElasticBlockStoreVolumeSourcePartition, ..} ) <$> f v1AWSElasticBlockStoreVolumeSourcePartition
{-# INLINE v1AWSElasticBlockStoreVolumeSourcePartitionL #-}

-- | 'v1AWSElasticBlockStoreVolumeSourceReadOnly' Lens
v1AWSElasticBlockStoreVolumeSourceReadOnlyL :: Lens_' V1AWSElasticBlockStoreVolumeSource (Maybe Bool)
v1AWSElasticBlockStoreVolumeSourceReadOnlyL f V1AWSElasticBlockStoreVolumeSource{..} = (\v1AWSElasticBlockStoreVolumeSourceReadOnly -> V1AWSElasticBlockStoreVolumeSource { v1AWSElasticBlockStoreVolumeSourceReadOnly, ..} ) <$> f v1AWSElasticBlockStoreVolumeSourceReadOnly
{-# INLINE v1AWSElasticBlockStoreVolumeSourceReadOnlyL #-}

-- | 'v1AWSElasticBlockStoreVolumeSourceVolumeId' Lens
v1AWSElasticBlockStoreVolumeSourceVolumeIdL :: Lens_' V1AWSElasticBlockStoreVolumeSource (Text)
v1AWSElasticBlockStoreVolumeSourceVolumeIdL f V1AWSElasticBlockStoreVolumeSource{..} = (\v1AWSElasticBlockStoreVolumeSourceVolumeId -> V1AWSElasticBlockStoreVolumeSource { v1AWSElasticBlockStoreVolumeSourceVolumeId, ..} ) <$> f v1AWSElasticBlockStoreVolumeSourceVolumeId
{-# INLINE v1AWSElasticBlockStoreVolumeSourceVolumeIdL #-}



-- * V1Affinity

-- | 'v1AffinityNodeAffinity' Lens
v1AffinityNodeAffinityL :: Lens_' V1Affinity (Maybe V1NodeAffinity)
v1AffinityNodeAffinityL f V1Affinity{..} = (\v1AffinityNodeAffinity -> V1Affinity { v1AffinityNodeAffinity, ..} ) <$> f v1AffinityNodeAffinity
{-# INLINE v1AffinityNodeAffinityL #-}

-- | 'v1AffinityPodAffinity' Lens
v1AffinityPodAffinityL :: Lens_' V1Affinity (Maybe V1PodAffinity)
v1AffinityPodAffinityL f V1Affinity{..} = (\v1AffinityPodAffinity -> V1Affinity { v1AffinityPodAffinity, ..} ) <$> f v1AffinityPodAffinity
{-# INLINE v1AffinityPodAffinityL #-}

-- | 'v1AffinityPodAntiAffinity' Lens
v1AffinityPodAntiAffinityL :: Lens_' V1Affinity (Maybe V1PodAntiAffinity)
v1AffinityPodAntiAffinityL f V1Affinity{..} = (\v1AffinityPodAntiAffinity -> V1Affinity { v1AffinityPodAntiAffinity, ..} ) <$> f v1AffinityPodAntiAffinity
{-# INLINE v1AffinityPodAntiAffinityL #-}



-- * V1AggregationRule

-- | 'v1AggregationRuleClusterRoleSelectors' Lens
v1AggregationRuleClusterRoleSelectorsL :: Lens_' V1AggregationRule (Maybe [V1LabelSelector])
v1AggregationRuleClusterRoleSelectorsL f V1AggregationRule{..} = (\v1AggregationRuleClusterRoleSelectors -> V1AggregationRule { v1AggregationRuleClusterRoleSelectors, ..} ) <$> f v1AggregationRuleClusterRoleSelectors
{-# INLINE v1AggregationRuleClusterRoleSelectorsL #-}



-- * V1AttachedVolume

-- | 'v1AttachedVolumeDevicePath' Lens
v1AttachedVolumeDevicePathL :: Lens_' V1AttachedVolume (Text)
v1AttachedVolumeDevicePathL f V1AttachedVolume{..} = (\v1AttachedVolumeDevicePath -> V1AttachedVolume { v1AttachedVolumeDevicePath, ..} ) <$> f v1AttachedVolumeDevicePath
{-# INLINE v1AttachedVolumeDevicePathL #-}

-- | 'v1AttachedVolumeName' Lens
v1AttachedVolumeNameL :: Lens_' V1AttachedVolume (Text)
v1AttachedVolumeNameL f V1AttachedVolume{..} = (\v1AttachedVolumeName -> V1AttachedVolume { v1AttachedVolumeName, ..} ) <$> f v1AttachedVolumeName
{-# INLINE v1AttachedVolumeNameL #-}



-- * V1AzureDiskVolumeSource

-- | 'v1AzureDiskVolumeSourceCachingMode' Lens
v1AzureDiskVolumeSourceCachingModeL :: Lens_' V1AzureDiskVolumeSource (Maybe Text)
v1AzureDiskVolumeSourceCachingModeL f V1AzureDiskVolumeSource{..} = (\v1AzureDiskVolumeSourceCachingMode -> V1AzureDiskVolumeSource { v1AzureDiskVolumeSourceCachingMode, ..} ) <$> f v1AzureDiskVolumeSourceCachingMode
{-# INLINE v1AzureDiskVolumeSourceCachingModeL #-}

-- | 'v1AzureDiskVolumeSourceDiskName' Lens
v1AzureDiskVolumeSourceDiskNameL :: Lens_' V1AzureDiskVolumeSource (Text)
v1AzureDiskVolumeSourceDiskNameL f V1AzureDiskVolumeSource{..} = (\v1AzureDiskVolumeSourceDiskName -> V1AzureDiskVolumeSource { v1AzureDiskVolumeSourceDiskName, ..} ) <$> f v1AzureDiskVolumeSourceDiskName
{-# INLINE v1AzureDiskVolumeSourceDiskNameL #-}

-- | 'v1AzureDiskVolumeSourceDiskUri' Lens
v1AzureDiskVolumeSourceDiskUriL :: Lens_' V1AzureDiskVolumeSource (Text)
v1AzureDiskVolumeSourceDiskUriL f V1AzureDiskVolumeSource{..} = (\v1AzureDiskVolumeSourceDiskUri -> V1AzureDiskVolumeSource { v1AzureDiskVolumeSourceDiskUri, ..} ) <$> f v1AzureDiskVolumeSourceDiskUri
{-# INLINE v1AzureDiskVolumeSourceDiskUriL #-}

-- | 'v1AzureDiskVolumeSourceFsType' Lens
v1AzureDiskVolumeSourceFsTypeL :: Lens_' V1AzureDiskVolumeSource (Maybe Text)
v1AzureDiskVolumeSourceFsTypeL f V1AzureDiskVolumeSource{..} = (\v1AzureDiskVolumeSourceFsType -> V1AzureDiskVolumeSource { v1AzureDiskVolumeSourceFsType, ..} ) <$> f v1AzureDiskVolumeSourceFsType
{-# INLINE v1AzureDiskVolumeSourceFsTypeL #-}

-- | 'v1AzureDiskVolumeSourceKind' Lens
v1AzureDiskVolumeSourceKindL :: Lens_' V1AzureDiskVolumeSource (Maybe Text)
v1AzureDiskVolumeSourceKindL f V1AzureDiskVolumeSource{..} = (\v1AzureDiskVolumeSourceKind -> V1AzureDiskVolumeSource { v1AzureDiskVolumeSourceKind, ..} ) <$> f v1AzureDiskVolumeSourceKind
{-# INLINE v1AzureDiskVolumeSourceKindL #-}

-- | 'v1AzureDiskVolumeSourceReadOnly' Lens
v1AzureDiskVolumeSourceReadOnlyL :: Lens_' V1AzureDiskVolumeSource (Maybe Bool)
v1AzureDiskVolumeSourceReadOnlyL f V1AzureDiskVolumeSource{..} = (\v1AzureDiskVolumeSourceReadOnly -> V1AzureDiskVolumeSource { v1AzureDiskVolumeSourceReadOnly, ..} ) <$> f v1AzureDiskVolumeSourceReadOnly
{-# INLINE v1AzureDiskVolumeSourceReadOnlyL #-}



-- * V1AzureFilePersistentVolumeSource

-- | 'v1AzureFilePersistentVolumeSourceReadOnly' Lens
v1AzureFilePersistentVolumeSourceReadOnlyL :: Lens_' V1AzureFilePersistentVolumeSource (Maybe Bool)
v1AzureFilePersistentVolumeSourceReadOnlyL f V1AzureFilePersistentVolumeSource{..} = (\v1AzureFilePersistentVolumeSourceReadOnly -> V1AzureFilePersistentVolumeSource { v1AzureFilePersistentVolumeSourceReadOnly, ..} ) <$> f v1AzureFilePersistentVolumeSourceReadOnly
{-# INLINE v1AzureFilePersistentVolumeSourceReadOnlyL #-}

-- | 'v1AzureFilePersistentVolumeSourceSecretName' Lens
v1AzureFilePersistentVolumeSourceSecretNameL :: Lens_' V1AzureFilePersistentVolumeSource (Text)
v1AzureFilePersistentVolumeSourceSecretNameL f V1AzureFilePersistentVolumeSource{..} = (\v1AzureFilePersistentVolumeSourceSecretName -> V1AzureFilePersistentVolumeSource { v1AzureFilePersistentVolumeSourceSecretName, ..} ) <$> f v1AzureFilePersistentVolumeSourceSecretName
{-# INLINE v1AzureFilePersistentVolumeSourceSecretNameL #-}

-- | 'v1AzureFilePersistentVolumeSourceSecretNamespace' Lens
v1AzureFilePersistentVolumeSourceSecretNamespaceL :: Lens_' V1AzureFilePersistentVolumeSource (Maybe Text)
v1AzureFilePersistentVolumeSourceSecretNamespaceL f V1AzureFilePersistentVolumeSource{..} = (\v1AzureFilePersistentVolumeSourceSecretNamespace -> V1AzureFilePersistentVolumeSource { v1AzureFilePersistentVolumeSourceSecretNamespace, ..} ) <$> f v1AzureFilePersistentVolumeSourceSecretNamespace
{-# INLINE v1AzureFilePersistentVolumeSourceSecretNamespaceL #-}

-- | 'v1AzureFilePersistentVolumeSourceShareName' Lens
v1AzureFilePersistentVolumeSourceShareNameL :: Lens_' V1AzureFilePersistentVolumeSource (Text)
v1AzureFilePersistentVolumeSourceShareNameL f V1AzureFilePersistentVolumeSource{..} = (\v1AzureFilePersistentVolumeSourceShareName -> V1AzureFilePersistentVolumeSource { v1AzureFilePersistentVolumeSourceShareName, ..} ) <$> f v1AzureFilePersistentVolumeSourceShareName
{-# INLINE v1AzureFilePersistentVolumeSourceShareNameL #-}



-- * V1AzureFileVolumeSource

-- | 'v1AzureFileVolumeSourceReadOnly' Lens
v1AzureFileVolumeSourceReadOnlyL :: Lens_' V1AzureFileVolumeSource (Maybe Bool)
v1AzureFileVolumeSourceReadOnlyL f V1AzureFileVolumeSource{..} = (\v1AzureFileVolumeSourceReadOnly -> V1AzureFileVolumeSource { v1AzureFileVolumeSourceReadOnly, ..} ) <$> f v1AzureFileVolumeSourceReadOnly
{-# INLINE v1AzureFileVolumeSourceReadOnlyL #-}

-- | 'v1AzureFileVolumeSourceSecretName' Lens
v1AzureFileVolumeSourceSecretNameL :: Lens_' V1AzureFileVolumeSource (Text)
v1AzureFileVolumeSourceSecretNameL f V1AzureFileVolumeSource{..} = (\v1AzureFileVolumeSourceSecretName -> V1AzureFileVolumeSource { v1AzureFileVolumeSourceSecretName, ..} ) <$> f v1AzureFileVolumeSourceSecretName
{-# INLINE v1AzureFileVolumeSourceSecretNameL #-}

-- | 'v1AzureFileVolumeSourceShareName' Lens
v1AzureFileVolumeSourceShareNameL :: Lens_' V1AzureFileVolumeSource (Text)
v1AzureFileVolumeSourceShareNameL f V1AzureFileVolumeSource{..} = (\v1AzureFileVolumeSourceShareName -> V1AzureFileVolumeSource { v1AzureFileVolumeSourceShareName, ..} ) <$> f v1AzureFileVolumeSourceShareName
{-# INLINE v1AzureFileVolumeSourceShareNameL #-}



-- * V1Binding

-- | 'v1BindingApiVersion' Lens
v1BindingApiVersionL :: Lens_' V1Binding (Maybe Text)
v1BindingApiVersionL f V1Binding{..} = (\v1BindingApiVersion -> V1Binding { v1BindingApiVersion, ..} ) <$> f v1BindingApiVersion
{-# INLINE v1BindingApiVersionL #-}

-- | 'v1BindingKind' Lens
v1BindingKindL :: Lens_' V1Binding (Maybe Text)
v1BindingKindL f V1Binding{..} = (\v1BindingKind -> V1Binding { v1BindingKind, ..} ) <$> f v1BindingKind
{-# INLINE v1BindingKindL #-}

-- | 'v1BindingMetadata' Lens
v1BindingMetadataL :: Lens_' V1Binding (Maybe V1ObjectMeta)
v1BindingMetadataL f V1Binding{..} = (\v1BindingMetadata -> V1Binding { v1BindingMetadata, ..} ) <$> f v1BindingMetadata
{-# INLINE v1BindingMetadataL #-}

-- | 'v1BindingTarget' Lens
v1BindingTargetL :: Lens_' V1Binding (V1ObjectReference)
v1BindingTargetL f V1Binding{..} = (\v1BindingTarget -> V1Binding { v1BindingTarget, ..} ) <$> f v1BindingTarget
{-# INLINE v1BindingTargetL #-}



-- * V1BoundObjectReference

-- | 'v1BoundObjectReferenceApiVersion' Lens
v1BoundObjectReferenceApiVersionL :: Lens_' V1BoundObjectReference (Maybe Text)
v1BoundObjectReferenceApiVersionL f V1BoundObjectReference{..} = (\v1BoundObjectReferenceApiVersion -> V1BoundObjectReference { v1BoundObjectReferenceApiVersion, ..} ) <$> f v1BoundObjectReferenceApiVersion
{-# INLINE v1BoundObjectReferenceApiVersionL #-}

-- | 'v1BoundObjectReferenceKind' Lens
v1BoundObjectReferenceKindL :: Lens_' V1BoundObjectReference (Maybe Text)
v1BoundObjectReferenceKindL f V1BoundObjectReference{..} = (\v1BoundObjectReferenceKind -> V1BoundObjectReference { v1BoundObjectReferenceKind, ..} ) <$> f v1BoundObjectReferenceKind
{-# INLINE v1BoundObjectReferenceKindL #-}

-- | 'v1BoundObjectReferenceName' Lens
v1BoundObjectReferenceNameL :: Lens_' V1BoundObjectReference (Maybe Text)
v1BoundObjectReferenceNameL f V1BoundObjectReference{..} = (\v1BoundObjectReferenceName -> V1BoundObjectReference { v1BoundObjectReferenceName, ..} ) <$> f v1BoundObjectReferenceName
{-# INLINE v1BoundObjectReferenceNameL #-}

-- | 'v1BoundObjectReferenceUid' Lens
v1BoundObjectReferenceUidL :: Lens_' V1BoundObjectReference (Maybe Text)
v1BoundObjectReferenceUidL f V1BoundObjectReference{..} = (\v1BoundObjectReferenceUid -> V1BoundObjectReference { v1BoundObjectReferenceUid, ..} ) <$> f v1BoundObjectReferenceUid
{-# INLINE v1BoundObjectReferenceUidL #-}



-- * V1CSIDriver

-- | 'v1CSIDriverApiVersion' Lens
v1CSIDriverApiVersionL :: Lens_' V1CSIDriver (Maybe Text)
v1CSIDriverApiVersionL f V1CSIDriver{..} = (\v1CSIDriverApiVersion -> V1CSIDriver { v1CSIDriverApiVersion, ..} ) <$> f v1CSIDriverApiVersion
{-# INLINE v1CSIDriverApiVersionL #-}

-- | 'v1CSIDriverKind' Lens
v1CSIDriverKindL :: Lens_' V1CSIDriver (Maybe Text)
v1CSIDriverKindL f V1CSIDriver{..} = (\v1CSIDriverKind -> V1CSIDriver { v1CSIDriverKind, ..} ) <$> f v1CSIDriverKind
{-# INLINE v1CSIDriverKindL #-}

-- | 'v1CSIDriverMetadata' Lens
v1CSIDriverMetadataL :: Lens_' V1CSIDriver (Maybe V1ObjectMeta)
v1CSIDriverMetadataL f V1CSIDriver{..} = (\v1CSIDriverMetadata -> V1CSIDriver { v1CSIDriverMetadata, ..} ) <$> f v1CSIDriverMetadata
{-# INLINE v1CSIDriverMetadataL #-}

-- | 'v1CSIDriverSpec' Lens
v1CSIDriverSpecL :: Lens_' V1CSIDriver (V1CSIDriverSpec)
v1CSIDriverSpecL f V1CSIDriver{..} = (\v1CSIDriverSpec -> V1CSIDriver { v1CSIDriverSpec, ..} ) <$> f v1CSIDriverSpec
{-# INLINE v1CSIDriverSpecL #-}



-- * V1CSIDriverList

-- | 'v1CSIDriverListApiVersion' Lens
v1CSIDriverListApiVersionL :: Lens_' V1CSIDriverList (Maybe Text)
v1CSIDriverListApiVersionL f V1CSIDriverList{..} = (\v1CSIDriverListApiVersion -> V1CSIDriverList { v1CSIDriverListApiVersion, ..} ) <$> f v1CSIDriverListApiVersion
{-# INLINE v1CSIDriverListApiVersionL #-}

-- | 'v1CSIDriverListItems' Lens
v1CSIDriverListItemsL :: Lens_' V1CSIDriverList ([V1CSIDriver])
v1CSIDriverListItemsL f V1CSIDriverList{..} = (\v1CSIDriverListItems -> V1CSIDriverList { v1CSIDriverListItems, ..} ) <$> f v1CSIDriverListItems
{-# INLINE v1CSIDriverListItemsL #-}

-- | 'v1CSIDriverListKind' Lens
v1CSIDriverListKindL :: Lens_' V1CSIDriverList (Maybe Text)
v1CSIDriverListKindL f V1CSIDriverList{..} = (\v1CSIDriverListKind -> V1CSIDriverList { v1CSIDriverListKind, ..} ) <$> f v1CSIDriverListKind
{-# INLINE v1CSIDriverListKindL #-}

-- | 'v1CSIDriverListMetadata' Lens
v1CSIDriverListMetadataL :: Lens_' V1CSIDriverList (Maybe V1ListMeta)
v1CSIDriverListMetadataL f V1CSIDriverList{..} = (\v1CSIDriverListMetadata -> V1CSIDriverList { v1CSIDriverListMetadata, ..} ) <$> f v1CSIDriverListMetadata
{-# INLINE v1CSIDriverListMetadataL #-}



-- * V1CSIDriverSpec

-- | 'v1CSIDriverSpecAttachRequired' Lens
v1CSIDriverSpecAttachRequiredL :: Lens_' V1CSIDriverSpec (Maybe Bool)
v1CSIDriverSpecAttachRequiredL f V1CSIDriverSpec{..} = (\v1CSIDriverSpecAttachRequired -> V1CSIDriverSpec { v1CSIDriverSpecAttachRequired, ..} ) <$> f v1CSIDriverSpecAttachRequired
{-# INLINE v1CSIDriverSpecAttachRequiredL #-}

-- | 'v1CSIDriverSpecFsGroupPolicy' Lens
v1CSIDriverSpecFsGroupPolicyL :: Lens_' V1CSIDriverSpec (Maybe Text)
v1CSIDriverSpecFsGroupPolicyL f V1CSIDriverSpec{..} = (\v1CSIDriverSpecFsGroupPolicy -> V1CSIDriverSpec { v1CSIDriverSpecFsGroupPolicy, ..} ) <$> f v1CSIDriverSpecFsGroupPolicy
{-# INLINE v1CSIDriverSpecFsGroupPolicyL #-}

-- | 'v1CSIDriverSpecPodInfoOnMount' Lens
v1CSIDriverSpecPodInfoOnMountL :: Lens_' V1CSIDriverSpec (Maybe Bool)
v1CSIDriverSpecPodInfoOnMountL f V1CSIDriverSpec{..} = (\v1CSIDriverSpecPodInfoOnMount -> V1CSIDriverSpec { v1CSIDriverSpecPodInfoOnMount, ..} ) <$> f v1CSIDriverSpecPodInfoOnMount
{-# INLINE v1CSIDriverSpecPodInfoOnMountL #-}

-- | 'v1CSIDriverSpecRequiresRepublish' Lens
v1CSIDriverSpecRequiresRepublishL :: Lens_' V1CSIDriverSpec (Maybe Bool)
v1CSIDriverSpecRequiresRepublishL f V1CSIDriverSpec{..} = (\v1CSIDriverSpecRequiresRepublish -> V1CSIDriverSpec { v1CSIDriverSpecRequiresRepublish, ..} ) <$> f v1CSIDriverSpecRequiresRepublish
{-# INLINE v1CSIDriverSpecRequiresRepublishL #-}

-- | 'v1CSIDriverSpecStorageCapacity' Lens
v1CSIDriverSpecStorageCapacityL :: Lens_' V1CSIDriverSpec (Maybe Bool)
v1CSIDriverSpecStorageCapacityL f V1CSIDriverSpec{..} = (\v1CSIDriverSpecStorageCapacity -> V1CSIDriverSpec { v1CSIDriverSpecStorageCapacity, ..} ) <$> f v1CSIDriverSpecStorageCapacity
{-# INLINE v1CSIDriverSpecStorageCapacityL #-}

-- | 'v1CSIDriverSpecTokenRequests' Lens
v1CSIDriverSpecTokenRequestsL :: Lens_' V1CSIDriverSpec (Maybe [StorageV1TokenRequest])
v1CSIDriverSpecTokenRequestsL f V1CSIDriverSpec{..} = (\v1CSIDriverSpecTokenRequests -> V1CSIDriverSpec { v1CSIDriverSpecTokenRequests, ..} ) <$> f v1CSIDriverSpecTokenRequests
{-# INLINE v1CSIDriverSpecTokenRequestsL #-}

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



-- * V1CSINode

-- | 'v1CSINodeApiVersion' Lens
v1CSINodeApiVersionL :: Lens_' V1CSINode (Maybe Text)
v1CSINodeApiVersionL f V1CSINode{..} = (\v1CSINodeApiVersion -> V1CSINode { v1CSINodeApiVersion, ..} ) <$> f v1CSINodeApiVersion
{-# INLINE v1CSINodeApiVersionL #-}

-- | 'v1CSINodeKind' Lens
v1CSINodeKindL :: Lens_' V1CSINode (Maybe Text)
v1CSINodeKindL f V1CSINode{..} = (\v1CSINodeKind -> V1CSINode { v1CSINodeKind, ..} ) <$> f v1CSINodeKind
{-# INLINE v1CSINodeKindL #-}

-- | 'v1CSINodeMetadata' Lens
v1CSINodeMetadataL :: Lens_' V1CSINode (Maybe V1ObjectMeta)
v1CSINodeMetadataL f V1CSINode{..} = (\v1CSINodeMetadata -> V1CSINode { v1CSINodeMetadata, ..} ) <$> f v1CSINodeMetadata
{-# INLINE v1CSINodeMetadataL #-}

-- | 'v1CSINodeSpec' Lens
v1CSINodeSpecL :: Lens_' V1CSINode (V1CSINodeSpec)
v1CSINodeSpecL f V1CSINode{..} = (\v1CSINodeSpec -> V1CSINode { v1CSINodeSpec, ..} ) <$> f v1CSINodeSpec
{-# INLINE v1CSINodeSpecL #-}



-- * V1CSINodeDriver

-- | 'v1CSINodeDriverAllocatable' Lens
v1CSINodeDriverAllocatableL :: Lens_' V1CSINodeDriver (Maybe V1VolumeNodeResources)
v1CSINodeDriverAllocatableL f V1CSINodeDriver{..} = (\v1CSINodeDriverAllocatable -> V1CSINodeDriver { v1CSINodeDriverAllocatable, ..} ) <$> f v1CSINodeDriverAllocatable
{-# INLINE v1CSINodeDriverAllocatableL #-}

-- | 'v1CSINodeDriverName' Lens
v1CSINodeDriverNameL :: Lens_' V1CSINodeDriver (Text)
v1CSINodeDriverNameL f V1CSINodeDriver{..} = (\v1CSINodeDriverName -> V1CSINodeDriver { v1CSINodeDriverName, ..} ) <$> f v1CSINodeDriverName
{-# INLINE v1CSINodeDriverNameL #-}

-- | 'v1CSINodeDriverNodeId' Lens
v1CSINodeDriverNodeIdL :: Lens_' V1CSINodeDriver (Text)
v1CSINodeDriverNodeIdL f V1CSINodeDriver{..} = (\v1CSINodeDriverNodeId -> V1CSINodeDriver { v1CSINodeDriverNodeId, ..} ) <$> f v1CSINodeDriverNodeId
{-# INLINE v1CSINodeDriverNodeIdL #-}

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



-- * V1CSINodeList

-- | 'v1CSINodeListApiVersion' Lens
v1CSINodeListApiVersionL :: Lens_' V1CSINodeList (Maybe Text)
v1CSINodeListApiVersionL f V1CSINodeList{..} = (\v1CSINodeListApiVersion -> V1CSINodeList { v1CSINodeListApiVersion, ..} ) <$> f v1CSINodeListApiVersion
{-# INLINE v1CSINodeListApiVersionL #-}

-- | 'v1CSINodeListItems' Lens
v1CSINodeListItemsL :: Lens_' V1CSINodeList ([V1CSINode])
v1CSINodeListItemsL f V1CSINodeList{..} = (\v1CSINodeListItems -> V1CSINodeList { v1CSINodeListItems, ..} ) <$> f v1CSINodeListItems
{-# INLINE v1CSINodeListItemsL #-}

-- | 'v1CSINodeListKind' Lens
v1CSINodeListKindL :: Lens_' V1CSINodeList (Maybe Text)
v1CSINodeListKindL f V1CSINodeList{..} = (\v1CSINodeListKind -> V1CSINodeList { v1CSINodeListKind, ..} ) <$> f v1CSINodeListKind
{-# INLINE v1CSINodeListKindL #-}

-- | 'v1CSINodeListMetadata' Lens
v1CSINodeListMetadataL :: Lens_' V1CSINodeList (Maybe V1ListMeta)
v1CSINodeListMetadataL f V1CSINodeList{..} = (\v1CSINodeListMetadata -> V1CSINodeList { v1CSINodeListMetadata, ..} ) <$> f v1CSINodeListMetadata
{-# INLINE v1CSINodeListMetadataL #-}



-- * V1CSINodeSpec

-- | 'v1CSINodeSpecDrivers' Lens
v1CSINodeSpecDriversL :: Lens_' V1CSINodeSpec ([V1CSINodeDriver])
v1CSINodeSpecDriversL f V1CSINodeSpec{..} = (\v1CSINodeSpecDrivers -> V1CSINodeSpec { v1CSINodeSpecDrivers, ..} ) <$> f v1CSINodeSpecDrivers
{-# INLINE v1CSINodeSpecDriversL #-}



-- * V1CSIPersistentVolumeSource

-- | 'v1CSIPersistentVolumeSourceControllerExpandSecretRef' Lens
v1CSIPersistentVolumeSourceControllerExpandSecretRefL :: Lens_' V1CSIPersistentVolumeSource (Maybe V1SecretReference)
v1CSIPersistentVolumeSourceControllerExpandSecretRefL f V1CSIPersistentVolumeSource{..} = (\v1CSIPersistentVolumeSourceControllerExpandSecretRef -> V1CSIPersistentVolumeSource { v1CSIPersistentVolumeSourceControllerExpandSecretRef, ..} ) <$> f v1CSIPersistentVolumeSourceControllerExpandSecretRef
{-# INLINE v1CSIPersistentVolumeSourceControllerExpandSecretRefL #-}

-- | 'v1CSIPersistentVolumeSourceControllerPublishSecretRef' Lens
v1CSIPersistentVolumeSourceControllerPublishSecretRefL :: Lens_' V1CSIPersistentVolumeSource (Maybe V1SecretReference)
v1CSIPersistentVolumeSourceControllerPublishSecretRefL f V1CSIPersistentVolumeSource{..} = (\v1CSIPersistentVolumeSourceControllerPublishSecretRef -> V1CSIPersistentVolumeSource { v1CSIPersistentVolumeSourceControllerPublishSecretRef, ..} ) <$> f v1CSIPersistentVolumeSourceControllerPublishSecretRef
{-# INLINE v1CSIPersistentVolumeSourceControllerPublishSecretRefL #-}

-- | 'v1CSIPersistentVolumeSourceDriver' Lens
v1CSIPersistentVolumeSourceDriverL :: Lens_' V1CSIPersistentVolumeSource (Text)
v1CSIPersistentVolumeSourceDriverL f V1CSIPersistentVolumeSource{..} = (\v1CSIPersistentVolumeSourceDriver -> V1CSIPersistentVolumeSource { v1CSIPersistentVolumeSourceDriver, ..} ) <$> f v1CSIPersistentVolumeSourceDriver
{-# INLINE v1CSIPersistentVolumeSourceDriverL #-}

-- | 'v1CSIPersistentVolumeSourceFsType' Lens
v1CSIPersistentVolumeSourceFsTypeL :: Lens_' V1CSIPersistentVolumeSource (Maybe Text)
v1CSIPersistentVolumeSourceFsTypeL f V1CSIPersistentVolumeSource{..} = (\v1CSIPersistentVolumeSourceFsType -> V1CSIPersistentVolumeSource { v1CSIPersistentVolumeSourceFsType, ..} ) <$> f v1CSIPersistentVolumeSourceFsType
{-# INLINE v1CSIPersistentVolumeSourceFsTypeL #-}

-- | 'v1CSIPersistentVolumeSourceNodePublishSecretRef' Lens
v1CSIPersistentVolumeSourceNodePublishSecretRefL :: Lens_' V1CSIPersistentVolumeSource (Maybe V1SecretReference)
v1CSIPersistentVolumeSourceNodePublishSecretRefL f V1CSIPersistentVolumeSource{..} = (\v1CSIPersistentVolumeSourceNodePublishSecretRef -> V1CSIPersistentVolumeSource { v1CSIPersistentVolumeSourceNodePublishSecretRef, ..} ) <$> f v1CSIPersistentVolumeSourceNodePublishSecretRef
{-# INLINE v1CSIPersistentVolumeSourceNodePublishSecretRefL #-}

-- | 'v1CSIPersistentVolumeSourceNodeStageSecretRef' Lens
v1CSIPersistentVolumeSourceNodeStageSecretRefL :: Lens_' V1CSIPersistentVolumeSource (Maybe V1SecretReference)
v1CSIPersistentVolumeSourceNodeStageSecretRefL f V1CSIPersistentVolumeSource{..} = (\v1CSIPersistentVolumeSourceNodeStageSecretRef -> V1CSIPersistentVolumeSource { v1CSIPersistentVolumeSourceNodeStageSecretRef, ..} ) <$> f v1CSIPersistentVolumeSourceNodeStageSecretRef
{-# INLINE v1CSIPersistentVolumeSourceNodeStageSecretRefL #-}

-- | 'v1CSIPersistentVolumeSourceReadOnly' Lens
v1CSIPersistentVolumeSourceReadOnlyL :: Lens_' V1CSIPersistentVolumeSource (Maybe Bool)
v1CSIPersistentVolumeSourceReadOnlyL f V1CSIPersistentVolumeSource{..} = (\v1CSIPersistentVolumeSourceReadOnly -> V1CSIPersistentVolumeSource { v1CSIPersistentVolumeSourceReadOnly, ..} ) <$> f v1CSIPersistentVolumeSourceReadOnly
{-# INLINE v1CSIPersistentVolumeSourceReadOnlyL #-}

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

-- | 'v1CSIPersistentVolumeSourceVolumeHandle' Lens
v1CSIPersistentVolumeSourceVolumeHandleL :: Lens_' V1CSIPersistentVolumeSource (Text)
v1CSIPersistentVolumeSourceVolumeHandleL f V1CSIPersistentVolumeSource{..} = (\v1CSIPersistentVolumeSourceVolumeHandle -> V1CSIPersistentVolumeSource { v1CSIPersistentVolumeSourceVolumeHandle, ..} ) <$> f v1CSIPersistentVolumeSourceVolumeHandle
{-# INLINE v1CSIPersistentVolumeSourceVolumeHandleL #-}



-- * V1CSIVolumeSource

-- | 'v1CSIVolumeSourceDriver' Lens
v1CSIVolumeSourceDriverL :: Lens_' V1CSIVolumeSource (Text)
v1CSIVolumeSourceDriverL f V1CSIVolumeSource{..} = (\v1CSIVolumeSourceDriver -> V1CSIVolumeSource { v1CSIVolumeSourceDriver, ..} ) <$> f v1CSIVolumeSourceDriver
{-# INLINE v1CSIVolumeSourceDriverL #-}

-- | 'v1CSIVolumeSourceFsType' Lens
v1CSIVolumeSourceFsTypeL :: Lens_' V1CSIVolumeSource (Maybe Text)
v1CSIVolumeSourceFsTypeL f V1CSIVolumeSource{..} = (\v1CSIVolumeSourceFsType -> V1CSIVolumeSource { v1CSIVolumeSourceFsType, ..} ) <$> f v1CSIVolumeSourceFsType
{-# INLINE v1CSIVolumeSourceFsTypeL #-}

-- | 'v1CSIVolumeSourceNodePublishSecretRef' Lens
v1CSIVolumeSourceNodePublishSecretRefL :: Lens_' V1CSIVolumeSource (Maybe V1LocalObjectReference)
v1CSIVolumeSourceNodePublishSecretRefL f V1CSIVolumeSource{..} = (\v1CSIVolumeSourceNodePublishSecretRef -> V1CSIVolumeSource { v1CSIVolumeSourceNodePublishSecretRef, ..} ) <$> f v1CSIVolumeSourceNodePublishSecretRef
{-# INLINE v1CSIVolumeSourceNodePublishSecretRefL #-}

-- | 'v1CSIVolumeSourceReadOnly' Lens
v1CSIVolumeSourceReadOnlyL :: Lens_' V1CSIVolumeSource (Maybe Bool)
v1CSIVolumeSourceReadOnlyL f V1CSIVolumeSource{..} = (\v1CSIVolumeSourceReadOnly -> V1CSIVolumeSource { v1CSIVolumeSourceReadOnly, ..} ) <$> f v1CSIVolumeSourceReadOnly
{-# INLINE v1CSIVolumeSourceReadOnlyL #-}

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



-- * V1Capabilities

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

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



-- * V1CephFSPersistentVolumeSource

-- | 'v1CephFSPersistentVolumeSourceMonitors' Lens
v1CephFSPersistentVolumeSourceMonitorsL :: Lens_' V1CephFSPersistentVolumeSource ([Text])
v1CephFSPersistentVolumeSourceMonitorsL f V1CephFSPersistentVolumeSource{..} = (\v1CephFSPersistentVolumeSourceMonitors -> V1CephFSPersistentVolumeSource { v1CephFSPersistentVolumeSourceMonitors, ..} ) <$> f v1CephFSPersistentVolumeSourceMonitors
{-# INLINE v1CephFSPersistentVolumeSourceMonitorsL #-}

-- | 'v1CephFSPersistentVolumeSourcePath' Lens
v1CephFSPersistentVolumeSourcePathL :: Lens_' V1CephFSPersistentVolumeSource (Maybe Text)
v1CephFSPersistentVolumeSourcePathL f V1CephFSPersistentVolumeSource{..} = (\v1CephFSPersistentVolumeSourcePath -> V1CephFSPersistentVolumeSource { v1CephFSPersistentVolumeSourcePath, ..} ) <$> f v1CephFSPersistentVolumeSourcePath
{-# INLINE v1CephFSPersistentVolumeSourcePathL #-}

-- | 'v1CephFSPersistentVolumeSourceReadOnly' Lens
v1CephFSPersistentVolumeSourceReadOnlyL :: Lens_' V1CephFSPersistentVolumeSource (Maybe Bool)
v1CephFSPersistentVolumeSourceReadOnlyL f V1CephFSPersistentVolumeSource{..} = (\v1CephFSPersistentVolumeSourceReadOnly -> V1CephFSPersistentVolumeSource { v1CephFSPersistentVolumeSourceReadOnly, ..} ) <$> f v1CephFSPersistentVolumeSourceReadOnly
{-# INLINE v1CephFSPersistentVolumeSourceReadOnlyL #-}

-- | 'v1CephFSPersistentVolumeSourceSecretFile' Lens
v1CephFSPersistentVolumeSourceSecretFileL :: Lens_' V1CephFSPersistentVolumeSource (Maybe Text)
v1CephFSPersistentVolumeSourceSecretFileL f V1CephFSPersistentVolumeSource{..} = (\v1CephFSPersistentVolumeSourceSecretFile -> V1CephFSPersistentVolumeSource { v1CephFSPersistentVolumeSourceSecretFile, ..} ) <$> f v1CephFSPersistentVolumeSourceSecretFile
{-# INLINE v1CephFSPersistentVolumeSourceSecretFileL #-}

-- | 'v1CephFSPersistentVolumeSourceSecretRef' Lens
v1CephFSPersistentVolumeSourceSecretRefL :: Lens_' V1CephFSPersistentVolumeSource (Maybe V1SecretReference)
v1CephFSPersistentVolumeSourceSecretRefL f V1CephFSPersistentVolumeSource{..} = (\v1CephFSPersistentVolumeSourceSecretRef -> V1CephFSPersistentVolumeSource { v1CephFSPersistentVolumeSourceSecretRef, ..} ) <$> f v1CephFSPersistentVolumeSourceSecretRef
{-# INLINE v1CephFSPersistentVolumeSourceSecretRefL #-}

-- | 'v1CephFSPersistentVolumeSourceUser' Lens
v1CephFSPersistentVolumeSourceUserL :: Lens_' V1CephFSPersistentVolumeSource (Maybe Text)
v1CephFSPersistentVolumeSourceUserL f V1CephFSPersistentVolumeSource{..} = (\v1CephFSPersistentVolumeSourceUser -> V1CephFSPersistentVolumeSource { v1CephFSPersistentVolumeSourceUser, ..} ) <$> f v1CephFSPersistentVolumeSourceUser
{-# INLINE v1CephFSPersistentVolumeSourceUserL #-}



-- * V1CephFSVolumeSource

-- | 'v1CephFSVolumeSourceMonitors' Lens
v1CephFSVolumeSourceMonitorsL :: Lens_' V1CephFSVolumeSource ([Text])
v1CephFSVolumeSourceMonitorsL f V1CephFSVolumeSource{..} = (\v1CephFSVolumeSourceMonitors -> V1CephFSVolumeSource { v1CephFSVolumeSourceMonitors, ..} ) <$> f v1CephFSVolumeSourceMonitors
{-# INLINE v1CephFSVolumeSourceMonitorsL #-}

-- | 'v1CephFSVolumeSourcePath' Lens
v1CephFSVolumeSourcePathL :: Lens_' V1CephFSVolumeSource (Maybe Text)
v1CephFSVolumeSourcePathL f V1CephFSVolumeSource{..} = (\v1CephFSVolumeSourcePath -> V1CephFSVolumeSource { v1CephFSVolumeSourcePath, ..} ) <$> f v1CephFSVolumeSourcePath
{-# INLINE v1CephFSVolumeSourcePathL #-}

-- | 'v1CephFSVolumeSourceReadOnly' Lens
v1CephFSVolumeSourceReadOnlyL :: Lens_' V1CephFSVolumeSource (Maybe Bool)
v1CephFSVolumeSourceReadOnlyL f V1CephFSVolumeSource{..} = (\v1CephFSVolumeSourceReadOnly -> V1CephFSVolumeSource { v1CephFSVolumeSourceReadOnly, ..} ) <$> f v1CephFSVolumeSourceReadOnly
{-# INLINE v1CephFSVolumeSourceReadOnlyL #-}

-- | 'v1CephFSVolumeSourceSecretFile' Lens
v1CephFSVolumeSourceSecretFileL :: Lens_' V1CephFSVolumeSource (Maybe Text)
v1CephFSVolumeSourceSecretFileL f V1CephFSVolumeSource{..} = (\v1CephFSVolumeSourceSecretFile -> V1CephFSVolumeSource { v1CephFSVolumeSourceSecretFile, ..} ) <$> f v1CephFSVolumeSourceSecretFile
{-# INLINE v1CephFSVolumeSourceSecretFileL #-}

-- | 'v1CephFSVolumeSourceSecretRef' Lens
v1CephFSVolumeSourceSecretRefL :: Lens_' V1CephFSVolumeSource (Maybe V1LocalObjectReference)
v1CephFSVolumeSourceSecretRefL f V1CephFSVolumeSource{..} = (\v1CephFSVolumeSourceSecretRef -> V1CephFSVolumeSource { v1CephFSVolumeSourceSecretRef, ..} ) <$> f v1CephFSVolumeSourceSecretRef
{-# INLINE v1CephFSVolumeSourceSecretRefL #-}

-- | 'v1CephFSVolumeSourceUser' Lens
v1CephFSVolumeSourceUserL :: Lens_' V1CephFSVolumeSource (Maybe Text)
v1CephFSVolumeSourceUserL f V1CephFSVolumeSource{..} = (\v1CephFSVolumeSourceUser -> V1CephFSVolumeSource { v1CephFSVolumeSourceUser, ..} ) <$> f v1CephFSVolumeSourceUser
{-# INLINE v1CephFSVolumeSourceUserL #-}



-- * V1CertificateSigningRequest

-- | 'v1CertificateSigningRequestApiVersion' Lens
v1CertificateSigningRequestApiVersionL :: Lens_' V1CertificateSigningRequest (Maybe Text)
v1CertificateSigningRequestApiVersionL f V1CertificateSigningRequest{..} = (\v1CertificateSigningRequestApiVersion -> V1CertificateSigningRequest { v1CertificateSigningRequestApiVersion, ..} ) <$> f v1CertificateSigningRequestApiVersion
{-# INLINE v1CertificateSigningRequestApiVersionL #-}

-- | 'v1CertificateSigningRequestKind' Lens
v1CertificateSigningRequestKindL :: Lens_' V1CertificateSigningRequest (Maybe Text)
v1CertificateSigningRequestKindL f V1CertificateSigningRequest{..} = (\v1CertificateSigningRequestKind -> V1CertificateSigningRequest { v1CertificateSigningRequestKind, ..} ) <$> f v1CertificateSigningRequestKind
{-# INLINE v1CertificateSigningRequestKindL #-}

-- | 'v1CertificateSigningRequestMetadata' Lens
v1CertificateSigningRequestMetadataL :: Lens_' V1CertificateSigningRequest (Maybe V1ObjectMeta)
v1CertificateSigningRequestMetadataL f V1CertificateSigningRequest{..} = (\v1CertificateSigningRequestMetadata -> V1CertificateSigningRequest { v1CertificateSigningRequestMetadata, ..} ) <$> f v1CertificateSigningRequestMetadata
{-# INLINE v1CertificateSigningRequestMetadataL #-}

-- | 'v1CertificateSigningRequestSpec' Lens
v1CertificateSigningRequestSpecL :: Lens_' V1CertificateSigningRequest (V1CertificateSigningRequestSpec)
v1CertificateSigningRequestSpecL f V1CertificateSigningRequest{..} = (\v1CertificateSigningRequestSpec -> V1CertificateSigningRequest { v1CertificateSigningRequestSpec, ..} ) <$> f v1CertificateSigningRequestSpec
{-# INLINE v1CertificateSigningRequestSpecL #-}

-- | 'v1CertificateSigningRequestStatus' Lens
v1CertificateSigningRequestStatusL :: Lens_' V1CertificateSigningRequest (Maybe V1CertificateSigningRequestStatus)
v1CertificateSigningRequestStatusL f V1CertificateSigningRequest{..} = (\v1CertificateSigningRequestStatus -> V1CertificateSigningRequest { v1CertificateSigningRequestStatus, ..} ) <$> f v1CertificateSigningRequestStatus
{-# INLINE v1CertificateSigningRequestStatusL #-}



-- * V1CertificateSigningRequestCondition

-- | 'v1CertificateSigningRequestConditionLastTransitionTime' Lens
v1CertificateSigningRequestConditionLastTransitionTimeL :: Lens_' V1CertificateSigningRequestCondition (Maybe DateTime)
v1CertificateSigningRequestConditionLastTransitionTimeL f V1CertificateSigningRequestCondition{..} = (\v1CertificateSigningRequestConditionLastTransitionTime -> V1CertificateSigningRequestCondition { v1CertificateSigningRequestConditionLastTransitionTime, ..} ) <$> f v1CertificateSigningRequestConditionLastTransitionTime
{-# INLINE v1CertificateSigningRequestConditionLastTransitionTimeL #-}

-- | 'v1CertificateSigningRequestConditionLastUpdateTime' Lens
v1CertificateSigningRequestConditionLastUpdateTimeL :: Lens_' V1CertificateSigningRequestCondition (Maybe DateTime)
v1CertificateSigningRequestConditionLastUpdateTimeL f V1CertificateSigningRequestCondition{..} = (\v1CertificateSigningRequestConditionLastUpdateTime -> V1CertificateSigningRequestCondition { v1CertificateSigningRequestConditionLastUpdateTime, ..} ) <$> f v1CertificateSigningRequestConditionLastUpdateTime
{-# INLINE v1CertificateSigningRequestConditionLastUpdateTimeL #-}

-- | 'v1CertificateSigningRequestConditionMessage' Lens
v1CertificateSigningRequestConditionMessageL :: Lens_' V1CertificateSigningRequestCondition (Maybe Text)
v1CertificateSigningRequestConditionMessageL f V1CertificateSigningRequestCondition{..} = (\v1CertificateSigningRequestConditionMessage -> V1CertificateSigningRequestCondition { v1CertificateSigningRequestConditionMessage, ..} ) <$> f v1CertificateSigningRequestConditionMessage
{-# INLINE v1CertificateSigningRequestConditionMessageL #-}

-- | 'v1CertificateSigningRequestConditionReason' Lens
v1CertificateSigningRequestConditionReasonL :: Lens_' V1CertificateSigningRequestCondition (Maybe Text)
v1CertificateSigningRequestConditionReasonL f V1CertificateSigningRequestCondition{..} = (\v1CertificateSigningRequestConditionReason -> V1CertificateSigningRequestCondition { v1CertificateSigningRequestConditionReason, ..} ) <$> f v1CertificateSigningRequestConditionReason
{-# INLINE v1CertificateSigningRequestConditionReasonL #-}

-- | 'v1CertificateSigningRequestConditionStatus' Lens
v1CertificateSigningRequestConditionStatusL :: Lens_' V1CertificateSigningRequestCondition (Text)
v1CertificateSigningRequestConditionStatusL f V1CertificateSigningRequestCondition{..} = (\v1CertificateSigningRequestConditionStatus -> V1CertificateSigningRequestCondition { v1CertificateSigningRequestConditionStatus, ..} ) <$> f v1CertificateSigningRequestConditionStatus
{-# INLINE v1CertificateSigningRequestConditionStatusL #-}

-- | 'v1CertificateSigningRequestConditionType' Lens
v1CertificateSigningRequestConditionTypeL :: Lens_' V1CertificateSigningRequestCondition (Text)
v1CertificateSigningRequestConditionTypeL f V1CertificateSigningRequestCondition{..} = (\v1CertificateSigningRequestConditionType -> V1CertificateSigningRequestCondition { v1CertificateSigningRequestConditionType, ..} ) <$> f v1CertificateSigningRequestConditionType
{-# INLINE v1CertificateSigningRequestConditionTypeL #-}



-- * V1CertificateSigningRequestList

-- | 'v1CertificateSigningRequestListApiVersion' Lens
v1CertificateSigningRequestListApiVersionL :: Lens_' V1CertificateSigningRequestList (Maybe Text)
v1CertificateSigningRequestListApiVersionL f V1CertificateSigningRequestList{..} = (\v1CertificateSigningRequestListApiVersion -> V1CertificateSigningRequestList { v1CertificateSigningRequestListApiVersion, ..} ) <$> f v1CertificateSigningRequestListApiVersion
{-# INLINE v1CertificateSigningRequestListApiVersionL #-}

-- | 'v1CertificateSigningRequestListItems' Lens
v1CertificateSigningRequestListItemsL :: Lens_' V1CertificateSigningRequestList ([V1CertificateSigningRequest])
v1CertificateSigningRequestListItemsL f V1CertificateSigningRequestList{..} = (\v1CertificateSigningRequestListItems -> V1CertificateSigningRequestList { v1CertificateSigningRequestListItems, ..} ) <$> f v1CertificateSigningRequestListItems
{-# INLINE v1CertificateSigningRequestListItemsL #-}

-- | 'v1CertificateSigningRequestListKind' Lens
v1CertificateSigningRequestListKindL :: Lens_' V1CertificateSigningRequestList (Maybe Text)
v1CertificateSigningRequestListKindL f V1CertificateSigningRequestList{..} = (\v1CertificateSigningRequestListKind -> V1CertificateSigningRequestList { v1CertificateSigningRequestListKind, ..} ) <$> f v1CertificateSigningRequestListKind
{-# INLINE v1CertificateSigningRequestListKindL #-}

-- | 'v1CertificateSigningRequestListMetadata' Lens
v1CertificateSigningRequestListMetadataL :: Lens_' V1CertificateSigningRequestList (Maybe V1ListMeta)
v1CertificateSigningRequestListMetadataL f V1CertificateSigningRequestList{..} = (\v1CertificateSigningRequestListMetadata -> V1CertificateSigningRequestList { v1CertificateSigningRequestListMetadata, ..} ) <$> f v1CertificateSigningRequestListMetadata
{-# INLINE v1CertificateSigningRequestListMetadataL #-}



-- * V1CertificateSigningRequestSpec

-- | 'v1CertificateSigningRequestSpecExpirationSeconds' Lens
v1CertificateSigningRequestSpecExpirationSecondsL :: Lens_' V1CertificateSigningRequestSpec (Maybe Int)
v1CertificateSigningRequestSpecExpirationSecondsL f V1CertificateSigningRequestSpec{..} = (\v1CertificateSigningRequestSpecExpirationSeconds -> V1CertificateSigningRequestSpec { v1CertificateSigningRequestSpecExpirationSeconds, ..} ) <$> f v1CertificateSigningRequestSpecExpirationSeconds
{-# INLINE v1CertificateSigningRequestSpecExpirationSecondsL #-}

-- | 'v1CertificateSigningRequestSpecExtra' Lens
v1CertificateSigningRequestSpecExtraL :: Lens_' V1CertificateSigningRequestSpec (Maybe (Map.Map String [Text]))
v1CertificateSigningRequestSpecExtraL f V1CertificateSigningRequestSpec{..} = (\v1CertificateSigningRequestSpecExtra -> V1CertificateSigningRequestSpec { v1CertificateSigningRequestSpecExtra, ..} ) <$> f v1CertificateSigningRequestSpecExtra
{-# INLINE v1CertificateSigningRequestSpecExtraL #-}

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

-- | 'v1CertificateSigningRequestSpecRequest' Lens
v1CertificateSigningRequestSpecRequestL :: Lens_' V1CertificateSigningRequestSpec (ByteArray)
v1CertificateSigningRequestSpecRequestL f V1CertificateSigningRequestSpec{..} = (\v1CertificateSigningRequestSpecRequest -> V1CertificateSigningRequestSpec { v1CertificateSigningRequestSpecRequest, ..} ) <$> f v1CertificateSigningRequestSpecRequest
{-# INLINE v1CertificateSigningRequestSpecRequestL #-}

-- | 'v1CertificateSigningRequestSpecSignerName' Lens
v1CertificateSigningRequestSpecSignerNameL :: Lens_' V1CertificateSigningRequestSpec (Text)
v1CertificateSigningRequestSpecSignerNameL f V1CertificateSigningRequestSpec{..} = (\v1CertificateSigningRequestSpecSignerName -> V1CertificateSigningRequestSpec { v1CertificateSigningRequestSpecSignerName, ..} ) <$> f v1CertificateSigningRequestSpecSignerName
{-# INLINE v1CertificateSigningRequestSpecSignerNameL #-}

-- | 'v1CertificateSigningRequestSpecUid' Lens
v1CertificateSigningRequestSpecUidL :: Lens_' V1CertificateSigningRequestSpec (Maybe Text)
v1CertificateSigningRequestSpecUidL f V1CertificateSigningRequestSpec{..} = (\v1CertificateSigningRequestSpecUid -> V1CertificateSigningRequestSpec { v1CertificateSigningRequestSpecUid, ..} ) <$> f v1CertificateSigningRequestSpecUid
{-# INLINE v1CertificateSigningRequestSpecUidL #-}

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

-- | 'v1CertificateSigningRequestSpecUsername' Lens
v1CertificateSigningRequestSpecUsernameL :: Lens_' V1CertificateSigningRequestSpec (Maybe Text)
v1CertificateSigningRequestSpecUsernameL f V1CertificateSigningRequestSpec{..} = (\v1CertificateSigningRequestSpecUsername -> V1CertificateSigningRequestSpec { v1CertificateSigningRequestSpecUsername, ..} ) <$> f v1CertificateSigningRequestSpecUsername
{-# INLINE v1CertificateSigningRequestSpecUsernameL #-}



-- * V1CertificateSigningRequestStatus

-- | 'v1CertificateSigningRequestStatusCertificate' Lens
v1CertificateSigningRequestStatusCertificateL :: Lens_' V1CertificateSigningRequestStatus (Maybe ByteArray)
v1CertificateSigningRequestStatusCertificateL f V1CertificateSigningRequestStatus{..} = (\v1CertificateSigningRequestStatusCertificate -> V1CertificateSigningRequestStatus { v1CertificateSigningRequestStatusCertificate, ..} ) <$> f v1CertificateSigningRequestStatusCertificate
{-# INLINE v1CertificateSigningRequestStatusCertificateL #-}

-- | 'v1CertificateSigningRequestStatusConditions' Lens
v1CertificateSigningRequestStatusConditionsL :: Lens_' V1CertificateSigningRequestStatus (Maybe [V1CertificateSigningRequestCondition])
v1CertificateSigningRequestStatusConditionsL f V1CertificateSigningRequestStatus{..} = (\v1CertificateSigningRequestStatusConditions -> V1CertificateSigningRequestStatus { v1CertificateSigningRequestStatusConditions, ..} ) <$> f v1CertificateSigningRequestStatusConditions
{-# INLINE v1CertificateSigningRequestStatusConditionsL #-}



-- * V1CinderPersistentVolumeSource

-- | 'v1CinderPersistentVolumeSourceFsType' Lens
v1CinderPersistentVolumeSourceFsTypeL :: Lens_' V1CinderPersistentVolumeSource (Maybe Text)
v1CinderPersistentVolumeSourceFsTypeL f V1CinderPersistentVolumeSource{..} = (\v1CinderPersistentVolumeSourceFsType -> V1CinderPersistentVolumeSource { v1CinderPersistentVolumeSourceFsType, ..} ) <$> f v1CinderPersistentVolumeSourceFsType
{-# INLINE v1CinderPersistentVolumeSourceFsTypeL #-}

-- | 'v1CinderPersistentVolumeSourceReadOnly' Lens
v1CinderPersistentVolumeSourceReadOnlyL :: Lens_' V1CinderPersistentVolumeSource (Maybe Bool)
v1CinderPersistentVolumeSourceReadOnlyL f V1CinderPersistentVolumeSource{..} = (\v1CinderPersistentVolumeSourceReadOnly -> V1CinderPersistentVolumeSource { v1CinderPersistentVolumeSourceReadOnly, ..} ) <$> f v1CinderPersistentVolumeSourceReadOnly
{-# INLINE v1CinderPersistentVolumeSourceReadOnlyL #-}

-- | 'v1CinderPersistentVolumeSourceSecretRef' Lens
v1CinderPersistentVolumeSourceSecretRefL :: Lens_' V1CinderPersistentVolumeSource (Maybe V1SecretReference)
v1CinderPersistentVolumeSourceSecretRefL f V1CinderPersistentVolumeSource{..} = (\v1CinderPersistentVolumeSourceSecretRef -> V1CinderPersistentVolumeSource { v1CinderPersistentVolumeSourceSecretRef, ..} ) <$> f v1CinderPersistentVolumeSourceSecretRef
{-# INLINE v1CinderPersistentVolumeSourceSecretRefL #-}

-- | 'v1CinderPersistentVolumeSourceVolumeId' Lens
v1CinderPersistentVolumeSourceVolumeIdL :: Lens_' V1CinderPersistentVolumeSource (Text)
v1CinderPersistentVolumeSourceVolumeIdL f V1CinderPersistentVolumeSource{..} = (\v1CinderPersistentVolumeSourceVolumeId -> V1CinderPersistentVolumeSource { v1CinderPersistentVolumeSourceVolumeId, ..} ) <$> f v1CinderPersistentVolumeSourceVolumeId
{-# INLINE v1CinderPersistentVolumeSourceVolumeIdL #-}



-- * V1CinderVolumeSource

-- | 'v1CinderVolumeSourceFsType' Lens
v1CinderVolumeSourceFsTypeL :: Lens_' V1CinderVolumeSource (Maybe Text)
v1CinderVolumeSourceFsTypeL f V1CinderVolumeSource{..} = (\v1CinderVolumeSourceFsType -> V1CinderVolumeSource { v1CinderVolumeSourceFsType, ..} ) <$> f v1CinderVolumeSourceFsType
{-# INLINE v1CinderVolumeSourceFsTypeL #-}

-- | 'v1CinderVolumeSourceReadOnly' Lens
v1CinderVolumeSourceReadOnlyL :: Lens_' V1CinderVolumeSource (Maybe Bool)
v1CinderVolumeSourceReadOnlyL f V1CinderVolumeSource{..} = (\v1CinderVolumeSourceReadOnly -> V1CinderVolumeSource { v1CinderVolumeSourceReadOnly, ..} ) <$> f v1CinderVolumeSourceReadOnly
{-# INLINE v1CinderVolumeSourceReadOnlyL #-}

-- | 'v1CinderVolumeSourceSecretRef' Lens
v1CinderVolumeSourceSecretRefL :: Lens_' V1CinderVolumeSource (Maybe V1LocalObjectReference)
v1CinderVolumeSourceSecretRefL f V1CinderVolumeSource{..} = (\v1CinderVolumeSourceSecretRef -> V1CinderVolumeSource { v1CinderVolumeSourceSecretRef, ..} ) <$> f v1CinderVolumeSourceSecretRef
{-# INLINE v1CinderVolumeSourceSecretRefL #-}

-- | 'v1CinderVolumeSourceVolumeId' Lens
v1CinderVolumeSourceVolumeIdL :: Lens_' V1CinderVolumeSource (Text)
v1CinderVolumeSourceVolumeIdL f V1CinderVolumeSource{..} = (\v1CinderVolumeSourceVolumeId -> V1CinderVolumeSource { v1CinderVolumeSourceVolumeId, ..} ) <$> f v1CinderVolumeSourceVolumeId
{-# INLINE v1CinderVolumeSourceVolumeIdL #-}



-- * V1ClientIPConfig

-- | 'v1ClientIPConfigTimeoutSeconds' Lens
v1ClientIPConfigTimeoutSecondsL :: Lens_' V1ClientIPConfig (Maybe Int)
v1ClientIPConfigTimeoutSecondsL f V1ClientIPConfig{..} = (\v1ClientIPConfigTimeoutSeconds -> V1ClientIPConfig { v1ClientIPConfigTimeoutSeconds, ..} ) <$> f v1ClientIPConfigTimeoutSeconds
{-# INLINE v1ClientIPConfigTimeoutSecondsL #-}



-- * V1ClusterRole

-- | 'v1ClusterRoleAggregationRule' Lens
v1ClusterRoleAggregationRuleL :: Lens_' V1ClusterRole (Maybe V1AggregationRule)
v1ClusterRoleAggregationRuleL f V1ClusterRole{..} = (\v1ClusterRoleAggregationRule -> V1ClusterRole { v1ClusterRoleAggregationRule, ..} ) <$> f v1ClusterRoleAggregationRule
{-# INLINE v1ClusterRoleAggregationRuleL #-}

-- | 'v1ClusterRoleApiVersion' Lens
v1ClusterRoleApiVersionL :: Lens_' V1ClusterRole (Maybe Text)
v1ClusterRoleApiVersionL f V1ClusterRole{..} = (\v1ClusterRoleApiVersion -> V1ClusterRole { v1ClusterRoleApiVersion, ..} ) <$> f v1ClusterRoleApiVersion
{-# INLINE v1ClusterRoleApiVersionL #-}

-- | 'v1ClusterRoleKind' Lens
v1ClusterRoleKindL :: Lens_' V1ClusterRole (Maybe Text)
v1ClusterRoleKindL f V1ClusterRole{..} = (\v1ClusterRoleKind -> V1ClusterRole { v1ClusterRoleKind, ..} ) <$> f v1ClusterRoleKind
{-# INLINE v1ClusterRoleKindL #-}

-- | 'v1ClusterRoleMetadata' Lens
v1ClusterRoleMetadataL :: Lens_' V1ClusterRole (Maybe V1ObjectMeta)
v1ClusterRoleMetadataL f V1ClusterRole{..} = (\v1ClusterRoleMetadata -> V1ClusterRole { v1ClusterRoleMetadata, ..} ) <$> f v1ClusterRoleMetadata
{-# INLINE v1ClusterRoleMetadataL #-}

-- | 'v1ClusterRoleRules' Lens
v1ClusterRoleRulesL :: Lens_' V1ClusterRole (Maybe [V1PolicyRule])
v1ClusterRoleRulesL f V1ClusterRole{..} = (\v1ClusterRoleRules -> V1ClusterRole { v1ClusterRoleRules, ..} ) <$> f v1ClusterRoleRules
{-# INLINE v1ClusterRoleRulesL #-}



-- * V1ClusterRoleBinding

-- | 'v1ClusterRoleBindingApiVersion' Lens
v1ClusterRoleBindingApiVersionL :: Lens_' V1ClusterRoleBinding (Maybe Text)
v1ClusterRoleBindingApiVersionL f V1ClusterRoleBinding{..} = (\v1ClusterRoleBindingApiVersion -> V1ClusterRoleBinding { v1ClusterRoleBindingApiVersion, ..} ) <$> f v1ClusterRoleBindingApiVersion
{-# INLINE v1ClusterRoleBindingApiVersionL #-}

-- | 'v1ClusterRoleBindingKind' Lens
v1ClusterRoleBindingKindL :: Lens_' V1ClusterRoleBinding (Maybe Text)
v1ClusterRoleBindingKindL f V1ClusterRoleBinding{..} = (\v1ClusterRoleBindingKind -> V1ClusterRoleBinding { v1ClusterRoleBindingKind, ..} ) <$> f v1ClusterRoleBindingKind
{-# INLINE v1ClusterRoleBindingKindL #-}

-- | 'v1ClusterRoleBindingMetadata' Lens
v1ClusterRoleBindingMetadataL :: Lens_' V1ClusterRoleBinding (Maybe V1ObjectMeta)
v1ClusterRoleBindingMetadataL f V1ClusterRoleBinding{..} = (\v1ClusterRoleBindingMetadata -> V1ClusterRoleBinding { v1ClusterRoleBindingMetadata, ..} ) <$> f v1ClusterRoleBindingMetadata
{-# INLINE v1ClusterRoleBindingMetadataL #-}

-- | 'v1ClusterRoleBindingRoleRef' Lens
v1ClusterRoleBindingRoleRefL :: Lens_' V1ClusterRoleBinding (V1RoleRef)
v1ClusterRoleBindingRoleRefL f V1ClusterRoleBinding{..} = (\v1ClusterRoleBindingRoleRef -> V1ClusterRoleBinding { v1ClusterRoleBindingRoleRef, ..} ) <$> f v1ClusterRoleBindingRoleRef
{-# INLINE v1ClusterRoleBindingRoleRefL #-}

-- | 'v1ClusterRoleBindingSubjects' Lens
v1ClusterRoleBindingSubjectsL :: Lens_' V1ClusterRoleBinding (Maybe [V1Subject])
v1ClusterRoleBindingSubjectsL f V1ClusterRoleBinding{..} = (\v1ClusterRoleBindingSubjects -> V1ClusterRoleBinding { v1ClusterRoleBindingSubjects, ..} ) <$> f v1ClusterRoleBindingSubjects
{-# INLINE v1ClusterRoleBindingSubjectsL #-}



-- * V1ClusterRoleBindingList

-- | 'v1ClusterRoleBindingListApiVersion' Lens
v1ClusterRoleBindingListApiVersionL :: Lens_' V1ClusterRoleBindingList (Maybe Text)
v1ClusterRoleBindingListApiVersionL f V1ClusterRoleBindingList{..} = (\v1ClusterRoleBindingListApiVersion -> V1ClusterRoleBindingList { v1ClusterRoleBindingListApiVersion, ..} ) <$> f v1ClusterRoleBindingListApiVersion
{-# INLINE v1ClusterRoleBindingListApiVersionL #-}

-- | 'v1ClusterRoleBindingListItems' Lens
v1ClusterRoleBindingListItemsL :: Lens_' V1ClusterRoleBindingList ([V1ClusterRoleBinding])
v1ClusterRoleBindingListItemsL f V1ClusterRoleBindingList{..} = (\v1ClusterRoleBindingListItems -> V1ClusterRoleBindingList { v1ClusterRoleBindingListItems, ..} ) <$> f v1ClusterRoleBindingListItems
{-# INLINE v1ClusterRoleBindingListItemsL #-}

-- | 'v1ClusterRoleBindingListKind' Lens
v1ClusterRoleBindingListKindL :: Lens_' V1ClusterRoleBindingList (Maybe Text)
v1ClusterRoleBindingListKindL f V1ClusterRoleBindingList{..} = (\v1ClusterRoleBindingListKind -> V1ClusterRoleBindingList { v1ClusterRoleBindingListKind, ..} ) <$> f v1ClusterRoleBindingListKind
{-# INLINE v1ClusterRoleBindingListKindL #-}

-- | 'v1ClusterRoleBindingListMetadata' Lens
v1ClusterRoleBindingListMetadataL :: Lens_' V1ClusterRoleBindingList (Maybe V1ListMeta)
v1ClusterRoleBindingListMetadataL f V1ClusterRoleBindingList{..} = (\v1ClusterRoleBindingListMetadata -> V1ClusterRoleBindingList { v1ClusterRoleBindingListMetadata, ..} ) <$> f v1ClusterRoleBindingListMetadata
{-# INLINE v1ClusterRoleBindingListMetadataL #-}



-- * V1ClusterRoleList

-- | 'v1ClusterRoleListApiVersion' Lens
v1ClusterRoleListApiVersionL :: Lens_' V1ClusterRoleList (Maybe Text)
v1ClusterRoleListApiVersionL f V1ClusterRoleList{..} = (\v1ClusterRoleListApiVersion -> V1ClusterRoleList { v1ClusterRoleListApiVersion, ..} ) <$> f v1ClusterRoleListApiVersion
{-# INLINE v1ClusterRoleListApiVersionL #-}

-- | 'v1ClusterRoleListItems' Lens
v1ClusterRoleListItemsL :: Lens_' V1ClusterRoleList ([V1ClusterRole])
v1ClusterRoleListItemsL f V1ClusterRoleList{..} = (\v1ClusterRoleListItems -> V1ClusterRoleList { v1ClusterRoleListItems, ..} ) <$> f v1ClusterRoleListItems
{-# INLINE v1ClusterRoleListItemsL #-}

-- | 'v1ClusterRoleListKind' Lens
v1ClusterRoleListKindL :: Lens_' V1ClusterRoleList (Maybe Text)
v1ClusterRoleListKindL f V1ClusterRoleList{..} = (\v1ClusterRoleListKind -> V1ClusterRoleList { v1ClusterRoleListKind, ..} ) <$> f v1ClusterRoleListKind
{-# INLINE v1ClusterRoleListKindL #-}

-- | 'v1ClusterRoleListMetadata' Lens
v1ClusterRoleListMetadataL :: Lens_' V1ClusterRoleList (Maybe V1ListMeta)
v1ClusterRoleListMetadataL f V1ClusterRoleList{..} = (\v1ClusterRoleListMetadata -> V1ClusterRoleList { v1ClusterRoleListMetadata, ..} ) <$> f v1ClusterRoleListMetadata
{-# INLINE v1ClusterRoleListMetadataL #-}



-- * V1ComponentCondition

-- | 'v1ComponentConditionError' Lens
v1ComponentConditionErrorL :: Lens_' V1ComponentCondition (Maybe Text)
v1ComponentConditionErrorL f V1ComponentCondition{..} = (\v1ComponentConditionError -> V1ComponentCondition { v1ComponentConditionError, ..} ) <$> f v1ComponentConditionError
{-# INLINE v1ComponentConditionErrorL #-}

-- | 'v1ComponentConditionMessage' Lens
v1ComponentConditionMessageL :: Lens_' V1ComponentCondition (Maybe Text)
v1ComponentConditionMessageL f V1ComponentCondition{..} = (\v1ComponentConditionMessage -> V1ComponentCondition { v1ComponentConditionMessage, ..} ) <$> f v1ComponentConditionMessage
{-# INLINE v1ComponentConditionMessageL #-}

-- | 'v1ComponentConditionStatus' Lens
v1ComponentConditionStatusL :: Lens_' V1ComponentCondition (Text)
v1ComponentConditionStatusL f V1ComponentCondition{..} = (\v1ComponentConditionStatus -> V1ComponentCondition { v1ComponentConditionStatus, ..} ) <$> f v1ComponentConditionStatus
{-# INLINE v1ComponentConditionStatusL #-}

-- | 'v1ComponentConditionType' Lens
v1ComponentConditionTypeL :: Lens_' V1ComponentCondition (Text)
v1ComponentConditionTypeL f V1ComponentCondition{..} = (\v1ComponentConditionType -> V1ComponentCondition { v1ComponentConditionType, ..} ) <$> f v1ComponentConditionType
{-# INLINE v1ComponentConditionTypeL #-}



-- * V1ComponentStatus

-- | 'v1ComponentStatusApiVersion' Lens
v1ComponentStatusApiVersionL :: Lens_' V1ComponentStatus (Maybe Text)
v1ComponentStatusApiVersionL f V1ComponentStatus{..} = (\v1ComponentStatusApiVersion -> V1ComponentStatus { v1ComponentStatusApiVersion, ..} ) <$> f v1ComponentStatusApiVersion
{-# INLINE v1ComponentStatusApiVersionL #-}

-- | 'v1ComponentStatusConditions' Lens
v1ComponentStatusConditionsL :: Lens_' V1ComponentStatus (Maybe [V1ComponentCondition])
v1ComponentStatusConditionsL f V1ComponentStatus{..} = (\v1ComponentStatusConditions -> V1ComponentStatus { v1ComponentStatusConditions, ..} ) <$> f v1ComponentStatusConditions
{-# INLINE v1ComponentStatusConditionsL #-}

-- | 'v1ComponentStatusKind' Lens
v1ComponentStatusKindL :: Lens_' V1ComponentStatus (Maybe Text)
v1ComponentStatusKindL f V1ComponentStatus{..} = (\v1ComponentStatusKind -> V1ComponentStatus { v1ComponentStatusKind, ..} ) <$> f v1ComponentStatusKind
{-# INLINE v1ComponentStatusKindL #-}

-- | 'v1ComponentStatusMetadata' Lens
v1ComponentStatusMetadataL :: Lens_' V1ComponentStatus (Maybe V1ObjectMeta)
v1ComponentStatusMetadataL f V1ComponentStatus{..} = (\v1ComponentStatusMetadata -> V1ComponentStatus { v1ComponentStatusMetadata, ..} ) <$> f v1ComponentStatusMetadata
{-# INLINE v1ComponentStatusMetadataL #-}



-- * V1ComponentStatusList

-- | 'v1ComponentStatusListApiVersion' Lens
v1ComponentStatusListApiVersionL :: Lens_' V1ComponentStatusList (Maybe Text)
v1ComponentStatusListApiVersionL f V1ComponentStatusList{..} = (\v1ComponentStatusListApiVersion -> V1ComponentStatusList { v1ComponentStatusListApiVersion, ..} ) <$> f v1ComponentStatusListApiVersion
{-# INLINE v1ComponentStatusListApiVersionL #-}

-- | 'v1ComponentStatusListItems' Lens
v1ComponentStatusListItemsL :: Lens_' V1ComponentStatusList ([V1ComponentStatus])
v1ComponentStatusListItemsL f V1ComponentStatusList{..} = (\v1ComponentStatusListItems -> V1ComponentStatusList { v1ComponentStatusListItems, ..} ) <$> f v1ComponentStatusListItems
{-# INLINE v1ComponentStatusListItemsL #-}

-- | 'v1ComponentStatusListKind' Lens
v1ComponentStatusListKindL :: Lens_' V1ComponentStatusList (Maybe Text)
v1ComponentStatusListKindL f V1ComponentStatusList{..} = (\v1ComponentStatusListKind -> V1ComponentStatusList { v1ComponentStatusListKind, ..} ) <$> f v1ComponentStatusListKind
{-# INLINE v1ComponentStatusListKindL #-}

-- | 'v1ComponentStatusListMetadata' Lens
v1ComponentStatusListMetadataL :: Lens_' V1ComponentStatusList (Maybe V1ListMeta)
v1ComponentStatusListMetadataL f V1ComponentStatusList{..} = (\v1ComponentStatusListMetadata -> V1ComponentStatusList { v1ComponentStatusListMetadata, ..} ) <$> f v1ComponentStatusListMetadata
{-# INLINE v1ComponentStatusListMetadataL #-}



-- * V1Condition

-- | 'v1ConditionLastTransitionTime' Lens
v1ConditionLastTransitionTimeL :: Lens_' V1Condition (DateTime)
v1ConditionLastTransitionTimeL f V1Condition{..} = (\v1ConditionLastTransitionTime -> V1Condition { v1ConditionLastTransitionTime, ..} ) <$> f v1ConditionLastTransitionTime
{-# INLINE v1ConditionLastTransitionTimeL #-}

-- | 'v1ConditionMessage' Lens
v1ConditionMessageL :: Lens_' V1Condition (Text)
v1ConditionMessageL f V1Condition{..} = (\v1ConditionMessage -> V1Condition { v1ConditionMessage, ..} ) <$> f v1ConditionMessage
{-# INLINE v1ConditionMessageL #-}

-- | 'v1ConditionObservedGeneration' Lens
v1ConditionObservedGenerationL :: Lens_' V1Condition (Maybe Integer)
v1ConditionObservedGenerationL f V1Condition{..} = (\v1ConditionObservedGeneration -> V1Condition { v1ConditionObservedGeneration, ..} ) <$> f v1ConditionObservedGeneration
{-# INLINE v1ConditionObservedGenerationL #-}

-- | 'v1ConditionReason' Lens
v1ConditionReasonL :: Lens_' V1Condition (Text)
v1ConditionReasonL f V1Condition{..} = (\v1ConditionReason -> V1Condition { v1ConditionReason, ..} ) <$> f v1ConditionReason
{-# INLINE v1ConditionReasonL #-}

-- | 'v1ConditionStatus' Lens
v1ConditionStatusL :: Lens_' V1Condition (Text)
v1ConditionStatusL f V1Condition{..} = (\v1ConditionStatus -> V1Condition { v1ConditionStatus, ..} ) <$> f v1ConditionStatus
{-# INLINE v1ConditionStatusL #-}

-- | 'v1ConditionType' Lens
v1ConditionTypeL :: Lens_' V1Condition (Text)
v1ConditionTypeL f V1Condition{..} = (\v1ConditionType -> V1Condition { v1ConditionType, ..} ) <$> f v1ConditionType
{-# INLINE v1ConditionTypeL #-}



-- * V1ConfigMap

-- | 'v1ConfigMapApiVersion' Lens
v1ConfigMapApiVersionL :: Lens_' V1ConfigMap (Maybe Text)
v1ConfigMapApiVersionL f V1ConfigMap{..} = (\v1ConfigMapApiVersion -> V1ConfigMap { v1ConfigMapApiVersion, ..} ) <$> f v1ConfigMapApiVersion
{-# INLINE v1ConfigMapApiVersionL #-}

-- | 'v1ConfigMapBinaryData' Lens
v1ConfigMapBinaryDataL :: Lens_' V1ConfigMap (Maybe (Map.Map String ByteArray))
v1ConfigMapBinaryDataL f V1ConfigMap{..} = (\v1ConfigMapBinaryData -> V1ConfigMap { v1ConfigMapBinaryData, ..} ) <$> f v1ConfigMapBinaryData
{-# INLINE v1ConfigMapBinaryDataL #-}

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

-- | 'v1ConfigMapImmutable' Lens
v1ConfigMapImmutableL :: Lens_' V1ConfigMap (Maybe Bool)
v1ConfigMapImmutableL f V1ConfigMap{..} = (\v1ConfigMapImmutable -> V1ConfigMap { v1ConfigMapImmutable, ..} ) <$> f v1ConfigMapImmutable
{-# INLINE v1ConfigMapImmutableL #-}

-- | 'v1ConfigMapKind' Lens
v1ConfigMapKindL :: Lens_' V1ConfigMap (Maybe Text)
v1ConfigMapKindL f V1ConfigMap{..} = (\v1ConfigMapKind -> V1ConfigMap { v1ConfigMapKind, ..} ) <$> f v1ConfigMapKind
{-# INLINE v1ConfigMapKindL #-}

-- | 'v1ConfigMapMetadata' Lens
v1ConfigMapMetadataL :: Lens_' V1ConfigMap (Maybe V1ObjectMeta)
v1ConfigMapMetadataL f V1ConfigMap{..} = (\v1ConfigMapMetadata -> V1ConfigMap { v1ConfigMapMetadata, ..} ) <$> f v1ConfigMapMetadata
{-# INLINE v1ConfigMapMetadataL #-}



-- * V1ConfigMapEnvSource

-- | 'v1ConfigMapEnvSourceName' Lens
v1ConfigMapEnvSourceNameL :: Lens_' V1ConfigMapEnvSource (Maybe Text)
v1ConfigMapEnvSourceNameL f V1ConfigMapEnvSource{..} = (\v1ConfigMapEnvSourceName -> V1ConfigMapEnvSource { v1ConfigMapEnvSourceName, ..} ) <$> f v1ConfigMapEnvSourceName
{-# INLINE v1ConfigMapEnvSourceNameL #-}

-- | 'v1ConfigMapEnvSourceOptional' Lens
v1ConfigMapEnvSourceOptionalL :: Lens_' V1ConfigMapEnvSource (Maybe Bool)
v1ConfigMapEnvSourceOptionalL f V1ConfigMapEnvSource{..} = (\v1ConfigMapEnvSourceOptional -> V1ConfigMapEnvSource { v1ConfigMapEnvSourceOptional, ..} ) <$> f v1ConfigMapEnvSourceOptional
{-# INLINE v1ConfigMapEnvSourceOptionalL #-}



-- * V1ConfigMapKeySelector

-- | 'v1ConfigMapKeySelectorKey' Lens
v1ConfigMapKeySelectorKeyL :: Lens_' V1ConfigMapKeySelector (Text)
v1ConfigMapKeySelectorKeyL f V1ConfigMapKeySelector{..} = (\v1ConfigMapKeySelectorKey -> V1ConfigMapKeySelector { v1ConfigMapKeySelectorKey, ..} ) <$> f v1ConfigMapKeySelectorKey
{-# INLINE v1ConfigMapKeySelectorKeyL #-}

-- | 'v1ConfigMapKeySelectorName' Lens
v1ConfigMapKeySelectorNameL :: Lens_' V1ConfigMapKeySelector (Maybe Text)
v1ConfigMapKeySelectorNameL f V1ConfigMapKeySelector{..} = (\v1ConfigMapKeySelectorName -> V1ConfigMapKeySelector { v1ConfigMapKeySelectorName, ..} ) <$> f v1ConfigMapKeySelectorName
{-# INLINE v1ConfigMapKeySelectorNameL #-}

-- | 'v1ConfigMapKeySelectorOptional' Lens
v1ConfigMapKeySelectorOptionalL :: Lens_' V1ConfigMapKeySelector (Maybe Bool)
v1ConfigMapKeySelectorOptionalL f V1ConfigMapKeySelector{..} = (\v1ConfigMapKeySelectorOptional -> V1ConfigMapKeySelector { v1ConfigMapKeySelectorOptional, ..} ) <$> f v1ConfigMapKeySelectorOptional
{-# INLINE v1ConfigMapKeySelectorOptionalL #-}



-- * V1ConfigMapList

-- | 'v1ConfigMapListApiVersion' Lens
v1ConfigMapListApiVersionL :: Lens_' V1ConfigMapList (Maybe Text)
v1ConfigMapListApiVersionL f V1ConfigMapList{..} = (\v1ConfigMapListApiVersion -> V1ConfigMapList { v1ConfigMapListApiVersion, ..} ) <$> f v1ConfigMapListApiVersion
{-# INLINE v1ConfigMapListApiVersionL #-}

-- | 'v1ConfigMapListItems' Lens
v1ConfigMapListItemsL :: Lens_' V1ConfigMapList ([V1ConfigMap])
v1ConfigMapListItemsL f V1ConfigMapList{..} = (\v1ConfigMapListItems -> V1ConfigMapList { v1ConfigMapListItems, ..} ) <$> f v1ConfigMapListItems
{-# INLINE v1ConfigMapListItemsL #-}

-- | 'v1ConfigMapListKind' Lens
v1ConfigMapListKindL :: Lens_' V1ConfigMapList (Maybe Text)
v1ConfigMapListKindL f V1ConfigMapList{..} = (\v1ConfigMapListKind -> V1ConfigMapList { v1ConfigMapListKind, ..} ) <$> f v1ConfigMapListKind
{-# INLINE v1ConfigMapListKindL #-}

-- | 'v1ConfigMapListMetadata' Lens
v1ConfigMapListMetadataL :: Lens_' V1ConfigMapList (Maybe V1ListMeta)
v1ConfigMapListMetadataL f V1ConfigMapList{..} = (\v1ConfigMapListMetadata -> V1ConfigMapList { v1ConfigMapListMetadata, ..} ) <$> f v1ConfigMapListMetadata
{-# INLINE v1ConfigMapListMetadataL #-}



-- * V1ConfigMapNodeConfigSource

-- | 'v1ConfigMapNodeConfigSourceKubeletConfigKey' Lens
v1ConfigMapNodeConfigSourceKubeletConfigKeyL :: Lens_' V1ConfigMapNodeConfigSource (Text)
v1ConfigMapNodeConfigSourceKubeletConfigKeyL f V1ConfigMapNodeConfigSource{..} = (\v1ConfigMapNodeConfigSourceKubeletConfigKey -> V1ConfigMapNodeConfigSource { v1ConfigMapNodeConfigSourceKubeletConfigKey, ..} ) <$> f v1ConfigMapNodeConfigSourceKubeletConfigKey
{-# INLINE v1ConfigMapNodeConfigSourceKubeletConfigKeyL #-}

-- | 'v1ConfigMapNodeConfigSourceName' Lens
v1ConfigMapNodeConfigSourceNameL :: Lens_' V1ConfigMapNodeConfigSource (Text)
v1ConfigMapNodeConfigSourceNameL f V1ConfigMapNodeConfigSource{..} = (\v1ConfigMapNodeConfigSourceName -> V1ConfigMapNodeConfigSource { v1ConfigMapNodeConfigSourceName, ..} ) <$> f v1ConfigMapNodeConfigSourceName
{-# INLINE v1ConfigMapNodeConfigSourceNameL #-}

-- | 'v1ConfigMapNodeConfigSourceNamespace' Lens
v1ConfigMapNodeConfigSourceNamespaceL :: Lens_' V1ConfigMapNodeConfigSource (Text)
v1ConfigMapNodeConfigSourceNamespaceL f V1ConfigMapNodeConfigSource{..} = (\v1ConfigMapNodeConfigSourceNamespace -> V1ConfigMapNodeConfigSource { v1ConfigMapNodeConfigSourceNamespace, ..} ) <$> f v1ConfigMapNodeConfigSourceNamespace
{-# INLINE v1ConfigMapNodeConfigSourceNamespaceL #-}

-- | 'v1ConfigMapNodeConfigSourceResourceVersion' Lens
v1ConfigMapNodeConfigSourceResourceVersionL :: Lens_' V1ConfigMapNodeConfigSource (Maybe Text)
v1ConfigMapNodeConfigSourceResourceVersionL f V1ConfigMapNodeConfigSource{..} = (\v1ConfigMapNodeConfigSourceResourceVersion -> V1ConfigMapNodeConfigSource { v1ConfigMapNodeConfigSourceResourceVersion, ..} ) <$> f v1ConfigMapNodeConfigSourceResourceVersion
{-# INLINE v1ConfigMapNodeConfigSourceResourceVersionL #-}

-- | 'v1ConfigMapNodeConfigSourceUid' Lens
v1ConfigMapNodeConfigSourceUidL :: Lens_' V1ConfigMapNodeConfigSource (Maybe Text)
v1ConfigMapNodeConfigSourceUidL f V1ConfigMapNodeConfigSource{..} = (\v1ConfigMapNodeConfigSourceUid -> V1ConfigMapNodeConfigSource { v1ConfigMapNodeConfigSourceUid, ..} ) <$> f v1ConfigMapNodeConfigSourceUid
{-# INLINE v1ConfigMapNodeConfigSourceUidL #-}



-- * V1ConfigMapProjection

-- | 'v1ConfigMapProjectionItems' Lens
v1ConfigMapProjectionItemsL :: Lens_' V1ConfigMapProjection (Maybe [V1KeyToPath])
v1ConfigMapProjectionItemsL f V1ConfigMapProjection{..} = (\v1ConfigMapProjectionItems -> V1ConfigMapProjection { v1ConfigMapProjectionItems, ..} ) <$> f v1ConfigMapProjectionItems
{-# INLINE v1ConfigMapProjectionItemsL #-}

-- | 'v1ConfigMapProjectionName' Lens
v1ConfigMapProjectionNameL :: Lens_' V1ConfigMapProjection (Maybe Text)
v1ConfigMapProjectionNameL f V1ConfigMapProjection{..} = (\v1ConfigMapProjectionName -> V1ConfigMapProjection { v1ConfigMapProjectionName, ..} ) <$> f v1ConfigMapProjectionName
{-# INLINE v1ConfigMapProjectionNameL #-}

-- | 'v1ConfigMapProjectionOptional' Lens
v1ConfigMapProjectionOptionalL :: Lens_' V1ConfigMapProjection (Maybe Bool)
v1ConfigMapProjectionOptionalL f V1ConfigMapProjection{..} = (\v1ConfigMapProjectionOptional -> V1ConfigMapProjection { v1ConfigMapProjectionOptional, ..} ) <$> f v1ConfigMapProjectionOptional
{-# INLINE v1ConfigMapProjectionOptionalL #-}



-- * V1ConfigMapVolumeSource

-- | 'v1ConfigMapVolumeSourceDefaultMode' Lens
v1ConfigMapVolumeSourceDefaultModeL :: Lens_' V1ConfigMapVolumeSource (Maybe Int)
v1ConfigMapVolumeSourceDefaultModeL f V1ConfigMapVolumeSource{..} = (\v1ConfigMapVolumeSourceDefaultMode -> V1ConfigMapVolumeSource { v1ConfigMapVolumeSourceDefaultMode, ..} ) <$> f v1ConfigMapVolumeSourceDefaultMode
{-# INLINE v1ConfigMapVolumeSourceDefaultModeL #-}

-- | 'v1ConfigMapVolumeSourceItems' Lens
v1ConfigMapVolumeSourceItemsL :: Lens_' V1ConfigMapVolumeSource (Maybe [V1KeyToPath])
v1ConfigMapVolumeSourceItemsL f V1ConfigMapVolumeSource{..} = (\v1ConfigMapVolumeSourceItems -> V1ConfigMapVolumeSource { v1ConfigMapVolumeSourceItems, ..} ) <$> f v1ConfigMapVolumeSourceItems
{-# INLINE v1ConfigMapVolumeSourceItemsL #-}

-- | 'v1ConfigMapVolumeSourceName' Lens
v1ConfigMapVolumeSourceNameL :: Lens_' V1ConfigMapVolumeSource (Maybe Text)
v1ConfigMapVolumeSourceNameL f V1ConfigMapVolumeSource{..} = (\v1ConfigMapVolumeSourceName -> V1ConfigMapVolumeSource { v1ConfigMapVolumeSourceName, ..} ) <$> f v1ConfigMapVolumeSourceName
{-# INLINE v1ConfigMapVolumeSourceNameL #-}

-- | 'v1ConfigMapVolumeSourceOptional' Lens
v1ConfigMapVolumeSourceOptionalL :: Lens_' V1ConfigMapVolumeSource (Maybe Bool)
v1ConfigMapVolumeSourceOptionalL f V1ConfigMapVolumeSource{..} = (\v1ConfigMapVolumeSourceOptional -> V1ConfigMapVolumeSource { v1ConfigMapVolumeSourceOptional, ..} ) <$> f v1ConfigMapVolumeSourceOptional
{-# INLINE v1ConfigMapVolumeSourceOptionalL #-}



-- * V1Container

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

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

-- | 'v1ContainerEnv' Lens
v1ContainerEnvL :: Lens_' V1Container (Maybe [V1EnvVar])
v1ContainerEnvL f V1Container{..} = (\v1ContainerEnv -> V1Container { v1ContainerEnv, ..} ) <$> f v1ContainerEnv
{-# INLINE v1ContainerEnvL #-}

-- | 'v1ContainerEnvFrom' Lens
v1ContainerEnvFromL :: Lens_' V1Container (Maybe [V1EnvFromSource])
v1ContainerEnvFromL f V1Container{..} = (\v1ContainerEnvFrom -> V1Container { v1ContainerEnvFrom, ..} ) <$> f v1ContainerEnvFrom
{-# INLINE v1ContainerEnvFromL #-}

-- | 'v1ContainerImage' Lens
v1ContainerImageL :: Lens_' V1Container (Maybe Text)
v1ContainerImageL f V1Container{..} = (\v1ContainerImage -> V1Container { v1ContainerImage, ..} ) <$> f v1ContainerImage
{-# INLINE v1ContainerImageL #-}

-- | 'v1ContainerImagePullPolicy' Lens
v1ContainerImagePullPolicyL :: Lens_' V1Container (Maybe Text)
v1ContainerImagePullPolicyL f V1Container{..} = (\v1ContainerImagePullPolicy -> V1Container { v1ContainerImagePullPolicy, ..} ) <$> f v1ContainerImagePullPolicy
{-# INLINE v1ContainerImagePullPolicyL #-}

-- | 'v1ContainerLifecycle' Lens
v1ContainerLifecycleL :: Lens_' V1Container (Maybe V1Lifecycle)
v1ContainerLifecycleL f V1Container{..} = (\v1ContainerLifecycle -> V1Container { v1ContainerLifecycle, ..} ) <$> f v1ContainerLifecycle
{-# INLINE v1ContainerLifecycleL #-}

-- | 'v1ContainerLivenessProbe' Lens
v1ContainerLivenessProbeL :: Lens_' V1Container (Maybe V1Probe)
v1ContainerLivenessProbeL f V1Container{..} = (\v1ContainerLivenessProbe -> V1Container { v1ContainerLivenessProbe, ..} ) <$> f v1ContainerLivenessProbe
{-# INLINE v1ContainerLivenessProbeL #-}

-- | 'v1ContainerName' Lens
v1ContainerNameL :: Lens_' V1Container (Text)
v1ContainerNameL f V1Container{..} = (\v1ContainerName -> V1Container { v1ContainerName, ..} ) <$> f v1ContainerName
{-# INLINE v1ContainerNameL #-}

-- | 'v1ContainerPorts' Lens
v1ContainerPortsL :: Lens_' V1Container (Maybe [V1ContainerPort])
v1ContainerPortsL f V1Container{..} = (\v1ContainerPorts -> V1Container { v1ContainerPorts, ..} ) <$> f v1ContainerPorts
{-# INLINE v1ContainerPortsL #-}

-- | 'v1ContainerReadinessProbe' Lens
v1ContainerReadinessProbeL :: Lens_' V1Container (Maybe V1Probe)
v1ContainerReadinessProbeL f V1Container{..} = (\v1ContainerReadinessProbe -> V1Container { v1ContainerReadinessProbe, ..} ) <$> f v1ContainerReadinessProbe
{-# INLINE v1ContainerReadinessProbeL #-}

-- | 'v1ContainerResources' Lens
v1ContainerResourcesL :: Lens_' V1Container (Maybe V1ResourceRequirements)
v1ContainerResourcesL f V1Container{..} = (\v1ContainerResources -> V1Container { v1ContainerResources, ..} ) <$> f v1ContainerResources
{-# INLINE v1ContainerResourcesL #-}

-- | 'v1ContainerSecurityContext' Lens
v1ContainerSecurityContextL :: Lens_' V1Container (Maybe V1SecurityContext)
v1ContainerSecurityContextL f V1Container{..} = (\v1ContainerSecurityContext -> V1Container { v1ContainerSecurityContext, ..} ) <$> f v1ContainerSecurityContext
{-# INLINE v1ContainerSecurityContextL #-}

-- | 'v1ContainerStartupProbe' Lens
v1ContainerStartupProbeL :: Lens_' V1Container (Maybe V1Probe)
v1ContainerStartupProbeL f V1Container{..} = (\v1ContainerStartupProbe -> V1Container { v1ContainerStartupProbe, ..} ) <$> f v1ContainerStartupProbe
{-# INLINE v1ContainerStartupProbeL #-}

-- | 'v1ContainerStdin' Lens
v1ContainerStdinL :: Lens_' V1Container (Maybe Bool)
v1ContainerStdinL f V1Container{..} = (\v1ContainerStdin -> V1Container { v1ContainerStdin, ..} ) <$> f v1ContainerStdin
{-# INLINE v1ContainerStdinL #-}

-- | 'v1ContainerStdinOnce' Lens
v1ContainerStdinOnceL :: Lens_' V1Container (Maybe Bool)
v1ContainerStdinOnceL f V1Container{..} = (\v1ContainerStdinOnce -> V1Container { v1ContainerStdinOnce, ..} ) <$> f v1ContainerStdinOnce
{-# INLINE v1ContainerStdinOnceL #-}

-- | 'v1ContainerTerminationMessagePath' Lens
v1ContainerTerminationMessagePathL :: Lens_' V1Container (Maybe Text)
v1ContainerTerminationMessagePathL f V1Container{..} = (\v1ContainerTerminationMessagePath -> V1Container { v1ContainerTerminationMessagePath, ..} ) <$> f v1ContainerTerminationMessagePath
{-# INLINE v1ContainerTerminationMessagePathL #-}

-- | 'v1ContainerTerminationMessagePolicy' Lens
v1ContainerTerminationMessagePolicyL :: Lens_' V1Container (Maybe Text)
v1ContainerTerminationMessagePolicyL f V1Container{..} = (\v1ContainerTerminationMessagePolicy -> V1Container { v1ContainerTerminationMessagePolicy, ..} ) <$> f v1ContainerTerminationMessagePolicy
{-# INLINE v1ContainerTerminationMessagePolicyL #-}

-- | 'v1ContainerTty' Lens
v1ContainerTtyL :: Lens_' V1Container (Maybe Bool)
v1ContainerTtyL f V1Container{..} = (\v1ContainerTty -> V1Container { v1ContainerTty, ..} ) <$> f v1ContainerTty
{-# INLINE v1ContainerTtyL #-}

-- | 'v1ContainerVolumeDevices' Lens
v1ContainerVolumeDevicesL :: Lens_' V1Container (Maybe [V1VolumeDevice])
v1ContainerVolumeDevicesL f V1Container{..} = (\v1ContainerVolumeDevices -> V1Container { v1ContainerVolumeDevices, ..} ) <$> f v1ContainerVolumeDevices
{-# INLINE v1ContainerVolumeDevicesL #-}

-- | 'v1ContainerVolumeMounts' Lens
v1ContainerVolumeMountsL :: Lens_' V1Container (Maybe [V1VolumeMount])
v1ContainerVolumeMountsL f V1Container{..} = (\v1ContainerVolumeMounts -> V1Container { v1ContainerVolumeMounts, ..} ) <$> f v1ContainerVolumeMounts
{-# INLINE v1ContainerVolumeMountsL #-}

-- | 'v1ContainerWorkingDir' Lens
v1ContainerWorkingDirL :: Lens_' V1Container (Maybe Text)
v1ContainerWorkingDirL f V1Container{..} = (\v1ContainerWorkingDir -> V1Container { v1ContainerWorkingDir, ..} ) <$> f v1ContainerWorkingDir
{-# INLINE v1ContainerWorkingDirL #-}



-- * V1ContainerImage

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

-- | 'v1ContainerImageSizeBytes' Lens
v1ContainerImageSizeBytesL :: Lens_' V1ContainerImage (Maybe Integer)
v1ContainerImageSizeBytesL f V1ContainerImage{..} = (\v1ContainerImageSizeBytes -> V1ContainerImage { v1ContainerImageSizeBytes, ..} ) <$> f v1ContainerImageSizeBytes
{-# INLINE v1ContainerImageSizeBytesL #-}



-- * V1ContainerPort

-- | 'v1ContainerPortContainerPort' Lens
v1ContainerPortContainerPortL :: Lens_' V1ContainerPort (Int)
v1ContainerPortContainerPortL f V1ContainerPort{..} = (\v1ContainerPortContainerPort -> V1ContainerPort { v1ContainerPortContainerPort, ..} ) <$> f v1ContainerPortContainerPort
{-# INLINE v1ContainerPortContainerPortL #-}

-- | 'v1ContainerPortHostIp' Lens
v1ContainerPortHostIpL :: Lens_' V1ContainerPort (Maybe Text)
v1ContainerPortHostIpL f V1ContainerPort{..} = (\v1ContainerPortHostIp -> V1ContainerPort { v1ContainerPortHostIp, ..} ) <$> f v1ContainerPortHostIp
{-# INLINE v1ContainerPortHostIpL #-}

-- | 'v1ContainerPortHostPort' Lens
v1ContainerPortHostPortL :: Lens_' V1ContainerPort (Maybe Int)
v1ContainerPortHostPortL f V1ContainerPort{..} = (\v1ContainerPortHostPort -> V1ContainerPort { v1ContainerPortHostPort, ..} ) <$> f v1ContainerPortHostPort
{-# INLINE v1ContainerPortHostPortL #-}

-- | 'v1ContainerPortName' Lens
v1ContainerPortNameL :: Lens_' V1ContainerPort (Maybe Text)
v1ContainerPortNameL f V1ContainerPort{..} = (\v1ContainerPortName -> V1ContainerPort { v1ContainerPortName, ..} ) <$> f v1ContainerPortName
{-# INLINE v1ContainerPortNameL #-}

-- | 'v1ContainerPortProtocol' Lens
v1ContainerPortProtocolL :: Lens_' V1ContainerPort (Maybe Text)
v1ContainerPortProtocolL f V1ContainerPort{..} = (\v1ContainerPortProtocol -> V1ContainerPort { v1ContainerPortProtocol, ..} ) <$> f v1ContainerPortProtocol
{-# INLINE v1ContainerPortProtocolL #-}



-- * V1ContainerState

-- | 'v1ContainerStateRunning' Lens
v1ContainerStateRunningL :: Lens_' V1ContainerState (Maybe V1ContainerStateRunning)
v1ContainerStateRunningL f V1ContainerState{..} = (\v1ContainerStateRunning -> V1ContainerState { v1ContainerStateRunning, ..} ) <$> f v1ContainerStateRunning
{-# INLINE v1ContainerStateRunningL #-}

-- | 'v1ContainerStateTerminated' Lens
v1ContainerStateTerminatedL :: Lens_' V1ContainerState (Maybe V1ContainerStateTerminated)
v1ContainerStateTerminatedL f V1ContainerState{..} = (\v1ContainerStateTerminated -> V1ContainerState { v1ContainerStateTerminated, ..} ) <$> f v1ContainerStateTerminated
{-# INLINE v1ContainerStateTerminatedL #-}

-- | 'v1ContainerStateWaiting' Lens
v1ContainerStateWaitingL :: Lens_' V1ContainerState (Maybe V1ContainerStateWaiting)
v1ContainerStateWaitingL f V1ContainerState{..} = (\v1ContainerStateWaiting -> V1ContainerState { v1ContainerStateWaiting, ..} ) <$> f v1ContainerStateWaiting
{-# INLINE v1ContainerStateWaitingL #-}



-- * V1ContainerStateRunning

-- | 'v1ContainerStateRunningStartedAt' Lens
v1ContainerStateRunningStartedAtL :: Lens_' V1ContainerStateRunning (Maybe DateTime)
v1ContainerStateRunningStartedAtL f V1ContainerStateRunning{..} = (\v1ContainerStateRunningStartedAt -> V1ContainerStateRunning { v1ContainerStateRunningStartedAt, ..} ) <$> f v1ContainerStateRunningStartedAt
{-# INLINE v1ContainerStateRunningStartedAtL #-}



-- * V1ContainerStateTerminated

-- | 'v1ContainerStateTerminatedContainerId' Lens
v1ContainerStateTerminatedContainerIdL :: Lens_' V1ContainerStateTerminated (Maybe Text)
v1ContainerStateTerminatedContainerIdL f V1ContainerStateTerminated{..} = (\v1ContainerStateTerminatedContainerId -> V1ContainerStateTerminated { v1ContainerStateTerminatedContainerId, ..} ) <$> f v1ContainerStateTerminatedContainerId
{-# INLINE v1ContainerStateTerminatedContainerIdL #-}

-- | 'v1ContainerStateTerminatedExitCode' Lens
v1ContainerStateTerminatedExitCodeL :: Lens_' V1ContainerStateTerminated (Int)
v1ContainerStateTerminatedExitCodeL f V1ContainerStateTerminated{..} = (\v1ContainerStateTerminatedExitCode -> V1ContainerStateTerminated { v1ContainerStateTerminatedExitCode, ..} ) <$> f v1ContainerStateTerminatedExitCode
{-# INLINE v1ContainerStateTerminatedExitCodeL #-}

-- | 'v1ContainerStateTerminatedFinishedAt' Lens
v1ContainerStateTerminatedFinishedAtL :: Lens_' V1ContainerStateTerminated (Maybe DateTime)
v1ContainerStateTerminatedFinishedAtL f V1ContainerStateTerminated{..} = (\v1ContainerStateTerminatedFinishedAt -> V1ContainerStateTerminated { v1ContainerStateTerminatedFinishedAt, ..} ) <$> f v1ContainerStateTerminatedFinishedAt
{-# INLINE v1ContainerStateTerminatedFinishedAtL #-}

-- | 'v1ContainerStateTerminatedMessage' Lens
v1ContainerStateTerminatedMessageL :: Lens_' V1ContainerStateTerminated (Maybe Text)
v1ContainerStateTerminatedMessageL f V1ContainerStateTerminated{..} = (\v1ContainerStateTerminatedMessage -> V1ContainerStateTerminated { v1ContainerStateTerminatedMessage, ..} ) <$> f v1ContainerStateTerminatedMessage
{-# INLINE v1ContainerStateTerminatedMessageL #-}

-- | 'v1ContainerStateTerminatedReason' Lens
v1ContainerStateTerminatedReasonL :: Lens_' V1ContainerStateTerminated (Maybe Text)
v1ContainerStateTerminatedReasonL f V1ContainerStateTerminated{..} = (\v1ContainerStateTerminatedReason -> V1ContainerStateTerminated { v1ContainerStateTerminatedReason, ..} ) <$> f v1ContainerStateTerminatedReason
{-# INLINE v1ContainerStateTerminatedReasonL #-}

-- | 'v1ContainerStateTerminatedSignal' Lens
v1ContainerStateTerminatedSignalL :: Lens_' V1ContainerStateTerminated (Maybe Int)
v1ContainerStateTerminatedSignalL f V1ContainerStateTerminated{..} = (\v1ContainerStateTerminatedSignal -> V1ContainerStateTerminated { v1ContainerStateTerminatedSignal, ..} ) <$> f v1ContainerStateTerminatedSignal
{-# INLINE v1ContainerStateTerminatedSignalL #-}

-- | 'v1ContainerStateTerminatedStartedAt' Lens
v1ContainerStateTerminatedStartedAtL :: Lens_' V1ContainerStateTerminated (Maybe DateTime)
v1ContainerStateTerminatedStartedAtL f V1ContainerStateTerminated{..} = (\v1ContainerStateTerminatedStartedAt -> V1ContainerStateTerminated { v1ContainerStateTerminatedStartedAt, ..} ) <$> f v1ContainerStateTerminatedStartedAt
{-# INLINE v1ContainerStateTerminatedStartedAtL #-}



-- * V1ContainerStateWaiting

-- | 'v1ContainerStateWaitingMessage' Lens
v1ContainerStateWaitingMessageL :: Lens_' V1ContainerStateWaiting (Maybe Text)
v1ContainerStateWaitingMessageL f V1ContainerStateWaiting{..} = (\v1ContainerStateWaitingMessage -> V1ContainerStateWaiting { v1ContainerStateWaitingMessage, ..} ) <$> f v1ContainerStateWaitingMessage
{-# INLINE v1ContainerStateWaitingMessageL #-}

-- | 'v1ContainerStateWaitingReason' Lens
v1ContainerStateWaitingReasonL :: Lens_' V1ContainerStateWaiting (Maybe Text)
v1ContainerStateWaitingReasonL f V1ContainerStateWaiting{..} = (\v1ContainerStateWaitingReason -> V1ContainerStateWaiting { v1ContainerStateWaitingReason, ..} ) <$> f v1ContainerStateWaitingReason
{-# INLINE v1ContainerStateWaitingReasonL #-}



-- * V1ContainerStatus

-- | 'v1ContainerStatusContainerId' Lens
v1ContainerStatusContainerIdL :: Lens_' V1ContainerStatus (Maybe Text)
v1ContainerStatusContainerIdL f V1ContainerStatus{..} = (\v1ContainerStatusContainerId -> V1ContainerStatus { v1ContainerStatusContainerId, ..} ) <$> f v1ContainerStatusContainerId
{-# INLINE v1ContainerStatusContainerIdL #-}

-- | 'v1ContainerStatusImage' Lens
v1ContainerStatusImageL :: Lens_' V1ContainerStatus (Text)
v1ContainerStatusImageL f V1ContainerStatus{..} = (\v1ContainerStatusImage -> V1ContainerStatus { v1ContainerStatusImage, ..} ) <$> f v1ContainerStatusImage
{-# INLINE v1ContainerStatusImageL #-}

-- | 'v1ContainerStatusImageId' Lens
v1ContainerStatusImageIdL :: Lens_' V1ContainerStatus (Text)
v1ContainerStatusImageIdL f V1ContainerStatus{..} = (\v1ContainerStatusImageId -> V1ContainerStatus { v1ContainerStatusImageId, ..} ) <$> f v1ContainerStatusImageId
{-# INLINE v1ContainerStatusImageIdL #-}

-- | 'v1ContainerStatusLastState' Lens
v1ContainerStatusLastStateL :: Lens_' V1ContainerStatus (Maybe V1ContainerState)
v1ContainerStatusLastStateL f V1ContainerStatus{..} = (\v1ContainerStatusLastState -> V1ContainerStatus { v1ContainerStatusLastState, ..} ) <$> f v1ContainerStatusLastState
{-# INLINE v1ContainerStatusLastStateL #-}

-- | 'v1ContainerStatusName' Lens
v1ContainerStatusNameL :: Lens_' V1ContainerStatus (Text)
v1ContainerStatusNameL f V1ContainerStatus{..} = (\v1ContainerStatusName -> V1ContainerStatus { v1ContainerStatusName, ..} ) <$> f v1ContainerStatusName
{-# INLINE v1ContainerStatusNameL #-}

-- | 'v1ContainerStatusReady' Lens
v1ContainerStatusReadyL :: Lens_' V1ContainerStatus (Bool)
v1ContainerStatusReadyL f V1ContainerStatus{..} = (\v1ContainerStatusReady -> V1ContainerStatus { v1ContainerStatusReady, ..} ) <$> f v1ContainerStatusReady
{-# INLINE v1ContainerStatusReadyL #-}

-- | 'v1ContainerStatusRestartCount' Lens
v1ContainerStatusRestartCountL :: Lens_' V1ContainerStatus (Int)
v1ContainerStatusRestartCountL f V1ContainerStatus{..} = (\v1ContainerStatusRestartCount -> V1ContainerStatus { v1ContainerStatusRestartCount, ..} ) <$> f v1ContainerStatusRestartCount
{-# INLINE v1ContainerStatusRestartCountL #-}

-- | 'v1ContainerStatusStarted' Lens
v1ContainerStatusStartedL :: Lens_' V1ContainerStatus (Maybe Bool)
v1ContainerStatusStartedL f V1ContainerStatus{..} = (\v1ContainerStatusStarted -> V1ContainerStatus { v1ContainerStatusStarted, ..} ) <$> f v1ContainerStatusStarted
{-# INLINE v1ContainerStatusStartedL #-}

-- | 'v1ContainerStatusState' Lens
v1ContainerStatusStateL :: Lens_' V1ContainerStatus (Maybe V1ContainerState)
v1ContainerStatusStateL f V1ContainerStatus{..} = (\v1ContainerStatusState -> V1ContainerStatus { v1ContainerStatusState, ..} ) <$> f v1ContainerStatusState
{-# INLINE v1ContainerStatusStateL #-}



-- * V1ControllerRevision

-- | 'v1ControllerRevisionApiVersion' Lens
v1ControllerRevisionApiVersionL :: Lens_' V1ControllerRevision (Maybe Text)
v1ControllerRevisionApiVersionL f V1ControllerRevision{..} = (\v1ControllerRevisionApiVersion -> V1ControllerRevision { v1ControllerRevisionApiVersion, ..} ) <$> f v1ControllerRevisionApiVersion
{-# INLINE v1ControllerRevisionApiVersionL #-}

-- | 'v1ControllerRevisionData' Lens
v1ControllerRevisionDataL :: Lens_' V1ControllerRevision (Maybe A.Value)
v1ControllerRevisionDataL f V1ControllerRevision{..} = (\v1ControllerRevisionData -> V1ControllerRevision { v1ControllerRevisionData, ..} ) <$> f v1ControllerRevisionData
{-# INLINE v1ControllerRevisionDataL #-}

-- | 'v1ControllerRevisionKind' Lens
v1ControllerRevisionKindL :: Lens_' V1ControllerRevision (Maybe Text)
v1ControllerRevisionKindL f V1ControllerRevision{..} = (\v1ControllerRevisionKind -> V1ControllerRevision { v1ControllerRevisionKind, ..} ) <$> f v1ControllerRevisionKind
{-# INLINE v1ControllerRevisionKindL #-}

-- | 'v1ControllerRevisionMetadata' Lens
v1ControllerRevisionMetadataL :: Lens_' V1ControllerRevision (Maybe V1ObjectMeta)
v1ControllerRevisionMetadataL f V1ControllerRevision{..} = (\v1ControllerRevisionMetadata -> V1ControllerRevision { v1ControllerRevisionMetadata, ..} ) <$> f v1ControllerRevisionMetadata
{-# INLINE v1ControllerRevisionMetadataL #-}

-- | 'v1ControllerRevisionRevision' Lens
v1ControllerRevisionRevisionL :: Lens_' V1ControllerRevision (Integer)
v1ControllerRevisionRevisionL f V1ControllerRevision{..} = (\v1ControllerRevisionRevision -> V1ControllerRevision { v1ControllerRevisionRevision, ..} ) <$> f v1ControllerRevisionRevision
{-# INLINE v1ControllerRevisionRevisionL #-}



-- * V1ControllerRevisionList

-- | 'v1ControllerRevisionListApiVersion' Lens
v1ControllerRevisionListApiVersionL :: Lens_' V1ControllerRevisionList (Maybe Text)
v1ControllerRevisionListApiVersionL f V1ControllerRevisionList{..} = (\v1ControllerRevisionListApiVersion -> V1ControllerRevisionList { v1ControllerRevisionListApiVersion, ..} ) <$> f v1ControllerRevisionListApiVersion
{-# INLINE v1ControllerRevisionListApiVersionL #-}

-- | 'v1ControllerRevisionListItems' Lens
v1ControllerRevisionListItemsL :: Lens_' V1ControllerRevisionList ([V1ControllerRevision])
v1ControllerRevisionListItemsL f V1ControllerRevisionList{..} = (\v1ControllerRevisionListItems -> V1ControllerRevisionList { v1ControllerRevisionListItems, ..} ) <$> f v1ControllerRevisionListItems
{-# INLINE v1ControllerRevisionListItemsL #-}

-- | 'v1ControllerRevisionListKind' Lens
v1ControllerRevisionListKindL :: Lens_' V1ControllerRevisionList (Maybe Text)
v1ControllerRevisionListKindL f V1ControllerRevisionList{..} = (\v1ControllerRevisionListKind -> V1ControllerRevisionList { v1ControllerRevisionListKind, ..} ) <$> f v1ControllerRevisionListKind
{-# INLINE v1ControllerRevisionListKindL #-}

-- | 'v1ControllerRevisionListMetadata' Lens
v1ControllerRevisionListMetadataL :: Lens_' V1ControllerRevisionList (Maybe V1ListMeta)
v1ControllerRevisionListMetadataL f V1ControllerRevisionList{..} = (\v1ControllerRevisionListMetadata -> V1ControllerRevisionList { v1ControllerRevisionListMetadata, ..} ) <$> f v1ControllerRevisionListMetadata
{-# INLINE v1ControllerRevisionListMetadataL #-}



-- * V1CronJob

-- | 'v1CronJobApiVersion' Lens
v1CronJobApiVersionL :: Lens_' V1CronJob (Maybe Text)
v1CronJobApiVersionL f V1CronJob{..} = (\v1CronJobApiVersion -> V1CronJob { v1CronJobApiVersion, ..} ) <$> f v1CronJobApiVersion
{-# INLINE v1CronJobApiVersionL #-}

-- | 'v1CronJobKind' Lens
v1CronJobKindL :: Lens_' V1CronJob (Maybe Text)
v1CronJobKindL f V1CronJob{..} = (\v1CronJobKind -> V1CronJob { v1CronJobKind, ..} ) <$> f v1CronJobKind
{-# INLINE v1CronJobKindL #-}

-- | 'v1CronJobMetadata' Lens
v1CronJobMetadataL :: Lens_' V1CronJob (Maybe V1ObjectMeta)
v1CronJobMetadataL f V1CronJob{..} = (\v1CronJobMetadata -> V1CronJob { v1CronJobMetadata, ..} ) <$> f v1CronJobMetadata
{-# INLINE v1CronJobMetadataL #-}

-- | 'v1CronJobSpec' Lens
v1CronJobSpecL :: Lens_' V1CronJob (Maybe V1CronJobSpec)
v1CronJobSpecL f V1CronJob{..} = (\v1CronJobSpec -> V1CronJob { v1CronJobSpec, ..} ) <$> f v1CronJobSpec
{-# INLINE v1CronJobSpecL #-}

-- | 'v1CronJobStatus' Lens
v1CronJobStatusL :: Lens_' V1CronJob (Maybe V1CronJobStatus)
v1CronJobStatusL f V1CronJob{..} = (\v1CronJobStatus -> V1CronJob { v1CronJobStatus, ..} ) <$> f v1CronJobStatus
{-# INLINE v1CronJobStatusL #-}



-- * V1CronJobList

-- | 'v1CronJobListApiVersion' Lens
v1CronJobListApiVersionL :: Lens_' V1CronJobList (Maybe Text)
v1CronJobListApiVersionL f V1CronJobList{..} = (\v1CronJobListApiVersion -> V1CronJobList { v1CronJobListApiVersion, ..} ) <$> f v1CronJobListApiVersion
{-# INLINE v1CronJobListApiVersionL #-}

-- | 'v1CronJobListItems' Lens
v1CronJobListItemsL :: Lens_' V1CronJobList ([V1CronJob])
v1CronJobListItemsL f V1CronJobList{..} = (\v1CronJobListItems -> V1CronJobList { v1CronJobListItems, ..} ) <$> f v1CronJobListItems
{-# INLINE v1CronJobListItemsL #-}

-- | 'v1CronJobListKind' Lens
v1CronJobListKindL :: Lens_' V1CronJobList (Maybe Text)
v1CronJobListKindL f V1CronJobList{..} = (\v1CronJobListKind -> V1CronJobList { v1CronJobListKind, ..} ) <$> f v1CronJobListKind
{-# INLINE v1CronJobListKindL #-}

-- | 'v1CronJobListMetadata' Lens
v1CronJobListMetadataL :: Lens_' V1CronJobList (Maybe V1ListMeta)
v1CronJobListMetadataL f V1CronJobList{..} = (\v1CronJobListMetadata -> V1CronJobList { v1CronJobListMetadata, ..} ) <$> f v1CronJobListMetadata
{-# INLINE v1CronJobListMetadataL #-}



-- * V1CronJobSpec

-- | 'v1CronJobSpecConcurrencyPolicy' Lens
v1CronJobSpecConcurrencyPolicyL :: Lens_' V1CronJobSpec (Maybe Text)
v1CronJobSpecConcurrencyPolicyL f V1CronJobSpec{..} = (\v1CronJobSpecConcurrencyPolicy -> V1CronJobSpec { v1CronJobSpecConcurrencyPolicy, ..} ) <$> f v1CronJobSpecConcurrencyPolicy
{-# INLINE v1CronJobSpecConcurrencyPolicyL #-}

-- | 'v1CronJobSpecFailedJobsHistoryLimit' Lens
v1CronJobSpecFailedJobsHistoryLimitL :: Lens_' V1CronJobSpec (Maybe Int)
v1CronJobSpecFailedJobsHistoryLimitL f V1CronJobSpec{..} = (\v1CronJobSpecFailedJobsHistoryLimit -> V1CronJobSpec { v1CronJobSpecFailedJobsHistoryLimit, ..} ) <$> f v1CronJobSpecFailedJobsHistoryLimit
{-# INLINE v1CronJobSpecFailedJobsHistoryLimitL #-}

-- | 'v1CronJobSpecJobTemplate' Lens
v1CronJobSpecJobTemplateL :: Lens_' V1CronJobSpec (V1JobTemplateSpec)
v1CronJobSpecJobTemplateL f V1CronJobSpec{..} = (\v1CronJobSpecJobTemplate -> V1CronJobSpec { v1CronJobSpecJobTemplate, ..} ) <$> f v1CronJobSpecJobTemplate
{-# INLINE v1CronJobSpecJobTemplateL #-}

-- | 'v1CronJobSpecSchedule' Lens
v1CronJobSpecScheduleL :: Lens_' V1CronJobSpec (Text)
v1CronJobSpecScheduleL f V1CronJobSpec{..} = (\v1CronJobSpecSchedule -> V1CronJobSpec { v1CronJobSpecSchedule, ..} ) <$> f v1CronJobSpecSchedule
{-# INLINE v1CronJobSpecScheduleL #-}

-- | 'v1CronJobSpecStartingDeadlineSeconds' Lens
v1CronJobSpecStartingDeadlineSecondsL :: Lens_' V1CronJobSpec (Maybe Integer)
v1CronJobSpecStartingDeadlineSecondsL f V1CronJobSpec{..} = (\v1CronJobSpecStartingDeadlineSeconds -> V1CronJobSpec { v1CronJobSpecStartingDeadlineSeconds, ..} ) <$> f v1CronJobSpecStartingDeadlineSeconds
{-# INLINE v1CronJobSpecStartingDeadlineSecondsL #-}

-- | 'v1CronJobSpecSuccessfulJobsHistoryLimit' Lens
v1CronJobSpecSuccessfulJobsHistoryLimitL :: Lens_' V1CronJobSpec (Maybe Int)
v1CronJobSpecSuccessfulJobsHistoryLimitL f V1CronJobSpec{..} = (\v1CronJobSpecSuccessfulJobsHistoryLimit -> V1CronJobSpec { v1CronJobSpecSuccessfulJobsHistoryLimit, ..} ) <$> f v1CronJobSpecSuccessfulJobsHistoryLimit
{-# INLINE v1CronJobSpecSuccessfulJobsHistoryLimitL #-}

-- | 'v1CronJobSpecSuspend' Lens
v1CronJobSpecSuspendL :: Lens_' V1CronJobSpec (Maybe Bool)
v1CronJobSpecSuspendL f V1CronJobSpec{..} = (\v1CronJobSpecSuspend -> V1CronJobSpec { v1CronJobSpecSuspend, ..} ) <$> f v1CronJobSpecSuspend
{-# INLINE v1CronJobSpecSuspendL #-}



-- * V1CronJobStatus

-- | 'v1CronJobStatusActive' Lens
v1CronJobStatusActiveL :: Lens_' V1CronJobStatus (Maybe [V1ObjectReference])
v1CronJobStatusActiveL f V1CronJobStatus{..} = (\v1CronJobStatusActive -> V1CronJobStatus { v1CronJobStatusActive, ..} ) <$> f v1CronJobStatusActive
{-# INLINE v1CronJobStatusActiveL #-}

-- | 'v1CronJobStatusLastScheduleTime' Lens
v1CronJobStatusLastScheduleTimeL :: Lens_' V1CronJobStatus (Maybe DateTime)
v1CronJobStatusLastScheduleTimeL f V1CronJobStatus{..} = (\v1CronJobStatusLastScheduleTime -> V1CronJobStatus { v1CronJobStatusLastScheduleTime, ..} ) <$> f v1CronJobStatusLastScheduleTime
{-# INLINE v1CronJobStatusLastScheduleTimeL #-}

-- | 'v1CronJobStatusLastSuccessfulTime' Lens
v1CronJobStatusLastSuccessfulTimeL :: Lens_' V1CronJobStatus (Maybe DateTime)
v1CronJobStatusLastSuccessfulTimeL f V1CronJobStatus{..} = (\v1CronJobStatusLastSuccessfulTime -> V1CronJobStatus { v1CronJobStatusLastSuccessfulTime, ..} ) <$> f v1CronJobStatusLastSuccessfulTime
{-# INLINE v1CronJobStatusLastSuccessfulTimeL #-}



-- * V1CrossVersionObjectReference

-- | 'v1CrossVersionObjectReferenceApiVersion' Lens
v1CrossVersionObjectReferenceApiVersionL :: Lens_' V1CrossVersionObjectReference (Maybe Text)
v1CrossVersionObjectReferenceApiVersionL f V1CrossVersionObjectReference{..} = (\v1CrossVersionObjectReferenceApiVersion -> V1CrossVersionObjectReference { v1CrossVersionObjectReferenceApiVersion, ..} ) <$> f v1CrossVersionObjectReferenceApiVersion
{-# INLINE v1CrossVersionObjectReferenceApiVersionL #-}

-- | 'v1CrossVersionObjectReferenceKind' Lens
v1CrossVersionObjectReferenceKindL :: Lens_' V1CrossVersionObjectReference (Text)
v1CrossVersionObjectReferenceKindL f V1CrossVersionObjectReference{..} = (\v1CrossVersionObjectReferenceKind -> V1CrossVersionObjectReference { v1CrossVersionObjectReferenceKind, ..} ) <$> f v1CrossVersionObjectReferenceKind
{-# INLINE v1CrossVersionObjectReferenceKindL #-}

-- | 'v1CrossVersionObjectReferenceName' Lens
v1CrossVersionObjectReferenceNameL :: Lens_' V1CrossVersionObjectReference (Text)
v1CrossVersionObjectReferenceNameL f V1CrossVersionObjectReference{..} = (\v1CrossVersionObjectReferenceName -> V1CrossVersionObjectReference { v1CrossVersionObjectReferenceName, ..} ) <$> f v1CrossVersionObjectReferenceName
{-# INLINE v1CrossVersionObjectReferenceNameL #-}



-- * V1CustomResourceColumnDefinition

-- | 'v1CustomResourceColumnDefinitionDescription' Lens
v1CustomResourceColumnDefinitionDescriptionL :: Lens_' V1CustomResourceColumnDefinition (Maybe Text)
v1CustomResourceColumnDefinitionDescriptionL f V1CustomResourceColumnDefinition{..} = (\v1CustomResourceColumnDefinitionDescription -> V1CustomResourceColumnDefinition { v1CustomResourceColumnDefinitionDescription, ..} ) <$> f v1CustomResourceColumnDefinitionDescription
{-# INLINE v1CustomResourceColumnDefinitionDescriptionL #-}

-- | 'v1CustomResourceColumnDefinitionFormat' Lens
v1CustomResourceColumnDefinitionFormatL :: Lens_' V1CustomResourceColumnDefinition (Maybe Text)
v1CustomResourceColumnDefinitionFormatL f V1CustomResourceColumnDefinition{..} = (\v1CustomResourceColumnDefinitionFormat -> V1CustomResourceColumnDefinition { v1CustomResourceColumnDefinitionFormat, ..} ) <$> f v1CustomResourceColumnDefinitionFormat
{-# INLINE v1CustomResourceColumnDefinitionFormatL #-}

-- | 'v1CustomResourceColumnDefinitionJsonPath' Lens
v1CustomResourceColumnDefinitionJsonPathL :: Lens_' V1CustomResourceColumnDefinition (Text)
v1CustomResourceColumnDefinitionJsonPathL f V1CustomResourceColumnDefinition{..} = (\v1CustomResourceColumnDefinitionJsonPath -> V1CustomResourceColumnDefinition { v1CustomResourceColumnDefinitionJsonPath, ..} ) <$> f v1CustomResourceColumnDefinitionJsonPath
{-# INLINE v1CustomResourceColumnDefinitionJsonPathL #-}

-- | 'v1CustomResourceColumnDefinitionName' Lens
v1CustomResourceColumnDefinitionNameL :: Lens_' V1CustomResourceColumnDefinition (Text)
v1CustomResourceColumnDefinitionNameL f V1CustomResourceColumnDefinition{..} = (\v1CustomResourceColumnDefinitionName -> V1CustomResourceColumnDefinition { v1CustomResourceColumnDefinitionName, ..} ) <$> f v1CustomResourceColumnDefinitionName
{-# INLINE v1CustomResourceColumnDefinitionNameL #-}

-- | 'v1CustomResourceColumnDefinitionPriority' Lens
v1CustomResourceColumnDefinitionPriorityL :: Lens_' V1CustomResourceColumnDefinition (Maybe Int)
v1CustomResourceColumnDefinitionPriorityL f V1CustomResourceColumnDefinition{..} = (\v1CustomResourceColumnDefinitionPriority -> V1CustomResourceColumnDefinition { v1CustomResourceColumnDefinitionPriority, ..} ) <$> f v1CustomResourceColumnDefinitionPriority
{-# INLINE v1CustomResourceColumnDefinitionPriorityL #-}

-- | 'v1CustomResourceColumnDefinitionType' Lens
v1CustomResourceColumnDefinitionTypeL :: Lens_' V1CustomResourceColumnDefinition (Text)
v1CustomResourceColumnDefinitionTypeL f V1CustomResourceColumnDefinition{..} = (\v1CustomResourceColumnDefinitionType -> V1CustomResourceColumnDefinition { v1CustomResourceColumnDefinitionType, ..} ) <$> f v1CustomResourceColumnDefinitionType
{-# INLINE v1CustomResourceColumnDefinitionTypeL #-}



-- * V1CustomResourceConversion

-- | 'v1CustomResourceConversionStrategy' Lens
v1CustomResourceConversionStrategyL :: Lens_' V1CustomResourceConversion (Text)
v1CustomResourceConversionStrategyL f V1CustomResourceConversion{..} = (\v1CustomResourceConversionStrategy -> V1CustomResourceConversion { v1CustomResourceConversionStrategy, ..} ) <$> f v1CustomResourceConversionStrategy
{-# INLINE v1CustomResourceConversionStrategyL #-}

-- | 'v1CustomResourceConversionWebhook' Lens
v1CustomResourceConversionWebhookL :: Lens_' V1CustomResourceConversion (Maybe V1WebhookConversion)
v1CustomResourceConversionWebhookL f V1CustomResourceConversion{..} = (\v1CustomResourceConversionWebhook -> V1CustomResourceConversion { v1CustomResourceConversionWebhook, ..} ) <$> f v1CustomResourceConversionWebhook
{-# INLINE v1CustomResourceConversionWebhookL #-}



-- * V1CustomResourceDefinition

-- | 'v1CustomResourceDefinitionApiVersion' Lens
v1CustomResourceDefinitionApiVersionL :: Lens_' V1CustomResourceDefinition (Maybe Text)
v1CustomResourceDefinitionApiVersionL f V1CustomResourceDefinition{..} = (\v1CustomResourceDefinitionApiVersion -> V1CustomResourceDefinition { v1CustomResourceDefinitionApiVersion, ..} ) <$> f v1CustomResourceDefinitionApiVersion
{-# INLINE v1CustomResourceDefinitionApiVersionL #-}

-- | 'v1CustomResourceDefinitionKind' Lens
v1CustomResourceDefinitionKindL :: Lens_' V1CustomResourceDefinition (Maybe Text)
v1CustomResourceDefinitionKindL f V1CustomResourceDefinition{..} = (\v1CustomResourceDefinitionKind -> V1CustomResourceDefinition { v1CustomResourceDefinitionKind, ..} ) <$> f v1CustomResourceDefinitionKind
{-# INLINE v1CustomResourceDefinitionKindL #-}

-- | 'v1CustomResourceDefinitionMetadata' Lens
v1CustomResourceDefinitionMetadataL :: Lens_' V1CustomResourceDefinition (Maybe V1ObjectMeta)
v1CustomResourceDefinitionMetadataL f V1CustomResourceDefinition{..} = (\v1CustomResourceDefinitionMetadata -> V1CustomResourceDefinition { v1CustomResourceDefinitionMetadata, ..} ) <$> f v1CustomResourceDefinitionMetadata
{-# INLINE v1CustomResourceDefinitionMetadataL #-}

-- | 'v1CustomResourceDefinitionSpec' Lens
v1CustomResourceDefinitionSpecL :: Lens_' V1CustomResourceDefinition (V1CustomResourceDefinitionSpec)
v1CustomResourceDefinitionSpecL f V1CustomResourceDefinition{..} = (\v1CustomResourceDefinitionSpec -> V1CustomResourceDefinition { v1CustomResourceDefinitionSpec, ..} ) <$> f v1CustomResourceDefinitionSpec
{-# INLINE v1CustomResourceDefinitionSpecL #-}

-- | 'v1CustomResourceDefinitionStatus' Lens
v1CustomResourceDefinitionStatusL :: Lens_' V1CustomResourceDefinition (Maybe V1CustomResourceDefinitionStatus)
v1CustomResourceDefinitionStatusL f V1CustomResourceDefinition{..} = (\v1CustomResourceDefinitionStatus -> V1CustomResourceDefinition { v1CustomResourceDefinitionStatus, ..} ) <$> f v1CustomResourceDefinitionStatus
{-# INLINE v1CustomResourceDefinitionStatusL #-}



-- * V1CustomResourceDefinitionCondition

-- | 'v1CustomResourceDefinitionConditionLastTransitionTime' Lens
v1CustomResourceDefinitionConditionLastTransitionTimeL :: Lens_' V1CustomResourceDefinitionCondition (Maybe DateTime)
v1CustomResourceDefinitionConditionLastTransitionTimeL f V1CustomResourceDefinitionCondition{..} = (\v1CustomResourceDefinitionConditionLastTransitionTime -> V1CustomResourceDefinitionCondition { v1CustomResourceDefinitionConditionLastTransitionTime, ..} ) <$> f v1CustomResourceDefinitionConditionLastTransitionTime
{-# INLINE v1CustomResourceDefinitionConditionLastTransitionTimeL #-}

-- | 'v1CustomResourceDefinitionConditionMessage' Lens
v1CustomResourceDefinitionConditionMessageL :: Lens_' V1CustomResourceDefinitionCondition (Maybe Text)
v1CustomResourceDefinitionConditionMessageL f V1CustomResourceDefinitionCondition{..} = (\v1CustomResourceDefinitionConditionMessage -> V1CustomResourceDefinitionCondition { v1CustomResourceDefinitionConditionMessage, ..} ) <$> f v1CustomResourceDefinitionConditionMessage
{-# INLINE v1CustomResourceDefinitionConditionMessageL #-}

-- | 'v1CustomResourceDefinitionConditionReason' Lens
v1CustomResourceDefinitionConditionReasonL :: Lens_' V1CustomResourceDefinitionCondition (Maybe Text)
v1CustomResourceDefinitionConditionReasonL f V1CustomResourceDefinitionCondition{..} = (\v1CustomResourceDefinitionConditionReason -> V1CustomResourceDefinitionCondition { v1CustomResourceDefinitionConditionReason, ..} ) <$> f v1CustomResourceDefinitionConditionReason
{-# INLINE v1CustomResourceDefinitionConditionReasonL #-}

-- | 'v1CustomResourceDefinitionConditionStatus' Lens
v1CustomResourceDefinitionConditionStatusL :: Lens_' V1CustomResourceDefinitionCondition (Text)
v1CustomResourceDefinitionConditionStatusL f V1CustomResourceDefinitionCondition{..} = (\v1CustomResourceDefinitionConditionStatus -> V1CustomResourceDefinitionCondition { v1CustomResourceDefinitionConditionStatus, ..} ) <$> f v1CustomResourceDefinitionConditionStatus
{-# INLINE v1CustomResourceDefinitionConditionStatusL #-}

-- | 'v1CustomResourceDefinitionConditionType' Lens
v1CustomResourceDefinitionConditionTypeL :: Lens_' V1CustomResourceDefinitionCondition (Text)
v1CustomResourceDefinitionConditionTypeL f V1CustomResourceDefinitionCondition{..} = (\v1CustomResourceDefinitionConditionType -> V1CustomResourceDefinitionCondition { v1CustomResourceDefinitionConditionType, ..} ) <$> f v1CustomResourceDefinitionConditionType
{-# INLINE v1CustomResourceDefinitionConditionTypeL #-}



-- * V1CustomResourceDefinitionList

-- | 'v1CustomResourceDefinitionListApiVersion' Lens
v1CustomResourceDefinitionListApiVersionL :: Lens_' V1CustomResourceDefinitionList (Maybe Text)
v1CustomResourceDefinitionListApiVersionL f V1CustomResourceDefinitionList{..} = (\v1CustomResourceDefinitionListApiVersion -> V1CustomResourceDefinitionList { v1CustomResourceDefinitionListApiVersion, ..} ) <$> f v1CustomResourceDefinitionListApiVersion
{-# INLINE v1CustomResourceDefinitionListApiVersionL #-}

-- | 'v1CustomResourceDefinitionListItems' Lens
v1CustomResourceDefinitionListItemsL :: Lens_' V1CustomResourceDefinitionList ([V1CustomResourceDefinition])
v1CustomResourceDefinitionListItemsL f V1CustomResourceDefinitionList{..} = (\v1CustomResourceDefinitionListItems -> V1CustomResourceDefinitionList { v1CustomResourceDefinitionListItems, ..} ) <$> f v1CustomResourceDefinitionListItems
{-# INLINE v1CustomResourceDefinitionListItemsL #-}

-- | 'v1CustomResourceDefinitionListKind' Lens
v1CustomResourceDefinitionListKindL :: Lens_' V1CustomResourceDefinitionList (Maybe Text)
v1CustomResourceDefinitionListKindL f V1CustomResourceDefinitionList{..} = (\v1CustomResourceDefinitionListKind -> V1CustomResourceDefinitionList { v1CustomResourceDefinitionListKind, ..} ) <$> f v1CustomResourceDefinitionListKind
{-# INLINE v1CustomResourceDefinitionListKindL #-}

-- | 'v1CustomResourceDefinitionListMetadata' Lens
v1CustomResourceDefinitionListMetadataL :: Lens_' V1CustomResourceDefinitionList (Maybe V1ListMeta)
v1CustomResourceDefinitionListMetadataL f V1CustomResourceDefinitionList{..} = (\v1CustomResourceDefinitionListMetadata -> V1CustomResourceDefinitionList { v1CustomResourceDefinitionListMetadata, ..} ) <$> f v1CustomResourceDefinitionListMetadata
{-# INLINE v1CustomResourceDefinitionListMetadataL #-}



-- * V1CustomResourceDefinitionNames

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

-- | 'v1CustomResourceDefinitionNamesKind' Lens
v1CustomResourceDefinitionNamesKindL :: Lens_' V1CustomResourceDefinitionNames (Text)
v1CustomResourceDefinitionNamesKindL f V1CustomResourceDefinitionNames{..} = (\v1CustomResourceDefinitionNamesKind -> V1CustomResourceDefinitionNames { v1CustomResourceDefinitionNamesKind, ..} ) <$> f v1CustomResourceDefinitionNamesKind
{-# INLINE v1CustomResourceDefinitionNamesKindL #-}

-- | 'v1CustomResourceDefinitionNamesListKind' Lens
v1CustomResourceDefinitionNamesListKindL :: Lens_' V1CustomResourceDefinitionNames (Maybe Text)
v1CustomResourceDefinitionNamesListKindL f V1CustomResourceDefinitionNames{..} = (\v1CustomResourceDefinitionNamesListKind -> V1CustomResourceDefinitionNames { v1CustomResourceDefinitionNamesListKind, ..} ) <$> f v1CustomResourceDefinitionNamesListKind
{-# INLINE v1CustomResourceDefinitionNamesListKindL #-}

-- | 'v1CustomResourceDefinitionNamesPlural' Lens
v1CustomResourceDefinitionNamesPluralL :: Lens_' V1CustomResourceDefinitionNames (Text)
v1CustomResourceDefinitionNamesPluralL f V1CustomResourceDefinitionNames{..} = (\v1CustomResourceDefinitionNamesPlural -> V1CustomResourceDefinitionNames { v1CustomResourceDefinitionNamesPlural, ..} ) <$> f v1CustomResourceDefinitionNamesPlural
{-# INLINE v1CustomResourceDefinitionNamesPluralL #-}

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

-- | 'v1CustomResourceDefinitionNamesSingular' Lens
v1CustomResourceDefinitionNamesSingularL :: Lens_' V1CustomResourceDefinitionNames (Maybe Text)
v1CustomResourceDefinitionNamesSingularL f V1CustomResourceDefinitionNames{..} = (\v1CustomResourceDefinitionNamesSingular -> V1CustomResourceDefinitionNames { v1CustomResourceDefinitionNamesSingular, ..} ) <$> f v1CustomResourceDefinitionNamesSingular
{-# INLINE v1CustomResourceDefinitionNamesSingularL #-}



-- * V1CustomResourceDefinitionSpec

-- | 'v1CustomResourceDefinitionSpecConversion' Lens
v1CustomResourceDefinitionSpecConversionL :: Lens_' V1CustomResourceDefinitionSpec (Maybe V1CustomResourceConversion)
v1CustomResourceDefinitionSpecConversionL f V1CustomResourceDefinitionSpec{..} = (\v1CustomResourceDefinitionSpecConversion -> V1CustomResourceDefinitionSpec { v1CustomResourceDefinitionSpecConversion, ..} ) <$> f v1CustomResourceDefinitionSpecConversion
{-# INLINE v1CustomResourceDefinitionSpecConversionL #-}

-- | 'v1CustomResourceDefinitionSpecGroup' Lens
v1CustomResourceDefinitionSpecGroupL :: Lens_' V1CustomResourceDefinitionSpec (Text)
v1CustomResourceDefinitionSpecGroupL f V1CustomResourceDefinitionSpec{..} = (\v1CustomResourceDefinitionSpecGroup -> V1CustomResourceDefinitionSpec { v1CustomResourceDefinitionSpecGroup, ..} ) <$> f v1CustomResourceDefinitionSpecGroup
{-# INLINE v1CustomResourceDefinitionSpecGroupL #-}

-- | 'v1CustomResourceDefinitionSpecNames' Lens
v1CustomResourceDefinitionSpecNamesL :: Lens_' V1CustomResourceDefinitionSpec (V1CustomResourceDefinitionNames)
v1CustomResourceDefinitionSpecNamesL f V1CustomResourceDefinitionSpec{..} = (\v1CustomResourceDefinitionSpecNames -> V1CustomResourceDefinitionSpec { v1CustomResourceDefinitionSpecNames, ..} ) <$> f v1CustomResourceDefinitionSpecNames
{-# INLINE v1CustomResourceDefinitionSpecNamesL #-}

-- | 'v1CustomResourceDefinitionSpecPreserveUnknownFields' Lens
v1CustomResourceDefinitionSpecPreserveUnknownFieldsL :: Lens_' V1CustomResourceDefinitionSpec (Maybe Bool)
v1CustomResourceDefinitionSpecPreserveUnknownFieldsL f V1CustomResourceDefinitionSpec{..} = (\v1CustomResourceDefinitionSpecPreserveUnknownFields -> V1CustomResourceDefinitionSpec { v1CustomResourceDefinitionSpecPreserveUnknownFields, ..} ) <$> f v1CustomResourceDefinitionSpecPreserveUnknownFields
{-# INLINE v1CustomResourceDefinitionSpecPreserveUnknownFieldsL #-}

-- | 'v1CustomResourceDefinitionSpecScope' Lens
v1CustomResourceDefinitionSpecScopeL :: Lens_' V1CustomResourceDefinitionSpec (Text)
v1CustomResourceDefinitionSpecScopeL f V1CustomResourceDefinitionSpec{..} = (\v1CustomResourceDefinitionSpecScope -> V1CustomResourceDefinitionSpec { v1CustomResourceDefinitionSpecScope, ..} ) <$> f v1CustomResourceDefinitionSpecScope
{-# INLINE v1CustomResourceDefinitionSpecScopeL #-}

-- | 'v1CustomResourceDefinitionSpecVersions' Lens
v1CustomResourceDefinitionSpecVersionsL :: Lens_' V1CustomResourceDefinitionSpec ([V1CustomResourceDefinitionVersion])
v1CustomResourceDefinitionSpecVersionsL f V1CustomResourceDefinitionSpec{..} = (\v1CustomResourceDefinitionSpecVersions -> V1CustomResourceDefinitionSpec { v1CustomResourceDefinitionSpecVersions, ..} ) <$> f v1CustomResourceDefinitionSpecVersions
{-# INLINE v1CustomResourceDefinitionSpecVersionsL #-}



-- * V1CustomResourceDefinitionStatus

-- | 'v1CustomResourceDefinitionStatusAcceptedNames' Lens
v1CustomResourceDefinitionStatusAcceptedNamesL :: Lens_' V1CustomResourceDefinitionStatus (Maybe V1CustomResourceDefinitionNames)
v1CustomResourceDefinitionStatusAcceptedNamesL f V1CustomResourceDefinitionStatus{..} = (\v1CustomResourceDefinitionStatusAcceptedNames -> V1CustomResourceDefinitionStatus { v1CustomResourceDefinitionStatusAcceptedNames, ..} ) <$> f v1CustomResourceDefinitionStatusAcceptedNames
{-# INLINE v1CustomResourceDefinitionStatusAcceptedNamesL #-}

-- | 'v1CustomResourceDefinitionStatusConditions' Lens
v1CustomResourceDefinitionStatusConditionsL :: Lens_' V1CustomResourceDefinitionStatus (Maybe [V1CustomResourceDefinitionCondition])
v1CustomResourceDefinitionStatusConditionsL f V1CustomResourceDefinitionStatus{..} = (\v1CustomResourceDefinitionStatusConditions -> V1CustomResourceDefinitionStatus { v1CustomResourceDefinitionStatusConditions, ..} ) <$> f v1CustomResourceDefinitionStatusConditions
{-# INLINE v1CustomResourceDefinitionStatusConditionsL #-}

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



-- * V1CustomResourceDefinitionVersion

-- | 'v1CustomResourceDefinitionVersionAdditionalPrinterColumns' Lens
v1CustomResourceDefinitionVersionAdditionalPrinterColumnsL :: Lens_' V1CustomResourceDefinitionVersion (Maybe [V1CustomResourceColumnDefinition])
v1CustomResourceDefinitionVersionAdditionalPrinterColumnsL f V1CustomResourceDefinitionVersion{..} = (\v1CustomResourceDefinitionVersionAdditionalPrinterColumns -> V1CustomResourceDefinitionVersion { v1CustomResourceDefinitionVersionAdditionalPrinterColumns, ..} ) <$> f v1CustomResourceDefinitionVersionAdditionalPrinterColumns
{-# INLINE v1CustomResourceDefinitionVersionAdditionalPrinterColumnsL #-}

-- | 'v1CustomResourceDefinitionVersionDeprecated' Lens
v1CustomResourceDefinitionVersionDeprecatedL :: Lens_' V1CustomResourceDefinitionVersion (Maybe Bool)
v1CustomResourceDefinitionVersionDeprecatedL f V1CustomResourceDefinitionVersion{..} = (\v1CustomResourceDefinitionVersionDeprecated -> V1CustomResourceDefinitionVersion { v1CustomResourceDefinitionVersionDeprecated, ..} ) <$> f v1CustomResourceDefinitionVersionDeprecated
{-# INLINE v1CustomResourceDefinitionVersionDeprecatedL #-}

-- | 'v1CustomResourceDefinitionVersionDeprecationWarning' Lens
v1CustomResourceDefinitionVersionDeprecationWarningL :: Lens_' V1CustomResourceDefinitionVersion (Maybe Text)
v1CustomResourceDefinitionVersionDeprecationWarningL f V1CustomResourceDefinitionVersion{..} = (\v1CustomResourceDefinitionVersionDeprecationWarning -> V1CustomResourceDefinitionVersion { v1CustomResourceDefinitionVersionDeprecationWarning, ..} ) <$> f v1CustomResourceDefinitionVersionDeprecationWarning
{-# INLINE v1CustomResourceDefinitionVersionDeprecationWarningL #-}

-- | 'v1CustomResourceDefinitionVersionName' Lens
v1CustomResourceDefinitionVersionNameL :: Lens_' V1CustomResourceDefinitionVersion (Text)
v1CustomResourceDefinitionVersionNameL f V1CustomResourceDefinitionVersion{..} = (\v1CustomResourceDefinitionVersionName -> V1CustomResourceDefinitionVersion { v1CustomResourceDefinitionVersionName, ..} ) <$> f v1CustomResourceDefinitionVersionName
{-# INLINE v1CustomResourceDefinitionVersionNameL #-}

-- | 'v1CustomResourceDefinitionVersionSchema' Lens
v1CustomResourceDefinitionVersionSchemaL :: Lens_' V1CustomResourceDefinitionVersion (Maybe V1CustomResourceValidation)
v1CustomResourceDefinitionVersionSchemaL f V1CustomResourceDefinitionVersion{..} = (\v1CustomResourceDefinitionVersionSchema -> V1CustomResourceDefinitionVersion { v1CustomResourceDefinitionVersionSchema, ..} ) <$> f v1CustomResourceDefinitionVersionSchema
{-# INLINE v1CustomResourceDefinitionVersionSchemaL #-}

-- | 'v1CustomResourceDefinitionVersionServed' Lens
v1CustomResourceDefinitionVersionServedL :: Lens_' V1CustomResourceDefinitionVersion (Bool)
v1CustomResourceDefinitionVersionServedL f V1CustomResourceDefinitionVersion{..} = (\v1CustomResourceDefinitionVersionServed -> V1CustomResourceDefinitionVersion { v1CustomResourceDefinitionVersionServed, ..} ) <$> f v1CustomResourceDefinitionVersionServed
{-# INLINE v1CustomResourceDefinitionVersionServedL #-}

-- | 'v1CustomResourceDefinitionVersionStorage' Lens
v1CustomResourceDefinitionVersionStorageL :: Lens_' V1CustomResourceDefinitionVersion (Bool)
v1CustomResourceDefinitionVersionStorageL f V1CustomResourceDefinitionVersion{..} = (\v1CustomResourceDefinitionVersionStorage -> V1CustomResourceDefinitionVersion { v1CustomResourceDefinitionVersionStorage, ..} ) <$> f v1CustomResourceDefinitionVersionStorage
{-# INLINE v1CustomResourceDefinitionVersionStorageL #-}

-- | 'v1CustomResourceDefinitionVersionSubresources' Lens
v1CustomResourceDefinitionVersionSubresourcesL :: Lens_' V1CustomResourceDefinitionVersion (Maybe V1CustomResourceSubresources)
v1CustomResourceDefinitionVersionSubresourcesL f V1CustomResourceDefinitionVersion{..} = (\v1CustomResourceDefinitionVersionSubresources -> V1CustomResourceDefinitionVersion { v1CustomResourceDefinitionVersionSubresources, ..} ) <$> f v1CustomResourceDefinitionVersionSubresources
{-# INLINE v1CustomResourceDefinitionVersionSubresourcesL #-}



-- * V1CustomResourceSubresourceScale

-- | 'v1CustomResourceSubresourceScaleLabelSelectorPath' Lens
v1CustomResourceSubresourceScaleLabelSelectorPathL :: Lens_' V1CustomResourceSubresourceScale (Maybe Text)
v1CustomResourceSubresourceScaleLabelSelectorPathL f V1CustomResourceSubresourceScale{..} = (\v1CustomResourceSubresourceScaleLabelSelectorPath -> V1CustomResourceSubresourceScale { v1CustomResourceSubresourceScaleLabelSelectorPath, ..} ) <$> f v1CustomResourceSubresourceScaleLabelSelectorPath
{-# INLINE v1CustomResourceSubresourceScaleLabelSelectorPathL #-}

-- | 'v1CustomResourceSubresourceScaleSpecReplicasPath' Lens
v1CustomResourceSubresourceScaleSpecReplicasPathL :: Lens_' V1CustomResourceSubresourceScale (Text)
v1CustomResourceSubresourceScaleSpecReplicasPathL f V1CustomResourceSubresourceScale{..} = (\v1CustomResourceSubresourceScaleSpecReplicasPath -> V1CustomResourceSubresourceScale { v1CustomResourceSubresourceScaleSpecReplicasPath, ..} ) <$> f v1CustomResourceSubresourceScaleSpecReplicasPath
{-# INLINE v1CustomResourceSubresourceScaleSpecReplicasPathL #-}

-- | 'v1CustomResourceSubresourceScaleStatusReplicasPath' Lens
v1CustomResourceSubresourceScaleStatusReplicasPathL :: Lens_' V1CustomResourceSubresourceScale (Text)
v1CustomResourceSubresourceScaleStatusReplicasPathL f V1CustomResourceSubresourceScale{..} = (\v1CustomResourceSubresourceScaleStatusReplicasPath -> V1CustomResourceSubresourceScale { v1CustomResourceSubresourceScaleStatusReplicasPath, ..} ) <$> f v1CustomResourceSubresourceScaleStatusReplicasPath
{-# INLINE v1CustomResourceSubresourceScaleStatusReplicasPathL #-}



-- * V1CustomResourceSubresources

-- | 'v1CustomResourceSubresourcesScale' Lens
v1CustomResourceSubresourcesScaleL :: Lens_' V1CustomResourceSubresources (Maybe V1CustomResourceSubresourceScale)
v1CustomResourceSubresourcesScaleL f V1CustomResourceSubresources{..} = (\v1CustomResourceSubresourcesScale -> V1CustomResourceSubresources { v1CustomResourceSubresourcesScale, ..} ) <$> f v1CustomResourceSubresourcesScale
{-# INLINE v1CustomResourceSubresourcesScaleL #-}

-- | 'v1CustomResourceSubresourcesStatus' Lens
v1CustomResourceSubresourcesStatusL :: Lens_' V1CustomResourceSubresources (Maybe A.Value)
v1CustomResourceSubresourcesStatusL f V1CustomResourceSubresources{..} = (\v1CustomResourceSubresourcesStatus -> V1CustomResourceSubresources { v1CustomResourceSubresourcesStatus, ..} ) <$> f v1CustomResourceSubresourcesStatus
{-# INLINE v1CustomResourceSubresourcesStatusL #-}



-- * V1CustomResourceValidation

-- | 'v1CustomResourceValidationOpenApiv3Schema' Lens
v1CustomResourceValidationOpenApiv3SchemaL :: Lens_' V1CustomResourceValidation (Maybe V1JSONSchemaProps)
v1CustomResourceValidationOpenApiv3SchemaL f V1CustomResourceValidation{..} = (\v1CustomResourceValidationOpenApiv3Schema -> V1CustomResourceValidation { v1CustomResourceValidationOpenApiv3Schema, ..} ) <$> f v1CustomResourceValidationOpenApiv3Schema
{-# INLINE v1CustomResourceValidationOpenApiv3SchemaL #-}



-- * V1DaemonEndpoint

-- | 'v1DaemonEndpointPort' Lens
v1DaemonEndpointPortL :: Lens_' V1DaemonEndpoint (Int)
v1DaemonEndpointPortL f V1DaemonEndpoint{..} = (\v1DaemonEndpointPort -> V1DaemonEndpoint { v1DaemonEndpointPort, ..} ) <$> f v1DaemonEndpointPort
{-# INLINE v1DaemonEndpointPortL #-}



-- * V1DaemonSet

-- | 'v1DaemonSetApiVersion' Lens
v1DaemonSetApiVersionL :: Lens_' V1DaemonSet (Maybe Text)
v1DaemonSetApiVersionL f V1DaemonSet{..} = (\v1DaemonSetApiVersion -> V1DaemonSet { v1DaemonSetApiVersion, ..} ) <$> f v1DaemonSetApiVersion
{-# INLINE v1DaemonSetApiVersionL #-}

-- | 'v1DaemonSetKind' Lens
v1DaemonSetKindL :: Lens_' V1DaemonSet (Maybe Text)
v1DaemonSetKindL f V1DaemonSet{..} = (\v1DaemonSetKind -> V1DaemonSet { v1DaemonSetKind, ..} ) <$> f v1DaemonSetKind
{-# INLINE v1DaemonSetKindL #-}

-- | 'v1DaemonSetMetadata' Lens
v1DaemonSetMetadataL :: Lens_' V1DaemonSet (Maybe V1ObjectMeta)
v1DaemonSetMetadataL f V1DaemonSet{..} = (\v1DaemonSetMetadata -> V1DaemonSet { v1DaemonSetMetadata, ..} ) <$> f v1DaemonSetMetadata
{-# INLINE v1DaemonSetMetadataL #-}

-- | 'v1DaemonSetSpec' Lens
v1DaemonSetSpecL :: Lens_' V1DaemonSet (Maybe V1DaemonSetSpec)
v1DaemonSetSpecL f V1DaemonSet{..} = (\v1DaemonSetSpec -> V1DaemonSet { v1DaemonSetSpec, ..} ) <$> f v1DaemonSetSpec
{-# INLINE v1DaemonSetSpecL #-}

-- | 'v1DaemonSetStatus' Lens
v1DaemonSetStatusL :: Lens_' V1DaemonSet (Maybe V1DaemonSetStatus)
v1DaemonSetStatusL f V1DaemonSet{..} = (\v1DaemonSetStatus -> V1DaemonSet { v1DaemonSetStatus, ..} ) <$> f v1DaemonSetStatus
{-# INLINE v1DaemonSetStatusL #-}



-- * V1DaemonSetCondition

-- | 'v1DaemonSetConditionLastTransitionTime' Lens
v1DaemonSetConditionLastTransitionTimeL :: Lens_' V1DaemonSetCondition (Maybe DateTime)
v1DaemonSetConditionLastTransitionTimeL f V1DaemonSetCondition{..} = (\v1DaemonSetConditionLastTransitionTime -> V1DaemonSetCondition { v1DaemonSetConditionLastTransitionTime, ..} ) <$> f v1DaemonSetConditionLastTransitionTime
{-# INLINE v1DaemonSetConditionLastTransitionTimeL #-}

-- | 'v1DaemonSetConditionMessage' Lens
v1DaemonSetConditionMessageL :: Lens_' V1DaemonSetCondition (Maybe Text)
v1DaemonSetConditionMessageL f V1DaemonSetCondition{..} = (\v1DaemonSetConditionMessage -> V1DaemonSetCondition { v1DaemonSetConditionMessage, ..} ) <$> f v1DaemonSetConditionMessage
{-# INLINE v1DaemonSetConditionMessageL #-}

-- | 'v1DaemonSetConditionReason' Lens
v1DaemonSetConditionReasonL :: Lens_' V1DaemonSetCondition (Maybe Text)
v1DaemonSetConditionReasonL f V1DaemonSetCondition{..} = (\v1DaemonSetConditionReason -> V1DaemonSetCondition { v1DaemonSetConditionReason, ..} ) <$> f v1DaemonSetConditionReason
{-# INLINE v1DaemonSetConditionReasonL #-}

-- | 'v1DaemonSetConditionStatus' Lens
v1DaemonSetConditionStatusL :: Lens_' V1DaemonSetCondition (Text)
v1DaemonSetConditionStatusL f V1DaemonSetCondition{..} = (\v1DaemonSetConditionStatus -> V1DaemonSetCondition { v1DaemonSetConditionStatus, ..} ) <$> f v1DaemonSetConditionStatus
{-# INLINE v1DaemonSetConditionStatusL #-}

-- | 'v1DaemonSetConditionType' Lens
v1DaemonSetConditionTypeL :: Lens_' V1DaemonSetCondition (Text)
v1DaemonSetConditionTypeL f V1DaemonSetCondition{..} = (\v1DaemonSetConditionType -> V1DaemonSetCondition { v1DaemonSetConditionType, ..} ) <$> f v1DaemonSetConditionType
{-# INLINE v1DaemonSetConditionTypeL #-}



-- * V1DaemonSetList

-- | 'v1DaemonSetListApiVersion' Lens
v1DaemonSetListApiVersionL :: Lens_' V1DaemonSetList (Maybe Text)
v1DaemonSetListApiVersionL f V1DaemonSetList{..} = (\v1DaemonSetListApiVersion -> V1DaemonSetList { v1DaemonSetListApiVersion, ..} ) <$> f v1DaemonSetListApiVersion
{-# INLINE v1DaemonSetListApiVersionL #-}

-- | 'v1DaemonSetListItems' Lens
v1DaemonSetListItemsL :: Lens_' V1DaemonSetList ([V1DaemonSet])
v1DaemonSetListItemsL f V1DaemonSetList{..} = (\v1DaemonSetListItems -> V1DaemonSetList { v1DaemonSetListItems, ..} ) <$> f v1DaemonSetListItems
{-# INLINE v1DaemonSetListItemsL #-}

-- | 'v1DaemonSetListKind' Lens
v1DaemonSetListKindL :: Lens_' V1DaemonSetList (Maybe Text)
v1DaemonSetListKindL f V1DaemonSetList{..} = (\v1DaemonSetListKind -> V1DaemonSetList { v1DaemonSetListKind, ..} ) <$> f v1DaemonSetListKind
{-# INLINE v1DaemonSetListKindL #-}

-- | 'v1DaemonSetListMetadata' Lens
v1DaemonSetListMetadataL :: Lens_' V1DaemonSetList (Maybe V1ListMeta)
v1DaemonSetListMetadataL f V1DaemonSetList{..} = (\v1DaemonSetListMetadata -> V1DaemonSetList { v1DaemonSetListMetadata, ..} ) <$> f v1DaemonSetListMetadata
{-# INLINE v1DaemonSetListMetadataL #-}



-- * V1DaemonSetSpec

-- | 'v1DaemonSetSpecMinReadySeconds' Lens
v1DaemonSetSpecMinReadySecondsL :: Lens_' V1DaemonSetSpec (Maybe Int)
v1DaemonSetSpecMinReadySecondsL f V1DaemonSetSpec{..} = (\v1DaemonSetSpecMinReadySeconds -> V1DaemonSetSpec { v1DaemonSetSpecMinReadySeconds, ..} ) <$> f v1DaemonSetSpecMinReadySeconds
{-# INLINE v1DaemonSetSpecMinReadySecondsL #-}

-- | 'v1DaemonSetSpecRevisionHistoryLimit' Lens
v1DaemonSetSpecRevisionHistoryLimitL :: Lens_' V1DaemonSetSpec (Maybe Int)
v1DaemonSetSpecRevisionHistoryLimitL f V1DaemonSetSpec{..} = (\v1DaemonSetSpecRevisionHistoryLimit -> V1DaemonSetSpec { v1DaemonSetSpecRevisionHistoryLimit, ..} ) <$> f v1DaemonSetSpecRevisionHistoryLimit
{-# INLINE v1DaemonSetSpecRevisionHistoryLimitL #-}

-- | 'v1DaemonSetSpecSelector' Lens
v1DaemonSetSpecSelectorL :: Lens_' V1DaemonSetSpec (V1LabelSelector)
v1DaemonSetSpecSelectorL f V1DaemonSetSpec{..} = (\v1DaemonSetSpecSelector -> V1DaemonSetSpec { v1DaemonSetSpecSelector, ..} ) <$> f v1DaemonSetSpecSelector
{-# INLINE v1DaemonSetSpecSelectorL #-}

-- | 'v1DaemonSetSpecTemplate' Lens
v1DaemonSetSpecTemplateL :: Lens_' V1DaemonSetSpec (V1PodTemplateSpec)
v1DaemonSetSpecTemplateL f V1DaemonSetSpec{..} = (\v1DaemonSetSpecTemplate -> V1DaemonSetSpec { v1DaemonSetSpecTemplate, ..} ) <$> f v1DaemonSetSpecTemplate
{-# INLINE v1DaemonSetSpecTemplateL #-}

-- | 'v1DaemonSetSpecUpdateStrategy' Lens
v1DaemonSetSpecUpdateStrategyL :: Lens_' V1DaemonSetSpec (Maybe V1DaemonSetUpdateStrategy)
v1DaemonSetSpecUpdateStrategyL f V1DaemonSetSpec{..} = (\v1DaemonSetSpecUpdateStrategy -> V1DaemonSetSpec { v1DaemonSetSpecUpdateStrategy, ..} ) <$> f v1DaemonSetSpecUpdateStrategy
{-# INLINE v1DaemonSetSpecUpdateStrategyL #-}



-- * V1DaemonSetStatus

-- | 'v1DaemonSetStatusCollisionCount' Lens
v1DaemonSetStatusCollisionCountL :: Lens_' V1DaemonSetStatus (Maybe Int)
v1DaemonSetStatusCollisionCountL f V1DaemonSetStatus{..} = (\v1DaemonSetStatusCollisionCount -> V1DaemonSetStatus { v1DaemonSetStatusCollisionCount, ..} ) <$> f v1DaemonSetStatusCollisionCount
{-# INLINE v1DaemonSetStatusCollisionCountL #-}

-- | 'v1DaemonSetStatusConditions' Lens
v1DaemonSetStatusConditionsL :: Lens_' V1DaemonSetStatus (Maybe [V1DaemonSetCondition])
v1DaemonSetStatusConditionsL f V1DaemonSetStatus{..} = (\v1DaemonSetStatusConditions -> V1DaemonSetStatus { v1DaemonSetStatusConditions, ..} ) <$> f v1DaemonSetStatusConditions
{-# INLINE v1DaemonSetStatusConditionsL #-}

-- | 'v1DaemonSetStatusCurrentNumberScheduled' Lens
v1DaemonSetStatusCurrentNumberScheduledL :: Lens_' V1DaemonSetStatus (Int)
v1DaemonSetStatusCurrentNumberScheduledL f V1DaemonSetStatus{..} = (\v1DaemonSetStatusCurrentNumberScheduled -> V1DaemonSetStatus { v1DaemonSetStatusCurrentNumberScheduled, ..} ) <$> f v1DaemonSetStatusCurrentNumberScheduled
{-# INLINE v1DaemonSetStatusCurrentNumberScheduledL #-}

-- | 'v1DaemonSetStatusDesiredNumberScheduled' Lens
v1DaemonSetStatusDesiredNumberScheduledL :: Lens_' V1DaemonSetStatus (Int)
v1DaemonSetStatusDesiredNumberScheduledL f V1DaemonSetStatus{..} = (\v1DaemonSetStatusDesiredNumberScheduled -> V1DaemonSetStatus { v1DaemonSetStatusDesiredNumberScheduled, ..} ) <$> f v1DaemonSetStatusDesiredNumberScheduled
{-# INLINE v1DaemonSetStatusDesiredNumberScheduledL #-}

-- | 'v1DaemonSetStatusNumberAvailable' Lens
v1DaemonSetStatusNumberAvailableL :: Lens_' V1DaemonSetStatus (Maybe Int)
v1DaemonSetStatusNumberAvailableL f V1DaemonSetStatus{..} = (\v1DaemonSetStatusNumberAvailable -> V1DaemonSetStatus { v1DaemonSetStatusNumberAvailable, ..} ) <$> f v1DaemonSetStatusNumberAvailable
{-# INLINE v1DaemonSetStatusNumberAvailableL #-}

-- | 'v1DaemonSetStatusNumberMisscheduled' Lens
v1DaemonSetStatusNumberMisscheduledL :: Lens_' V1DaemonSetStatus (Int)
v1DaemonSetStatusNumberMisscheduledL f V1DaemonSetStatus{..} = (\v1DaemonSetStatusNumberMisscheduled -> V1DaemonSetStatus { v1DaemonSetStatusNumberMisscheduled, ..} ) <$> f v1DaemonSetStatusNumberMisscheduled
{-# INLINE v1DaemonSetStatusNumberMisscheduledL #-}

-- | 'v1DaemonSetStatusNumberReady' Lens
v1DaemonSetStatusNumberReadyL :: Lens_' V1DaemonSetStatus (Int)
v1DaemonSetStatusNumberReadyL f V1DaemonSetStatus{..} = (\v1DaemonSetStatusNumberReady -> V1DaemonSetStatus { v1DaemonSetStatusNumberReady, ..} ) <$> f v1DaemonSetStatusNumberReady
{-# INLINE v1DaemonSetStatusNumberReadyL #-}

-- | 'v1DaemonSetStatusNumberUnavailable' Lens
v1DaemonSetStatusNumberUnavailableL :: Lens_' V1DaemonSetStatus (Maybe Int)
v1DaemonSetStatusNumberUnavailableL f V1DaemonSetStatus{..} = (\v1DaemonSetStatusNumberUnavailable -> V1DaemonSetStatus { v1DaemonSetStatusNumberUnavailable, ..} ) <$> f v1DaemonSetStatusNumberUnavailable
{-# INLINE v1DaemonSetStatusNumberUnavailableL #-}

-- | 'v1DaemonSetStatusObservedGeneration' Lens
v1DaemonSetStatusObservedGenerationL :: Lens_' V1DaemonSetStatus (Maybe Integer)
v1DaemonSetStatusObservedGenerationL f V1DaemonSetStatus{..} = (\v1DaemonSetStatusObservedGeneration -> V1DaemonSetStatus { v1DaemonSetStatusObservedGeneration, ..} ) <$> f v1DaemonSetStatusObservedGeneration
{-# INLINE v1DaemonSetStatusObservedGenerationL #-}

-- | 'v1DaemonSetStatusUpdatedNumberScheduled' Lens
v1DaemonSetStatusUpdatedNumberScheduledL :: Lens_' V1DaemonSetStatus (Maybe Int)
v1DaemonSetStatusUpdatedNumberScheduledL f V1DaemonSetStatus{..} = (\v1DaemonSetStatusUpdatedNumberScheduled -> V1DaemonSetStatus { v1DaemonSetStatusUpdatedNumberScheduled, ..} ) <$> f v1DaemonSetStatusUpdatedNumberScheduled
{-# INLINE v1DaemonSetStatusUpdatedNumberScheduledL #-}



-- * V1DaemonSetUpdateStrategy

-- | 'v1DaemonSetUpdateStrategyRollingUpdate' Lens
v1DaemonSetUpdateStrategyRollingUpdateL :: Lens_' V1DaemonSetUpdateStrategy (Maybe V1RollingUpdateDaemonSet)
v1DaemonSetUpdateStrategyRollingUpdateL f V1DaemonSetUpdateStrategy{..} = (\v1DaemonSetUpdateStrategyRollingUpdate -> V1DaemonSetUpdateStrategy { v1DaemonSetUpdateStrategyRollingUpdate, ..} ) <$> f v1DaemonSetUpdateStrategyRollingUpdate
{-# INLINE v1DaemonSetUpdateStrategyRollingUpdateL #-}

-- | 'v1DaemonSetUpdateStrategyType' Lens
v1DaemonSetUpdateStrategyTypeL :: Lens_' V1DaemonSetUpdateStrategy (Maybe Text)
v1DaemonSetUpdateStrategyTypeL f V1DaemonSetUpdateStrategy{..} = (\v1DaemonSetUpdateStrategyType -> V1DaemonSetUpdateStrategy { v1DaemonSetUpdateStrategyType, ..} ) <$> f v1DaemonSetUpdateStrategyType
{-# INLINE v1DaemonSetUpdateStrategyTypeL #-}



-- * V1DeleteOptions

-- | 'v1DeleteOptionsApiVersion' Lens
v1DeleteOptionsApiVersionL :: Lens_' V1DeleteOptions (Maybe Text)
v1DeleteOptionsApiVersionL f V1DeleteOptions{..} = (\v1DeleteOptionsApiVersion -> V1DeleteOptions { v1DeleteOptionsApiVersion, ..} ) <$> f v1DeleteOptionsApiVersion
{-# INLINE v1DeleteOptionsApiVersionL #-}

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

-- | 'v1DeleteOptionsGracePeriodSeconds' Lens
v1DeleteOptionsGracePeriodSecondsL :: Lens_' V1DeleteOptions (Maybe Integer)
v1DeleteOptionsGracePeriodSecondsL f V1DeleteOptions{..} = (\v1DeleteOptionsGracePeriodSeconds -> V1DeleteOptions { v1DeleteOptionsGracePeriodSeconds, ..} ) <$> f v1DeleteOptionsGracePeriodSeconds
{-# INLINE v1DeleteOptionsGracePeriodSecondsL #-}

-- | 'v1DeleteOptionsKind' Lens
v1DeleteOptionsKindL :: Lens_' V1DeleteOptions (Maybe Text)
v1DeleteOptionsKindL f V1DeleteOptions{..} = (\v1DeleteOptionsKind -> V1DeleteOptions { v1DeleteOptionsKind, ..} ) <$> f v1DeleteOptionsKind
{-# INLINE v1DeleteOptionsKindL #-}

-- | 'v1DeleteOptionsOrphanDependents' Lens
v1DeleteOptionsOrphanDependentsL :: Lens_' V1DeleteOptions (Maybe Bool)
v1DeleteOptionsOrphanDependentsL f V1DeleteOptions{..} = (\v1DeleteOptionsOrphanDependents -> V1DeleteOptions { v1DeleteOptionsOrphanDependents, ..} ) <$> f v1DeleteOptionsOrphanDependents
{-# INLINE v1DeleteOptionsOrphanDependentsL #-}

-- | 'v1DeleteOptionsPreconditions' Lens
v1DeleteOptionsPreconditionsL :: Lens_' V1DeleteOptions (Maybe V1Preconditions)
v1DeleteOptionsPreconditionsL f V1DeleteOptions{..} = (\v1DeleteOptionsPreconditions -> V1DeleteOptions { v1DeleteOptionsPreconditions, ..} ) <$> f v1DeleteOptionsPreconditions
{-# INLINE v1DeleteOptionsPreconditionsL #-}

-- | 'v1DeleteOptionsPropagationPolicy' Lens
v1DeleteOptionsPropagationPolicyL :: Lens_' V1DeleteOptions (Maybe Text)
v1DeleteOptionsPropagationPolicyL f V1DeleteOptions{..} = (\v1DeleteOptionsPropagationPolicy -> V1DeleteOptions { v1DeleteOptionsPropagationPolicy, ..} ) <$> f v1DeleteOptionsPropagationPolicy
{-# INLINE v1DeleteOptionsPropagationPolicyL #-}



-- * V1Deployment

-- | 'v1DeploymentApiVersion' Lens
v1DeploymentApiVersionL :: Lens_' V1Deployment (Maybe Text)
v1DeploymentApiVersionL f V1Deployment{..} = (\v1DeploymentApiVersion -> V1Deployment { v1DeploymentApiVersion, ..} ) <$> f v1DeploymentApiVersion
{-# INLINE v1DeploymentApiVersionL #-}

-- | 'v1DeploymentKind' Lens
v1DeploymentKindL :: Lens_' V1Deployment (Maybe Text)
v1DeploymentKindL f V1Deployment{..} = (\v1DeploymentKind -> V1Deployment { v1DeploymentKind, ..} ) <$> f v1DeploymentKind
{-# INLINE v1DeploymentKindL #-}

-- | 'v1DeploymentMetadata' Lens
v1DeploymentMetadataL :: Lens_' V1Deployment (Maybe V1ObjectMeta)
v1DeploymentMetadataL f V1Deployment{..} = (\v1DeploymentMetadata -> V1Deployment { v1DeploymentMetadata, ..} ) <$> f v1DeploymentMetadata
{-# INLINE v1DeploymentMetadataL #-}

-- | 'v1DeploymentSpec' Lens
v1DeploymentSpecL :: Lens_' V1Deployment (Maybe V1DeploymentSpec)
v1DeploymentSpecL f V1Deployment{..} = (\v1DeploymentSpec -> V1Deployment { v1DeploymentSpec, ..} ) <$> f v1DeploymentSpec
{-# INLINE v1DeploymentSpecL #-}

-- | 'v1DeploymentStatus' Lens
v1DeploymentStatusL :: Lens_' V1Deployment (Maybe V1DeploymentStatus)
v1DeploymentStatusL f V1Deployment{..} = (\v1DeploymentStatus -> V1Deployment { v1DeploymentStatus, ..} ) <$> f v1DeploymentStatus
{-# INLINE v1DeploymentStatusL #-}



-- * V1DeploymentCondition

-- | 'v1DeploymentConditionLastTransitionTime' Lens
v1DeploymentConditionLastTransitionTimeL :: Lens_' V1DeploymentCondition (Maybe DateTime)
v1DeploymentConditionLastTransitionTimeL f V1DeploymentCondition{..} = (\v1DeploymentConditionLastTransitionTime -> V1DeploymentCondition { v1DeploymentConditionLastTransitionTime, ..} ) <$> f v1DeploymentConditionLastTransitionTime
{-# INLINE v1DeploymentConditionLastTransitionTimeL #-}

-- | 'v1DeploymentConditionLastUpdateTime' Lens
v1DeploymentConditionLastUpdateTimeL :: Lens_' V1DeploymentCondition (Maybe DateTime)
v1DeploymentConditionLastUpdateTimeL f V1DeploymentCondition{..} = (\v1DeploymentConditionLastUpdateTime -> V1DeploymentCondition { v1DeploymentConditionLastUpdateTime, ..} ) <$> f v1DeploymentConditionLastUpdateTime
{-# INLINE v1DeploymentConditionLastUpdateTimeL #-}

-- | 'v1DeploymentConditionMessage' Lens
v1DeploymentConditionMessageL :: Lens_' V1DeploymentCondition (Maybe Text)
v1DeploymentConditionMessageL f V1DeploymentCondition{..} = (\v1DeploymentConditionMessage -> V1DeploymentCondition { v1DeploymentConditionMessage, ..} ) <$> f v1DeploymentConditionMessage
{-# INLINE v1DeploymentConditionMessageL #-}

-- | 'v1DeploymentConditionReason' Lens
v1DeploymentConditionReasonL :: Lens_' V1DeploymentCondition (Maybe Text)
v1DeploymentConditionReasonL f V1DeploymentCondition{..} = (\v1DeploymentConditionReason -> V1DeploymentCondition { v1DeploymentConditionReason, ..} ) <$> f v1DeploymentConditionReason
{-# INLINE v1DeploymentConditionReasonL #-}

-- | 'v1DeploymentConditionStatus' Lens
v1DeploymentConditionStatusL :: Lens_' V1DeploymentCondition (Text)
v1DeploymentConditionStatusL f V1DeploymentCondition{..} = (\v1DeploymentConditionStatus -> V1DeploymentCondition { v1DeploymentConditionStatus, ..} ) <$> f v1DeploymentConditionStatus
{-# INLINE v1DeploymentConditionStatusL #-}

-- | 'v1DeploymentConditionType' Lens
v1DeploymentConditionTypeL :: Lens_' V1DeploymentCondition (Text)
v1DeploymentConditionTypeL f V1DeploymentCondition{..} = (\v1DeploymentConditionType -> V1DeploymentCondition { v1DeploymentConditionType, ..} ) <$> f v1DeploymentConditionType
{-# INLINE v1DeploymentConditionTypeL #-}



-- * V1DeploymentList

-- | 'v1DeploymentListApiVersion' Lens
v1DeploymentListApiVersionL :: Lens_' V1DeploymentList (Maybe Text)
v1DeploymentListApiVersionL f V1DeploymentList{..} = (\v1DeploymentListApiVersion -> V1DeploymentList { v1DeploymentListApiVersion, ..} ) <$> f v1DeploymentListApiVersion
{-# INLINE v1DeploymentListApiVersionL #-}

-- | 'v1DeploymentListItems' Lens
v1DeploymentListItemsL :: Lens_' V1DeploymentList ([V1Deployment])
v1DeploymentListItemsL f V1DeploymentList{..} = (\v1DeploymentListItems -> V1DeploymentList { v1DeploymentListItems, ..} ) <$> f v1DeploymentListItems
{-# INLINE v1DeploymentListItemsL #-}

-- | 'v1DeploymentListKind' Lens
v1DeploymentListKindL :: Lens_' V1DeploymentList (Maybe Text)
v1DeploymentListKindL f V1DeploymentList{..} = (\v1DeploymentListKind -> V1DeploymentList { v1DeploymentListKind, ..} ) <$> f v1DeploymentListKind
{-# INLINE v1DeploymentListKindL #-}

-- | 'v1DeploymentListMetadata' Lens
v1DeploymentListMetadataL :: Lens_' V1DeploymentList (Maybe V1ListMeta)
v1DeploymentListMetadataL f V1DeploymentList{..} = (\v1DeploymentListMetadata -> V1DeploymentList { v1DeploymentListMetadata, ..} ) <$> f v1DeploymentListMetadata
{-# INLINE v1DeploymentListMetadataL #-}



-- * V1DeploymentSpec

-- | 'v1DeploymentSpecMinReadySeconds' Lens
v1DeploymentSpecMinReadySecondsL :: Lens_' V1DeploymentSpec (Maybe Int)
v1DeploymentSpecMinReadySecondsL f V1DeploymentSpec{..} = (\v1DeploymentSpecMinReadySeconds -> V1DeploymentSpec { v1DeploymentSpecMinReadySeconds, ..} ) <$> f v1DeploymentSpecMinReadySeconds
{-# INLINE v1DeploymentSpecMinReadySecondsL #-}

-- | 'v1DeploymentSpecPaused' Lens
v1DeploymentSpecPausedL :: Lens_' V1DeploymentSpec (Maybe Bool)
v1DeploymentSpecPausedL f V1DeploymentSpec{..} = (\v1DeploymentSpecPaused -> V1DeploymentSpec { v1DeploymentSpecPaused, ..} ) <$> f v1DeploymentSpecPaused
{-# INLINE v1DeploymentSpecPausedL #-}

-- | 'v1DeploymentSpecProgressDeadlineSeconds' Lens
v1DeploymentSpecProgressDeadlineSecondsL :: Lens_' V1DeploymentSpec (Maybe Int)
v1DeploymentSpecProgressDeadlineSecondsL f V1DeploymentSpec{..} = (\v1DeploymentSpecProgressDeadlineSeconds -> V1DeploymentSpec { v1DeploymentSpecProgressDeadlineSeconds, ..} ) <$> f v1DeploymentSpecProgressDeadlineSeconds
{-# INLINE v1DeploymentSpecProgressDeadlineSecondsL #-}

-- | 'v1DeploymentSpecReplicas' Lens
v1DeploymentSpecReplicasL :: Lens_' V1DeploymentSpec (Maybe Int)
v1DeploymentSpecReplicasL f V1DeploymentSpec{..} = (\v1DeploymentSpecReplicas -> V1DeploymentSpec { v1DeploymentSpecReplicas, ..} ) <$> f v1DeploymentSpecReplicas
{-# INLINE v1DeploymentSpecReplicasL #-}

-- | 'v1DeploymentSpecRevisionHistoryLimit' Lens
v1DeploymentSpecRevisionHistoryLimitL :: Lens_' V1DeploymentSpec (Maybe Int)
v1DeploymentSpecRevisionHistoryLimitL f V1DeploymentSpec{..} = (\v1DeploymentSpecRevisionHistoryLimit -> V1DeploymentSpec { v1DeploymentSpecRevisionHistoryLimit, ..} ) <$> f v1DeploymentSpecRevisionHistoryLimit
{-# INLINE v1DeploymentSpecRevisionHistoryLimitL #-}

-- | 'v1DeploymentSpecSelector' Lens
v1DeploymentSpecSelectorL :: Lens_' V1DeploymentSpec (V1LabelSelector)
v1DeploymentSpecSelectorL f V1DeploymentSpec{..} = (\v1DeploymentSpecSelector -> V1DeploymentSpec { v1DeploymentSpecSelector, ..} ) <$> f v1DeploymentSpecSelector
{-# INLINE v1DeploymentSpecSelectorL #-}

-- | 'v1DeploymentSpecStrategy' Lens
v1DeploymentSpecStrategyL :: Lens_' V1DeploymentSpec (Maybe V1DeploymentStrategy)
v1DeploymentSpecStrategyL f V1DeploymentSpec{..} = (\v1DeploymentSpecStrategy -> V1DeploymentSpec { v1DeploymentSpecStrategy, ..} ) <$> f v1DeploymentSpecStrategy
{-# INLINE v1DeploymentSpecStrategyL #-}

-- | 'v1DeploymentSpecTemplate' Lens
v1DeploymentSpecTemplateL :: Lens_' V1DeploymentSpec (V1PodTemplateSpec)
v1DeploymentSpecTemplateL f V1DeploymentSpec{..} = (\v1DeploymentSpecTemplate -> V1DeploymentSpec { v1DeploymentSpecTemplate, ..} ) <$> f v1DeploymentSpecTemplate
{-# INLINE v1DeploymentSpecTemplateL #-}



-- * V1DeploymentStatus

-- | 'v1DeploymentStatusAvailableReplicas' Lens
v1DeploymentStatusAvailableReplicasL :: Lens_' V1DeploymentStatus (Maybe Int)
v1DeploymentStatusAvailableReplicasL f V1DeploymentStatus{..} = (\v1DeploymentStatusAvailableReplicas -> V1DeploymentStatus { v1DeploymentStatusAvailableReplicas, ..} ) <$> f v1DeploymentStatusAvailableReplicas
{-# INLINE v1DeploymentStatusAvailableReplicasL #-}

-- | 'v1DeploymentStatusCollisionCount' Lens
v1DeploymentStatusCollisionCountL :: Lens_' V1DeploymentStatus (Maybe Int)
v1DeploymentStatusCollisionCountL f V1DeploymentStatus{..} = (\v1DeploymentStatusCollisionCount -> V1DeploymentStatus { v1DeploymentStatusCollisionCount, ..} ) <$> f v1DeploymentStatusCollisionCount
{-# INLINE v1DeploymentStatusCollisionCountL #-}

-- | 'v1DeploymentStatusConditions' Lens
v1DeploymentStatusConditionsL :: Lens_' V1DeploymentStatus (Maybe [V1DeploymentCondition])
v1DeploymentStatusConditionsL f V1DeploymentStatus{..} = (\v1DeploymentStatusConditions -> V1DeploymentStatus { v1DeploymentStatusConditions, ..} ) <$> f v1DeploymentStatusConditions
{-# INLINE v1DeploymentStatusConditionsL #-}

-- | 'v1DeploymentStatusObservedGeneration' Lens
v1DeploymentStatusObservedGenerationL :: Lens_' V1DeploymentStatus (Maybe Integer)
v1DeploymentStatusObservedGenerationL f V1DeploymentStatus{..} = (\v1DeploymentStatusObservedGeneration -> V1DeploymentStatus { v1DeploymentStatusObservedGeneration, ..} ) <$> f v1DeploymentStatusObservedGeneration
{-# INLINE v1DeploymentStatusObservedGenerationL #-}

-- | 'v1DeploymentStatusReadyReplicas' Lens
v1DeploymentStatusReadyReplicasL :: Lens_' V1DeploymentStatus (Maybe Int)
v1DeploymentStatusReadyReplicasL f V1DeploymentStatus{..} = (\v1DeploymentStatusReadyReplicas -> V1DeploymentStatus { v1DeploymentStatusReadyReplicas, ..} ) <$> f v1DeploymentStatusReadyReplicas
{-# INLINE v1DeploymentStatusReadyReplicasL #-}

-- | 'v1DeploymentStatusReplicas' Lens
v1DeploymentStatusReplicasL :: Lens_' V1DeploymentStatus (Maybe Int)
v1DeploymentStatusReplicasL f V1DeploymentStatus{..} = (\v1DeploymentStatusReplicas -> V1DeploymentStatus { v1DeploymentStatusReplicas, ..} ) <$> f v1DeploymentStatusReplicas
{-# INLINE v1DeploymentStatusReplicasL #-}

-- | 'v1DeploymentStatusUnavailableReplicas' Lens
v1DeploymentStatusUnavailableReplicasL :: Lens_' V1DeploymentStatus (Maybe Int)
v1DeploymentStatusUnavailableReplicasL f V1DeploymentStatus{..} = (\v1DeploymentStatusUnavailableReplicas -> V1DeploymentStatus { v1DeploymentStatusUnavailableReplicas, ..} ) <$> f v1DeploymentStatusUnavailableReplicas
{-# INLINE v1DeploymentStatusUnavailableReplicasL #-}

-- | 'v1DeploymentStatusUpdatedReplicas' Lens
v1DeploymentStatusUpdatedReplicasL :: Lens_' V1DeploymentStatus (Maybe Int)
v1DeploymentStatusUpdatedReplicasL f V1DeploymentStatus{..} = (\v1DeploymentStatusUpdatedReplicas -> V1DeploymentStatus { v1DeploymentStatusUpdatedReplicas, ..} ) <$> f v1DeploymentStatusUpdatedReplicas
{-# INLINE v1DeploymentStatusUpdatedReplicasL #-}



-- * V1DeploymentStrategy

-- | 'v1DeploymentStrategyRollingUpdate' Lens
v1DeploymentStrategyRollingUpdateL :: Lens_' V1DeploymentStrategy (Maybe V1RollingUpdateDeployment)
v1DeploymentStrategyRollingUpdateL f V1DeploymentStrategy{..} = (\v1DeploymentStrategyRollingUpdate -> V1DeploymentStrategy { v1DeploymentStrategyRollingUpdate, ..} ) <$> f v1DeploymentStrategyRollingUpdate
{-# INLINE v1DeploymentStrategyRollingUpdateL #-}

-- | 'v1DeploymentStrategyType' Lens
v1DeploymentStrategyTypeL :: Lens_' V1DeploymentStrategy (Maybe Text)
v1DeploymentStrategyTypeL f V1DeploymentStrategy{..} = (\v1DeploymentStrategyType -> V1DeploymentStrategy { v1DeploymentStrategyType, ..} ) <$> f v1DeploymentStrategyType
{-# INLINE v1DeploymentStrategyTypeL #-}



-- * V1DownwardAPIProjection

-- | 'v1DownwardAPIProjectionItems' Lens
v1DownwardAPIProjectionItemsL :: Lens_' V1DownwardAPIProjection (Maybe [V1DownwardAPIVolumeFile])
v1DownwardAPIProjectionItemsL f V1DownwardAPIProjection{..} = (\v1DownwardAPIProjectionItems -> V1DownwardAPIProjection { v1DownwardAPIProjectionItems, ..} ) <$> f v1DownwardAPIProjectionItems
{-# INLINE v1DownwardAPIProjectionItemsL #-}



-- * V1DownwardAPIVolumeFile

-- | 'v1DownwardAPIVolumeFileFieldRef' Lens
v1DownwardAPIVolumeFileFieldRefL :: Lens_' V1DownwardAPIVolumeFile (Maybe V1ObjectFieldSelector)
v1DownwardAPIVolumeFileFieldRefL f V1DownwardAPIVolumeFile{..} = (\v1DownwardAPIVolumeFileFieldRef -> V1DownwardAPIVolumeFile { v1DownwardAPIVolumeFileFieldRef, ..} ) <$> f v1DownwardAPIVolumeFileFieldRef
{-# INLINE v1DownwardAPIVolumeFileFieldRefL #-}

-- | 'v1DownwardAPIVolumeFileMode' Lens
v1DownwardAPIVolumeFileModeL :: Lens_' V1DownwardAPIVolumeFile (Maybe Int)
v1DownwardAPIVolumeFileModeL f V1DownwardAPIVolumeFile{..} = (\v1DownwardAPIVolumeFileMode -> V1DownwardAPIVolumeFile { v1DownwardAPIVolumeFileMode, ..} ) <$> f v1DownwardAPIVolumeFileMode
{-# INLINE v1DownwardAPIVolumeFileModeL #-}

-- | 'v1DownwardAPIVolumeFilePath' Lens
v1DownwardAPIVolumeFilePathL :: Lens_' V1DownwardAPIVolumeFile (Text)
v1DownwardAPIVolumeFilePathL f V1DownwardAPIVolumeFile{..} = (\v1DownwardAPIVolumeFilePath -> V1DownwardAPIVolumeFile { v1DownwardAPIVolumeFilePath, ..} ) <$> f v1DownwardAPIVolumeFilePath
{-# INLINE v1DownwardAPIVolumeFilePathL #-}

-- | 'v1DownwardAPIVolumeFileResourceFieldRef' Lens
v1DownwardAPIVolumeFileResourceFieldRefL :: Lens_' V1DownwardAPIVolumeFile (Maybe V1ResourceFieldSelector)
v1DownwardAPIVolumeFileResourceFieldRefL f V1DownwardAPIVolumeFile{..} = (\v1DownwardAPIVolumeFileResourceFieldRef -> V1DownwardAPIVolumeFile { v1DownwardAPIVolumeFileResourceFieldRef, ..} ) <$> f v1DownwardAPIVolumeFileResourceFieldRef
{-# INLINE v1DownwardAPIVolumeFileResourceFieldRefL #-}



-- * V1DownwardAPIVolumeSource

-- | 'v1DownwardAPIVolumeSourceDefaultMode' Lens
v1DownwardAPIVolumeSourceDefaultModeL :: Lens_' V1DownwardAPIVolumeSource (Maybe Int)
v1DownwardAPIVolumeSourceDefaultModeL f V1DownwardAPIVolumeSource{..} = (\v1DownwardAPIVolumeSourceDefaultMode -> V1DownwardAPIVolumeSource { v1DownwardAPIVolumeSourceDefaultMode, ..} ) <$> f v1DownwardAPIVolumeSourceDefaultMode
{-# INLINE v1DownwardAPIVolumeSourceDefaultModeL #-}

-- | 'v1DownwardAPIVolumeSourceItems' Lens
v1DownwardAPIVolumeSourceItemsL :: Lens_' V1DownwardAPIVolumeSource (Maybe [V1DownwardAPIVolumeFile])
v1DownwardAPIVolumeSourceItemsL f V1DownwardAPIVolumeSource{..} = (\v1DownwardAPIVolumeSourceItems -> V1DownwardAPIVolumeSource { v1DownwardAPIVolumeSourceItems, ..} ) <$> f v1DownwardAPIVolumeSourceItems
{-# INLINE v1DownwardAPIVolumeSourceItemsL #-}



-- * V1EmptyDirVolumeSource

-- | 'v1EmptyDirVolumeSourceMedium' Lens
v1EmptyDirVolumeSourceMediumL :: Lens_' V1EmptyDirVolumeSource (Maybe Text)
v1EmptyDirVolumeSourceMediumL f V1EmptyDirVolumeSource{..} = (\v1EmptyDirVolumeSourceMedium -> V1EmptyDirVolumeSource { v1EmptyDirVolumeSourceMedium, ..} ) <$> f v1EmptyDirVolumeSourceMedium
{-# INLINE v1EmptyDirVolumeSourceMediumL #-}

-- | 'v1EmptyDirVolumeSourceSizeLimit' Lens
v1EmptyDirVolumeSourceSizeLimitL :: Lens_' V1EmptyDirVolumeSource (Maybe Quantity)
v1EmptyDirVolumeSourceSizeLimitL f V1EmptyDirVolumeSource{..} = (\v1EmptyDirVolumeSourceSizeLimit -> V1EmptyDirVolumeSource { v1EmptyDirVolumeSourceSizeLimit, ..} ) <$> f v1EmptyDirVolumeSourceSizeLimit
{-# INLINE v1EmptyDirVolumeSourceSizeLimitL #-}



-- * V1Endpoint

-- | 'v1EndpointAddresses' Lens
v1EndpointAddressesL :: Lens_' V1Endpoint ([Text])
v1EndpointAddressesL f V1Endpoint{..} = (\v1EndpointAddresses -> V1Endpoint { v1EndpointAddresses, ..} ) <$> f v1EndpointAddresses
{-# INLINE v1EndpointAddressesL #-}

-- | 'v1EndpointConditions' Lens
v1EndpointConditionsL :: Lens_' V1Endpoint (Maybe V1EndpointConditions)
v1EndpointConditionsL f V1Endpoint{..} = (\v1EndpointConditions -> V1Endpoint { v1EndpointConditions, ..} ) <$> f v1EndpointConditions
{-# INLINE v1EndpointConditionsL #-}

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

-- | 'v1EndpointHints' Lens
v1EndpointHintsL :: Lens_' V1Endpoint (Maybe V1EndpointHints)
v1EndpointHintsL f V1Endpoint{..} = (\v1EndpointHints -> V1Endpoint { v1EndpointHints, ..} ) <$> f v1EndpointHints
{-# INLINE v1EndpointHintsL #-}

-- | 'v1EndpointHostname' Lens
v1EndpointHostnameL :: Lens_' V1Endpoint (Maybe Text)
v1EndpointHostnameL f V1Endpoint{..} = (\v1EndpointHostname -> V1Endpoint { v1EndpointHostname, ..} ) <$> f v1EndpointHostname
{-# INLINE v1EndpointHostnameL #-}

-- | 'v1EndpointNodeName' Lens
v1EndpointNodeNameL :: Lens_' V1Endpoint (Maybe Text)
v1EndpointNodeNameL f V1Endpoint{..} = (\v1EndpointNodeName -> V1Endpoint { v1EndpointNodeName, ..} ) <$> f v1EndpointNodeName
{-# INLINE v1EndpointNodeNameL #-}

-- | 'v1EndpointTargetRef' Lens
v1EndpointTargetRefL :: Lens_' V1Endpoint (Maybe V1ObjectReference)
v1EndpointTargetRefL f V1Endpoint{..} = (\v1EndpointTargetRef -> V1Endpoint { v1EndpointTargetRef, ..} ) <$> f v1EndpointTargetRef
{-# INLINE v1EndpointTargetRefL #-}

-- | 'v1EndpointZone' Lens
v1EndpointZoneL :: Lens_' V1Endpoint (Maybe Text)
v1EndpointZoneL f V1Endpoint{..} = (\v1EndpointZone -> V1Endpoint { v1EndpointZone, ..} ) <$> f v1EndpointZone
{-# INLINE v1EndpointZoneL #-}



-- * V1EndpointAddress

-- | 'v1EndpointAddressHostname' Lens
v1EndpointAddressHostnameL :: Lens_' V1EndpointAddress (Maybe Text)
v1EndpointAddressHostnameL f V1EndpointAddress{..} = (\v1EndpointAddressHostname -> V1EndpointAddress { v1EndpointAddressHostname, ..} ) <$> f v1EndpointAddressHostname
{-# INLINE v1EndpointAddressHostnameL #-}

-- | 'v1EndpointAddressIp' Lens
v1EndpointAddressIpL :: Lens_' V1EndpointAddress (Text)
v1EndpointAddressIpL f V1EndpointAddress{..} = (\v1EndpointAddressIp -> V1EndpointAddress { v1EndpointAddressIp, ..} ) <$> f v1EndpointAddressIp
{-# INLINE v1EndpointAddressIpL #-}

-- | 'v1EndpointAddressNodeName' Lens
v1EndpointAddressNodeNameL :: Lens_' V1EndpointAddress (Maybe Text)
v1EndpointAddressNodeNameL f V1EndpointAddress{..} = (\v1EndpointAddressNodeName -> V1EndpointAddress { v1EndpointAddressNodeName, ..} ) <$> f v1EndpointAddressNodeName
{-# INLINE v1EndpointAddressNodeNameL #-}

-- | 'v1EndpointAddressTargetRef' Lens
v1EndpointAddressTargetRefL :: Lens_' V1EndpointAddress (Maybe V1ObjectReference)
v1EndpointAddressTargetRefL f V1EndpointAddress{..} = (\v1EndpointAddressTargetRef -> V1EndpointAddress { v1EndpointAddressTargetRef, ..} ) <$> f v1EndpointAddressTargetRef
{-# INLINE v1EndpointAddressTargetRefL #-}



-- * V1EndpointConditions

-- | 'v1EndpointConditionsReady' Lens
v1EndpointConditionsReadyL :: Lens_' V1EndpointConditions (Maybe Bool)
v1EndpointConditionsReadyL f V1EndpointConditions{..} = (\v1EndpointConditionsReady -> V1EndpointConditions { v1EndpointConditionsReady, ..} ) <$> f v1EndpointConditionsReady
{-# INLINE v1EndpointConditionsReadyL #-}

-- | 'v1EndpointConditionsServing' Lens
v1EndpointConditionsServingL :: Lens_' V1EndpointConditions (Maybe Bool)
v1EndpointConditionsServingL f V1EndpointConditions{..} = (\v1EndpointConditionsServing -> V1EndpointConditions { v1EndpointConditionsServing, ..} ) <$> f v1EndpointConditionsServing
{-# INLINE v1EndpointConditionsServingL #-}

-- | 'v1EndpointConditionsTerminating' Lens
v1EndpointConditionsTerminatingL :: Lens_' V1EndpointConditions (Maybe Bool)
v1EndpointConditionsTerminatingL f V1EndpointConditions{..} = (\v1EndpointConditionsTerminating -> V1EndpointConditions { v1EndpointConditionsTerminating, ..} ) <$> f v1EndpointConditionsTerminating
{-# INLINE v1EndpointConditionsTerminatingL #-}



-- * V1EndpointHints

-- | 'v1EndpointHintsForZones' Lens
v1EndpointHintsForZonesL :: Lens_' V1EndpointHints (Maybe [V1ForZone])
v1EndpointHintsForZonesL f V1EndpointHints{..} = (\v1EndpointHintsForZones -> V1EndpointHints { v1EndpointHintsForZones, ..} ) <$> f v1EndpointHintsForZones
{-# INLINE v1EndpointHintsForZonesL #-}



-- * V1EndpointSlice

-- | 'v1EndpointSliceAddressType' Lens
v1EndpointSliceAddressTypeL :: Lens_' V1EndpointSlice (Text)
v1EndpointSliceAddressTypeL f V1EndpointSlice{..} = (\v1EndpointSliceAddressType -> V1EndpointSlice { v1EndpointSliceAddressType, ..} ) <$> f v1EndpointSliceAddressType
{-# INLINE v1EndpointSliceAddressTypeL #-}

-- | 'v1EndpointSliceApiVersion' Lens
v1EndpointSliceApiVersionL :: Lens_' V1EndpointSlice (Maybe Text)
v1EndpointSliceApiVersionL f V1EndpointSlice{..} = (\v1EndpointSliceApiVersion -> V1EndpointSlice { v1EndpointSliceApiVersion, ..} ) <$> f v1EndpointSliceApiVersion
{-# INLINE v1EndpointSliceApiVersionL #-}

-- | 'v1EndpointSliceEndpoints' Lens
v1EndpointSliceEndpointsL :: Lens_' V1EndpointSlice ([V1Endpoint])
v1EndpointSliceEndpointsL f V1EndpointSlice{..} = (\v1EndpointSliceEndpoints -> V1EndpointSlice { v1EndpointSliceEndpoints, ..} ) <$> f v1EndpointSliceEndpoints
{-# INLINE v1EndpointSliceEndpointsL #-}

-- | 'v1EndpointSliceKind' Lens
v1EndpointSliceKindL :: Lens_' V1EndpointSlice (Maybe Text)
v1EndpointSliceKindL f V1EndpointSlice{..} = (\v1EndpointSliceKind -> V1EndpointSlice { v1EndpointSliceKind, ..} ) <$> f v1EndpointSliceKind
{-# INLINE v1EndpointSliceKindL #-}

-- | 'v1EndpointSliceMetadata' Lens
v1EndpointSliceMetadataL :: Lens_' V1EndpointSlice (Maybe V1ObjectMeta)
v1EndpointSliceMetadataL f V1EndpointSlice{..} = (\v1EndpointSliceMetadata -> V1EndpointSlice { v1EndpointSliceMetadata, ..} ) <$> f v1EndpointSliceMetadata
{-# INLINE v1EndpointSliceMetadataL #-}

-- | 'v1EndpointSlicePorts' Lens
v1EndpointSlicePortsL :: Lens_' V1EndpointSlice (Maybe [DiscoveryV1EndpointPort])
v1EndpointSlicePortsL f V1EndpointSlice{..} = (\v1EndpointSlicePorts -> V1EndpointSlice { v1EndpointSlicePorts, ..} ) <$> f v1EndpointSlicePorts
{-# INLINE v1EndpointSlicePortsL #-}



-- * V1EndpointSliceList

-- | 'v1EndpointSliceListApiVersion' Lens
v1EndpointSliceListApiVersionL :: Lens_' V1EndpointSliceList (Maybe Text)
v1EndpointSliceListApiVersionL f V1EndpointSliceList{..} = (\v1EndpointSliceListApiVersion -> V1EndpointSliceList { v1EndpointSliceListApiVersion, ..} ) <$> f v1EndpointSliceListApiVersion
{-# INLINE v1EndpointSliceListApiVersionL #-}

-- | 'v1EndpointSliceListItems' Lens
v1EndpointSliceListItemsL :: Lens_' V1EndpointSliceList ([V1EndpointSlice])
v1EndpointSliceListItemsL f V1EndpointSliceList{..} = (\v1EndpointSliceListItems -> V1EndpointSliceList { v1EndpointSliceListItems, ..} ) <$> f v1EndpointSliceListItems
{-# INLINE v1EndpointSliceListItemsL #-}

-- | 'v1EndpointSliceListKind' Lens
v1EndpointSliceListKindL :: Lens_' V1EndpointSliceList (Maybe Text)
v1EndpointSliceListKindL f V1EndpointSliceList{..} = (\v1EndpointSliceListKind -> V1EndpointSliceList { v1EndpointSliceListKind, ..} ) <$> f v1EndpointSliceListKind
{-# INLINE v1EndpointSliceListKindL #-}

-- | 'v1EndpointSliceListMetadata' Lens
v1EndpointSliceListMetadataL :: Lens_' V1EndpointSliceList (Maybe V1ListMeta)
v1EndpointSliceListMetadataL f V1EndpointSliceList{..} = (\v1EndpointSliceListMetadata -> V1EndpointSliceList { v1EndpointSliceListMetadata, ..} ) <$> f v1EndpointSliceListMetadata
{-# INLINE v1EndpointSliceListMetadataL #-}



-- * V1EndpointSubset

-- | 'v1EndpointSubsetAddresses' Lens
v1EndpointSubsetAddressesL :: Lens_' V1EndpointSubset (Maybe [V1EndpointAddress])
v1EndpointSubsetAddressesL f V1EndpointSubset{..} = (\v1EndpointSubsetAddresses -> V1EndpointSubset { v1EndpointSubsetAddresses, ..} ) <$> f v1EndpointSubsetAddresses
{-# INLINE v1EndpointSubsetAddressesL #-}

-- | 'v1EndpointSubsetNotReadyAddresses' Lens
v1EndpointSubsetNotReadyAddressesL :: Lens_' V1EndpointSubset (Maybe [V1EndpointAddress])
v1EndpointSubsetNotReadyAddressesL f V1EndpointSubset{..} = (\v1EndpointSubsetNotReadyAddresses -> V1EndpointSubset { v1EndpointSubsetNotReadyAddresses, ..} ) <$> f v1EndpointSubsetNotReadyAddresses
{-# INLINE v1EndpointSubsetNotReadyAddressesL #-}

-- | 'v1EndpointSubsetPorts' Lens
v1EndpointSubsetPortsL :: Lens_' V1EndpointSubset (Maybe [CoreV1EndpointPort])
v1EndpointSubsetPortsL f V1EndpointSubset{..} = (\v1EndpointSubsetPorts -> V1EndpointSubset { v1EndpointSubsetPorts, ..} ) <$> f v1EndpointSubsetPorts
{-# INLINE v1EndpointSubsetPortsL #-}



-- * V1Endpoints

-- | 'v1EndpointsApiVersion' Lens
v1EndpointsApiVersionL :: Lens_' V1Endpoints (Maybe Text)
v1EndpointsApiVersionL f V1Endpoints{..} = (\v1EndpointsApiVersion -> V1Endpoints { v1EndpointsApiVersion, ..} ) <$> f v1EndpointsApiVersion
{-# INLINE v1EndpointsApiVersionL #-}

-- | 'v1EndpointsKind' Lens
v1EndpointsKindL :: Lens_' V1Endpoints (Maybe Text)
v1EndpointsKindL f V1Endpoints{..} = (\v1EndpointsKind -> V1Endpoints { v1EndpointsKind, ..} ) <$> f v1EndpointsKind
{-# INLINE v1EndpointsKindL #-}

-- | 'v1EndpointsMetadata' Lens
v1EndpointsMetadataL :: Lens_' V1Endpoints (Maybe V1ObjectMeta)
v1EndpointsMetadataL f V1Endpoints{..} = (\v1EndpointsMetadata -> V1Endpoints { v1EndpointsMetadata, ..} ) <$> f v1EndpointsMetadata
{-# INLINE v1EndpointsMetadataL #-}

-- | 'v1EndpointsSubsets' Lens
v1EndpointsSubsetsL :: Lens_' V1Endpoints (Maybe [V1EndpointSubset])
v1EndpointsSubsetsL f V1Endpoints{..} = (\v1EndpointsSubsets -> V1Endpoints { v1EndpointsSubsets, ..} ) <$> f v1EndpointsSubsets
{-# INLINE v1EndpointsSubsetsL #-}



-- * V1EndpointsList

-- | 'v1EndpointsListApiVersion' Lens
v1EndpointsListApiVersionL :: Lens_' V1EndpointsList (Maybe Text)
v1EndpointsListApiVersionL f V1EndpointsList{..} = (\v1EndpointsListApiVersion -> V1EndpointsList { v1EndpointsListApiVersion, ..} ) <$> f v1EndpointsListApiVersion
{-# INLINE v1EndpointsListApiVersionL #-}

-- | 'v1EndpointsListItems' Lens
v1EndpointsListItemsL :: Lens_' V1EndpointsList ([V1Endpoints])
v1EndpointsListItemsL f V1EndpointsList{..} = (\v1EndpointsListItems -> V1EndpointsList { v1EndpointsListItems, ..} ) <$> f v1EndpointsListItems
{-# INLINE v1EndpointsListItemsL #-}

-- | 'v1EndpointsListKind' Lens
v1EndpointsListKindL :: Lens_' V1EndpointsList (Maybe Text)
v1EndpointsListKindL f V1EndpointsList{..} = (\v1EndpointsListKind -> V1EndpointsList { v1EndpointsListKind, ..} ) <$> f v1EndpointsListKind
{-# INLINE v1EndpointsListKindL #-}

-- | 'v1EndpointsListMetadata' Lens
v1EndpointsListMetadataL :: Lens_' V1EndpointsList (Maybe V1ListMeta)
v1EndpointsListMetadataL f V1EndpointsList{..} = (\v1EndpointsListMetadata -> V1EndpointsList { v1EndpointsListMetadata, ..} ) <$> f v1EndpointsListMetadata
{-# INLINE v1EndpointsListMetadataL #-}



-- * V1EnvFromSource

-- | 'v1EnvFromSourceConfigMapRef' Lens
v1EnvFromSourceConfigMapRefL :: Lens_' V1EnvFromSource (Maybe V1ConfigMapEnvSource)
v1EnvFromSourceConfigMapRefL f V1EnvFromSource{..} = (\v1EnvFromSourceConfigMapRef -> V1EnvFromSource { v1EnvFromSourceConfigMapRef, ..} ) <$> f v1EnvFromSourceConfigMapRef
{-# INLINE v1EnvFromSourceConfigMapRefL #-}

-- | 'v1EnvFromSourcePrefix' Lens
v1EnvFromSourcePrefixL :: Lens_' V1EnvFromSource (Maybe Text)
v1EnvFromSourcePrefixL f V1EnvFromSource{..} = (\v1EnvFromSourcePrefix -> V1EnvFromSource { v1EnvFromSourcePrefix, ..} ) <$> f v1EnvFromSourcePrefix
{-# INLINE v1EnvFromSourcePrefixL #-}

-- | 'v1EnvFromSourceSecretRef' Lens
v1EnvFromSourceSecretRefL :: Lens_' V1EnvFromSource (Maybe V1SecretEnvSource)
v1EnvFromSourceSecretRefL f V1EnvFromSource{..} = (\v1EnvFromSourceSecretRef -> V1EnvFromSource { v1EnvFromSourceSecretRef, ..} ) <$> f v1EnvFromSourceSecretRef
{-# INLINE v1EnvFromSourceSecretRefL #-}



-- * V1EnvVar

-- | 'v1EnvVarName' Lens
v1EnvVarNameL :: Lens_' V1EnvVar (Text)
v1EnvVarNameL f V1EnvVar{..} = (\v1EnvVarName -> V1EnvVar { v1EnvVarName, ..} ) <$> f v1EnvVarName
{-# INLINE v1EnvVarNameL #-}

-- | 'v1EnvVarValue' Lens
v1EnvVarValueL :: Lens_' V1EnvVar (Maybe Text)
v1EnvVarValueL f V1EnvVar{..} = (\v1EnvVarValue -> V1EnvVar { v1EnvVarValue, ..} ) <$> f v1EnvVarValue
{-# INLINE v1EnvVarValueL #-}

-- | 'v1EnvVarValueFrom' Lens
v1EnvVarValueFromL :: Lens_' V1EnvVar (Maybe V1EnvVarSource)
v1EnvVarValueFromL f V1EnvVar{..} = (\v1EnvVarValueFrom -> V1EnvVar { v1EnvVarValueFrom, ..} ) <$> f v1EnvVarValueFrom
{-# INLINE v1EnvVarValueFromL #-}



-- * V1EnvVarSource

-- | 'v1EnvVarSourceConfigMapKeyRef' Lens
v1EnvVarSourceConfigMapKeyRefL :: Lens_' V1EnvVarSource (Maybe V1ConfigMapKeySelector)
v1EnvVarSourceConfigMapKeyRefL f V1EnvVarSource{..} = (\v1EnvVarSourceConfigMapKeyRef -> V1EnvVarSource { v1EnvVarSourceConfigMapKeyRef, ..} ) <$> f v1EnvVarSourceConfigMapKeyRef
{-# INLINE v1EnvVarSourceConfigMapKeyRefL #-}

-- | 'v1EnvVarSourceFieldRef' Lens
v1EnvVarSourceFieldRefL :: Lens_' V1EnvVarSource (Maybe V1ObjectFieldSelector)
v1EnvVarSourceFieldRefL f V1EnvVarSource{..} = (\v1EnvVarSourceFieldRef -> V1EnvVarSource { v1EnvVarSourceFieldRef, ..} ) <$> f v1EnvVarSourceFieldRef
{-# INLINE v1EnvVarSourceFieldRefL #-}

-- | 'v1EnvVarSourceResourceFieldRef' Lens
v1EnvVarSourceResourceFieldRefL :: Lens_' V1EnvVarSource (Maybe V1ResourceFieldSelector)
v1EnvVarSourceResourceFieldRefL f V1EnvVarSource{..} = (\v1EnvVarSourceResourceFieldRef -> V1EnvVarSource { v1EnvVarSourceResourceFieldRef, ..} ) <$> f v1EnvVarSourceResourceFieldRef
{-# INLINE v1EnvVarSourceResourceFieldRefL #-}

-- | 'v1EnvVarSourceSecretKeyRef' Lens
v1EnvVarSourceSecretKeyRefL :: Lens_' V1EnvVarSource (Maybe V1SecretKeySelector)
v1EnvVarSourceSecretKeyRefL f V1EnvVarSource{..} = (\v1EnvVarSourceSecretKeyRef -> V1EnvVarSource { v1EnvVarSourceSecretKeyRef, ..} ) <$> f v1EnvVarSourceSecretKeyRef
{-# INLINE v1EnvVarSourceSecretKeyRefL #-}



-- * V1EphemeralContainer

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

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

-- | 'v1EphemeralContainerEnv' Lens
v1EphemeralContainerEnvL :: Lens_' V1EphemeralContainer (Maybe [V1EnvVar])
v1EphemeralContainerEnvL f V1EphemeralContainer{..} = (\v1EphemeralContainerEnv -> V1EphemeralContainer { v1EphemeralContainerEnv, ..} ) <$> f v1EphemeralContainerEnv
{-# INLINE v1EphemeralContainerEnvL #-}

-- | 'v1EphemeralContainerEnvFrom' Lens
v1EphemeralContainerEnvFromL :: Lens_' V1EphemeralContainer (Maybe [V1EnvFromSource])
v1EphemeralContainerEnvFromL f V1EphemeralContainer{..} = (\v1EphemeralContainerEnvFrom -> V1EphemeralContainer { v1EphemeralContainerEnvFrom, ..} ) <$> f v1EphemeralContainerEnvFrom
{-# INLINE v1EphemeralContainerEnvFromL #-}

-- | 'v1EphemeralContainerImage' Lens
v1EphemeralContainerImageL :: Lens_' V1EphemeralContainer (Maybe Text)
v1EphemeralContainerImageL f V1EphemeralContainer{..} = (\v1EphemeralContainerImage -> V1EphemeralContainer { v1EphemeralContainerImage, ..} ) <$> f v1EphemeralContainerImage
{-# INLINE v1EphemeralContainerImageL #-}

-- | 'v1EphemeralContainerImagePullPolicy' Lens
v1EphemeralContainerImagePullPolicyL :: Lens_' V1EphemeralContainer (Maybe Text)
v1EphemeralContainerImagePullPolicyL f V1EphemeralContainer{..} = (\v1EphemeralContainerImagePullPolicy -> V1EphemeralContainer { v1EphemeralContainerImagePullPolicy, ..} ) <$> f v1EphemeralContainerImagePullPolicy
{-# INLINE v1EphemeralContainerImagePullPolicyL #-}

-- | 'v1EphemeralContainerLifecycle' Lens
v1EphemeralContainerLifecycleL :: Lens_' V1EphemeralContainer (Maybe V1Lifecycle)
v1EphemeralContainerLifecycleL f V1EphemeralContainer{..} = (\v1EphemeralContainerLifecycle -> V1EphemeralContainer { v1EphemeralContainerLifecycle, ..} ) <$> f v1EphemeralContainerLifecycle
{-# INLINE v1EphemeralContainerLifecycleL #-}

-- | 'v1EphemeralContainerLivenessProbe' Lens
v1EphemeralContainerLivenessProbeL :: Lens_' V1EphemeralContainer (Maybe V1Probe)
v1EphemeralContainerLivenessProbeL f V1EphemeralContainer{..} = (\v1EphemeralContainerLivenessProbe -> V1EphemeralContainer { v1EphemeralContainerLivenessProbe, ..} ) <$> f v1EphemeralContainerLivenessProbe
{-# INLINE v1EphemeralContainerLivenessProbeL #-}

-- | 'v1EphemeralContainerName' Lens
v1EphemeralContainerNameL :: Lens_' V1EphemeralContainer (Text)
v1EphemeralContainerNameL f V1EphemeralContainer{..} = (\v1EphemeralContainerName -> V1EphemeralContainer { v1EphemeralContainerName, ..} ) <$> f v1EphemeralContainerName
{-# INLINE v1EphemeralContainerNameL #-}

-- | 'v1EphemeralContainerPorts' Lens
v1EphemeralContainerPortsL :: Lens_' V1EphemeralContainer (Maybe [V1ContainerPort])
v1EphemeralContainerPortsL f V1EphemeralContainer{..} = (\v1EphemeralContainerPorts -> V1EphemeralContainer { v1EphemeralContainerPorts, ..} ) <$> f v1EphemeralContainerPorts
{-# INLINE v1EphemeralContainerPortsL #-}

-- | 'v1EphemeralContainerReadinessProbe' Lens
v1EphemeralContainerReadinessProbeL :: Lens_' V1EphemeralContainer (Maybe V1Probe)
v1EphemeralContainerReadinessProbeL f V1EphemeralContainer{..} = (\v1EphemeralContainerReadinessProbe -> V1EphemeralContainer { v1EphemeralContainerReadinessProbe, ..} ) <$> f v1EphemeralContainerReadinessProbe
{-# INLINE v1EphemeralContainerReadinessProbeL #-}

-- | 'v1EphemeralContainerResources' Lens
v1EphemeralContainerResourcesL :: Lens_' V1EphemeralContainer (Maybe V1ResourceRequirements)
v1EphemeralContainerResourcesL f V1EphemeralContainer{..} = (\v1EphemeralContainerResources -> V1EphemeralContainer { v1EphemeralContainerResources, ..} ) <$> f v1EphemeralContainerResources
{-# INLINE v1EphemeralContainerResourcesL #-}

-- | 'v1EphemeralContainerSecurityContext' Lens
v1EphemeralContainerSecurityContextL :: Lens_' V1EphemeralContainer (Maybe V1SecurityContext)
v1EphemeralContainerSecurityContextL f V1EphemeralContainer{..} = (\v1EphemeralContainerSecurityContext -> V1EphemeralContainer { v1EphemeralContainerSecurityContext, ..} ) <$> f v1EphemeralContainerSecurityContext
{-# INLINE v1EphemeralContainerSecurityContextL #-}

-- | 'v1EphemeralContainerStartupProbe' Lens
v1EphemeralContainerStartupProbeL :: Lens_' V1EphemeralContainer (Maybe V1Probe)
v1EphemeralContainerStartupProbeL f V1EphemeralContainer{..} = (\v1EphemeralContainerStartupProbe -> V1EphemeralContainer { v1EphemeralContainerStartupProbe, ..} ) <$> f v1EphemeralContainerStartupProbe
{-# INLINE v1EphemeralContainerStartupProbeL #-}

-- | 'v1EphemeralContainerStdin' Lens
v1EphemeralContainerStdinL :: Lens_' V1EphemeralContainer (Maybe Bool)
v1EphemeralContainerStdinL f V1EphemeralContainer{..} = (\v1EphemeralContainerStdin -> V1EphemeralContainer { v1EphemeralContainerStdin, ..} ) <$> f v1EphemeralContainerStdin
{-# INLINE v1EphemeralContainerStdinL #-}

-- | 'v1EphemeralContainerStdinOnce' Lens
v1EphemeralContainerStdinOnceL :: Lens_' V1EphemeralContainer (Maybe Bool)
v1EphemeralContainerStdinOnceL f V1EphemeralContainer{..} = (\v1EphemeralContainerStdinOnce -> V1EphemeralContainer { v1EphemeralContainerStdinOnce, ..} ) <$> f v1EphemeralContainerStdinOnce
{-# INLINE v1EphemeralContainerStdinOnceL #-}

-- | 'v1EphemeralContainerTargetContainerName' Lens
v1EphemeralContainerTargetContainerNameL :: Lens_' V1EphemeralContainer (Maybe Text)
v1EphemeralContainerTargetContainerNameL f V1EphemeralContainer{..} = (\v1EphemeralContainerTargetContainerName -> V1EphemeralContainer { v1EphemeralContainerTargetContainerName, ..} ) <$> f v1EphemeralContainerTargetContainerName
{-# INLINE v1EphemeralContainerTargetContainerNameL #-}

-- | 'v1EphemeralContainerTerminationMessagePath' Lens
v1EphemeralContainerTerminationMessagePathL :: Lens_' V1EphemeralContainer (Maybe Text)
v1EphemeralContainerTerminationMessagePathL f V1EphemeralContainer{..} = (\v1EphemeralContainerTerminationMessagePath -> V1EphemeralContainer { v1EphemeralContainerTerminationMessagePath, ..} ) <$> f v1EphemeralContainerTerminationMessagePath
{-# INLINE v1EphemeralContainerTerminationMessagePathL #-}

-- | 'v1EphemeralContainerTerminationMessagePolicy' Lens
v1EphemeralContainerTerminationMessagePolicyL :: Lens_' V1EphemeralContainer (Maybe Text)
v1EphemeralContainerTerminationMessagePolicyL f V1EphemeralContainer{..} = (\v1EphemeralContainerTerminationMessagePolicy -> V1EphemeralContainer { v1EphemeralContainerTerminationMessagePolicy, ..} ) <$> f v1EphemeralContainerTerminationMessagePolicy
{-# INLINE v1EphemeralContainerTerminationMessagePolicyL #-}

-- | 'v1EphemeralContainerTty' Lens
v1EphemeralContainerTtyL :: Lens_' V1EphemeralContainer (Maybe Bool)
v1EphemeralContainerTtyL f V1EphemeralContainer{..} = (\v1EphemeralContainerTty -> V1EphemeralContainer { v1EphemeralContainerTty, ..} ) <$> f v1EphemeralContainerTty
{-# INLINE v1EphemeralContainerTtyL #-}

-- | 'v1EphemeralContainerVolumeDevices' Lens
v1EphemeralContainerVolumeDevicesL :: Lens_' V1EphemeralContainer (Maybe [V1VolumeDevice])
v1EphemeralContainerVolumeDevicesL f V1EphemeralContainer{..} = (\v1EphemeralContainerVolumeDevices -> V1EphemeralContainer { v1EphemeralContainerVolumeDevices, ..} ) <$> f v1EphemeralContainerVolumeDevices
{-# INLINE v1EphemeralContainerVolumeDevicesL #-}

-- | 'v1EphemeralContainerVolumeMounts' Lens
v1EphemeralContainerVolumeMountsL :: Lens_' V1EphemeralContainer (Maybe [V1VolumeMount])
v1EphemeralContainerVolumeMountsL f V1EphemeralContainer{..} = (\v1EphemeralContainerVolumeMounts -> V1EphemeralContainer { v1EphemeralContainerVolumeMounts, ..} ) <$> f v1EphemeralContainerVolumeMounts
{-# INLINE v1EphemeralContainerVolumeMountsL #-}

-- | 'v1EphemeralContainerWorkingDir' Lens
v1EphemeralContainerWorkingDirL :: Lens_' V1EphemeralContainer (Maybe Text)
v1EphemeralContainerWorkingDirL f V1EphemeralContainer{..} = (\v1EphemeralContainerWorkingDir -> V1EphemeralContainer { v1EphemeralContainerWorkingDir, ..} ) <$> f v1EphemeralContainerWorkingDir
{-# INLINE v1EphemeralContainerWorkingDirL #-}



-- * V1EphemeralVolumeSource

-- | 'v1EphemeralVolumeSourceVolumeClaimTemplate' Lens
v1EphemeralVolumeSourceVolumeClaimTemplateL :: Lens_' V1EphemeralVolumeSource (Maybe V1PersistentVolumeClaimTemplate)
v1EphemeralVolumeSourceVolumeClaimTemplateL f V1EphemeralVolumeSource{..} = (\v1EphemeralVolumeSourceVolumeClaimTemplate -> V1EphemeralVolumeSource { v1EphemeralVolumeSourceVolumeClaimTemplate, ..} ) <$> f v1EphemeralVolumeSourceVolumeClaimTemplate
{-# INLINE v1EphemeralVolumeSourceVolumeClaimTemplateL #-}



-- * V1EventSource

-- | 'v1EventSourceComponent' Lens
v1EventSourceComponentL :: Lens_' V1EventSource (Maybe Text)
v1EventSourceComponentL f V1EventSource{..} = (\v1EventSourceComponent -> V1EventSource { v1EventSourceComponent, ..} ) <$> f v1EventSourceComponent
{-# INLINE v1EventSourceComponentL #-}

-- | 'v1EventSourceHost' Lens
v1EventSourceHostL :: Lens_' V1EventSource (Maybe Text)
v1EventSourceHostL f V1EventSource{..} = (\v1EventSourceHost -> V1EventSource { v1EventSourceHost, ..} ) <$> f v1EventSourceHost
{-# INLINE v1EventSourceHostL #-}



-- * V1Eviction

-- | 'v1EvictionApiVersion' Lens
v1EvictionApiVersionL :: Lens_' V1Eviction (Maybe Text)
v1EvictionApiVersionL f V1Eviction{..} = (\v1EvictionApiVersion -> V1Eviction { v1EvictionApiVersion, ..} ) <$> f v1EvictionApiVersion
{-# INLINE v1EvictionApiVersionL #-}

-- | 'v1EvictionDeleteOptions' Lens
v1EvictionDeleteOptionsL :: Lens_' V1Eviction (Maybe V1DeleteOptions)
v1EvictionDeleteOptionsL f V1Eviction{..} = (\v1EvictionDeleteOptions -> V1Eviction { v1EvictionDeleteOptions, ..} ) <$> f v1EvictionDeleteOptions
{-# INLINE v1EvictionDeleteOptionsL #-}

-- | 'v1EvictionKind' Lens
v1EvictionKindL :: Lens_' V1Eviction (Maybe Text)
v1EvictionKindL f V1Eviction{..} = (\v1EvictionKind -> V1Eviction { v1EvictionKind, ..} ) <$> f v1EvictionKind
{-# INLINE v1EvictionKindL #-}

-- | 'v1EvictionMetadata' Lens
v1EvictionMetadataL :: Lens_' V1Eviction (Maybe V1ObjectMeta)
v1EvictionMetadataL f V1Eviction{..} = (\v1EvictionMetadata -> V1Eviction { v1EvictionMetadata, ..} ) <$> f v1EvictionMetadata
{-# INLINE v1EvictionMetadataL #-}



-- * V1ExecAction

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



-- * V1ExternalDocumentation

-- | 'v1ExternalDocumentationDescription' Lens
v1ExternalDocumentationDescriptionL :: Lens_' V1ExternalDocumentation (Maybe Text)
v1ExternalDocumentationDescriptionL f V1ExternalDocumentation{..} = (\v1ExternalDocumentationDescription -> V1ExternalDocumentation { v1ExternalDocumentationDescription, ..} ) <$> f v1ExternalDocumentationDescription
{-# INLINE v1ExternalDocumentationDescriptionL #-}

-- | 'v1ExternalDocumentationUrl' Lens
v1ExternalDocumentationUrlL :: Lens_' V1ExternalDocumentation (Maybe Text)
v1ExternalDocumentationUrlL f V1ExternalDocumentation{..} = (\v1ExternalDocumentationUrl -> V1ExternalDocumentation { v1ExternalDocumentationUrl, ..} ) <$> f v1ExternalDocumentationUrl
{-# INLINE v1ExternalDocumentationUrlL #-}



-- * V1FCVolumeSource

-- | 'v1FCVolumeSourceFsType' Lens
v1FCVolumeSourceFsTypeL :: Lens_' V1FCVolumeSource (Maybe Text)
v1FCVolumeSourceFsTypeL f V1FCVolumeSource{..} = (\v1FCVolumeSourceFsType -> V1FCVolumeSource { v1FCVolumeSourceFsType, ..} ) <$> f v1FCVolumeSourceFsType
{-# INLINE v1FCVolumeSourceFsTypeL #-}

-- | 'v1FCVolumeSourceLun' Lens
v1FCVolumeSourceLunL :: Lens_' V1FCVolumeSource (Maybe Int)
v1FCVolumeSourceLunL f V1FCVolumeSource{..} = (\v1FCVolumeSourceLun -> V1FCVolumeSource { v1FCVolumeSourceLun, ..} ) <$> f v1FCVolumeSourceLun
{-# INLINE v1FCVolumeSourceLunL #-}

-- | 'v1FCVolumeSourceReadOnly' Lens
v1FCVolumeSourceReadOnlyL :: Lens_' V1FCVolumeSource (Maybe Bool)
v1FCVolumeSourceReadOnlyL f V1FCVolumeSource{..} = (\v1FCVolumeSourceReadOnly -> V1FCVolumeSource { v1FCVolumeSourceReadOnly, ..} ) <$> f v1FCVolumeSourceReadOnly
{-# INLINE v1FCVolumeSourceReadOnlyL #-}

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

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



-- * V1FlexPersistentVolumeSource

-- | 'v1FlexPersistentVolumeSourceDriver' Lens
v1FlexPersistentVolumeSourceDriverL :: Lens_' V1FlexPersistentVolumeSource (Text)
v1FlexPersistentVolumeSourceDriverL f V1FlexPersistentVolumeSource{..} = (\v1FlexPersistentVolumeSourceDriver -> V1FlexPersistentVolumeSource { v1FlexPersistentVolumeSourceDriver, ..} ) <$> f v1FlexPersistentVolumeSourceDriver
{-# INLINE v1FlexPersistentVolumeSourceDriverL #-}

-- | 'v1FlexPersistentVolumeSourceFsType' Lens
v1FlexPersistentVolumeSourceFsTypeL :: Lens_' V1FlexPersistentVolumeSource (Maybe Text)
v1FlexPersistentVolumeSourceFsTypeL f V1FlexPersistentVolumeSource{..} = (\v1FlexPersistentVolumeSourceFsType -> V1FlexPersistentVolumeSource { v1FlexPersistentVolumeSourceFsType, ..} ) <$> f v1FlexPersistentVolumeSourceFsType
{-# INLINE v1FlexPersistentVolumeSourceFsTypeL #-}

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

-- | 'v1FlexPersistentVolumeSourceReadOnly' Lens
v1FlexPersistentVolumeSourceReadOnlyL :: Lens_' V1FlexPersistentVolumeSource (Maybe Bool)
v1FlexPersistentVolumeSourceReadOnlyL f V1FlexPersistentVolumeSource{..} = (\v1FlexPersistentVolumeSourceReadOnly -> V1FlexPersistentVolumeSource { v1FlexPersistentVolumeSourceReadOnly, ..} ) <$> f v1FlexPersistentVolumeSourceReadOnly
{-# INLINE v1FlexPersistentVolumeSourceReadOnlyL #-}

-- | 'v1FlexPersistentVolumeSourceSecretRef' Lens
v1FlexPersistentVolumeSourceSecretRefL :: Lens_' V1FlexPersistentVolumeSource (Maybe V1SecretReference)
v1FlexPersistentVolumeSourceSecretRefL f V1FlexPersistentVolumeSource{..} = (\v1FlexPersistentVolumeSourceSecretRef -> V1FlexPersistentVolumeSource { v1FlexPersistentVolumeSourceSecretRef, ..} ) <$> f v1FlexPersistentVolumeSourceSecretRef
{-# INLINE v1FlexPersistentVolumeSourceSecretRefL #-}



-- * V1FlexVolumeSource

-- | 'v1FlexVolumeSourceDriver' Lens
v1FlexVolumeSourceDriverL :: Lens_' V1FlexVolumeSource (Text)
v1FlexVolumeSourceDriverL f V1FlexVolumeSource{..} = (\v1FlexVolumeSourceDriver -> V1FlexVolumeSource { v1FlexVolumeSourceDriver, ..} ) <$> f v1FlexVolumeSourceDriver
{-# INLINE v1FlexVolumeSourceDriverL #-}

-- | 'v1FlexVolumeSourceFsType' Lens
v1FlexVolumeSourceFsTypeL :: Lens_' V1FlexVolumeSource (Maybe Text)
v1FlexVolumeSourceFsTypeL f V1FlexVolumeSource{..} = (\v1FlexVolumeSourceFsType -> V1FlexVolumeSource { v1FlexVolumeSourceFsType, ..} ) <$> f v1FlexVolumeSourceFsType
{-# INLINE v1FlexVolumeSourceFsTypeL #-}

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

-- | 'v1FlexVolumeSourceReadOnly' Lens
v1FlexVolumeSourceReadOnlyL :: Lens_' V1FlexVolumeSource (Maybe Bool)
v1FlexVolumeSourceReadOnlyL f V1FlexVolumeSource{..} = (\v1FlexVolumeSourceReadOnly -> V1FlexVolumeSource { v1FlexVolumeSourceReadOnly, ..} ) <$> f v1FlexVolumeSourceReadOnly
{-# INLINE v1FlexVolumeSourceReadOnlyL #-}

-- | 'v1FlexVolumeSourceSecretRef' Lens
v1FlexVolumeSourceSecretRefL :: Lens_' V1FlexVolumeSource (Maybe V1LocalObjectReference)
v1FlexVolumeSourceSecretRefL f V1FlexVolumeSource{..} = (\v1FlexVolumeSourceSecretRef -> V1FlexVolumeSource { v1FlexVolumeSourceSecretRef, ..} ) <$> f v1FlexVolumeSourceSecretRef
{-# INLINE v1FlexVolumeSourceSecretRefL #-}



-- * V1FlockerVolumeSource

-- | 'v1FlockerVolumeSourceDatasetName' Lens
v1FlockerVolumeSourceDatasetNameL :: Lens_' V1FlockerVolumeSource (Maybe Text)
v1FlockerVolumeSourceDatasetNameL f V1FlockerVolumeSource{..} = (\v1FlockerVolumeSourceDatasetName -> V1FlockerVolumeSource { v1FlockerVolumeSourceDatasetName, ..} ) <$> f v1FlockerVolumeSourceDatasetName
{-# INLINE v1FlockerVolumeSourceDatasetNameL #-}

-- | 'v1FlockerVolumeSourceDatasetUuid' Lens
v1FlockerVolumeSourceDatasetUuidL :: Lens_' V1FlockerVolumeSource (Maybe Text)
v1FlockerVolumeSourceDatasetUuidL f V1FlockerVolumeSource{..} = (\v1FlockerVolumeSourceDatasetUuid -> V1FlockerVolumeSource { v1FlockerVolumeSourceDatasetUuid, ..} ) <$> f v1FlockerVolumeSourceDatasetUuid
{-# INLINE v1FlockerVolumeSourceDatasetUuidL #-}



-- * V1ForZone

-- | 'v1ForZoneName' Lens
v1ForZoneNameL :: Lens_' V1ForZone (Text)
v1ForZoneNameL f V1ForZone{..} = (\v1ForZoneName -> V1ForZone { v1ForZoneName, ..} ) <$> f v1ForZoneName
{-# INLINE v1ForZoneNameL #-}



-- * V1GCEPersistentDiskVolumeSource

-- | 'v1GCEPersistentDiskVolumeSourceFsType' Lens
v1GCEPersistentDiskVolumeSourceFsTypeL :: Lens_' V1GCEPersistentDiskVolumeSource (Maybe Text)
v1GCEPersistentDiskVolumeSourceFsTypeL f V1GCEPersistentDiskVolumeSource{..} = (\v1GCEPersistentDiskVolumeSourceFsType -> V1GCEPersistentDiskVolumeSource { v1GCEPersistentDiskVolumeSourceFsType, ..} ) <$> f v1GCEPersistentDiskVolumeSourceFsType
{-# INLINE v1GCEPersistentDiskVolumeSourceFsTypeL #-}

-- | 'v1GCEPersistentDiskVolumeSourcePartition' Lens
v1GCEPersistentDiskVolumeSourcePartitionL :: Lens_' V1GCEPersistentDiskVolumeSource (Maybe Int)
v1GCEPersistentDiskVolumeSourcePartitionL f V1GCEPersistentDiskVolumeSource{..} = (\v1GCEPersistentDiskVolumeSourcePartition -> V1GCEPersistentDiskVolumeSource { v1GCEPersistentDiskVolumeSourcePartition, ..} ) <$> f v1GCEPersistentDiskVolumeSourcePartition
{-# INLINE v1GCEPersistentDiskVolumeSourcePartitionL #-}

-- | 'v1GCEPersistentDiskVolumeSourcePdName' Lens
v1GCEPersistentDiskVolumeSourcePdNameL :: Lens_' V1GCEPersistentDiskVolumeSource (Text)
v1GCEPersistentDiskVolumeSourcePdNameL f V1GCEPersistentDiskVolumeSource{..} = (\v1GCEPersistentDiskVolumeSourcePdName -> V1GCEPersistentDiskVolumeSource { v1GCEPersistentDiskVolumeSourcePdName, ..} ) <$> f v1GCEPersistentDiskVolumeSourcePdName
{-# INLINE v1GCEPersistentDiskVolumeSourcePdNameL #-}

-- | 'v1GCEPersistentDiskVolumeSourceReadOnly' Lens
v1GCEPersistentDiskVolumeSourceReadOnlyL :: Lens_' V1GCEPersistentDiskVolumeSource (Maybe Bool)
v1GCEPersistentDiskVolumeSourceReadOnlyL f V1GCEPersistentDiskVolumeSource{..} = (\v1GCEPersistentDiskVolumeSourceReadOnly -> V1GCEPersistentDiskVolumeSource { v1GCEPersistentDiskVolumeSourceReadOnly, ..} ) <$> f v1GCEPersistentDiskVolumeSourceReadOnly
{-# INLINE v1GCEPersistentDiskVolumeSourceReadOnlyL #-}



-- * V1GRPCAction

-- | 'v1GRPCActionPort' Lens
v1GRPCActionPortL :: Lens_' V1GRPCAction (Int)
v1GRPCActionPortL f V1GRPCAction{..} = (\v1GRPCActionPort -> V1GRPCAction { v1GRPCActionPort, ..} ) <$> f v1GRPCActionPort
{-# INLINE v1GRPCActionPortL #-}

-- | 'v1GRPCActionService' Lens
v1GRPCActionServiceL :: Lens_' V1GRPCAction (Maybe Text)
v1GRPCActionServiceL f V1GRPCAction{..} = (\v1GRPCActionService -> V1GRPCAction { v1GRPCActionService, ..} ) <$> f v1GRPCActionService
{-# INLINE v1GRPCActionServiceL #-}



-- * V1GitRepoVolumeSource

-- | 'v1GitRepoVolumeSourceDirectory' Lens
v1GitRepoVolumeSourceDirectoryL :: Lens_' V1GitRepoVolumeSource (Maybe Text)
v1GitRepoVolumeSourceDirectoryL f V1GitRepoVolumeSource{..} = (\v1GitRepoVolumeSourceDirectory -> V1GitRepoVolumeSource { v1GitRepoVolumeSourceDirectory, ..} ) <$> f v1GitRepoVolumeSourceDirectory
{-# INLINE v1GitRepoVolumeSourceDirectoryL #-}

-- | 'v1GitRepoVolumeSourceRepository' Lens
v1GitRepoVolumeSourceRepositoryL :: Lens_' V1GitRepoVolumeSource (Text)
v1GitRepoVolumeSourceRepositoryL f V1GitRepoVolumeSource{..} = (\v1GitRepoVolumeSourceRepository -> V1GitRepoVolumeSource { v1GitRepoVolumeSourceRepository, ..} ) <$> f v1GitRepoVolumeSourceRepository
{-# INLINE v1GitRepoVolumeSourceRepositoryL #-}

-- | 'v1GitRepoVolumeSourceRevision' Lens
v1GitRepoVolumeSourceRevisionL :: Lens_' V1GitRepoVolumeSource (Maybe Text)
v1GitRepoVolumeSourceRevisionL f V1GitRepoVolumeSource{..} = (\v1GitRepoVolumeSourceRevision -> V1GitRepoVolumeSource { v1GitRepoVolumeSourceRevision, ..} ) <$> f v1GitRepoVolumeSourceRevision
{-# INLINE v1GitRepoVolumeSourceRevisionL #-}



-- * V1GlusterfsPersistentVolumeSource

-- | 'v1GlusterfsPersistentVolumeSourceEndpoints' Lens
v1GlusterfsPersistentVolumeSourceEndpointsL :: Lens_' V1GlusterfsPersistentVolumeSource (Text)
v1GlusterfsPersistentVolumeSourceEndpointsL f V1GlusterfsPersistentVolumeSource{..} = (\v1GlusterfsPersistentVolumeSourceEndpoints -> V1GlusterfsPersistentVolumeSource { v1GlusterfsPersistentVolumeSourceEndpoints, ..} ) <$> f v1GlusterfsPersistentVolumeSourceEndpoints
{-# INLINE v1GlusterfsPersistentVolumeSourceEndpointsL #-}

-- | 'v1GlusterfsPersistentVolumeSourceEndpointsNamespace' Lens
v1GlusterfsPersistentVolumeSourceEndpointsNamespaceL :: Lens_' V1GlusterfsPersistentVolumeSource (Maybe Text)
v1GlusterfsPersistentVolumeSourceEndpointsNamespaceL f V1GlusterfsPersistentVolumeSource{..} = (\v1GlusterfsPersistentVolumeSourceEndpointsNamespace -> V1GlusterfsPersistentVolumeSource { v1GlusterfsPersistentVolumeSourceEndpointsNamespace, ..} ) <$> f v1GlusterfsPersistentVolumeSourceEndpointsNamespace
{-# INLINE v1GlusterfsPersistentVolumeSourceEndpointsNamespaceL #-}

-- | 'v1GlusterfsPersistentVolumeSourcePath' Lens
v1GlusterfsPersistentVolumeSourcePathL :: Lens_' V1GlusterfsPersistentVolumeSource (Text)
v1GlusterfsPersistentVolumeSourcePathL f V1GlusterfsPersistentVolumeSource{..} = (\v1GlusterfsPersistentVolumeSourcePath -> V1GlusterfsPersistentVolumeSource { v1GlusterfsPersistentVolumeSourcePath, ..} ) <$> f v1GlusterfsPersistentVolumeSourcePath
{-# INLINE v1GlusterfsPersistentVolumeSourcePathL #-}

-- | 'v1GlusterfsPersistentVolumeSourceReadOnly' Lens
v1GlusterfsPersistentVolumeSourceReadOnlyL :: Lens_' V1GlusterfsPersistentVolumeSource (Maybe Bool)
v1GlusterfsPersistentVolumeSourceReadOnlyL f V1GlusterfsPersistentVolumeSource{..} = (\v1GlusterfsPersistentVolumeSourceReadOnly -> V1GlusterfsPersistentVolumeSource { v1GlusterfsPersistentVolumeSourceReadOnly, ..} ) <$> f v1GlusterfsPersistentVolumeSourceReadOnly
{-# INLINE v1GlusterfsPersistentVolumeSourceReadOnlyL #-}



-- * V1GlusterfsVolumeSource

-- | 'v1GlusterfsVolumeSourceEndpoints' Lens
v1GlusterfsVolumeSourceEndpointsL :: Lens_' V1GlusterfsVolumeSource (Text)
v1GlusterfsVolumeSourceEndpointsL f V1GlusterfsVolumeSource{..} = (\v1GlusterfsVolumeSourceEndpoints -> V1GlusterfsVolumeSource { v1GlusterfsVolumeSourceEndpoints, ..} ) <$> f v1GlusterfsVolumeSourceEndpoints
{-# INLINE v1GlusterfsVolumeSourceEndpointsL #-}

-- | 'v1GlusterfsVolumeSourcePath' Lens
v1GlusterfsVolumeSourcePathL :: Lens_' V1GlusterfsVolumeSource (Text)
v1GlusterfsVolumeSourcePathL f V1GlusterfsVolumeSource{..} = (\v1GlusterfsVolumeSourcePath -> V1GlusterfsVolumeSource { v1GlusterfsVolumeSourcePath, ..} ) <$> f v1GlusterfsVolumeSourcePath
{-# INLINE v1GlusterfsVolumeSourcePathL #-}

-- | 'v1GlusterfsVolumeSourceReadOnly' Lens
v1GlusterfsVolumeSourceReadOnlyL :: Lens_' V1GlusterfsVolumeSource (Maybe Bool)
v1GlusterfsVolumeSourceReadOnlyL f V1GlusterfsVolumeSource{..} = (\v1GlusterfsVolumeSourceReadOnly -> V1GlusterfsVolumeSource { v1GlusterfsVolumeSourceReadOnly, ..} ) <$> f v1GlusterfsVolumeSourceReadOnly
{-# INLINE v1GlusterfsVolumeSourceReadOnlyL #-}



-- * V1GroupVersionForDiscovery

-- | 'v1GroupVersionForDiscoveryGroupVersion' Lens
v1GroupVersionForDiscoveryGroupVersionL :: Lens_' V1GroupVersionForDiscovery (Text)
v1GroupVersionForDiscoveryGroupVersionL f V1GroupVersionForDiscovery{..} = (\v1GroupVersionForDiscoveryGroupVersion -> V1GroupVersionForDiscovery { v1GroupVersionForDiscoveryGroupVersion, ..} ) <$> f v1GroupVersionForDiscoveryGroupVersion
{-# INLINE v1GroupVersionForDiscoveryGroupVersionL #-}

-- | 'v1GroupVersionForDiscoveryVersion' Lens
v1GroupVersionForDiscoveryVersionL :: Lens_' V1GroupVersionForDiscovery (Text)
v1GroupVersionForDiscoveryVersionL f V1GroupVersionForDiscovery{..} = (\v1GroupVersionForDiscoveryVersion -> V1GroupVersionForDiscovery { v1GroupVersionForDiscoveryVersion, ..} ) <$> f v1GroupVersionForDiscoveryVersion
{-# INLINE v1GroupVersionForDiscoveryVersionL #-}



-- * V1HTTPGetAction

-- | 'v1HTTPGetActionHost' Lens
v1HTTPGetActionHostL :: Lens_' V1HTTPGetAction (Maybe Text)
v1HTTPGetActionHostL f V1HTTPGetAction{..} = (\v1HTTPGetActionHost -> V1HTTPGetAction { v1HTTPGetActionHost, ..} ) <$> f v1HTTPGetActionHost
{-# INLINE v1HTTPGetActionHostL #-}

-- | 'v1HTTPGetActionHttpHeaders' Lens
v1HTTPGetActionHttpHeadersL :: Lens_' V1HTTPGetAction (Maybe [V1HTTPHeader])
v1HTTPGetActionHttpHeadersL f V1HTTPGetAction{..} = (\v1HTTPGetActionHttpHeaders -> V1HTTPGetAction { v1HTTPGetActionHttpHeaders, ..} ) <$> f v1HTTPGetActionHttpHeaders
{-# INLINE v1HTTPGetActionHttpHeadersL #-}

-- | 'v1HTTPGetActionPath' Lens
v1HTTPGetActionPathL :: Lens_' V1HTTPGetAction (Maybe Text)
v1HTTPGetActionPathL f V1HTTPGetAction{..} = (\v1HTTPGetActionPath -> V1HTTPGetAction { v1HTTPGetActionPath, ..} ) <$> f v1HTTPGetActionPath
{-# INLINE v1HTTPGetActionPathL #-}

-- | 'v1HTTPGetActionPort' Lens
v1HTTPGetActionPortL :: Lens_' V1HTTPGetAction (IntOrString)
v1HTTPGetActionPortL f V1HTTPGetAction{..} = (\v1HTTPGetActionPort -> V1HTTPGetAction { v1HTTPGetActionPort, ..} ) <$> f v1HTTPGetActionPort
{-# INLINE v1HTTPGetActionPortL #-}

-- | 'v1HTTPGetActionScheme' Lens
v1HTTPGetActionSchemeL :: Lens_' V1HTTPGetAction (Maybe Text)
v1HTTPGetActionSchemeL f V1HTTPGetAction{..} = (\v1HTTPGetActionScheme -> V1HTTPGetAction { v1HTTPGetActionScheme, ..} ) <$> f v1HTTPGetActionScheme
{-# INLINE v1HTTPGetActionSchemeL #-}



-- * V1HTTPHeader

-- | 'v1HTTPHeaderName' Lens
v1HTTPHeaderNameL :: Lens_' V1HTTPHeader (Text)
v1HTTPHeaderNameL f V1HTTPHeader{..} = (\v1HTTPHeaderName -> V1HTTPHeader { v1HTTPHeaderName, ..} ) <$> f v1HTTPHeaderName
{-# INLINE v1HTTPHeaderNameL #-}

-- | 'v1HTTPHeaderValue' Lens
v1HTTPHeaderValueL :: Lens_' V1HTTPHeader (Text)
v1HTTPHeaderValueL f V1HTTPHeader{..} = (\v1HTTPHeaderValue -> V1HTTPHeader { v1HTTPHeaderValue, ..} ) <$> f v1HTTPHeaderValue
{-# INLINE v1HTTPHeaderValueL #-}



-- * V1HTTPIngressPath

-- | 'v1HTTPIngressPathBackend' Lens
v1HTTPIngressPathBackendL :: Lens_' V1HTTPIngressPath (V1IngressBackend)
v1HTTPIngressPathBackendL f V1HTTPIngressPath{..} = (\v1HTTPIngressPathBackend -> V1HTTPIngressPath { v1HTTPIngressPathBackend, ..} ) <$> f v1HTTPIngressPathBackend
{-# INLINE v1HTTPIngressPathBackendL #-}

-- | 'v1HTTPIngressPathPath' Lens
v1HTTPIngressPathPathL :: Lens_' V1HTTPIngressPath (Maybe Text)
v1HTTPIngressPathPathL f V1HTTPIngressPath{..} = (\v1HTTPIngressPathPath -> V1HTTPIngressPath { v1HTTPIngressPathPath, ..} ) <$> f v1HTTPIngressPathPath
{-# INLINE v1HTTPIngressPathPathL #-}

-- | 'v1HTTPIngressPathPathType' Lens
v1HTTPIngressPathPathTypeL :: Lens_' V1HTTPIngressPath (Text)
v1HTTPIngressPathPathTypeL f V1HTTPIngressPath{..} = (\v1HTTPIngressPathPathType -> V1HTTPIngressPath { v1HTTPIngressPathPathType, ..} ) <$> f v1HTTPIngressPathPathType
{-# INLINE v1HTTPIngressPathPathTypeL #-}



-- * V1HTTPIngressRuleValue

-- | 'v1HTTPIngressRuleValuePaths' Lens
v1HTTPIngressRuleValuePathsL :: Lens_' V1HTTPIngressRuleValue ([V1HTTPIngressPath])
v1HTTPIngressRuleValuePathsL f V1HTTPIngressRuleValue{..} = (\v1HTTPIngressRuleValuePaths -> V1HTTPIngressRuleValue { v1HTTPIngressRuleValuePaths, ..} ) <$> f v1HTTPIngressRuleValuePaths
{-# INLINE v1HTTPIngressRuleValuePathsL #-}



-- * V1HorizontalPodAutoscaler

-- | 'v1HorizontalPodAutoscalerApiVersion' Lens
v1HorizontalPodAutoscalerApiVersionL :: Lens_' V1HorizontalPodAutoscaler (Maybe Text)
v1HorizontalPodAutoscalerApiVersionL f V1HorizontalPodAutoscaler{..} = (\v1HorizontalPodAutoscalerApiVersion -> V1HorizontalPodAutoscaler { v1HorizontalPodAutoscalerApiVersion, ..} ) <$> f v1HorizontalPodAutoscalerApiVersion
{-# INLINE v1HorizontalPodAutoscalerApiVersionL #-}

-- | 'v1HorizontalPodAutoscalerKind' Lens
v1HorizontalPodAutoscalerKindL :: Lens_' V1HorizontalPodAutoscaler (Maybe Text)
v1HorizontalPodAutoscalerKindL f V1HorizontalPodAutoscaler{..} = (\v1HorizontalPodAutoscalerKind -> V1HorizontalPodAutoscaler { v1HorizontalPodAutoscalerKind, ..} ) <$> f v1HorizontalPodAutoscalerKind
{-# INLINE v1HorizontalPodAutoscalerKindL #-}

-- | 'v1HorizontalPodAutoscalerMetadata' Lens
v1HorizontalPodAutoscalerMetadataL :: Lens_' V1HorizontalPodAutoscaler (Maybe V1ObjectMeta)
v1HorizontalPodAutoscalerMetadataL f V1HorizontalPodAutoscaler{..} = (\v1HorizontalPodAutoscalerMetadata -> V1HorizontalPodAutoscaler { v1HorizontalPodAutoscalerMetadata, ..} ) <$> f v1HorizontalPodAutoscalerMetadata
{-# INLINE v1HorizontalPodAutoscalerMetadataL #-}

-- | 'v1HorizontalPodAutoscalerSpec' Lens
v1HorizontalPodAutoscalerSpecL :: Lens_' V1HorizontalPodAutoscaler (Maybe V1HorizontalPodAutoscalerSpec)
v1HorizontalPodAutoscalerSpecL f V1HorizontalPodAutoscaler{..} = (\v1HorizontalPodAutoscalerSpec -> V1HorizontalPodAutoscaler { v1HorizontalPodAutoscalerSpec, ..} ) <$> f v1HorizontalPodAutoscalerSpec
{-# INLINE v1HorizontalPodAutoscalerSpecL #-}

-- | 'v1HorizontalPodAutoscalerStatus' Lens
v1HorizontalPodAutoscalerStatusL :: Lens_' V1HorizontalPodAutoscaler (Maybe V1HorizontalPodAutoscalerStatus)
v1HorizontalPodAutoscalerStatusL f V1HorizontalPodAutoscaler{..} = (\v1HorizontalPodAutoscalerStatus -> V1HorizontalPodAutoscaler { v1HorizontalPodAutoscalerStatus, ..} ) <$> f v1HorizontalPodAutoscalerStatus
{-# INLINE v1HorizontalPodAutoscalerStatusL #-}



-- * V1HorizontalPodAutoscalerList

-- | 'v1HorizontalPodAutoscalerListApiVersion' Lens
v1HorizontalPodAutoscalerListApiVersionL :: Lens_' V1HorizontalPodAutoscalerList (Maybe Text)
v1HorizontalPodAutoscalerListApiVersionL f V1HorizontalPodAutoscalerList{..} = (\v1HorizontalPodAutoscalerListApiVersion -> V1HorizontalPodAutoscalerList { v1HorizontalPodAutoscalerListApiVersion, ..} ) <$> f v1HorizontalPodAutoscalerListApiVersion
{-# INLINE v1HorizontalPodAutoscalerListApiVersionL #-}

-- | 'v1HorizontalPodAutoscalerListItems' Lens
v1HorizontalPodAutoscalerListItemsL :: Lens_' V1HorizontalPodAutoscalerList ([V1HorizontalPodAutoscaler])
v1HorizontalPodAutoscalerListItemsL f V1HorizontalPodAutoscalerList{..} = (\v1HorizontalPodAutoscalerListItems -> V1HorizontalPodAutoscalerList { v1HorizontalPodAutoscalerListItems, ..} ) <$> f v1HorizontalPodAutoscalerListItems
{-# INLINE v1HorizontalPodAutoscalerListItemsL #-}

-- | 'v1HorizontalPodAutoscalerListKind' Lens
v1HorizontalPodAutoscalerListKindL :: Lens_' V1HorizontalPodAutoscalerList (Maybe Text)
v1HorizontalPodAutoscalerListKindL f V1HorizontalPodAutoscalerList{..} = (\v1HorizontalPodAutoscalerListKind -> V1HorizontalPodAutoscalerList { v1HorizontalPodAutoscalerListKind, ..} ) <$> f v1HorizontalPodAutoscalerListKind
{-# INLINE v1HorizontalPodAutoscalerListKindL #-}

-- | 'v1HorizontalPodAutoscalerListMetadata' Lens
v1HorizontalPodAutoscalerListMetadataL :: Lens_' V1HorizontalPodAutoscalerList (Maybe V1ListMeta)
v1HorizontalPodAutoscalerListMetadataL f V1HorizontalPodAutoscalerList{..} = (\v1HorizontalPodAutoscalerListMetadata -> V1HorizontalPodAutoscalerList { v1HorizontalPodAutoscalerListMetadata, ..} ) <$> f v1HorizontalPodAutoscalerListMetadata
{-# INLINE v1HorizontalPodAutoscalerListMetadataL #-}



-- * V1HorizontalPodAutoscalerSpec

-- | 'v1HorizontalPodAutoscalerSpecMaxReplicas' Lens
v1HorizontalPodAutoscalerSpecMaxReplicasL :: Lens_' V1HorizontalPodAutoscalerSpec (Int)
v1HorizontalPodAutoscalerSpecMaxReplicasL f V1HorizontalPodAutoscalerSpec{..} = (\v1HorizontalPodAutoscalerSpecMaxReplicas -> V1HorizontalPodAutoscalerSpec { v1HorizontalPodAutoscalerSpecMaxReplicas, ..} ) <$> f v1HorizontalPodAutoscalerSpecMaxReplicas
{-# INLINE v1HorizontalPodAutoscalerSpecMaxReplicasL #-}

-- | 'v1HorizontalPodAutoscalerSpecMinReplicas' Lens
v1HorizontalPodAutoscalerSpecMinReplicasL :: Lens_' V1HorizontalPodAutoscalerSpec (Maybe Int)
v1HorizontalPodAutoscalerSpecMinReplicasL f V1HorizontalPodAutoscalerSpec{..} = (\v1HorizontalPodAutoscalerSpecMinReplicas -> V1HorizontalPodAutoscalerSpec { v1HorizontalPodAutoscalerSpecMinReplicas, ..} ) <$> f v1HorizontalPodAutoscalerSpecMinReplicas
{-# INLINE v1HorizontalPodAutoscalerSpecMinReplicasL #-}

-- | 'v1HorizontalPodAutoscalerSpecScaleTargetRef' Lens
v1HorizontalPodAutoscalerSpecScaleTargetRefL :: Lens_' V1HorizontalPodAutoscalerSpec (V1CrossVersionObjectReference)
v1HorizontalPodAutoscalerSpecScaleTargetRefL f V1HorizontalPodAutoscalerSpec{..} = (\v1HorizontalPodAutoscalerSpecScaleTargetRef -> V1HorizontalPodAutoscalerSpec { v1HorizontalPodAutoscalerSpecScaleTargetRef, ..} ) <$> f v1HorizontalPodAutoscalerSpecScaleTargetRef
{-# INLINE v1HorizontalPodAutoscalerSpecScaleTargetRefL #-}

-- | 'v1HorizontalPodAutoscalerSpecTargetCpuUtilizationPercentage' Lens
v1HorizontalPodAutoscalerSpecTargetCpuUtilizationPercentageL :: Lens_' V1HorizontalPodAutoscalerSpec (Maybe Int)
v1HorizontalPodAutoscalerSpecTargetCpuUtilizationPercentageL f V1HorizontalPodAutoscalerSpec{..} = (\v1HorizontalPodAutoscalerSpecTargetCpuUtilizationPercentage -> V1HorizontalPodAutoscalerSpec { v1HorizontalPodAutoscalerSpecTargetCpuUtilizationPercentage, ..} ) <$> f v1HorizontalPodAutoscalerSpecTargetCpuUtilizationPercentage
{-# INLINE v1HorizontalPodAutoscalerSpecTargetCpuUtilizationPercentageL #-}



-- * V1HorizontalPodAutoscalerStatus

-- | 'v1HorizontalPodAutoscalerStatusCurrentCpuUtilizationPercentage' Lens
v1HorizontalPodAutoscalerStatusCurrentCpuUtilizationPercentageL :: Lens_' V1HorizontalPodAutoscalerStatus (Maybe Int)
v1HorizontalPodAutoscalerStatusCurrentCpuUtilizationPercentageL f V1HorizontalPodAutoscalerStatus{..} = (\v1HorizontalPodAutoscalerStatusCurrentCpuUtilizationPercentage -> V1HorizontalPodAutoscalerStatus { v1HorizontalPodAutoscalerStatusCurrentCpuUtilizationPercentage, ..} ) <$> f v1HorizontalPodAutoscalerStatusCurrentCpuUtilizationPercentage
{-# INLINE v1HorizontalPodAutoscalerStatusCurrentCpuUtilizationPercentageL #-}

-- | 'v1HorizontalPodAutoscalerStatusCurrentReplicas' Lens
v1HorizontalPodAutoscalerStatusCurrentReplicasL :: Lens_' V1HorizontalPodAutoscalerStatus (Int)
v1HorizontalPodAutoscalerStatusCurrentReplicasL f V1HorizontalPodAutoscalerStatus{..} = (\v1HorizontalPodAutoscalerStatusCurrentReplicas -> V1HorizontalPodAutoscalerStatus { v1HorizontalPodAutoscalerStatusCurrentReplicas, ..} ) <$> f v1HorizontalPodAutoscalerStatusCurrentReplicas
{-# INLINE v1HorizontalPodAutoscalerStatusCurrentReplicasL #-}

-- | 'v1HorizontalPodAutoscalerStatusDesiredReplicas' Lens
v1HorizontalPodAutoscalerStatusDesiredReplicasL :: Lens_' V1HorizontalPodAutoscalerStatus (Int)
v1HorizontalPodAutoscalerStatusDesiredReplicasL f V1HorizontalPodAutoscalerStatus{..} = (\v1HorizontalPodAutoscalerStatusDesiredReplicas -> V1HorizontalPodAutoscalerStatus { v1HorizontalPodAutoscalerStatusDesiredReplicas, ..} ) <$> f v1HorizontalPodAutoscalerStatusDesiredReplicas
{-# INLINE v1HorizontalPodAutoscalerStatusDesiredReplicasL #-}

-- | 'v1HorizontalPodAutoscalerStatusLastScaleTime' Lens
v1HorizontalPodAutoscalerStatusLastScaleTimeL :: Lens_' V1HorizontalPodAutoscalerStatus (Maybe DateTime)
v1HorizontalPodAutoscalerStatusLastScaleTimeL f V1HorizontalPodAutoscalerStatus{..} = (\v1HorizontalPodAutoscalerStatusLastScaleTime -> V1HorizontalPodAutoscalerStatus { v1HorizontalPodAutoscalerStatusLastScaleTime, ..} ) <$> f v1HorizontalPodAutoscalerStatusLastScaleTime
{-# INLINE v1HorizontalPodAutoscalerStatusLastScaleTimeL #-}

-- | 'v1HorizontalPodAutoscalerStatusObservedGeneration' Lens
v1HorizontalPodAutoscalerStatusObservedGenerationL :: Lens_' V1HorizontalPodAutoscalerStatus (Maybe Integer)
v1HorizontalPodAutoscalerStatusObservedGenerationL f V1HorizontalPodAutoscalerStatus{..} = (\v1HorizontalPodAutoscalerStatusObservedGeneration -> V1HorizontalPodAutoscalerStatus { v1HorizontalPodAutoscalerStatusObservedGeneration, ..} ) <$> f v1HorizontalPodAutoscalerStatusObservedGeneration
{-# INLINE v1HorizontalPodAutoscalerStatusObservedGenerationL #-}



-- * V1HostAlias

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

-- | 'v1HostAliasIp' Lens
v1HostAliasIpL :: Lens_' V1HostAlias (Maybe Text)
v1HostAliasIpL f V1HostAlias{..} = (\v1HostAliasIp -> V1HostAlias { v1HostAliasIp, ..} ) <$> f v1HostAliasIp
{-# INLINE v1HostAliasIpL #-}



-- * V1HostPathVolumeSource

-- | 'v1HostPathVolumeSourcePath' Lens
v1HostPathVolumeSourcePathL :: Lens_' V1HostPathVolumeSource (Text)
v1HostPathVolumeSourcePathL f V1HostPathVolumeSource{..} = (\v1HostPathVolumeSourcePath -> V1HostPathVolumeSource { v1HostPathVolumeSourcePath, ..} ) <$> f v1HostPathVolumeSourcePath
{-# INLINE v1HostPathVolumeSourcePathL #-}

-- | 'v1HostPathVolumeSourceType' Lens
v1HostPathVolumeSourceTypeL :: Lens_' V1HostPathVolumeSource (Maybe Text)
v1HostPathVolumeSourceTypeL f V1HostPathVolumeSource{..} = (\v1HostPathVolumeSourceType -> V1HostPathVolumeSource { v1HostPathVolumeSourceType, ..} ) <$> f v1HostPathVolumeSourceType
{-# INLINE v1HostPathVolumeSourceTypeL #-}



-- * V1IPBlock

-- | 'v1IPBlockCidr' Lens
v1IPBlockCidrL :: Lens_' V1IPBlock (Text)
v1IPBlockCidrL f V1IPBlock{..} = (\v1IPBlockCidr -> V1IPBlock { v1IPBlockCidr, ..} ) <$> f v1IPBlockCidr
{-# INLINE v1IPBlockCidrL #-}

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



-- * V1ISCSIPersistentVolumeSource

-- | 'v1ISCSIPersistentVolumeSourceChapAuthDiscovery' Lens
v1ISCSIPersistentVolumeSourceChapAuthDiscoveryL :: Lens_' V1ISCSIPersistentVolumeSource (Maybe Bool)
v1ISCSIPersistentVolumeSourceChapAuthDiscoveryL f V1ISCSIPersistentVolumeSource{..} = (\v1ISCSIPersistentVolumeSourceChapAuthDiscovery -> V1ISCSIPersistentVolumeSource { v1ISCSIPersistentVolumeSourceChapAuthDiscovery, ..} ) <$> f v1ISCSIPersistentVolumeSourceChapAuthDiscovery
{-# INLINE v1ISCSIPersistentVolumeSourceChapAuthDiscoveryL #-}

-- | 'v1ISCSIPersistentVolumeSourceChapAuthSession' Lens
v1ISCSIPersistentVolumeSourceChapAuthSessionL :: Lens_' V1ISCSIPersistentVolumeSource (Maybe Bool)
v1ISCSIPersistentVolumeSourceChapAuthSessionL f V1ISCSIPersistentVolumeSource{..} = (\v1ISCSIPersistentVolumeSourceChapAuthSession -> V1ISCSIPersistentVolumeSource { v1ISCSIPersistentVolumeSourceChapAuthSession, ..} ) <$> f v1ISCSIPersistentVolumeSourceChapAuthSession
{-# INLINE v1ISCSIPersistentVolumeSourceChapAuthSessionL #-}

-- | 'v1ISCSIPersistentVolumeSourceFsType' Lens
v1ISCSIPersistentVolumeSourceFsTypeL :: Lens_' V1ISCSIPersistentVolumeSource (Maybe Text)
v1ISCSIPersistentVolumeSourceFsTypeL f V1ISCSIPersistentVolumeSource{..} = (\v1ISCSIPersistentVolumeSourceFsType -> V1ISCSIPersistentVolumeSource { v1ISCSIPersistentVolumeSourceFsType, ..} ) <$> f v1ISCSIPersistentVolumeSourceFsType
{-# INLINE v1ISCSIPersistentVolumeSourceFsTypeL #-}

-- | 'v1ISCSIPersistentVolumeSourceInitiatorName' Lens
v1ISCSIPersistentVolumeSourceInitiatorNameL :: Lens_' V1ISCSIPersistentVolumeSource (Maybe Text)
v1ISCSIPersistentVolumeSourceInitiatorNameL f V1ISCSIPersistentVolumeSource{..} = (\v1ISCSIPersistentVolumeSourceInitiatorName -> V1ISCSIPersistentVolumeSource { v1ISCSIPersistentVolumeSourceInitiatorName, ..} ) <$> f v1ISCSIPersistentVolumeSourceInitiatorName
{-# INLINE v1ISCSIPersistentVolumeSourceInitiatorNameL #-}

-- | 'v1ISCSIPersistentVolumeSourceIqn' Lens
v1ISCSIPersistentVolumeSourceIqnL :: Lens_' V1ISCSIPersistentVolumeSource (Text)
v1ISCSIPersistentVolumeSourceIqnL f V1ISCSIPersistentVolumeSource{..} = (\v1ISCSIPersistentVolumeSourceIqn -> V1ISCSIPersistentVolumeSource { v1ISCSIPersistentVolumeSourceIqn, ..} ) <$> f v1ISCSIPersistentVolumeSourceIqn
{-# INLINE v1ISCSIPersistentVolumeSourceIqnL #-}

-- | 'v1ISCSIPersistentVolumeSourceIscsiInterface' Lens
v1ISCSIPersistentVolumeSourceIscsiInterfaceL :: Lens_' V1ISCSIPersistentVolumeSource (Maybe Text)
v1ISCSIPersistentVolumeSourceIscsiInterfaceL f V1ISCSIPersistentVolumeSource{..} = (\v1ISCSIPersistentVolumeSourceIscsiInterface -> V1ISCSIPersistentVolumeSource { v1ISCSIPersistentVolumeSourceIscsiInterface, ..} ) <$> f v1ISCSIPersistentVolumeSourceIscsiInterface
{-# INLINE v1ISCSIPersistentVolumeSourceIscsiInterfaceL #-}

-- | 'v1ISCSIPersistentVolumeSourceLun' Lens
v1ISCSIPersistentVolumeSourceLunL :: Lens_' V1ISCSIPersistentVolumeSource (Int)
v1ISCSIPersistentVolumeSourceLunL f V1ISCSIPersistentVolumeSource{..} = (\v1ISCSIPersistentVolumeSourceLun -> V1ISCSIPersistentVolumeSource { v1ISCSIPersistentVolumeSourceLun, ..} ) <$> f v1ISCSIPersistentVolumeSourceLun
{-# INLINE v1ISCSIPersistentVolumeSourceLunL #-}

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

-- | 'v1ISCSIPersistentVolumeSourceReadOnly' Lens
v1ISCSIPersistentVolumeSourceReadOnlyL :: Lens_' V1ISCSIPersistentVolumeSource (Maybe Bool)
v1ISCSIPersistentVolumeSourceReadOnlyL f V1ISCSIPersistentVolumeSource{..} = (\v1ISCSIPersistentVolumeSourceReadOnly -> V1ISCSIPersistentVolumeSource { v1ISCSIPersistentVolumeSourceReadOnly, ..} ) <$> f v1ISCSIPersistentVolumeSourceReadOnly
{-# INLINE v1ISCSIPersistentVolumeSourceReadOnlyL #-}

-- | 'v1ISCSIPersistentVolumeSourceSecretRef' Lens
v1ISCSIPersistentVolumeSourceSecretRefL :: Lens_' V1ISCSIPersistentVolumeSource (Maybe V1SecretReference)
v1ISCSIPersistentVolumeSourceSecretRefL f V1ISCSIPersistentVolumeSource{..} = (\v1ISCSIPersistentVolumeSourceSecretRef -> V1ISCSIPersistentVolumeSource { v1ISCSIPersistentVolumeSourceSecretRef, ..} ) <$> f v1ISCSIPersistentVolumeSourceSecretRef
{-# INLINE v1ISCSIPersistentVolumeSourceSecretRefL #-}

-- | 'v1ISCSIPersistentVolumeSourceTargetPortal' Lens
v1ISCSIPersistentVolumeSourceTargetPortalL :: Lens_' V1ISCSIPersistentVolumeSource (Text)
v1ISCSIPersistentVolumeSourceTargetPortalL f V1ISCSIPersistentVolumeSource{..} = (\v1ISCSIPersistentVolumeSourceTargetPortal -> V1ISCSIPersistentVolumeSource { v1ISCSIPersistentVolumeSourceTargetPortal, ..} ) <$> f v1ISCSIPersistentVolumeSourceTargetPortal
{-# INLINE v1ISCSIPersistentVolumeSourceTargetPortalL #-}



-- * V1ISCSIVolumeSource

-- | 'v1ISCSIVolumeSourceChapAuthDiscovery' Lens
v1ISCSIVolumeSourceChapAuthDiscoveryL :: Lens_' V1ISCSIVolumeSource (Maybe Bool)
v1ISCSIVolumeSourceChapAuthDiscoveryL f V1ISCSIVolumeSource{..} = (\v1ISCSIVolumeSourceChapAuthDiscovery -> V1ISCSIVolumeSource { v1ISCSIVolumeSourceChapAuthDiscovery, ..} ) <$> f v1ISCSIVolumeSourceChapAuthDiscovery
{-# INLINE v1ISCSIVolumeSourceChapAuthDiscoveryL #-}

-- | 'v1ISCSIVolumeSourceChapAuthSession' Lens
v1ISCSIVolumeSourceChapAuthSessionL :: Lens_' V1ISCSIVolumeSource (Maybe Bool)
v1ISCSIVolumeSourceChapAuthSessionL f V1ISCSIVolumeSource{..} = (\v1ISCSIVolumeSourceChapAuthSession -> V1ISCSIVolumeSource { v1ISCSIVolumeSourceChapAuthSession, ..} ) <$> f v1ISCSIVolumeSourceChapAuthSession
{-# INLINE v1ISCSIVolumeSourceChapAuthSessionL #-}

-- | 'v1ISCSIVolumeSourceFsType' Lens
v1ISCSIVolumeSourceFsTypeL :: Lens_' V1ISCSIVolumeSource (Maybe Text)
v1ISCSIVolumeSourceFsTypeL f V1ISCSIVolumeSource{..} = (\v1ISCSIVolumeSourceFsType -> V1ISCSIVolumeSource { v1ISCSIVolumeSourceFsType, ..} ) <$> f v1ISCSIVolumeSourceFsType
{-# INLINE v1ISCSIVolumeSourceFsTypeL #-}

-- | 'v1ISCSIVolumeSourceInitiatorName' Lens
v1ISCSIVolumeSourceInitiatorNameL :: Lens_' V1ISCSIVolumeSource (Maybe Text)
v1ISCSIVolumeSourceInitiatorNameL f V1ISCSIVolumeSource{..} = (\v1ISCSIVolumeSourceInitiatorName -> V1ISCSIVolumeSource { v1ISCSIVolumeSourceInitiatorName, ..} ) <$> f v1ISCSIVolumeSourceInitiatorName
{-# INLINE v1ISCSIVolumeSourceInitiatorNameL #-}

-- | 'v1ISCSIVolumeSourceIqn' Lens
v1ISCSIVolumeSourceIqnL :: Lens_' V1ISCSIVolumeSource (Text)
v1ISCSIVolumeSourceIqnL f V1ISCSIVolumeSource{..} = (\v1ISCSIVolumeSourceIqn -> V1ISCSIVolumeSource { v1ISCSIVolumeSourceIqn, ..} ) <$> f v1ISCSIVolumeSourceIqn
{-# INLINE v1ISCSIVolumeSourceIqnL #-}

-- | 'v1ISCSIVolumeSourceIscsiInterface' Lens
v1ISCSIVolumeSourceIscsiInterfaceL :: Lens_' V1ISCSIVolumeSource (Maybe Text)
v1ISCSIVolumeSourceIscsiInterfaceL f V1ISCSIVolumeSource{..} = (\v1ISCSIVolumeSourceIscsiInterface -> V1ISCSIVolumeSource { v1ISCSIVolumeSourceIscsiInterface, ..} ) <$> f v1ISCSIVolumeSourceIscsiInterface
{-# INLINE v1ISCSIVolumeSourceIscsiInterfaceL #-}

-- | 'v1ISCSIVolumeSourceLun' Lens
v1ISCSIVolumeSourceLunL :: Lens_' V1ISCSIVolumeSource (Int)
v1ISCSIVolumeSourceLunL f V1ISCSIVolumeSource{..} = (\v1ISCSIVolumeSourceLun -> V1ISCSIVolumeSource { v1ISCSIVolumeSourceLun, ..} ) <$> f v1ISCSIVolumeSourceLun
{-# INLINE v1ISCSIVolumeSourceLunL #-}

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

-- | 'v1ISCSIVolumeSourceReadOnly' Lens
v1ISCSIVolumeSourceReadOnlyL :: Lens_' V1ISCSIVolumeSource (Maybe Bool)
v1ISCSIVolumeSourceReadOnlyL f V1ISCSIVolumeSource{..} = (\v1ISCSIVolumeSourceReadOnly -> V1ISCSIVolumeSource { v1ISCSIVolumeSourceReadOnly, ..} ) <$> f v1ISCSIVolumeSourceReadOnly
{-# INLINE v1ISCSIVolumeSourceReadOnlyL #-}

-- | 'v1ISCSIVolumeSourceSecretRef' Lens
v1ISCSIVolumeSourceSecretRefL :: Lens_' V1ISCSIVolumeSource (Maybe V1LocalObjectReference)
v1ISCSIVolumeSourceSecretRefL f V1ISCSIVolumeSource{..} = (\v1ISCSIVolumeSourceSecretRef -> V1ISCSIVolumeSource { v1ISCSIVolumeSourceSecretRef, ..} ) <$> f v1ISCSIVolumeSourceSecretRef
{-# INLINE v1ISCSIVolumeSourceSecretRefL #-}

-- | 'v1ISCSIVolumeSourceTargetPortal' Lens
v1ISCSIVolumeSourceTargetPortalL :: Lens_' V1ISCSIVolumeSource (Text)
v1ISCSIVolumeSourceTargetPortalL f V1ISCSIVolumeSource{..} = (\v1ISCSIVolumeSourceTargetPortal -> V1ISCSIVolumeSource { v1ISCSIVolumeSourceTargetPortal, ..} ) <$> f v1ISCSIVolumeSourceTargetPortal
{-# INLINE v1ISCSIVolumeSourceTargetPortalL #-}



-- * V1Ingress

-- | 'v1IngressApiVersion' Lens
v1IngressApiVersionL :: Lens_' V1Ingress (Maybe Text)
v1IngressApiVersionL f V1Ingress{..} = (\v1IngressApiVersion -> V1Ingress { v1IngressApiVersion, ..} ) <$> f v1IngressApiVersion
{-# INLINE v1IngressApiVersionL #-}

-- | 'v1IngressKind' Lens
v1IngressKindL :: Lens_' V1Ingress (Maybe Text)
v1IngressKindL f V1Ingress{..} = (\v1IngressKind -> V1Ingress { v1IngressKind, ..} ) <$> f v1IngressKind
{-# INLINE v1IngressKindL #-}

-- | 'v1IngressMetadata' Lens
v1IngressMetadataL :: Lens_' V1Ingress (Maybe V1ObjectMeta)
v1IngressMetadataL f V1Ingress{..} = (\v1IngressMetadata -> V1Ingress { v1IngressMetadata, ..} ) <$> f v1IngressMetadata
{-# INLINE v1IngressMetadataL #-}

-- | 'v1IngressSpec' Lens
v1IngressSpecL :: Lens_' V1Ingress (Maybe V1IngressSpec)
v1IngressSpecL f V1Ingress{..} = (\v1IngressSpec -> V1Ingress { v1IngressSpec, ..} ) <$> f v1IngressSpec
{-# INLINE v1IngressSpecL #-}

-- | 'v1IngressStatus' Lens
v1IngressStatusL :: Lens_' V1Ingress (Maybe V1IngressStatus)
v1IngressStatusL f V1Ingress{..} = (\v1IngressStatus -> V1Ingress { v1IngressStatus, ..} ) <$> f v1IngressStatus
{-# INLINE v1IngressStatusL #-}



-- * V1IngressBackend

-- | 'v1IngressBackendResource' Lens
v1IngressBackendResourceL :: Lens_' V1IngressBackend (Maybe V1TypedLocalObjectReference)
v1IngressBackendResourceL f V1IngressBackend{..} = (\v1IngressBackendResource -> V1IngressBackend { v1IngressBackendResource, ..} ) <$> f v1IngressBackendResource
{-# INLINE v1IngressBackendResourceL #-}

-- | 'v1IngressBackendService' Lens
v1IngressBackendServiceL :: Lens_' V1IngressBackend (Maybe V1IngressServiceBackend)
v1IngressBackendServiceL f V1IngressBackend{..} = (\v1IngressBackendService -> V1IngressBackend { v1IngressBackendService, ..} ) <$> f v1IngressBackendService
{-# INLINE v1IngressBackendServiceL #-}



-- * V1IngressClass

-- | 'v1IngressClassApiVersion' Lens
v1IngressClassApiVersionL :: Lens_' V1IngressClass (Maybe Text)
v1IngressClassApiVersionL f V1IngressClass{..} = (\v1IngressClassApiVersion -> V1IngressClass { v1IngressClassApiVersion, ..} ) <$> f v1IngressClassApiVersion
{-# INLINE v1IngressClassApiVersionL #-}

-- | 'v1IngressClassKind' Lens
v1IngressClassKindL :: Lens_' V1IngressClass (Maybe Text)
v1IngressClassKindL f V1IngressClass{..} = (\v1IngressClassKind -> V1IngressClass { v1IngressClassKind, ..} ) <$> f v1IngressClassKind
{-# INLINE v1IngressClassKindL #-}

-- | 'v1IngressClassMetadata' Lens
v1IngressClassMetadataL :: Lens_' V1IngressClass (Maybe V1ObjectMeta)
v1IngressClassMetadataL f V1IngressClass{..} = (\v1IngressClassMetadata -> V1IngressClass { v1IngressClassMetadata, ..} ) <$> f v1IngressClassMetadata
{-# INLINE v1IngressClassMetadataL #-}

-- | 'v1IngressClassSpec' Lens
v1IngressClassSpecL :: Lens_' V1IngressClass (Maybe V1IngressClassSpec)
v1IngressClassSpecL f V1IngressClass{..} = (\v1IngressClassSpec -> V1IngressClass { v1IngressClassSpec, ..} ) <$> f v1IngressClassSpec
{-# INLINE v1IngressClassSpecL #-}



-- * V1IngressClassList

-- | 'v1IngressClassListApiVersion' Lens
v1IngressClassListApiVersionL :: Lens_' V1IngressClassList (Maybe Text)
v1IngressClassListApiVersionL f V1IngressClassList{..} = (\v1IngressClassListApiVersion -> V1IngressClassList { v1IngressClassListApiVersion, ..} ) <$> f v1IngressClassListApiVersion
{-# INLINE v1IngressClassListApiVersionL #-}

-- | 'v1IngressClassListItems' Lens
v1IngressClassListItemsL :: Lens_' V1IngressClassList ([V1IngressClass])
v1IngressClassListItemsL f V1IngressClassList{..} = (\v1IngressClassListItems -> V1IngressClassList { v1IngressClassListItems, ..} ) <$> f v1IngressClassListItems
{-# INLINE v1IngressClassListItemsL #-}

-- | 'v1IngressClassListKind' Lens
v1IngressClassListKindL :: Lens_' V1IngressClassList (Maybe Text)
v1IngressClassListKindL f V1IngressClassList{..} = (\v1IngressClassListKind -> V1IngressClassList { v1IngressClassListKind, ..} ) <$> f v1IngressClassListKind
{-# INLINE v1IngressClassListKindL #-}

-- | 'v1IngressClassListMetadata' Lens
v1IngressClassListMetadataL :: Lens_' V1IngressClassList (Maybe V1ListMeta)
v1IngressClassListMetadataL f V1IngressClassList{..} = (\v1IngressClassListMetadata -> V1IngressClassList { v1IngressClassListMetadata, ..} ) <$> f v1IngressClassListMetadata
{-# INLINE v1IngressClassListMetadataL #-}



-- * V1IngressClassParametersReference

-- | 'v1IngressClassParametersReferenceApiGroup' Lens
v1IngressClassParametersReferenceApiGroupL :: Lens_' V1IngressClassParametersReference (Maybe Text)
v1IngressClassParametersReferenceApiGroupL f V1IngressClassParametersReference{..} = (\v1IngressClassParametersReferenceApiGroup -> V1IngressClassParametersReference { v1IngressClassParametersReferenceApiGroup, ..} ) <$> f v1IngressClassParametersReferenceApiGroup
{-# INLINE v1IngressClassParametersReferenceApiGroupL #-}

-- | 'v1IngressClassParametersReferenceKind' Lens
v1IngressClassParametersReferenceKindL :: Lens_' V1IngressClassParametersReference (Text)
v1IngressClassParametersReferenceKindL f V1IngressClassParametersReference{..} = (\v1IngressClassParametersReferenceKind -> V1IngressClassParametersReference { v1IngressClassParametersReferenceKind, ..} ) <$> f v1IngressClassParametersReferenceKind
{-# INLINE v1IngressClassParametersReferenceKindL #-}

-- | 'v1IngressClassParametersReferenceName' Lens
v1IngressClassParametersReferenceNameL :: Lens_' V1IngressClassParametersReference (Text)
v1IngressClassParametersReferenceNameL f V1IngressClassParametersReference{..} = (\v1IngressClassParametersReferenceName -> V1IngressClassParametersReference { v1IngressClassParametersReferenceName, ..} ) <$> f v1IngressClassParametersReferenceName
{-# INLINE v1IngressClassParametersReferenceNameL #-}

-- | 'v1IngressClassParametersReferenceNamespace' Lens
v1IngressClassParametersReferenceNamespaceL :: Lens_' V1IngressClassParametersReference (Maybe Text)
v1IngressClassParametersReferenceNamespaceL f V1IngressClassParametersReference{..} = (\v1IngressClassParametersReferenceNamespace -> V1IngressClassParametersReference { v1IngressClassParametersReferenceNamespace, ..} ) <$> f v1IngressClassParametersReferenceNamespace
{-# INLINE v1IngressClassParametersReferenceNamespaceL #-}

-- | 'v1IngressClassParametersReferenceScope' Lens
v1IngressClassParametersReferenceScopeL :: Lens_' V1IngressClassParametersReference (Maybe Text)
v1IngressClassParametersReferenceScopeL f V1IngressClassParametersReference{..} = (\v1IngressClassParametersReferenceScope -> V1IngressClassParametersReference { v1IngressClassParametersReferenceScope, ..} ) <$> f v1IngressClassParametersReferenceScope
{-# INLINE v1IngressClassParametersReferenceScopeL #-}



-- * V1IngressClassSpec

-- | 'v1IngressClassSpecController' Lens
v1IngressClassSpecControllerL :: Lens_' V1IngressClassSpec (Maybe Text)
v1IngressClassSpecControllerL f V1IngressClassSpec{..} = (\v1IngressClassSpecController -> V1IngressClassSpec { v1IngressClassSpecController, ..} ) <$> f v1IngressClassSpecController
{-# INLINE v1IngressClassSpecControllerL #-}

-- | 'v1IngressClassSpecParameters' Lens
v1IngressClassSpecParametersL :: Lens_' V1IngressClassSpec (Maybe V1IngressClassParametersReference)
v1IngressClassSpecParametersL f V1IngressClassSpec{..} = (\v1IngressClassSpecParameters -> V1IngressClassSpec { v1IngressClassSpecParameters, ..} ) <$> f v1IngressClassSpecParameters
{-# INLINE v1IngressClassSpecParametersL #-}



-- * V1IngressList

-- | 'v1IngressListApiVersion' Lens
v1IngressListApiVersionL :: Lens_' V1IngressList (Maybe Text)
v1IngressListApiVersionL f V1IngressList{..} = (\v1IngressListApiVersion -> V1IngressList { v1IngressListApiVersion, ..} ) <$> f v1IngressListApiVersion
{-# INLINE v1IngressListApiVersionL #-}

-- | 'v1IngressListItems' Lens
v1IngressListItemsL :: Lens_' V1IngressList ([V1Ingress])
v1IngressListItemsL f V1IngressList{..} = (\v1IngressListItems -> V1IngressList { v1IngressListItems, ..} ) <$> f v1IngressListItems
{-# INLINE v1IngressListItemsL #-}

-- | 'v1IngressListKind' Lens
v1IngressListKindL :: Lens_' V1IngressList (Maybe Text)
v1IngressListKindL f V1IngressList{..} = (\v1IngressListKind -> V1IngressList { v1IngressListKind, ..} ) <$> f v1IngressListKind
{-# INLINE v1IngressListKindL #-}

-- | 'v1IngressListMetadata' Lens
v1IngressListMetadataL :: Lens_' V1IngressList (Maybe V1ListMeta)
v1IngressListMetadataL f V1IngressList{..} = (\v1IngressListMetadata -> V1IngressList { v1IngressListMetadata, ..} ) <$> f v1IngressListMetadata
{-# INLINE v1IngressListMetadataL #-}



-- * V1IngressRule

-- | 'v1IngressRuleHost' Lens
v1IngressRuleHostL :: Lens_' V1IngressRule (Maybe Text)
v1IngressRuleHostL f V1IngressRule{..} = (\v1IngressRuleHost -> V1IngressRule { v1IngressRuleHost, ..} ) <$> f v1IngressRuleHost
{-# INLINE v1IngressRuleHostL #-}

-- | 'v1IngressRuleHttp' Lens
v1IngressRuleHttpL :: Lens_' V1IngressRule (Maybe V1HTTPIngressRuleValue)
v1IngressRuleHttpL f V1IngressRule{..} = (\v1IngressRuleHttp -> V1IngressRule { v1IngressRuleHttp, ..} ) <$> f v1IngressRuleHttp
{-# INLINE v1IngressRuleHttpL #-}



-- * V1IngressServiceBackend

-- | 'v1IngressServiceBackendName' Lens
v1IngressServiceBackendNameL :: Lens_' V1IngressServiceBackend (Text)
v1IngressServiceBackendNameL f V1IngressServiceBackend{..} = (\v1IngressServiceBackendName -> V1IngressServiceBackend { v1IngressServiceBackendName, ..} ) <$> f v1IngressServiceBackendName
{-# INLINE v1IngressServiceBackendNameL #-}

-- | 'v1IngressServiceBackendPort' Lens
v1IngressServiceBackendPortL :: Lens_' V1IngressServiceBackend (Maybe V1ServiceBackendPort)
v1IngressServiceBackendPortL f V1IngressServiceBackend{..} = (\v1IngressServiceBackendPort -> V1IngressServiceBackend { v1IngressServiceBackendPort, ..} ) <$> f v1IngressServiceBackendPort
{-# INLINE v1IngressServiceBackendPortL #-}



-- * V1IngressSpec

-- | 'v1IngressSpecDefaultBackend' Lens
v1IngressSpecDefaultBackendL :: Lens_' V1IngressSpec (Maybe V1IngressBackend)
v1IngressSpecDefaultBackendL f V1IngressSpec{..} = (\v1IngressSpecDefaultBackend -> V1IngressSpec { v1IngressSpecDefaultBackend, ..} ) <$> f v1IngressSpecDefaultBackend
{-# INLINE v1IngressSpecDefaultBackendL #-}

-- | 'v1IngressSpecIngressClassName' Lens
v1IngressSpecIngressClassNameL :: Lens_' V1IngressSpec (Maybe Text)
v1IngressSpecIngressClassNameL f V1IngressSpec{..} = (\v1IngressSpecIngressClassName -> V1IngressSpec { v1IngressSpecIngressClassName, ..} ) <$> f v1IngressSpecIngressClassName
{-# INLINE v1IngressSpecIngressClassNameL #-}

-- | 'v1IngressSpecRules' Lens
v1IngressSpecRulesL :: Lens_' V1IngressSpec (Maybe [V1IngressRule])
v1IngressSpecRulesL f V1IngressSpec{..} = (\v1IngressSpecRules -> V1IngressSpec { v1IngressSpecRules, ..} ) <$> f v1IngressSpecRules
{-# INLINE v1IngressSpecRulesL #-}

-- | 'v1IngressSpecTls' Lens
v1IngressSpecTlsL :: Lens_' V1IngressSpec (Maybe [V1IngressTLS])
v1IngressSpecTlsL f V1IngressSpec{..} = (\v1IngressSpecTls -> V1IngressSpec { v1IngressSpecTls, ..} ) <$> f v1IngressSpecTls
{-# INLINE v1IngressSpecTlsL #-}



-- * V1IngressStatus

-- | 'v1IngressStatusLoadBalancer' Lens
v1IngressStatusLoadBalancerL :: Lens_' V1IngressStatus (Maybe V1LoadBalancerStatus)
v1IngressStatusLoadBalancerL f V1IngressStatus{..} = (\v1IngressStatusLoadBalancer -> V1IngressStatus { v1IngressStatusLoadBalancer, ..} ) <$> f v1IngressStatusLoadBalancer
{-# INLINE v1IngressStatusLoadBalancerL #-}



-- * V1IngressTLS

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

-- | 'v1IngressTLSSecretName' Lens
v1IngressTLSSecretNameL :: Lens_' V1IngressTLS (Maybe Text)
v1IngressTLSSecretNameL f V1IngressTLS{..} = (\v1IngressTLSSecretName -> V1IngressTLS { v1IngressTLSSecretName, ..} ) <$> f v1IngressTLSSecretName
{-# INLINE v1IngressTLSSecretNameL #-}



-- * V1JSONSchemaProps

-- | 'v1JSONSchemaPropsRef' Lens
v1JSONSchemaPropsRefL :: Lens_' V1JSONSchemaProps (Maybe Text)
v1JSONSchemaPropsRefL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsRef -> V1JSONSchemaProps { v1JSONSchemaPropsRef, ..} ) <$> f v1JSONSchemaPropsRef
{-# INLINE v1JSONSchemaPropsRefL #-}

-- | 'v1JSONSchemaPropsSchema' Lens
v1JSONSchemaPropsSchemaL :: Lens_' V1JSONSchemaProps (Maybe Text)
v1JSONSchemaPropsSchemaL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsSchema -> V1JSONSchemaProps { v1JSONSchemaPropsSchema, ..} ) <$> f v1JSONSchemaPropsSchema
{-# INLINE v1JSONSchemaPropsSchemaL #-}

-- | 'v1JSONSchemaPropsAdditionalItems' Lens
v1JSONSchemaPropsAdditionalItemsL :: Lens_' V1JSONSchemaProps (Maybe A.Value)
v1JSONSchemaPropsAdditionalItemsL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsAdditionalItems -> V1JSONSchemaProps { v1JSONSchemaPropsAdditionalItems, ..} ) <$> f v1JSONSchemaPropsAdditionalItems
{-# INLINE v1JSONSchemaPropsAdditionalItemsL #-}

-- | 'v1JSONSchemaPropsAdditionalProperties' Lens
v1JSONSchemaPropsAdditionalPropertiesL :: Lens_' V1JSONSchemaProps (Maybe A.Value)
v1JSONSchemaPropsAdditionalPropertiesL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsAdditionalProperties -> V1JSONSchemaProps { v1JSONSchemaPropsAdditionalProperties, ..} ) <$> f v1JSONSchemaPropsAdditionalProperties
{-# INLINE v1JSONSchemaPropsAdditionalPropertiesL #-}

-- | 'v1JSONSchemaPropsAllOf' Lens
v1JSONSchemaPropsAllOfL :: Lens_' V1JSONSchemaProps (Maybe [V1JSONSchemaProps])
v1JSONSchemaPropsAllOfL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsAllOf -> V1JSONSchemaProps { v1JSONSchemaPropsAllOf, ..} ) <$> f v1JSONSchemaPropsAllOf
{-# INLINE v1JSONSchemaPropsAllOfL #-}

-- | 'v1JSONSchemaPropsAnyOf' Lens
v1JSONSchemaPropsAnyOfL :: Lens_' V1JSONSchemaProps (Maybe [V1JSONSchemaProps])
v1JSONSchemaPropsAnyOfL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsAnyOf -> V1JSONSchemaProps { v1JSONSchemaPropsAnyOf, ..} ) <$> f v1JSONSchemaPropsAnyOf
{-# INLINE v1JSONSchemaPropsAnyOfL #-}

-- | 'v1JSONSchemaPropsDefault' Lens
v1JSONSchemaPropsDefaultL :: Lens_' V1JSONSchemaProps (Maybe A.Value)
v1JSONSchemaPropsDefaultL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsDefault -> V1JSONSchemaProps { v1JSONSchemaPropsDefault, ..} ) <$> f v1JSONSchemaPropsDefault
{-# INLINE v1JSONSchemaPropsDefaultL #-}

-- | 'v1JSONSchemaPropsDefinitions' Lens
v1JSONSchemaPropsDefinitionsL :: Lens_' V1JSONSchemaProps (Maybe (Map.Map String V1JSONSchemaProps))
v1JSONSchemaPropsDefinitionsL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsDefinitions -> V1JSONSchemaProps { v1JSONSchemaPropsDefinitions, ..} ) <$> f v1JSONSchemaPropsDefinitions
{-# INLINE v1JSONSchemaPropsDefinitionsL #-}

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

-- | 'v1JSONSchemaPropsDescription' Lens
v1JSONSchemaPropsDescriptionL :: Lens_' V1JSONSchemaProps (Maybe Text)
v1JSONSchemaPropsDescriptionL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsDescription -> V1JSONSchemaProps { v1JSONSchemaPropsDescription, ..} ) <$> f v1JSONSchemaPropsDescription
{-# INLINE v1JSONSchemaPropsDescriptionL #-}

-- | 'v1JSONSchemaPropsEnum' Lens
v1JSONSchemaPropsEnumL :: Lens_' V1JSONSchemaProps (Maybe [A.Value])
v1JSONSchemaPropsEnumL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsEnum -> V1JSONSchemaProps { v1JSONSchemaPropsEnum, ..} ) <$> f v1JSONSchemaPropsEnum
{-# INLINE v1JSONSchemaPropsEnumL #-}

-- | 'v1JSONSchemaPropsExample' Lens
v1JSONSchemaPropsExampleL :: Lens_' V1JSONSchemaProps (Maybe A.Value)
v1JSONSchemaPropsExampleL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsExample -> V1JSONSchemaProps { v1JSONSchemaPropsExample, ..} ) <$> f v1JSONSchemaPropsExample
{-# INLINE v1JSONSchemaPropsExampleL #-}

-- | 'v1JSONSchemaPropsExclusiveMaximum' Lens
v1JSONSchemaPropsExclusiveMaximumL :: Lens_' V1JSONSchemaProps (Maybe Bool)
v1JSONSchemaPropsExclusiveMaximumL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsExclusiveMaximum -> V1JSONSchemaProps { v1JSONSchemaPropsExclusiveMaximum, ..} ) <$> f v1JSONSchemaPropsExclusiveMaximum
{-# INLINE v1JSONSchemaPropsExclusiveMaximumL #-}

-- | 'v1JSONSchemaPropsExclusiveMinimum' Lens
v1JSONSchemaPropsExclusiveMinimumL :: Lens_' V1JSONSchemaProps (Maybe Bool)
v1JSONSchemaPropsExclusiveMinimumL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsExclusiveMinimum -> V1JSONSchemaProps { v1JSONSchemaPropsExclusiveMinimum, ..} ) <$> f v1JSONSchemaPropsExclusiveMinimum
{-# INLINE v1JSONSchemaPropsExclusiveMinimumL #-}

-- | 'v1JSONSchemaPropsExternalDocs' Lens
v1JSONSchemaPropsExternalDocsL :: Lens_' V1JSONSchemaProps (Maybe V1ExternalDocumentation)
v1JSONSchemaPropsExternalDocsL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsExternalDocs -> V1JSONSchemaProps { v1JSONSchemaPropsExternalDocs, ..} ) <$> f v1JSONSchemaPropsExternalDocs
{-# INLINE v1JSONSchemaPropsExternalDocsL #-}

-- | 'v1JSONSchemaPropsFormat' Lens
v1JSONSchemaPropsFormatL :: Lens_' V1JSONSchemaProps (Maybe Text)
v1JSONSchemaPropsFormatL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsFormat -> V1JSONSchemaProps { v1JSONSchemaPropsFormat, ..} ) <$> f v1JSONSchemaPropsFormat
{-# INLINE v1JSONSchemaPropsFormatL #-}

-- | 'v1JSONSchemaPropsId' Lens
v1JSONSchemaPropsIdL :: Lens_' V1JSONSchemaProps (Maybe Text)
v1JSONSchemaPropsIdL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsId -> V1JSONSchemaProps { v1JSONSchemaPropsId, ..} ) <$> f v1JSONSchemaPropsId
{-# INLINE v1JSONSchemaPropsIdL #-}

-- | 'v1JSONSchemaPropsItems' Lens
v1JSONSchemaPropsItemsL :: Lens_' V1JSONSchemaProps (Maybe A.Value)
v1JSONSchemaPropsItemsL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsItems -> V1JSONSchemaProps { v1JSONSchemaPropsItems, ..} ) <$> f v1JSONSchemaPropsItems
{-# INLINE v1JSONSchemaPropsItemsL #-}

-- | 'v1JSONSchemaPropsMaxItems' Lens
v1JSONSchemaPropsMaxItemsL :: Lens_' V1JSONSchemaProps (Maybe Integer)
v1JSONSchemaPropsMaxItemsL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsMaxItems -> V1JSONSchemaProps { v1JSONSchemaPropsMaxItems, ..} ) <$> f v1JSONSchemaPropsMaxItems
{-# INLINE v1JSONSchemaPropsMaxItemsL #-}

-- | 'v1JSONSchemaPropsMaxLength' Lens
v1JSONSchemaPropsMaxLengthL :: Lens_' V1JSONSchemaProps (Maybe Integer)
v1JSONSchemaPropsMaxLengthL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsMaxLength -> V1JSONSchemaProps { v1JSONSchemaPropsMaxLength, ..} ) <$> f v1JSONSchemaPropsMaxLength
{-# INLINE v1JSONSchemaPropsMaxLengthL #-}

-- | 'v1JSONSchemaPropsMaxProperties' Lens
v1JSONSchemaPropsMaxPropertiesL :: Lens_' V1JSONSchemaProps (Maybe Integer)
v1JSONSchemaPropsMaxPropertiesL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsMaxProperties -> V1JSONSchemaProps { v1JSONSchemaPropsMaxProperties, ..} ) <$> f v1JSONSchemaPropsMaxProperties
{-# INLINE v1JSONSchemaPropsMaxPropertiesL #-}

-- | 'v1JSONSchemaPropsMaximum' Lens
v1JSONSchemaPropsMaximumL :: Lens_' V1JSONSchemaProps (Maybe Double)
v1JSONSchemaPropsMaximumL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsMaximum -> V1JSONSchemaProps { v1JSONSchemaPropsMaximum, ..} ) <$> f v1JSONSchemaPropsMaximum
{-# INLINE v1JSONSchemaPropsMaximumL #-}

-- | 'v1JSONSchemaPropsMinItems' Lens
v1JSONSchemaPropsMinItemsL :: Lens_' V1JSONSchemaProps (Maybe Integer)
v1JSONSchemaPropsMinItemsL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsMinItems -> V1JSONSchemaProps { v1JSONSchemaPropsMinItems, ..} ) <$> f v1JSONSchemaPropsMinItems
{-# INLINE v1JSONSchemaPropsMinItemsL #-}

-- | 'v1JSONSchemaPropsMinLength' Lens
v1JSONSchemaPropsMinLengthL :: Lens_' V1JSONSchemaProps (Maybe Integer)
v1JSONSchemaPropsMinLengthL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsMinLength -> V1JSONSchemaProps { v1JSONSchemaPropsMinLength, ..} ) <$> f v1JSONSchemaPropsMinLength
{-# INLINE v1JSONSchemaPropsMinLengthL #-}

-- | 'v1JSONSchemaPropsMinProperties' Lens
v1JSONSchemaPropsMinPropertiesL :: Lens_' V1JSONSchemaProps (Maybe Integer)
v1JSONSchemaPropsMinPropertiesL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsMinProperties -> V1JSONSchemaProps { v1JSONSchemaPropsMinProperties, ..} ) <$> f v1JSONSchemaPropsMinProperties
{-# INLINE v1JSONSchemaPropsMinPropertiesL #-}

-- | 'v1JSONSchemaPropsMinimum' Lens
v1JSONSchemaPropsMinimumL :: Lens_' V1JSONSchemaProps (Maybe Double)
v1JSONSchemaPropsMinimumL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsMinimum -> V1JSONSchemaProps { v1JSONSchemaPropsMinimum, ..} ) <$> f v1JSONSchemaPropsMinimum
{-# INLINE v1JSONSchemaPropsMinimumL #-}

-- | 'v1JSONSchemaPropsMultipleOf' Lens
v1JSONSchemaPropsMultipleOfL :: Lens_' V1JSONSchemaProps (Maybe Double)
v1JSONSchemaPropsMultipleOfL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsMultipleOf -> V1JSONSchemaProps { v1JSONSchemaPropsMultipleOf, ..} ) <$> f v1JSONSchemaPropsMultipleOf
{-# INLINE v1JSONSchemaPropsMultipleOfL #-}

-- | 'v1JSONSchemaPropsNot' Lens
v1JSONSchemaPropsNotL :: Lens_' V1JSONSchemaProps (Maybe V1JSONSchemaProps)
v1JSONSchemaPropsNotL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsNot -> V1JSONSchemaProps { v1JSONSchemaPropsNot, ..} ) <$> f v1JSONSchemaPropsNot
{-# INLINE v1JSONSchemaPropsNotL #-}

-- | 'v1JSONSchemaPropsNullable' Lens
v1JSONSchemaPropsNullableL :: Lens_' V1JSONSchemaProps (Maybe Bool)
v1JSONSchemaPropsNullableL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsNullable -> V1JSONSchemaProps { v1JSONSchemaPropsNullable, ..} ) <$> f v1JSONSchemaPropsNullable
{-# INLINE v1JSONSchemaPropsNullableL #-}

-- | 'v1JSONSchemaPropsOneOf' Lens
v1JSONSchemaPropsOneOfL :: Lens_' V1JSONSchemaProps (Maybe [V1JSONSchemaProps])
v1JSONSchemaPropsOneOfL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsOneOf -> V1JSONSchemaProps { v1JSONSchemaPropsOneOf, ..} ) <$> f v1JSONSchemaPropsOneOf
{-# INLINE v1JSONSchemaPropsOneOfL #-}

-- | 'v1JSONSchemaPropsPattern' Lens
v1JSONSchemaPropsPatternL :: Lens_' V1JSONSchemaProps (Maybe Text)
v1JSONSchemaPropsPatternL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsPattern -> V1JSONSchemaProps { v1JSONSchemaPropsPattern, ..} ) <$> f v1JSONSchemaPropsPattern
{-# INLINE v1JSONSchemaPropsPatternL #-}

-- | 'v1JSONSchemaPropsPatternProperties' Lens
v1JSONSchemaPropsPatternPropertiesL :: Lens_' V1JSONSchemaProps (Maybe (Map.Map String V1JSONSchemaProps))
v1JSONSchemaPropsPatternPropertiesL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsPatternProperties -> V1JSONSchemaProps { v1JSONSchemaPropsPatternProperties, ..} ) <$> f v1JSONSchemaPropsPatternProperties
{-# INLINE v1JSONSchemaPropsPatternPropertiesL #-}

-- | 'v1JSONSchemaPropsProperties' Lens
v1JSONSchemaPropsPropertiesL :: Lens_' V1JSONSchemaProps (Maybe (Map.Map String V1JSONSchemaProps))
v1JSONSchemaPropsPropertiesL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsProperties -> V1JSONSchemaProps { v1JSONSchemaPropsProperties, ..} ) <$> f v1JSONSchemaPropsProperties
{-# INLINE v1JSONSchemaPropsPropertiesL #-}

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

-- | 'v1JSONSchemaPropsTitle' Lens
v1JSONSchemaPropsTitleL :: Lens_' V1JSONSchemaProps (Maybe Text)
v1JSONSchemaPropsTitleL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsTitle -> V1JSONSchemaProps { v1JSONSchemaPropsTitle, ..} ) <$> f v1JSONSchemaPropsTitle
{-# INLINE v1JSONSchemaPropsTitleL #-}

-- | 'v1JSONSchemaPropsType' Lens
v1JSONSchemaPropsTypeL :: Lens_' V1JSONSchemaProps (Maybe Text)
v1JSONSchemaPropsTypeL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsType -> V1JSONSchemaProps { v1JSONSchemaPropsType, ..} ) <$> f v1JSONSchemaPropsType
{-# INLINE v1JSONSchemaPropsTypeL #-}

-- | 'v1JSONSchemaPropsUniqueItems' Lens
v1JSONSchemaPropsUniqueItemsL :: Lens_' V1JSONSchemaProps (Maybe Bool)
v1JSONSchemaPropsUniqueItemsL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsUniqueItems -> V1JSONSchemaProps { v1JSONSchemaPropsUniqueItems, ..} ) <$> f v1JSONSchemaPropsUniqueItems
{-# INLINE v1JSONSchemaPropsUniqueItemsL #-}

-- | 'v1JSONSchemaPropsXKubernetesEmbeddedResource' Lens
v1JSONSchemaPropsXKubernetesEmbeddedResourceL :: Lens_' V1JSONSchemaProps (Maybe Bool)
v1JSONSchemaPropsXKubernetesEmbeddedResourceL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsXKubernetesEmbeddedResource -> V1JSONSchemaProps { v1JSONSchemaPropsXKubernetesEmbeddedResource, ..} ) <$> f v1JSONSchemaPropsXKubernetesEmbeddedResource
{-# INLINE v1JSONSchemaPropsXKubernetesEmbeddedResourceL #-}

-- | 'v1JSONSchemaPropsXKubernetesIntOrString' Lens
v1JSONSchemaPropsXKubernetesIntOrStringL :: Lens_' V1JSONSchemaProps (Maybe Bool)
v1JSONSchemaPropsXKubernetesIntOrStringL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsXKubernetesIntOrString -> V1JSONSchemaProps { v1JSONSchemaPropsXKubernetesIntOrString, ..} ) <$> f v1JSONSchemaPropsXKubernetesIntOrString
{-# INLINE v1JSONSchemaPropsXKubernetesIntOrStringL #-}

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

-- | 'v1JSONSchemaPropsXKubernetesListType' Lens
v1JSONSchemaPropsXKubernetesListTypeL :: Lens_' V1JSONSchemaProps (Maybe Text)
v1JSONSchemaPropsXKubernetesListTypeL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsXKubernetesListType -> V1JSONSchemaProps { v1JSONSchemaPropsXKubernetesListType, ..} ) <$> f v1JSONSchemaPropsXKubernetesListType
{-# INLINE v1JSONSchemaPropsXKubernetesListTypeL #-}

-- | 'v1JSONSchemaPropsXKubernetesMapType' Lens
v1JSONSchemaPropsXKubernetesMapTypeL :: Lens_' V1JSONSchemaProps (Maybe Text)
v1JSONSchemaPropsXKubernetesMapTypeL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsXKubernetesMapType -> V1JSONSchemaProps { v1JSONSchemaPropsXKubernetesMapType, ..} ) <$> f v1JSONSchemaPropsXKubernetesMapType
{-# INLINE v1JSONSchemaPropsXKubernetesMapTypeL #-}

-- | 'v1JSONSchemaPropsXKubernetesPreserveUnknownFields' Lens
v1JSONSchemaPropsXKubernetesPreserveUnknownFieldsL :: Lens_' V1JSONSchemaProps (Maybe Bool)
v1JSONSchemaPropsXKubernetesPreserveUnknownFieldsL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsXKubernetesPreserveUnknownFields -> V1JSONSchemaProps { v1JSONSchemaPropsXKubernetesPreserveUnknownFields, ..} ) <$> f v1JSONSchemaPropsXKubernetesPreserveUnknownFields
{-# INLINE v1JSONSchemaPropsXKubernetesPreserveUnknownFieldsL #-}

-- | 'v1JSONSchemaPropsXKubernetesValidations' Lens
v1JSONSchemaPropsXKubernetesValidationsL :: Lens_' V1JSONSchemaProps (Maybe [V1ValidationRule])
v1JSONSchemaPropsXKubernetesValidationsL f V1JSONSchemaProps{..} = (\v1JSONSchemaPropsXKubernetesValidations -> V1JSONSchemaProps { v1JSONSchemaPropsXKubernetesValidations, ..} ) <$> f v1JSONSchemaPropsXKubernetesValidations
{-# INLINE v1JSONSchemaPropsXKubernetesValidationsL #-}



-- * V1Job

-- | 'v1JobApiVersion' Lens
v1JobApiVersionL :: Lens_' V1Job (Maybe Text)
v1JobApiVersionL f V1Job{..} = (\v1JobApiVersion -> V1Job { v1JobApiVersion, ..} ) <$> f v1JobApiVersion
{-# INLINE v1JobApiVersionL #-}

-- | 'v1JobKind' Lens
v1JobKindL :: Lens_' V1Job (Maybe Text)
v1JobKindL f V1Job{..} = (\v1JobKind -> V1Job { v1JobKind, ..} ) <$> f v1JobKind
{-# INLINE v1JobKindL #-}

-- | 'v1JobMetadata' Lens
v1JobMetadataL :: Lens_' V1Job (Maybe V1ObjectMeta)
v1JobMetadataL f V1Job{..} = (\v1JobMetadata -> V1Job { v1JobMetadata, ..} ) <$> f v1JobMetadata
{-# INLINE v1JobMetadataL #-}

-- | 'v1JobSpec' Lens
v1JobSpecL :: Lens_' V1Job (Maybe V1JobSpec)
v1JobSpecL f V1Job{..} = (\v1JobSpec -> V1Job { v1JobSpec, ..} ) <$> f v1JobSpec
{-# INLINE v1JobSpecL #-}

-- | 'v1JobStatus' Lens
v1JobStatusL :: Lens_' V1Job (Maybe V1JobStatus)
v1JobStatusL f V1Job{..} = (\v1JobStatus -> V1Job { v1JobStatus, ..} ) <$> f v1JobStatus
{-# INLINE v1JobStatusL #-}



-- * V1JobCondition

-- | 'v1JobConditionLastProbeTime' Lens
v1JobConditionLastProbeTimeL :: Lens_' V1JobCondition (Maybe DateTime)
v1JobConditionLastProbeTimeL f V1JobCondition{..} = (\v1JobConditionLastProbeTime -> V1JobCondition { v1JobConditionLastProbeTime, ..} ) <$> f v1JobConditionLastProbeTime
{-# INLINE v1JobConditionLastProbeTimeL #-}

-- | 'v1JobConditionLastTransitionTime' Lens
v1JobConditionLastTransitionTimeL :: Lens_' V1JobCondition (Maybe DateTime)
v1JobConditionLastTransitionTimeL f V1JobCondition{..} = (\v1JobConditionLastTransitionTime -> V1JobCondition { v1JobConditionLastTransitionTime, ..} ) <$> f v1JobConditionLastTransitionTime
{-# INLINE v1JobConditionLastTransitionTimeL #-}

-- | 'v1JobConditionMessage' Lens
v1JobConditionMessageL :: Lens_' V1JobCondition (Maybe Text)
v1JobConditionMessageL f V1JobCondition{..} = (\v1JobConditionMessage -> V1JobCondition { v1JobConditionMessage, ..} ) <$> f v1JobConditionMessage
{-# INLINE v1JobConditionMessageL #-}

-- | 'v1JobConditionReason' Lens
v1JobConditionReasonL :: Lens_' V1JobCondition (Maybe Text)
v1JobConditionReasonL f V1JobCondition{..} = (\v1JobConditionReason -> V1JobCondition { v1JobConditionReason, ..} ) <$> f v1JobConditionReason
{-# INLINE v1JobConditionReasonL #-}

-- | 'v1JobConditionStatus' Lens
v1JobConditionStatusL :: Lens_' V1JobCondition (Text)
v1JobConditionStatusL f V1JobCondition{..} = (\v1JobConditionStatus -> V1JobCondition { v1JobConditionStatus, ..} ) <$> f v1JobConditionStatus
{-# INLINE v1JobConditionStatusL #-}

-- | 'v1JobConditionType' Lens
v1JobConditionTypeL :: Lens_' V1JobCondition (Text)
v1JobConditionTypeL f V1JobCondition{..} = (\v1JobConditionType -> V1JobCondition { v1JobConditionType, ..} ) <$> f v1JobConditionType
{-# INLINE v1JobConditionTypeL #-}



-- * V1JobList

-- | 'v1JobListApiVersion' Lens
v1JobListApiVersionL :: Lens_' V1JobList (Maybe Text)
v1JobListApiVersionL f V1JobList{..} = (\v1JobListApiVersion -> V1JobList { v1JobListApiVersion, ..} ) <$> f v1JobListApiVersion
{-# INLINE v1JobListApiVersionL #-}

-- | 'v1JobListItems' Lens
v1JobListItemsL :: Lens_' V1JobList ([V1Job])
v1JobListItemsL f V1JobList{..} = (\v1JobListItems -> V1JobList { v1JobListItems, ..} ) <$> f v1JobListItems
{-# INLINE v1JobListItemsL #-}

-- | 'v1JobListKind' Lens
v1JobListKindL :: Lens_' V1JobList (Maybe Text)
v1JobListKindL f V1JobList{..} = (\v1JobListKind -> V1JobList { v1JobListKind, ..} ) <$> f v1JobListKind
{-# INLINE v1JobListKindL #-}

-- | 'v1JobListMetadata' Lens
v1JobListMetadataL :: Lens_' V1JobList (Maybe V1ListMeta)
v1JobListMetadataL f V1JobList{..} = (\v1JobListMetadata -> V1JobList { v1JobListMetadata, ..} ) <$> f v1JobListMetadata
{-# INLINE v1JobListMetadataL #-}



-- * V1JobSpec

-- | 'v1JobSpecActiveDeadlineSeconds' Lens
v1JobSpecActiveDeadlineSecondsL :: Lens_' V1JobSpec (Maybe Integer)
v1JobSpecActiveDeadlineSecondsL f V1JobSpec{..} = (\v1JobSpecActiveDeadlineSeconds -> V1JobSpec { v1JobSpecActiveDeadlineSeconds, ..} ) <$> f v1JobSpecActiveDeadlineSeconds
{-# INLINE v1JobSpecActiveDeadlineSecondsL #-}

-- | 'v1JobSpecBackoffLimit' Lens
v1JobSpecBackoffLimitL :: Lens_' V1JobSpec (Maybe Int)
v1JobSpecBackoffLimitL f V1JobSpec{..} = (\v1JobSpecBackoffLimit -> V1JobSpec { v1JobSpecBackoffLimit, ..} ) <$> f v1JobSpecBackoffLimit
{-# INLINE v1JobSpecBackoffLimitL #-}

-- | 'v1JobSpecCompletionMode' Lens
v1JobSpecCompletionModeL :: Lens_' V1JobSpec (Maybe Text)
v1JobSpecCompletionModeL f V1JobSpec{..} = (\v1JobSpecCompletionMode -> V1JobSpec { v1JobSpecCompletionMode, ..} ) <$> f v1JobSpecCompletionMode
{-# INLINE v1JobSpecCompletionModeL #-}

-- | 'v1JobSpecCompletions' Lens
v1JobSpecCompletionsL :: Lens_' V1JobSpec (Maybe Int)
v1JobSpecCompletionsL f V1JobSpec{..} = (\v1JobSpecCompletions -> V1JobSpec { v1JobSpecCompletions, ..} ) <$> f v1JobSpecCompletions
{-# INLINE v1JobSpecCompletionsL #-}

-- | 'v1JobSpecManualSelector' Lens
v1JobSpecManualSelectorL :: Lens_' V1JobSpec (Maybe Bool)
v1JobSpecManualSelectorL f V1JobSpec{..} = (\v1JobSpecManualSelector -> V1JobSpec { v1JobSpecManualSelector, ..} ) <$> f v1JobSpecManualSelector
{-# INLINE v1JobSpecManualSelectorL #-}

-- | 'v1JobSpecParallelism' Lens
v1JobSpecParallelismL :: Lens_' V1JobSpec (Maybe Int)
v1JobSpecParallelismL f V1JobSpec{..} = (\v1JobSpecParallelism -> V1JobSpec { v1JobSpecParallelism, ..} ) <$> f v1JobSpecParallelism
{-# INLINE v1JobSpecParallelismL #-}

-- | 'v1JobSpecSelector' Lens
v1JobSpecSelectorL :: Lens_' V1JobSpec (Maybe V1LabelSelector)
v1JobSpecSelectorL f V1JobSpec{..} = (\v1JobSpecSelector -> V1JobSpec { v1JobSpecSelector, ..} ) <$> f v1JobSpecSelector
{-# INLINE v1JobSpecSelectorL #-}

-- | 'v1JobSpecSuspend' Lens
v1JobSpecSuspendL :: Lens_' V1JobSpec (Maybe Bool)
v1JobSpecSuspendL f V1JobSpec{..} = (\v1JobSpecSuspend -> V1JobSpec { v1JobSpecSuspend, ..} ) <$> f v1JobSpecSuspend
{-# INLINE v1JobSpecSuspendL #-}

-- | 'v1JobSpecTemplate' Lens
v1JobSpecTemplateL :: Lens_' V1JobSpec (V1PodTemplateSpec)
v1JobSpecTemplateL f V1JobSpec{..} = (\v1JobSpecTemplate -> V1JobSpec { v1JobSpecTemplate, ..} ) <$> f v1JobSpecTemplate
{-# INLINE v1JobSpecTemplateL #-}

-- | 'v1JobSpecTtlSecondsAfterFinished' Lens
v1JobSpecTtlSecondsAfterFinishedL :: Lens_' V1JobSpec (Maybe Int)
v1JobSpecTtlSecondsAfterFinishedL f V1JobSpec{..} = (\v1JobSpecTtlSecondsAfterFinished -> V1JobSpec { v1JobSpecTtlSecondsAfterFinished, ..} ) <$> f v1JobSpecTtlSecondsAfterFinished
{-# INLINE v1JobSpecTtlSecondsAfterFinishedL #-}



-- * V1JobStatus

-- | 'v1JobStatusActive' Lens
v1JobStatusActiveL :: Lens_' V1JobStatus (Maybe Int)
v1JobStatusActiveL f V1JobStatus{..} = (\v1JobStatusActive -> V1JobStatus { v1JobStatusActive, ..} ) <$> f v1JobStatusActive
{-# INLINE v1JobStatusActiveL #-}

-- | 'v1JobStatusCompletedIndexes' Lens
v1JobStatusCompletedIndexesL :: Lens_' V1JobStatus (Maybe Text)
v1JobStatusCompletedIndexesL f V1JobStatus{..} = (\v1JobStatusCompletedIndexes -> V1JobStatus { v1JobStatusCompletedIndexes, ..} ) <$> f v1JobStatusCompletedIndexes
{-# INLINE v1JobStatusCompletedIndexesL #-}

-- | 'v1JobStatusCompletionTime' Lens
v1JobStatusCompletionTimeL :: Lens_' V1JobStatus (Maybe DateTime)
v1JobStatusCompletionTimeL f V1JobStatus{..} = (\v1JobStatusCompletionTime -> V1JobStatus { v1JobStatusCompletionTime, ..} ) <$> f v1JobStatusCompletionTime
{-# INLINE v1JobStatusCompletionTimeL #-}

-- | 'v1JobStatusConditions' Lens
v1JobStatusConditionsL :: Lens_' V1JobStatus (Maybe [V1JobCondition])
v1JobStatusConditionsL f V1JobStatus{..} = (\v1JobStatusConditions -> V1JobStatus { v1JobStatusConditions, ..} ) <$> f v1JobStatusConditions
{-# INLINE v1JobStatusConditionsL #-}

-- | 'v1JobStatusFailed' Lens
v1JobStatusFailedL :: Lens_' V1JobStatus (Maybe Int)
v1JobStatusFailedL f V1JobStatus{..} = (\v1JobStatusFailed -> V1JobStatus { v1JobStatusFailed, ..} ) <$> f v1JobStatusFailed
{-# INLINE v1JobStatusFailedL #-}

-- | 'v1JobStatusReady' Lens
v1JobStatusReadyL :: Lens_' V1JobStatus (Maybe Int)
v1JobStatusReadyL f V1JobStatus{..} = (\v1JobStatusReady -> V1JobStatus { v1JobStatusReady, ..} ) <$> f v1JobStatusReady
{-# INLINE v1JobStatusReadyL #-}

-- | 'v1JobStatusStartTime' Lens
v1JobStatusStartTimeL :: Lens_' V1JobStatus (Maybe DateTime)
v1JobStatusStartTimeL f V1JobStatus{..} = (\v1JobStatusStartTime -> V1JobStatus { v1JobStatusStartTime, ..} ) <$> f v1JobStatusStartTime
{-# INLINE v1JobStatusStartTimeL #-}

-- | 'v1JobStatusSucceeded' Lens
v1JobStatusSucceededL :: Lens_' V1JobStatus (Maybe Int)
v1JobStatusSucceededL f V1JobStatus{..} = (\v1JobStatusSucceeded -> V1JobStatus { v1JobStatusSucceeded, ..} ) <$> f v1JobStatusSucceeded
{-# INLINE v1JobStatusSucceededL #-}

-- | 'v1JobStatusUncountedTerminatedPods' Lens
v1JobStatusUncountedTerminatedPodsL :: Lens_' V1JobStatus (Maybe V1UncountedTerminatedPods)
v1JobStatusUncountedTerminatedPodsL f V1JobStatus{..} = (\v1JobStatusUncountedTerminatedPods -> V1JobStatus { v1JobStatusUncountedTerminatedPods, ..} ) <$> f v1JobStatusUncountedTerminatedPods
{-# INLINE v1JobStatusUncountedTerminatedPodsL #-}



-- * V1JobTemplateSpec

-- | 'v1JobTemplateSpecMetadata' Lens
v1JobTemplateSpecMetadataL :: Lens_' V1JobTemplateSpec (Maybe V1ObjectMeta)
v1JobTemplateSpecMetadataL f V1JobTemplateSpec{..} = (\v1JobTemplateSpecMetadata -> V1JobTemplateSpec { v1JobTemplateSpecMetadata, ..} ) <$> f v1JobTemplateSpecMetadata
{-# INLINE v1JobTemplateSpecMetadataL #-}

-- | 'v1JobTemplateSpecSpec' Lens
v1JobTemplateSpecSpecL :: Lens_' V1JobTemplateSpec (Maybe V1JobSpec)
v1JobTemplateSpecSpecL f V1JobTemplateSpec{..} = (\v1JobTemplateSpecSpec -> V1JobTemplateSpec { v1JobTemplateSpecSpec, ..} ) <$> f v1JobTemplateSpecSpec
{-# INLINE v1JobTemplateSpecSpecL #-}



-- * V1KeyToPath

-- | 'v1KeyToPathKey' Lens
v1KeyToPathKeyL :: Lens_' V1KeyToPath (Text)
v1KeyToPathKeyL f V1KeyToPath{..} = (\v1KeyToPathKey -> V1KeyToPath { v1KeyToPathKey, ..} ) <$> f v1KeyToPathKey
{-# INLINE v1KeyToPathKeyL #-}

-- | 'v1KeyToPathMode' Lens
v1KeyToPathModeL :: Lens_' V1KeyToPath (Maybe Int)
v1KeyToPathModeL f V1KeyToPath{..} = (\v1KeyToPathMode -> V1KeyToPath { v1KeyToPathMode, ..} ) <$> f v1KeyToPathMode
{-# INLINE v1KeyToPathModeL #-}

-- | 'v1KeyToPathPath' Lens
v1KeyToPathPathL :: Lens_' V1KeyToPath (Text)
v1KeyToPathPathL f V1KeyToPath{..} = (\v1KeyToPathPath -> V1KeyToPath { v1KeyToPathPath, ..} ) <$> f v1KeyToPathPath
{-# INLINE v1KeyToPathPathL #-}



-- * V1LabelSelector

-- | 'v1LabelSelectorMatchExpressions' Lens
v1LabelSelectorMatchExpressionsL :: Lens_' V1LabelSelector (Maybe [V1LabelSelectorRequirement])
v1LabelSelectorMatchExpressionsL f V1LabelSelector{..} = (\v1LabelSelectorMatchExpressions -> V1LabelSelector { v1LabelSelectorMatchExpressions, ..} ) <$> f v1LabelSelectorMatchExpressions
{-# INLINE v1LabelSelectorMatchExpressionsL #-}

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



-- * V1LabelSelectorRequirement

-- | 'v1LabelSelectorRequirementKey' Lens
v1LabelSelectorRequirementKeyL :: Lens_' V1LabelSelectorRequirement (Text)
v1LabelSelectorRequirementKeyL f V1LabelSelectorRequirement{..} = (\v1LabelSelectorRequirementKey -> V1LabelSelectorRequirement { v1LabelSelectorRequirementKey, ..} ) <$> f v1LabelSelectorRequirementKey
{-# INLINE v1LabelSelectorRequirementKeyL #-}

-- | 'v1LabelSelectorRequirementOperator' Lens
v1LabelSelectorRequirementOperatorL :: Lens_' V1LabelSelectorRequirement (Text)
v1LabelSelectorRequirementOperatorL f V1LabelSelectorRequirement{..} = (\v1LabelSelectorRequirementOperator -> V1LabelSelectorRequirement { v1LabelSelectorRequirementOperator, ..} ) <$> f v1LabelSelectorRequirementOperator
{-# INLINE v1LabelSelectorRequirementOperatorL #-}

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



-- * V1Lease

-- | 'v1LeaseApiVersion' Lens
v1LeaseApiVersionL :: Lens_' V1Lease (Maybe Text)
v1LeaseApiVersionL f V1Lease{..} = (\v1LeaseApiVersion -> V1Lease { v1LeaseApiVersion, ..} ) <$> f v1LeaseApiVersion
{-# INLINE v1LeaseApiVersionL #-}

-- | 'v1LeaseKind' Lens
v1LeaseKindL :: Lens_' V1Lease (Maybe Text)
v1LeaseKindL f V1Lease{..} = (\v1LeaseKind -> V1Lease { v1LeaseKind, ..} ) <$> f v1LeaseKind
{-# INLINE v1LeaseKindL #-}

-- | 'v1LeaseMetadata' Lens
v1LeaseMetadataL :: Lens_' V1Lease (Maybe V1ObjectMeta)
v1LeaseMetadataL f V1Lease{..} = (\v1LeaseMetadata -> V1Lease { v1LeaseMetadata, ..} ) <$> f v1LeaseMetadata
{-# INLINE v1LeaseMetadataL #-}

-- | 'v1LeaseSpec' Lens
v1LeaseSpecL :: Lens_' V1Lease (Maybe V1LeaseSpec)
v1LeaseSpecL f V1Lease{..} = (\v1LeaseSpec -> V1Lease { v1LeaseSpec, ..} ) <$> f v1LeaseSpec
{-# INLINE v1LeaseSpecL #-}



-- * V1LeaseList

-- | 'v1LeaseListApiVersion' Lens
v1LeaseListApiVersionL :: Lens_' V1LeaseList (Maybe Text)
v1LeaseListApiVersionL f V1LeaseList{..} = (\v1LeaseListApiVersion -> V1LeaseList { v1LeaseListApiVersion, ..} ) <$> f v1LeaseListApiVersion
{-# INLINE v1LeaseListApiVersionL #-}

-- | 'v1LeaseListItems' Lens
v1LeaseListItemsL :: Lens_' V1LeaseList ([V1Lease])
v1LeaseListItemsL f V1LeaseList{..} = (\v1LeaseListItems -> V1LeaseList { v1LeaseListItems, ..} ) <$> f v1LeaseListItems
{-# INLINE v1LeaseListItemsL #-}

-- | 'v1LeaseListKind' Lens
v1LeaseListKindL :: Lens_' V1LeaseList (Maybe Text)
v1LeaseListKindL f V1LeaseList{..} = (\v1LeaseListKind -> V1LeaseList { v1LeaseListKind, ..} ) <$> f v1LeaseListKind
{-# INLINE v1LeaseListKindL #-}

-- | 'v1LeaseListMetadata' Lens
v1LeaseListMetadataL :: Lens_' V1LeaseList (Maybe V1ListMeta)
v1LeaseListMetadataL f V1LeaseList{..} = (\v1LeaseListMetadata -> V1LeaseList { v1LeaseListMetadata, ..} ) <$> f v1LeaseListMetadata
{-# INLINE v1LeaseListMetadataL #-}



-- * V1LeaseSpec

-- | 'v1LeaseSpecAcquireTime' Lens
v1LeaseSpecAcquireTimeL :: Lens_' V1LeaseSpec (Maybe DateTime)
v1LeaseSpecAcquireTimeL f V1LeaseSpec{..} = (\v1LeaseSpecAcquireTime -> V1LeaseSpec { v1LeaseSpecAcquireTime, ..} ) <$> f v1LeaseSpecAcquireTime
{-# INLINE v1LeaseSpecAcquireTimeL #-}

-- | 'v1LeaseSpecHolderIdentity' Lens
v1LeaseSpecHolderIdentityL :: Lens_' V1LeaseSpec (Maybe Text)
v1LeaseSpecHolderIdentityL f V1LeaseSpec{..} = (\v1LeaseSpecHolderIdentity -> V1LeaseSpec { v1LeaseSpecHolderIdentity, ..} ) <$> f v1LeaseSpecHolderIdentity
{-# INLINE v1LeaseSpecHolderIdentityL #-}

-- | 'v1LeaseSpecLeaseDurationSeconds' Lens
v1LeaseSpecLeaseDurationSecondsL :: Lens_' V1LeaseSpec (Maybe Int)
v1LeaseSpecLeaseDurationSecondsL f V1LeaseSpec{..} = (\v1LeaseSpecLeaseDurationSeconds -> V1LeaseSpec { v1LeaseSpecLeaseDurationSeconds, ..} ) <$> f v1LeaseSpecLeaseDurationSeconds
{-# INLINE v1LeaseSpecLeaseDurationSecondsL #-}

-- | 'v1LeaseSpecLeaseTransitions' Lens
v1LeaseSpecLeaseTransitionsL :: Lens_' V1LeaseSpec (Maybe Int)
v1LeaseSpecLeaseTransitionsL f V1LeaseSpec{..} = (\v1LeaseSpecLeaseTransitions -> V1LeaseSpec { v1LeaseSpecLeaseTransitions, ..} ) <$> f v1LeaseSpecLeaseTransitions
{-# INLINE v1LeaseSpecLeaseTransitionsL #-}

-- | 'v1LeaseSpecRenewTime' Lens
v1LeaseSpecRenewTimeL :: Lens_' V1LeaseSpec (Maybe DateTime)
v1LeaseSpecRenewTimeL f V1LeaseSpec{..} = (\v1LeaseSpecRenewTime -> V1LeaseSpec { v1LeaseSpecRenewTime, ..} ) <$> f v1LeaseSpecRenewTime
{-# INLINE v1LeaseSpecRenewTimeL #-}



-- * V1Lifecycle

-- | 'v1LifecyclePostStart' Lens
v1LifecyclePostStartL :: Lens_' V1Lifecycle (Maybe V1LifecycleHandler)
v1LifecyclePostStartL f V1Lifecycle{..} = (\v1LifecyclePostStart -> V1Lifecycle { v1LifecyclePostStart, ..} ) <$> f v1LifecyclePostStart
{-# INLINE v1LifecyclePostStartL #-}

-- | 'v1LifecyclePreStop' Lens
v1LifecyclePreStopL :: Lens_' V1Lifecycle (Maybe V1LifecycleHandler)
v1LifecyclePreStopL f V1Lifecycle{..} = (\v1LifecyclePreStop -> V1Lifecycle { v1LifecyclePreStop, ..} ) <$> f v1LifecyclePreStop
{-# INLINE v1LifecyclePreStopL #-}



-- * V1LifecycleHandler

-- | 'v1LifecycleHandlerExec' Lens
v1LifecycleHandlerExecL :: Lens_' V1LifecycleHandler (Maybe V1ExecAction)
v1LifecycleHandlerExecL f V1LifecycleHandler{..} = (\v1LifecycleHandlerExec -> V1LifecycleHandler { v1LifecycleHandlerExec, ..} ) <$> f v1LifecycleHandlerExec
{-# INLINE v1LifecycleHandlerExecL #-}

-- | 'v1LifecycleHandlerHttpGet' Lens
v1LifecycleHandlerHttpGetL :: Lens_' V1LifecycleHandler (Maybe V1HTTPGetAction)
v1LifecycleHandlerHttpGetL f V1LifecycleHandler{..} = (\v1LifecycleHandlerHttpGet -> V1LifecycleHandler { v1LifecycleHandlerHttpGet, ..} ) <$> f v1LifecycleHandlerHttpGet
{-# INLINE v1LifecycleHandlerHttpGetL #-}

-- | 'v1LifecycleHandlerTcpSocket' Lens
v1LifecycleHandlerTcpSocketL :: Lens_' V1LifecycleHandler (Maybe V1TCPSocketAction)
v1LifecycleHandlerTcpSocketL f V1LifecycleHandler{..} = (\v1LifecycleHandlerTcpSocket -> V1LifecycleHandler { v1LifecycleHandlerTcpSocket, ..} ) <$> f v1LifecycleHandlerTcpSocket
{-# INLINE v1LifecycleHandlerTcpSocketL #-}



-- * V1LimitRange

-- | 'v1LimitRangeApiVersion' Lens
v1LimitRangeApiVersionL :: Lens_' V1LimitRange (Maybe Text)
v1LimitRangeApiVersionL f V1LimitRange{..} = (\v1LimitRangeApiVersion -> V1LimitRange { v1LimitRangeApiVersion, ..} ) <$> f v1LimitRangeApiVersion
{-# INLINE v1LimitRangeApiVersionL #-}

-- | 'v1LimitRangeKind' Lens
v1LimitRangeKindL :: Lens_' V1LimitRange (Maybe Text)
v1LimitRangeKindL f V1LimitRange{..} = (\v1LimitRangeKind -> V1LimitRange { v1LimitRangeKind, ..} ) <$> f v1LimitRangeKind
{-# INLINE v1LimitRangeKindL #-}

-- | 'v1LimitRangeMetadata' Lens
v1LimitRangeMetadataL :: Lens_' V1LimitRange (Maybe V1ObjectMeta)
v1LimitRangeMetadataL f V1LimitRange{..} = (\v1LimitRangeMetadata -> V1LimitRange { v1LimitRangeMetadata, ..} ) <$> f v1LimitRangeMetadata
{-# INLINE v1LimitRangeMetadataL #-}

-- | 'v1LimitRangeSpec' Lens
v1LimitRangeSpecL :: Lens_' V1LimitRange (Maybe V1LimitRangeSpec)
v1LimitRangeSpecL f V1LimitRange{..} = (\v1LimitRangeSpec -> V1LimitRange { v1LimitRangeSpec, ..} ) <$> f v1LimitRangeSpec
{-# INLINE v1LimitRangeSpecL #-}



-- * V1LimitRangeItem

-- | 'v1LimitRangeItemDefault' Lens
v1LimitRangeItemDefaultL :: Lens_' V1LimitRangeItem (Maybe (Map.Map String Quantity))
v1LimitRangeItemDefaultL f V1LimitRangeItem{..} = (\v1LimitRangeItemDefault -> V1LimitRangeItem { v1LimitRangeItemDefault, ..} ) <$> f v1LimitRangeItemDefault
{-# INLINE v1LimitRangeItemDefaultL #-}

-- | 'v1LimitRangeItemDefaultRequest' Lens
v1LimitRangeItemDefaultRequestL :: Lens_' V1LimitRangeItem (Maybe (Map.Map String Quantity))
v1LimitRangeItemDefaultRequestL f V1LimitRangeItem{..} = (\v1LimitRangeItemDefaultRequest -> V1LimitRangeItem { v1LimitRangeItemDefaultRequest, ..} ) <$> f v1LimitRangeItemDefaultRequest
{-# INLINE v1LimitRangeItemDefaultRequestL #-}

-- | 'v1LimitRangeItemMax' Lens
v1LimitRangeItemMaxL :: Lens_' V1LimitRangeItem (Maybe (Map.Map String Quantity))
v1LimitRangeItemMaxL f V1LimitRangeItem{..} = (\v1LimitRangeItemMax -> V1LimitRangeItem { v1LimitRangeItemMax, ..} ) <$> f v1LimitRangeItemMax
{-# INLINE v1LimitRangeItemMaxL #-}

-- | 'v1LimitRangeItemMaxLimitRequestRatio' Lens
v1LimitRangeItemMaxLimitRequestRatioL :: Lens_' V1LimitRangeItem (Maybe (Map.Map String Quantity))
v1LimitRangeItemMaxLimitRequestRatioL f V1LimitRangeItem{..} = (\v1LimitRangeItemMaxLimitRequestRatio -> V1LimitRangeItem { v1LimitRangeItemMaxLimitRequestRatio, ..} ) <$> f v1LimitRangeItemMaxLimitRequestRatio
{-# INLINE v1LimitRangeItemMaxLimitRequestRatioL #-}

-- | 'v1LimitRangeItemMin' Lens
v1LimitRangeItemMinL :: Lens_' V1LimitRangeItem (Maybe (Map.Map String Quantity))
v1LimitRangeItemMinL f V1LimitRangeItem{..} = (\v1LimitRangeItemMin -> V1LimitRangeItem { v1LimitRangeItemMin, ..} ) <$> f v1LimitRangeItemMin
{-# INLINE v1LimitRangeItemMinL #-}

-- | 'v1LimitRangeItemType' Lens
v1LimitRangeItemTypeL :: Lens_' V1LimitRangeItem (Text)
v1LimitRangeItemTypeL f V1LimitRangeItem{..} = (\v1LimitRangeItemType -> V1LimitRangeItem { v1LimitRangeItemType, ..} ) <$> f v1LimitRangeItemType
{-# INLINE v1LimitRangeItemTypeL #-}



-- * V1LimitRangeList

-- | 'v1LimitRangeListApiVersion' Lens
v1LimitRangeListApiVersionL :: Lens_' V1LimitRangeList (Maybe Text)
v1LimitRangeListApiVersionL f V1LimitRangeList{..} = (\v1LimitRangeListApiVersion -> V1LimitRangeList { v1LimitRangeListApiVersion, ..} ) <$> f v1LimitRangeListApiVersion
{-# INLINE v1LimitRangeListApiVersionL #-}

-- | 'v1LimitRangeListItems' Lens
v1LimitRangeListItemsL :: Lens_' V1LimitRangeList ([V1LimitRange])
v1LimitRangeListItemsL f V1LimitRangeList{..} = (\v1LimitRangeListItems -> V1LimitRangeList { v1LimitRangeListItems, ..} ) <$> f v1LimitRangeListItems
{-# INLINE v1LimitRangeListItemsL #-}

-- | 'v1LimitRangeListKind' Lens
v1LimitRangeListKindL :: Lens_' V1LimitRangeList (Maybe Text)
v1LimitRangeListKindL f V1LimitRangeList{..} = (\v1LimitRangeListKind -> V1LimitRangeList { v1LimitRangeListKind, ..} ) <$> f v1LimitRangeListKind
{-# INLINE v1LimitRangeListKindL #-}

-- | 'v1LimitRangeListMetadata' Lens
v1LimitRangeListMetadataL :: Lens_' V1LimitRangeList (Maybe V1ListMeta)
v1LimitRangeListMetadataL f V1LimitRangeList{..} = (\v1LimitRangeListMetadata -> V1LimitRangeList { v1LimitRangeListMetadata, ..} ) <$> f v1LimitRangeListMetadata
{-# INLINE v1LimitRangeListMetadataL #-}



-- * V1LimitRangeSpec

-- | 'v1LimitRangeSpecLimits' Lens
v1LimitRangeSpecLimitsL :: Lens_' V1LimitRangeSpec ([V1LimitRangeItem])
v1LimitRangeSpecLimitsL f V1LimitRangeSpec{..} = (\v1LimitRangeSpecLimits -> V1LimitRangeSpec { v1LimitRangeSpecLimits, ..} ) <$> f v1LimitRangeSpecLimits
{-# INLINE v1LimitRangeSpecLimitsL #-}



-- * V1ListMeta

-- | 'v1ListMetaContinue' Lens
v1ListMetaContinueL :: Lens_' V1ListMeta (Maybe Text)
v1ListMetaContinueL f V1ListMeta{..} = (\v1ListMetaContinue -> V1ListMeta { v1ListMetaContinue, ..} ) <$> f v1ListMetaContinue
{-# INLINE v1ListMetaContinueL #-}

-- | 'v1ListMetaRemainingItemCount' Lens
v1ListMetaRemainingItemCountL :: Lens_' V1ListMeta (Maybe Integer)
v1ListMetaRemainingItemCountL f V1ListMeta{..} = (\v1ListMetaRemainingItemCount -> V1ListMeta { v1ListMetaRemainingItemCount, ..} ) <$> f v1ListMetaRemainingItemCount
{-# INLINE v1ListMetaRemainingItemCountL #-}

-- | 'v1ListMetaResourceVersion' Lens
v1ListMetaResourceVersionL :: Lens_' V1ListMeta (Maybe Text)
v1ListMetaResourceVersionL f V1ListMeta{..} = (\v1ListMetaResourceVersion -> V1ListMeta { v1ListMetaResourceVersion, ..} ) <$> f v1ListMetaResourceVersion
{-# INLINE v1ListMetaResourceVersionL #-}

-- | 'v1ListMetaSelfLink' Lens
v1ListMetaSelfLinkL :: Lens_' V1ListMeta (Maybe Text)
v1ListMetaSelfLinkL f V1ListMeta{..} = (\v1ListMetaSelfLink -> V1ListMeta { v1ListMetaSelfLink, ..} ) <$> f v1ListMetaSelfLink
{-# INLINE v1ListMetaSelfLinkL #-}



-- * V1LoadBalancerIngress

-- | 'v1LoadBalancerIngressHostname' Lens
v1LoadBalancerIngressHostnameL :: Lens_' V1LoadBalancerIngress (Maybe Text)
v1LoadBalancerIngressHostnameL f V1LoadBalancerIngress{..} = (\v1LoadBalancerIngressHostname -> V1LoadBalancerIngress { v1LoadBalancerIngressHostname, ..} ) <$> f v1LoadBalancerIngressHostname
{-# INLINE v1LoadBalancerIngressHostnameL #-}

-- | 'v1LoadBalancerIngressIp' Lens
v1LoadBalancerIngressIpL :: Lens_' V1LoadBalancerIngress (Maybe Text)
v1LoadBalancerIngressIpL f V1LoadBalancerIngress{..} = (\v1LoadBalancerIngressIp -> V1LoadBalancerIngress { v1LoadBalancerIngressIp, ..} ) <$> f v1LoadBalancerIngressIp
{-# INLINE v1LoadBalancerIngressIpL #-}

-- | 'v1LoadBalancerIngressPorts' Lens
v1LoadBalancerIngressPortsL :: Lens_' V1LoadBalancerIngress (Maybe [V1PortStatus])
v1LoadBalancerIngressPortsL f V1LoadBalancerIngress{..} = (\v1LoadBalancerIngressPorts -> V1LoadBalancerIngress { v1LoadBalancerIngressPorts, ..} ) <$> f v1LoadBalancerIngressPorts
{-# INLINE v1LoadBalancerIngressPortsL #-}



-- * V1LoadBalancerStatus

-- | 'v1LoadBalancerStatusIngress' Lens
v1LoadBalancerStatusIngressL :: Lens_' V1LoadBalancerStatus (Maybe [V1LoadBalancerIngress])
v1LoadBalancerStatusIngressL f V1LoadBalancerStatus{..} = (\v1LoadBalancerStatusIngress -> V1LoadBalancerStatus { v1LoadBalancerStatusIngress, ..} ) <$> f v1LoadBalancerStatusIngress
{-# INLINE v1LoadBalancerStatusIngressL #-}



-- * V1LocalObjectReference

-- | 'v1LocalObjectReferenceName' Lens
v1LocalObjectReferenceNameL :: Lens_' V1LocalObjectReference (Maybe Text)
v1LocalObjectReferenceNameL f V1LocalObjectReference{..} = (\v1LocalObjectReferenceName -> V1LocalObjectReference { v1LocalObjectReferenceName, ..} ) <$> f v1LocalObjectReferenceName
{-# INLINE v1LocalObjectReferenceNameL #-}



-- * V1LocalSubjectAccessReview

-- | 'v1LocalSubjectAccessReviewApiVersion' Lens
v1LocalSubjectAccessReviewApiVersionL :: Lens_' V1LocalSubjectAccessReview (Maybe Text)
v1LocalSubjectAccessReviewApiVersionL f V1LocalSubjectAccessReview{..} = (\v1LocalSubjectAccessReviewApiVersion -> V1LocalSubjectAccessReview { v1LocalSubjectAccessReviewApiVersion, ..} ) <$> f v1LocalSubjectAccessReviewApiVersion
{-# INLINE v1LocalSubjectAccessReviewApiVersionL #-}

-- | 'v1LocalSubjectAccessReviewKind' Lens
v1LocalSubjectAccessReviewKindL :: Lens_' V1LocalSubjectAccessReview (Maybe Text)
v1LocalSubjectAccessReviewKindL f V1LocalSubjectAccessReview{..} = (\v1LocalSubjectAccessReviewKind -> V1LocalSubjectAccessReview { v1LocalSubjectAccessReviewKind, ..} ) <$> f v1LocalSubjectAccessReviewKind
{-# INLINE v1LocalSubjectAccessReviewKindL #-}

-- | 'v1LocalSubjectAccessReviewMetadata' Lens
v1LocalSubjectAccessReviewMetadataL :: Lens_' V1LocalSubjectAccessReview (Maybe V1ObjectMeta)
v1LocalSubjectAccessReviewMetadataL f V1LocalSubjectAccessReview{..} = (\v1LocalSubjectAccessReviewMetadata -> V1LocalSubjectAccessReview { v1LocalSubjectAccessReviewMetadata, ..} ) <$> f v1LocalSubjectAccessReviewMetadata
{-# INLINE v1LocalSubjectAccessReviewMetadataL #-}

-- | 'v1LocalSubjectAccessReviewSpec' Lens
v1LocalSubjectAccessReviewSpecL :: Lens_' V1LocalSubjectAccessReview (V1SubjectAccessReviewSpec)
v1LocalSubjectAccessReviewSpecL f V1LocalSubjectAccessReview{..} = (\v1LocalSubjectAccessReviewSpec -> V1LocalSubjectAccessReview { v1LocalSubjectAccessReviewSpec, ..} ) <$> f v1LocalSubjectAccessReviewSpec
{-# INLINE v1LocalSubjectAccessReviewSpecL #-}

-- | 'v1LocalSubjectAccessReviewStatus' Lens
v1LocalSubjectAccessReviewStatusL :: Lens_' V1LocalSubjectAccessReview (Maybe V1SubjectAccessReviewStatus)
v1LocalSubjectAccessReviewStatusL f V1LocalSubjectAccessReview{..} = (\v1LocalSubjectAccessReviewStatus -> V1LocalSubjectAccessReview { v1LocalSubjectAccessReviewStatus, ..} ) <$> f v1LocalSubjectAccessReviewStatus
{-# INLINE v1LocalSubjectAccessReviewStatusL #-}



-- * V1LocalVolumeSource

-- | 'v1LocalVolumeSourceFsType' Lens
v1LocalVolumeSourceFsTypeL :: Lens_' V1LocalVolumeSource (Maybe Text)
v1LocalVolumeSourceFsTypeL f V1LocalVolumeSource{..} = (\v1LocalVolumeSourceFsType -> V1LocalVolumeSource { v1LocalVolumeSourceFsType, ..} ) <$> f v1LocalVolumeSourceFsType
{-# INLINE v1LocalVolumeSourceFsTypeL #-}

-- | 'v1LocalVolumeSourcePath' Lens
v1LocalVolumeSourcePathL :: Lens_' V1LocalVolumeSource (Text)
v1LocalVolumeSourcePathL f V1LocalVolumeSource{..} = (\v1LocalVolumeSourcePath -> V1LocalVolumeSource { v1LocalVolumeSourcePath, ..} ) <$> f v1LocalVolumeSourcePath
{-# INLINE v1LocalVolumeSourcePathL #-}



-- * V1ManagedFieldsEntry

-- | 'v1ManagedFieldsEntryApiVersion' Lens
v1ManagedFieldsEntryApiVersionL :: Lens_' V1ManagedFieldsEntry (Maybe Text)
v1ManagedFieldsEntryApiVersionL f V1ManagedFieldsEntry{..} = (\v1ManagedFieldsEntryApiVersion -> V1ManagedFieldsEntry { v1ManagedFieldsEntryApiVersion, ..} ) <$> f v1ManagedFieldsEntryApiVersion
{-# INLINE v1ManagedFieldsEntryApiVersionL #-}

-- | 'v1ManagedFieldsEntryFieldsType' Lens
v1ManagedFieldsEntryFieldsTypeL :: Lens_' V1ManagedFieldsEntry (Maybe Text)
v1ManagedFieldsEntryFieldsTypeL f V1ManagedFieldsEntry{..} = (\v1ManagedFieldsEntryFieldsType -> V1ManagedFieldsEntry { v1ManagedFieldsEntryFieldsType, ..} ) <$> f v1ManagedFieldsEntryFieldsType
{-# INLINE v1ManagedFieldsEntryFieldsTypeL #-}

-- | 'v1ManagedFieldsEntryFieldsV1' Lens
v1ManagedFieldsEntryFieldsV1L :: Lens_' V1ManagedFieldsEntry (Maybe A.Value)
v1ManagedFieldsEntryFieldsV1L f V1ManagedFieldsEntry{..} = (\v1ManagedFieldsEntryFieldsV1 -> V1ManagedFieldsEntry { v1ManagedFieldsEntryFieldsV1, ..} ) <$> f v1ManagedFieldsEntryFieldsV1
{-# INLINE v1ManagedFieldsEntryFieldsV1L #-}

-- | 'v1ManagedFieldsEntryManager' Lens
v1ManagedFieldsEntryManagerL :: Lens_' V1ManagedFieldsEntry (Maybe Text)
v1ManagedFieldsEntryManagerL f V1ManagedFieldsEntry{..} = (\v1ManagedFieldsEntryManager -> V1ManagedFieldsEntry { v1ManagedFieldsEntryManager, ..} ) <$> f v1ManagedFieldsEntryManager
{-# INLINE v1ManagedFieldsEntryManagerL #-}

-- | 'v1ManagedFieldsEntryOperation' Lens
v1ManagedFieldsEntryOperationL :: Lens_' V1ManagedFieldsEntry (Maybe Text)
v1ManagedFieldsEntryOperationL f V1ManagedFieldsEntry{..} = (\v1ManagedFieldsEntryOperation -> V1ManagedFieldsEntry { v1ManagedFieldsEntryOperation, ..} ) <$> f v1ManagedFieldsEntryOperation
{-# INLINE v1ManagedFieldsEntryOperationL #-}

-- | 'v1ManagedFieldsEntrySubresource' Lens
v1ManagedFieldsEntrySubresourceL :: Lens_' V1ManagedFieldsEntry (Maybe Text)
v1ManagedFieldsEntrySubresourceL f V1ManagedFieldsEntry{..} = (\v1ManagedFieldsEntrySubresource -> V1ManagedFieldsEntry { v1ManagedFieldsEntrySubresource, ..} ) <$> f v1ManagedFieldsEntrySubresource
{-# INLINE v1ManagedFieldsEntrySubresourceL #-}

-- | 'v1ManagedFieldsEntryTime' Lens
v1ManagedFieldsEntryTimeL :: Lens_' V1ManagedFieldsEntry (Maybe DateTime)
v1ManagedFieldsEntryTimeL f V1ManagedFieldsEntry{..} = (\v1ManagedFieldsEntryTime -> V1ManagedFieldsEntry { v1ManagedFieldsEntryTime, ..} ) <$> f v1ManagedFieldsEntryTime
{-# INLINE v1ManagedFieldsEntryTimeL #-}



-- * V1MutatingWebhook

-- | 'v1MutatingWebhookAdmissionReviewVersions' Lens
v1MutatingWebhookAdmissionReviewVersionsL :: Lens_' V1MutatingWebhook ([Text])
v1MutatingWebhookAdmissionReviewVersionsL f V1MutatingWebhook{..} = (\v1MutatingWebhookAdmissionReviewVersions -> V1MutatingWebhook { v1MutatingWebhookAdmissionReviewVersions, ..} ) <$> f v1MutatingWebhookAdmissionReviewVersions
{-# INLINE v1MutatingWebhookAdmissionReviewVersionsL #-}

-- | 'v1MutatingWebhookClientConfig' Lens
v1MutatingWebhookClientConfigL :: Lens_' V1MutatingWebhook (AdmissionregistrationV1WebhookClientConfig)
v1MutatingWebhookClientConfigL f V1MutatingWebhook{..} = (\v1MutatingWebhookClientConfig -> V1MutatingWebhook { v1MutatingWebhookClientConfig, ..} ) <$> f v1MutatingWebhookClientConfig
{-# INLINE v1MutatingWebhookClientConfigL #-}

-- | 'v1MutatingWebhookFailurePolicy' Lens
v1MutatingWebhookFailurePolicyL :: Lens_' V1MutatingWebhook (Maybe Text)
v1MutatingWebhookFailurePolicyL f V1MutatingWebhook{..} = (\v1MutatingWebhookFailurePolicy -> V1MutatingWebhook { v1MutatingWebhookFailurePolicy, ..} ) <$> f v1MutatingWebhookFailurePolicy
{-# INLINE v1MutatingWebhookFailurePolicyL #-}

-- | 'v1MutatingWebhookMatchPolicy' Lens
v1MutatingWebhookMatchPolicyL :: Lens_' V1MutatingWebhook (Maybe Text)
v1MutatingWebhookMatchPolicyL f V1MutatingWebhook{..} = (\v1MutatingWebhookMatchPolicy -> V1MutatingWebhook { v1MutatingWebhookMatchPolicy, ..} ) <$> f v1MutatingWebhookMatchPolicy
{-# INLINE v1MutatingWebhookMatchPolicyL #-}

-- | 'v1MutatingWebhookName' Lens
v1MutatingWebhookNameL :: Lens_' V1MutatingWebhook (Text)
v1MutatingWebhookNameL f V1MutatingWebhook{..} = (\v1MutatingWebhookName -> V1MutatingWebhook { v1MutatingWebhookName, ..} ) <$> f v1MutatingWebhookName
{-# INLINE v1MutatingWebhookNameL #-}

-- | 'v1MutatingWebhookNamespaceSelector' Lens
v1MutatingWebhookNamespaceSelectorL :: Lens_' V1MutatingWebhook (Maybe V1LabelSelector)
v1MutatingWebhookNamespaceSelectorL f V1MutatingWebhook{..} = (\v1MutatingWebhookNamespaceSelector -> V1MutatingWebhook { v1MutatingWebhookNamespaceSelector, ..} ) <$> f v1MutatingWebhookNamespaceSelector
{-# INLINE v1MutatingWebhookNamespaceSelectorL #-}

-- | 'v1MutatingWebhookObjectSelector' Lens
v1MutatingWebhookObjectSelectorL :: Lens_' V1MutatingWebhook (Maybe V1LabelSelector)
v1MutatingWebhookObjectSelectorL f V1MutatingWebhook{..} = (\v1MutatingWebhookObjectSelector -> V1MutatingWebhook { v1MutatingWebhookObjectSelector, ..} ) <$> f v1MutatingWebhookObjectSelector
{-# INLINE v1MutatingWebhookObjectSelectorL #-}

-- | 'v1MutatingWebhookReinvocationPolicy' Lens
v1MutatingWebhookReinvocationPolicyL :: Lens_' V1MutatingWebhook (Maybe Text)
v1MutatingWebhookReinvocationPolicyL f V1MutatingWebhook{..} = (\v1MutatingWebhookReinvocationPolicy -> V1MutatingWebhook { v1MutatingWebhookReinvocationPolicy, ..} ) <$> f v1MutatingWebhookReinvocationPolicy
{-# INLINE v1MutatingWebhookReinvocationPolicyL #-}

-- | 'v1MutatingWebhookRules' Lens
v1MutatingWebhookRulesL :: Lens_' V1MutatingWebhook (Maybe [V1RuleWithOperations])
v1MutatingWebhookRulesL f V1MutatingWebhook{..} = (\v1MutatingWebhookRules -> V1MutatingWebhook { v1MutatingWebhookRules, ..} ) <$> f v1MutatingWebhookRules
{-# INLINE v1MutatingWebhookRulesL #-}

-- | 'v1MutatingWebhookSideEffects' Lens
v1MutatingWebhookSideEffectsL :: Lens_' V1MutatingWebhook (Text)
v1MutatingWebhookSideEffectsL f V1MutatingWebhook{..} = (\v1MutatingWebhookSideEffects -> V1MutatingWebhook { v1MutatingWebhookSideEffects, ..} ) <$> f v1MutatingWebhookSideEffects
{-# INLINE v1MutatingWebhookSideEffectsL #-}

-- | 'v1MutatingWebhookTimeoutSeconds' Lens
v1MutatingWebhookTimeoutSecondsL :: Lens_' V1MutatingWebhook (Maybe Int)
v1MutatingWebhookTimeoutSecondsL f V1MutatingWebhook{..} = (\v1MutatingWebhookTimeoutSeconds -> V1MutatingWebhook { v1MutatingWebhookTimeoutSeconds, ..} ) <$> f v1MutatingWebhookTimeoutSeconds
{-# INLINE v1MutatingWebhookTimeoutSecondsL #-}



-- * V1MutatingWebhookConfiguration

-- | 'v1MutatingWebhookConfigurationApiVersion' Lens
v1MutatingWebhookConfigurationApiVersionL :: Lens_' V1MutatingWebhookConfiguration (Maybe Text)
v1MutatingWebhookConfigurationApiVersionL f V1MutatingWebhookConfiguration{..} = (\v1MutatingWebhookConfigurationApiVersion -> V1MutatingWebhookConfiguration { v1MutatingWebhookConfigurationApiVersion, ..} ) <$> f v1MutatingWebhookConfigurationApiVersion
{-# INLINE v1MutatingWebhookConfigurationApiVersionL #-}

-- | 'v1MutatingWebhookConfigurationKind' Lens
v1MutatingWebhookConfigurationKindL :: Lens_' V1MutatingWebhookConfiguration (Maybe Text)
v1MutatingWebhookConfigurationKindL f V1MutatingWebhookConfiguration{..} = (\v1MutatingWebhookConfigurationKind -> V1MutatingWebhookConfiguration { v1MutatingWebhookConfigurationKind, ..} ) <$> f v1MutatingWebhookConfigurationKind
{-# INLINE v1MutatingWebhookConfigurationKindL #-}

-- | 'v1MutatingWebhookConfigurationMetadata' Lens
v1MutatingWebhookConfigurationMetadataL :: Lens_' V1MutatingWebhookConfiguration (Maybe V1ObjectMeta)
v1MutatingWebhookConfigurationMetadataL f V1MutatingWebhookConfiguration{..} = (\v1MutatingWebhookConfigurationMetadata -> V1MutatingWebhookConfiguration { v1MutatingWebhookConfigurationMetadata, ..} ) <$> f v1MutatingWebhookConfigurationMetadata
{-# INLINE v1MutatingWebhookConfigurationMetadataL #-}

-- | 'v1MutatingWebhookConfigurationWebhooks' Lens
v1MutatingWebhookConfigurationWebhooksL :: Lens_' V1MutatingWebhookConfiguration (Maybe [V1MutatingWebhook])
v1MutatingWebhookConfigurationWebhooksL f V1MutatingWebhookConfiguration{..} = (\v1MutatingWebhookConfigurationWebhooks -> V1MutatingWebhookConfiguration { v1MutatingWebhookConfigurationWebhooks, ..} ) <$> f v1MutatingWebhookConfigurationWebhooks
{-# INLINE v1MutatingWebhookConfigurationWebhooksL #-}



-- * V1MutatingWebhookConfigurationList

-- | 'v1MutatingWebhookConfigurationListApiVersion' Lens
v1MutatingWebhookConfigurationListApiVersionL :: Lens_' V1MutatingWebhookConfigurationList (Maybe Text)
v1MutatingWebhookConfigurationListApiVersionL f V1MutatingWebhookConfigurationList{..} = (\v1MutatingWebhookConfigurationListApiVersion -> V1MutatingWebhookConfigurationList { v1MutatingWebhookConfigurationListApiVersion, ..} ) <$> f v1MutatingWebhookConfigurationListApiVersion
{-# INLINE v1MutatingWebhookConfigurationListApiVersionL #-}

-- | 'v1MutatingWebhookConfigurationListItems' Lens
v1MutatingWebhookConfigurationListItemsL :: Lens_' V1MutatingWebhookConfigurationList ([V1MutatingWebhookConfiguration])
v1MutatingWebhookConfigurationListItemsL f V1MutatingWebhookConfigurationList{..} = (\v1MutatingWebhookConfigurationListItems -> V1MutatingWebhookConfigurationList { v1MutatingWebhookConfigurationListItems, ..} ) <$> f v1MutatingWebhookConfigurationListItems
{-# INLINE v1MutatingWebhookConfigurationListItemsL #-}

-- | 'v1MutatingWebhookConfigurationListKind' Lens
v1MutatingWebhookConfigurationListKindL :: Lens_' V1MutatingWebhookConfigurationList (Maybe Text)
v1MutatingWebhookConfigurationListKindL f V1MutatingWebhookConfigurationList{..} = (\v1MutatingWebhookConfigurationListKind -> V1MutatingWebhookConfigurationList { v1MutatingWebhookConfigurationListKind, ..} ) <$> f v1MutatingWebhookConfigurationListKind
{-# INLINE v1MutatingWebhookConfigurationListKindL #-}

-- | 'v1MutatingWebhookConfigurationListMetadata' Lens
v1MutatingWebhookConfigurationListMetadataL :: Lens_' V1MutatingWebhookConfigurationList (Maybe V1ListMeta)
v1MutatingWebhookConfigurationListMetadataL f V1MutatingWebhookConfigurationList{..} = (\v1MutatingWebhookConfigurationListMetadata -> V1MutatingWebhookConfigurationList { v1MutatingWebhookConfigurationListMetadata, ..} ) <$> f v1MutatingWebhookConfigurationListMetadata
{-# INLINE v1MutatingWebhookConfigurationListMetadataL #-}



-- * V1NFSVolumeSource

-- | 'v1NFSVolumeSourcePath' Lens
v1NFSVolumeSourcePathL :: Lens_' V1NFSVolumeSource (Text)
v1NFSVolumeSourcePathL f V1NFSVolumeSource{..} = (\v1NFSVolumeSourcePath -> V1NFSVolumeSource { v1NFSVolumeSourcePath, ..} ) <$> f v1NFSVolumeSourcePath
{-# INLINE v1NFSVolumeSourcePathL #-}

-- | 'v1NFSVolumeSourceReadOnly' Lens
v1NFSVolumeSourceReadOnlyL :: Lens_' V1NFSVolumeSource (Maybe Bool)
v1NFSVolumeSourceReadOnlyL f V1NFSVolumeSource{..} = (\v1NFSVolumeSourceReadOnly -> V1NFSVolumeSource { v1NFSVolumeSourceReadOnly, ..} ) <$> f v1NFSVolumeSourceReadOnly
{-# INLINE v1NFSVolumeSourceReadOnlyL #-}

-- | 'v1NFSVolumeSourceServer' Lens
v1NFSVolumeSourceServerL :: Lens_' V1NFSVolumeSource (Text)
v1NFSVolumeSourceServerL f V1NFSVolumeSource{..} = (\v1NFSVolumeSourceServer -> V1NFSVolumeSource { v1NFSVolumeSourceServer, ..} ) <$> f v1NFSVolumeSourceServer
{-# INLINE v1NFSVolumeSourceServerL #-}



-- * V1Namespace

-- | 'v1NamespaceApiVersion' Lens
v1NamespaceApiVersionL :: Lens_' V1Namespace (Maybe Text)
v1NamespaceApiVersionL f V1Namespace{..} = (\v1NamespaceApiVersion -> V1Namespace { v1NamespaceApiVersion, ..} ) <$> f v1NamespaceApiVersion
{-# INLINE v1NamespaceApiVersionL #-}

-- | 'v1NamespaceKind' Lens
v1NamespaceKindL :: Lens_' V1Namespace (Maybe Text)
v1NamespaceKindL f V1Namespace{..} = (\v1NamespaceKind -> V1Namespace { v1NamespaceKind, ..} ) <$> f v1NamespaceKind
{-# INLINE v1NamespaceKindL #-}

-- | 'v1NamespaceMetadata' Lens
v1NamespaceMetadataL :: Lens_' V1Namespace (Maybe V1ObjectMeta)
v1NamespaceMetadataL f V1Namespace{..} = (\v1NamespaceMetadata -> V1Namespace { v1NamespaceMetadata, ..} ) <$> f v1NamespaceMetadata
{-# INLINE v1NamespaceMetadataL #-}

-- | 'v1NamespaceSpec' Lens
v1NamespaceSpecL :: Lens_' V1Namespace (Maybe V1NamespaceSpec)
v1NamespaceSpecL f V1Namespace{..} = (\v1NamespaceSpec -> V1Namespace { v1NamespaceSpec, ..} ) <$> f v1NamespaceSpec
{-# INLINE v1NamespaceSpecL #-}

-- | 'v1NamespaceStatus' Lens
v1NamespaceStatusL :: Lens_' V1Namespace (Maybe V1NamespaceStatus)
v1NamespaceStatusL f V1Namespace{..} = (\v1NamespaceStatus -> V1Namespace { v1NamespaceStatus, ..} ) <$> f v1NamespaceStatus
{-# INLINE v1NamespaceStatusL #-}



-- * V1NamespaceCondition

-- | 'v1NamespaceConditionLastTransitionTime' Lens
v1NamespaceConditionLastTransitionTimeL :: Lens_' V1NamespaceCondition (Maybe DateTime)
v1NamespaceConditionLastTransitionTimeL f V1NamespaceCondition{..} = (\v1NamespaceConditionLastTransitionTime -> V1NamespaceCondition { v1NamespaceConditionLastTransitionTime, ..} ) <$> f v1NamespaceConditionLastTransitionTime
{-# INLINE v1NamespaceConditionLastTransitionTimeL #-}

-- | 'v1NamespaceConditionMessage' Lens
v1NamespaceConditionMessageL :: Lens_' V1NamespaceCondition (Maybe Text)
v1NamespaceConditionMessageL f V1NamespaceCondition{..} = (\v1NamespaceConditionMessage -> V1NamespaceCondition { v1NamespaceConditionMessage, ..} ) <$> f v1NamespaceConditionMessage
{-# INLINE v1NamespaceConditionMessageL #-}

-- | 'v1NamespaceConditionReason' Lens
v1NamespaceConditionReasonL :: Lens_' V1NamespaceCondition (Maybe Text)
v1NamespaceConditionReasonL f V1NamespaceCondition{..} = (\v1NamespaceConditionReason -> V1NamespaceCondition { v1NamespaceConditionReason, ..} ) <$> f v1NamespaceConditionReason
{-# INLINE v1NamespaceConditionReasonL #-}

-- | 'v1NamespaceConditionStatus' Lens
v1NamespaceConditionStatusL :: Lens_' V1NamespaceCondition (Text)
v1NamespaceConditionStatusL f V1NamespaceCondition{..} = (\v1NamespaceConditionStatus -> V1NamespaceCondition { v1NamespaceConditionStatus, ..} ) <$> f v1NamespaceConditionStatus
{-# INLINE v1NamespaceConditionStatusL #-}

-- | 'v1NamespaceConditionType' Lens
v1NamespaceConditionTypeL :: Lens_' V1NamespaceCondition (Text)
v1NamespaceConditionTypeL f V1NamespaceCondition{..} = (\v1NamespaceConditionType -> V1NamespaceCondition { v1NamespaceConditionType, ..} ) <$> f v1NamespaceConditionType
{-# INLINE v1NamespaceConditionTypeL #-}



-- * V1NamespaceList

-- | 'v1NamespaceListApiVersion' Lens
v1NamespaceListApiVersionL :: Lens_' V1NamespaceList (Maybe Text)
v1NamespaceListApiVersionL f V1NamespaceList{..} = (\v1NamespaceListApiVersion -> V1NamespaceList { v1NamespaceListApiVersion, ..} ) <$> f v1NamespaceListApiVersion
{-# INLINE v1NamespaceListApiVersionL #-}

-- | 'v1NamespaceListItems' Lens
v1NamespaceListItemsL :: Lens_' V1NamespaceList ([V1Namespace])
v1NamespaceListItemsL f V1NamespaceList{..} = (\v1NamespaceListItems -> V1NamespaceList { v1NamespaceListItems, ..} ) <$> f v1NamespaceListItems
{-# INLINE v1NamespaceListItemsL #-}

-- | 'v1NamespaceListKind' Lens
v1NamespaceListKindL :: Lens_' V1NamespaceList (Maybe Text)
v1NamespaceListKindL f V1NamespaceList{..} = (\v1NamespaceListKind -> V1NamespaceList { v1NamespaceListKind, ..} ) <$> f v1NamespaceListKind
{-# INLINE v1NamespaceListKindL #-}

-- | 'v1NamespaceListMetadata' Lens
v1NamespaceListMetadataL :: Lens_' V1NamespaceList (Maybe V1ListMeta)
v1NamespaceListMetadataL f V1NamespaceList{..} = (\v1NamespaceListMetadata -> V1NamespaceList { v1NamespaceListMetadata, ..} ) <$> f v1NamespaceListMetadata
{-# INLINE v1NamespaceListMetadataL #-}



-- * V1NamespaceSpec

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



-- * V1NamespaceStatus

-- | 'v1NamespaceStatusConditions' Lens
v1NamespaceStatusConditionsL :: Lens_' V1NamespaceStatus (Maybe [V1NamespaceCondition])
v1NamespaceStatusConditionsL f V1NamespaceStatus{..} = (\v1NamespaceStatusConditions -> V1NamespaceStatus { v1NamespaceStatusConditions, ..} ) <$> f v1NamespaceStatusConditions
{-# INLINE v1NamespaceStatusConditionsL #-}

-- | 'v1NamespaceStatusPhase' Lens
v1NamespaceStatusPhaseL :: Lens_' V1NamespaceStatus (Maybe Text)
v1NamespaceStatusPhaseL f V1NamespaceStatus{..} = (\v1NamespaceStatusPhase -> V1NamespaceStatus { v1NamespaceStatusPhase, ..} ) <$> f v1NamespaceStatusPhase
{-# INLINE v1NamespaceStatusPhaseL #-}



-- * V1NetworkPolicy

-- | 'v1NetworkPolicyApiVersion' Lens
v1NetworkPolicyApiVersionL :: Lens_' V1NetworkPolicy (Maybe Text)
v1NetworkPolicyApiVersionL f V1NetworkPolicy{..} = (\v1NetworkPolicyApiVersion -> V1NetworkPolicy { v1NetworkPolicyApiVersion, ..} ) <$> f v1NetworkPolicyApiVersion
{-# INLINE v1NetworkPolicyApiVersionL #-}

-- | 'v1NetworkPolicyKind' Lens
v1NetworkPolicyKindL :: Lens_' V1NetworkPolicy (Maybe Text)
v1NetworkPolicyKindL f V1NetworkPolicy{..} = (\v1NetworkPolicyKind -> V1NetworkPolicy { v1NetworkPolicyKind, ..} ) <$> f v1NetworkPolicyKind
{-# INLINE v1NetworkPolicyKindL #-}

-- | 'v1NetworkPolicyMetadata' Lens
v1NetworkPolicyMetadataL :: Lens_' V1NetworkPolicy (Maybe V1ObjectMeta)
v1NetworkPolicyMetadataL f V1NetworkPolicy{..} = (\v1NetworkPolicyMetadata -> V1NetworkPolicy { v1NetworkPolicyMetadata, ..} ) <$> f v1NetworkPolicyMetadata
{-# INLINE v1NetworkPolicyMetadataL #-}

-- | 'v1NetworkPolicySpec' Lens
v1NetworkPolicySpecL :: Lens_' V1NetworkPolicy (Maybe V1NetworkPolicySpec)
v1NetworkPolicySpecL f V1NetworkPolicy{..} = (\v1NetworkPolicySpec -> V1NetworkPolicy { v1NetworkPolicySpec, ..} ) <$> f v1NetworkPolicySpec
{-# INLINE v1NetworkPolicySpecL #-}



-- * V1NetworkPolicyEgressRule

-- | 'v1NetworkPolicyEgressRulePorts' Lens
v1NetworkPolicyEgressRulePortsL :: Lens_' V1NetworkPolicyEgressRule (Maybe [V1NetworkPolicyPort])
v1NetworkPolicyEgressRulePortsL f V1NetworkPolicyEgressRule{..} = (\v1NetworkPolicyEgressRulePorts -> V1NetworkPolicyEgressRule { v1NetworkPolicyEgressRulePorts, ..} ) <$> f v1NetworkPolicyEgressRulePorts
{-# INLINE v1NetworkPolicyEgressRulePortsL #-}

-- | 'v1NetworkPolicyEgressRuleTo' Lens
v1NetworkPolicyEgressRuleToL :: Lens_' V1NetworkPolicyEgressRule (Maybe [V1NetworkPolicyPeer])
v1NetworkPolicyEgressRuleToL f V1NetworkPolicyEgressRule{..} = (\v1NetworkPolicyEgressRuleTo -> V1NetworkPolicyEgressRule { v1NetworkPolicyEgressRuleTo, ..} ) <$> f v1NetworkPolicyEgressRuleTo
{-# INLINE v1NetworkPolicyEgressRuleToL #-}



-- * V1NetworkPolicyIngressRule

-- | 'v1NetworkPolicyIngressRuleFrom' Lens
v1NetworkPolicyIngressRuleFromL :: Lens_' V1NetworkPolicyIngressRule (Maybe [V1NetworkPolicyPeer])
v1NetworkPolicyIngressRuleFromL f V1NetworkPolicyIngressRule{..} = (\v1NetworkPolicyIngressRuleFrom -> V1NetworkPolicyIngressRule { v1NetworkPolicyIngressRuleFrom, ..} ) <$> f v1NetworkPolicyIngressRuleFrom
{-# INLINE v1NetworkPolicyIngressRuleFromL #-}

-- | 'v1NetworkPolicyIngressRulePorts' Lens
v1NetworkPolicyIngressRulePortsL :: Lens_' V1NetworkPolicyIngressRule (Maybe [V1NetworkPolicyPort])
v1NetworkPolicyIngressRulePortsL f V1NetworkPolicyIngressRule{..} = (\v1NetworkPolicyIngressRulePorts -> V1NetworkPolicyIngressRule { v1NetworkPolicyIngressRulePorts, ..} ) <$> f v1NetworkPolicyIngressRulePorts
{-# INLINE v1NetworkPolicyIngressRulePortsL #-}



-- * V1NetworkPolicyList

-- | 'v1NetworkPolicyListApiVersion' Lens
v1NetworkPolicyListApiVersionL :: Lens_' V1NetworkPolicyList (Maybe Text)
v1NetworkPolicyListApiVersionL f V1NetworkPolicyList{..} = (\v1NetworkPolicyListApiVersion -> V1NetworkPolicyList { v1NetworkPolicyListApiVersion, ..} ) <$> f v1NetworkPolicyListApiVersion
{-# INLINE v1NetworkPolicyListApiVersionL #-}

-- | 'v1NetworkPolicyListItems' Lens
v1NetworkPolicyListItemsL :: Lens_' V1NetworkPolicyList ([V1NetworkPolicy])
v1NetworkPolicyListItemsL f V1NetworkPolicyList{..} = (\v1NetworkPolicyListItems -> V1NetworkPolicyList { v1NetworkPolicyListItems, ..} ) <$> f v1NetworkPolicyListItems
{-# INLINE v1NetworkPolicyListItemsL #-}

-- | 'v1NetworkPolicyListKind' Lens
v1NetworkPolicyListKindL :: Lens_' V1NetworkPolicyList (Maybe Text)
v1NetworkPolicyListKindL f V1NetworkPolicyList{..} = (\v1NetworkPolicyListKind -> V1NetworkPolicyList { v1NetworkPolicyListKind, ..} ) <$> f v1NetworkPolicyListKind
{-# INLINE v1NetworkPolicyListKindL #-}

-- | 'v1NetworkPolicyListMetadata' Lens
v1NetworkPolicyListMetadataL :: Lens_' V1NetworkPolicyList (Maybe V1ListMeta)
v1NetworkPolicyListMetadataL f V1NetworkPolicyList{..} = (\v1NetworkPolicyListMetadata -> V1NetworkPolicyList { v1NetworkPolicyListMetadata, ..} ) <$> f v1NetworkPolicyListMetadata
{-# INLINE v1NetworkPolicyListMetadataL #-}



-- * V1NetworkPolicyPeer

-- | 'v1NetworkPolicyPeerIpBlock' Lens
v1NetworkPolicyPeerIpBlockL :: Lens_' V1NetworkPolicyPeer (Maybe V1IPBlock)
v1NetworkPolicyPeerIpBlockL f V1NetworkPolicyPeer{..} = (\v1NetworkPolicyPeerIpBlock -> V1NetworkPolicyPeer { v1NetworkPolicyPeerIpBlock, ..} ) <$> f v1NetworkPolicyPeerIpBlock
{-# INLINE v1NetworkPolicyPeerIpBlockL #-}

-- | 'v1NetworkPolicyPeerNamespaceSelector' Lens
v1NetworkPolicyPeerNamespaceSelectorL :: Lens_' V1NetworkPolicyPeer (Maybe V1LabelSelector)
v1NetworkPolicyPeerNamespaceSelectorL f V1NetworkPolicyPeer{..} = (\v1NetworkPolicyPeerNamespaceSelector -> V1NetworkPolicyPeer { v1NetworkPolicyPeerNamespaceSelector, ..} ) <$> f v1NetworkPolicyPeerNamespaceSelector
{-# INLINE v1NetworkPolicyPeerNamespaceSelectorL #-}

-- | 'v1NetworkPolicyPeerPodSelector' Lens
v1NetworkPolicyPeerPodSelectorL :: Lens_' V1NetworkPolicyPeer (Maybe V1LabelSelector)
v1NetworkPolicyPeerPodSelectorL f V1NetworkPolicyPeer{..} = (\v1NetworkPolicyPeerPodSelector -> V1NetworkPolicyPeer { v1NetworkPolicyPeerPodSelector, ..} ) <$> f v1NetworkPolicyPeerPodSelector
{-# INLINE v1NetworkPolicyPeerPodSelectorL #-}



-- * V1NetworkPolicyPort

-- | 'v1NetworkPolicyPortEndPort' Lens
v1NetworkPolicyPortEndPortL :: Lens_' V1NetworkPolicyPort (Maybe Int)
v1NetworkPolicyPortEndPortL f V1NetworkPolicyPort{..} = (\v1NetworkPolicyPortEndPort -> V1NetworkPolicyPort { v1NetworkPolicyPortEndPort, ..} ) <$> f v1NetworkPolicyPortEndPort
{-# INLINE v1NetworkPolicyPortEndPortL #-}

-- | 'v1NetworkPolicyPortPort' Lens
v1NetworkPolicyPortPortL :: Lens_' V1NetworkPolicyPort (Maybe IntOrString)
v1NetworkPolicyPortPortL f V1NetworkPolicyPort{..} = (\v1NetworkPolicyPortPort -> V1NetworkPolicyPort { v1NetworkPolicyPortPort, ..} ) <$> f v1NetworkPolicyPortPort
{-# INLINE v1NetworkPolicyPortPortL #-}

-- | 'v1NetworkPolicyPortProtocol' Lens
v1NetworkPolicyPortProtocolL :: Lens_' V1NetworkPolicyPort (Maybe Text)
v1NetworkPolicyPortProtocolL f V1NetworkPolicyPort{..} = (\v1NetworkPolicyPortProtocol -> V1NetworkPolicyPort { v1NetworkPolicyPortProtocol, ..} ) <$> f v1NetworkPolicyPortProtocol
{-# INLINE v1NetworkPolicyPortProtocolL #-}



-- * V1NetworkPolicySpec

-- | 'v1NetworkPolicySpecEgress' Lens
v1NetworkPolicySpecEgressL :: Lens_' V1NetworkPolicySpec (Maybe [V1NetworkPolicyEgressRule])
v1NetworkPolicySpecEgressL f V1NetworkPolicySpec{..} = (\v1NetworkPolicySpecEgress -> V1NetworkPolicySpec { v1NetworkPolicySpecEgress, ..} ) <$> f v1NetworkPolicySpecEgress
{-# INLINE v1NetworkPolicySpecEgressL #-}

-- | 'v1NetworkPolicySpecIngress' Lens
v1NetworkPolicySpecIngressL :: Lens_' V1NetworkPolicySpec (Maybe [V1NetworkPolicyIngressRule])
v1NetworkPolicySpecIngressL f V1NetworkPolicySpec{..} = (\v1NetworkPolicySpecIngress -> V1NetworkPolicySpec { v1NetworkPolicySpecIngress, ..} ) <$> f v1NetworkPolicySpecIngress
{-# INLINE v1NetworkPolicySpecIngressL #-}

-- | 'v1NetworkPolicySpecPodSelector' Lens
v1NetworkPolicySpecPodSelectorL :: Lens_' V1NetworkPolicySpec (V1LabelSelector)
v1NetworkPolicySpecPodSelectorL f V1NetworkPolicySpec{..} = (\v1NetworkPolicySpecPodSelector -> V1NetworkPolicySpec { v1NetworkPolicySpecPodSelector, ..} ) <$> f v1NetworkPolicySpecPodSelector
{-# INLINE v1NetworkPolicySpecPodSelectorL #-}

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



-- * V1Node

-- | 'v1NodeApiVersion' Lens
v1NodeApiVersionL :: Lens_' V1Node (Maybe Text)
v1NodeApiVersionL f V1Node{..} = (\v1NodeApiVersion -> V1Node { v1NodeApiVersion, ..} ) <$> f v1NodeApiVersion
{-# INLINE v1NodeApiVersionL #-}

-- | 'v1NodeKind' Lens
v1NodeKindL :: Lens_' V1Node (Maybe Text)
v1NodeKindL f V1Node{..} = (\v1NodeKind -> V1Node { v1NodeKind, ..} ) <$> f v1NodeKind
{-# INLINE v1NodeKindL #-}

-- | 'v1NodeMetadata' Lens
v1NodeMetadataL :: Lens_' V1Node (Maybe V1ObjectMeta)
v1NodeMetadataL f V1Node{..} = (\v1NodeMetadata -> V1Node { v1NodeMetadata, ..} ) <$> f v1NodeMetadata
{-# INLINE v1NodeMetadataL #-}

-- | 'v1NodeSpec' Lens
v1NodeSpecL :: Lens_' V1Node (Maybe V1NodeSpec)
v1NodeSpecL f V1Node{..} = (\v1NodeSpec -> V1Node { v1NodeSpec, ..} ) <$> f v1NodeSpec
{-# INLINE v1NodeSpecL #-}

-- | 'v1NodeStatus' Lens
v1NodeStatusL :: Lens_' V1Node (Maybe V1NodeStatus)
v1NodeStatusL f V1Node{..} = (\v1NodeStatus -> V1Node { v1NodeStatus, ..} ) <$> f v1NodeStatus
{-# INLINE v1NodeStatusL #-}



-- * V1NodeAddress

-- | 'v1NodeAddressAddress' Lens
v1NodeAddressAddressL :: Lens_' V1NodeAddress (Text)
v1NodeAddressAddressL f V1NodeAddress{..} = (\v1NodeAddressAddress -> V1NodeAddress { v1NodeAddressAddress, ..} ) <$> f v1NodeAddressAddress
{-# INLINE v1NodeAddressAddressL #-}

-- | 'v1NodeAddressType' Lens
v1NodeAddressTypeL :: Lens_' V1NodeAddress (Text)
v1NodeAddressTypeL f V1NodeAddress{..} = (\v1NodeAddressType -> V1NodeAddress { v1NodeAddressType, ..} ) <$> f v1NodeAddressType
{-# INLINE v1NodeAddressTypeL #-}



-- * V1NodeAffinity

-- | 'v1NodeAffinityPreferredDuringSchedulingIgnoredDuringExecution' Lens
v1NodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionL :: Lens_' V1NodeAffinity (Maybe [V1PreferredSchedulingTerm])
v1NodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionL f V1NodeAffinity{..} = (\v1NodeAffinityPreferredDuringSchedulingIgnoredDuringExecution -> V1NodeAffinity { v1NodeAffinityPreferredDuringSchedulingIgnoredDuringExecution, ..} ) <$> f v1NodeAffinityPreferredDuringSchedulingIgnoredDuringExecution
{-# INLINE v1NodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionL #-}

-- | 'v1NodeAffinityRequiredDuringSchedulingIgnoredDuringExecution' Lens
v1NodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionL :: Lens_' V1NodeAffinity (Maybe V1NodeSelector)
v1NodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionL f V1NodeAffinity{..} = (\v1NodeAffinityRequiredDuringSchedulingIgnoredDuringExecution -> V1NodeAffinity { v1NodeAffinityRequiredDuringSchedulingIgnoredDuringExecution, ..} ) <$> f v1NodeAffinityRequiredDuringSchedulingIgnoredDuringExecution
{-# INLINE v1NodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionL #-}



-- * V1NodeCondition

-- | 'v1NodeConditionLastHeartbeatTime' Lens
v1NodeConditionLastHeartbeatTimeL :: Lens_' V1NodeCondition (Maybe DateTime)
v1NodeConditionLastHeartbeatTimeL f V1NodeCondition{..} = (\v1NodeConditionLastHeartbeatTime -> V1NodeCondition { v1NodeConditionLastHeartbeatTime, ..} ) <$> f v1NodeConditionLastHeartbeatTime
{-# INLINE v1NodeConditionLastHeartbeatTimeL #-}

-- | 'v1NodeConditionLastTransitionTime' Lens
v1NodeConditionLastTransitionTimeL :: Lens_' V1NodeCondition (Maybe DateTime)
v1NodeConditionLastTransitionTimeL f V1NodeCondition{..} = (\v1NodeConditionLastTransitionTime -> V1NodeCondition { v1NodeConditionLastTransitionTime, ..} ) <$> f v1NodeConditionLastTransitionTime
{-# INLINE v1NodeConditionLastTransitionTimeL #-}

-- | 'v1NodeConditionMessage' Lens
v1NodeConditionMessageL :: Lens_' V1NodeCondition (Maybe Text)
v1NodeConditionMessageL f V1NodeCondition{..} = (\v1NodeConditionMessage -> V1NodeCondition { v1NodeConditionMessage, ..} ) <$> f v1NodeConditionMessage
{-# INLINE v1NodeConditionMessageL #-}

-- | 'v1NodeConditionReason' Lens
v1NodeConditionReasonL :: Lens_' V1NodeCondition (Maybe Text)
v1NodeConditionReasonL f V1NodeCondition{..} = (\v1NodeConditionReason -> V1NodeCondition { v1NodeConditionReason, ..} ) <$> f v1NodeConditionReason
{-# INLINE v1NodeConditionReasonL #-}

-- | 'v1NodeConditionStatus' Lens
v1NodeConditionStatusL :: Lens_' V1NodeCondition (Text)
v1NodeConditionStatusL f V1NodeCondition{..} = (\v1NodeConditionStatus -> V1NodeCondition { v1NodeConditionStatus, ..} ) <$> f v1NodeConditionStatus
{-# INLINE v1NodeConditionStatusL #-}

-- | 'v1NodeConditionType' Lens
v1NodeConditionTypeL :: Lens_' V1NodeCondition (Text)
v1NodeConditionTypeL f V1NodeCondition{..} = (\v1NodeConditionType -> V1NodeCondition { v1NodeConditionType, ..} ) <$> f v1NodeConditionType
{-# INLINE v1NodeConditionTypeL #-}



-- * V1NodeConfigSource

-- | 'v1NodeConfigSourceConfigMap' Lens
v1NodeConfigSourceConfigMapL :: Lens_' V1NodeConfigSource (Maybe V1ConfigMapNodeConfigSource)
v1NodeConfigSourceConfigMapL f V1NodeConfigSource{..} = (\v1NodeConfigSourceConfigMap -> V1NodeConfigSource { v1NodeConfigSourceConfigMap, ..} ) <$> f v1NodeConfigSourceConfigMap
{-# INLINE v1NodeConfigSourceConfigMapL #-}



-- * V1NodeConfigStatus

-- | 'v1NodeConfigStatusActive' Lens
v1NodeConfigStatusActiveL :: Lens_' V1NodeConfigStatus (Maybe V1NodeConfigSource)
v1NodeConfigStatusActiveL f V1NodeConfigStatus{..} = (\v1NodeConfigStatusActive -> V1NodeConfigStatus { v1NodeConfigStatusActive, ..} ) <$> f v1NodeConfigStatusActive
{-# INLINE v1NodeConfigStatusActiveL #-}

-- | 'v1NodeConfigStatusAssigned' Lens
v1NodeConfigStatusAssignedL :: Lens_' V1NodeConfigStatus (Maybe V1NodeConfigSource)
v1NodeConfigStatusAssignedL f V1NodeConfigStatus{..} = (\v1NodeConfigStatusAssigned -> V1NodeConfigStatus { v1NodeConfigStatusAssigned, ..} ) <$> f v1NodeConfigStatusAssigned
{-# INLINE v1NodeConfigStatusAssignedL #-}

-- | 'v1NodeConfigStatusError' Lens
v1NodeConfigStatusErrorL :: Lens_' V1NodeConfigStatus (Maybe Text)
v1NodeConfigStatusErrorL f V1NodeConfigStatus{..} = (\v1NodeConfigStatusError -> V1NodeConfigStatus { v1NodeConfigStatusError, ..} ) <$> f v1NodeConfigStatusError
{-# INLINE v1NodeConfigStatusErrorL #-}

-- | 'v1NodeConfigStatusLastKnownGood' Lens
v1NodeConfigStatusLastKnownGoodL :: Lens_' V1NodeConfigStatus (Maybe V1NodeConfigSource)
v1NodeConfigStatusLastKnownGoodL f V1NodeConfigStatus{..} = (\v1NodeConfigStatusLastKnownGood -> V1NodeConfigStatus { v1NodeConfigStatusLastKnownGood, ..} ) <$> f v1NodeConfigStatusLastKnownGood
{-# INLINE v1NodeConfigStatusLastKnownGoodL #-}



-- * V1NodeDaemonEndpoints

-- | 'v1NodeDaemonEndpointsKubeletEndpoint' Lens
v1NodeDaemonEndpointsKubeletEndpointL :: Lens_' V1NodeDaemonEndpoints (Maybe V1DaemonEndpoint)
v1NodeDaemonEndpointsKubeletEndpointL f V1NodeDaemonEndpoints{..} = (\v1NodeDaemonEndpointsKubeletEndpoint -> V1NodeDaemonEndpoints { v1NodeDaemonEndpointsKubeletEndpoint, ..} ) <$> f v1NodeDaemonEndpointsKubeletEndpoint
{-# INLINE v1NodeDaemonEndpointsKubeletEndpointL #-}



-- * V1NodeList

-- | 'v1NodeListApiVersion' Lens
v1NodeListApiVersionL :: Lens_' V1NodeList (Maybe Text)
v1NodeListApiVersionL f V1NodeList{..} = (\v1NodeListApiVersion -> V1NodeList { v1NodeListApiVersion, ..} ) <$> f v1NodeListApiVersion
{-# INLINE v1NodeListApiVersionL #-}

-- | 'v1NodeListItems' Lens
v1NodeListItemsL :: Lens_' V1NodeList ([V1Node])
v1NodeListItemsL f V1NodeList{..} = (\v1NodeListItems -> V1NodeList { v1NodeListItems, ..} ) <$> f v1NodeListItems
{-# INLINE v1NodeListItemsL #-}

-- | 'v1NodeListKind' Lens
v1NodeListKindL :: Lens_' V1NodeList (Maybe Text)
v1NodeListKindL f V1NodeList{..} = (\v1NodeListKind -> V1NodeList { v1NodeListKind, ..} ) <$> f v1NodeListKind
{-# INLINE v1NodeListKindL #-}

-- | 'v1NodeListMetadata' Lens
v1NodeListMetadataL :: Lens_' V1NodeList (Maybe V1ListMeta)
v1NodeListMetadataL f V1NodeList{..} = (\v1NodeListMetadata -> V1NodeList { v1NodeListMetadata, ..} ) <$> f v1NodeListMetadata
{-# INLINE v1NodeListMetadataL #-}



-- * V1NodeSelector

-- | 'v1NodeSelectorNodeSelectorTerms' Lens
v1NodeSelectorNodeSelectorTermsL :: Lens_' V1NodeSelector ([V1NodeSelectorTerm])
v1NodeSelectorNodeSelectorTermsL f V1NodeSelector{..} = (\v1NodeSelectorNodeSelectorTerms -> V1NodeSelector { v1NodeSelectorNodeSelectorTerms, ..} ) <$> f v1NodeSelectorNodeSelectorTerms
{-# INLINE v1NodeSelectorNodeSelectorTermsL #-}



-- * V1NodeSelectorRequirement

-- | 'v1NodeSelectorRequirementKey' Lens
v1NodeSelectorRequirementKeyL :: Lens_' V1NodeSelectorRequirement (Text)
v1NodeSelectorRequirementKeyL f V1NodeSelectorRequirement{..} = (\v1NodeSelectorRequirementKey -> V1NodeSelectorRequirement { v1NodeSelectorRequirementKey, ..} ) <$> f v1NodeSelectorRequirementKey
{-# INLINE v1NodeSelectorRequirementKeyL #-}

-- | 'v1NodeSelectorRequirementOperator' Lens
v1NodeSelectorRequirementOperatorL :: Lens_' V1NodeSelectorRequirement (Text)
v1NodeSelectorRequirementOperatorL f V1NodeSelectorRequirement{..} = (\v1NodeSelectorRequirementOperator -> V1NodeSelectorRequirement { v1NodeSelectorRequirementOperator, ..} ) <$> f v1NodeSelectorRequirementOperator
{-# INLINE v1NodeSelectorRequirementOperatorL #-}

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



-- * V1NodeSelectorTerm

-- | 'v1NodeSelectorTermMatchExpressions' Lens
v1NodeSelectorTermMatchExpressionsL :: Lens_' V1NodeSelectorTerm (Maybe [V1NodeSelectorRequirement])
v1NodeSelectorTermMatchExpressionsL f V1NodeSelectorTerm{..} = (\v1NodeSelectorTermMatchExpressions -> V1NodeSelectorTerm { v1NodeSelectorTermMatchExpressions, ..} ) <$> f v1NodeSelectorTermMatchExpressions
{-# INLINE v1NodeSelectorTermMatchExpressionsL #-}

-- | 'v1NodeSelectorTermMatchFields' Lens
v1NodeSelectorTermMatchFieldsL :: Lens_' V1NodeSelectorTerm (Maybe [V1NodeSelectorRequirement])
v1NodeSelectorTermMatchFieldsL f V1NodeSelectorTerm{..} = (\v1NodeSelectorTermMatchFields -> V1NodeSelectorTerm { v1NodeSelectorTermMatchFields, ..} ) <$> f v1NodeSelectorTermMatchFields
{-# INLINE v1NodeSelectorTermMatchFieldsL #-}



-- * V1NodeSpec

-- | 'v1NodeSpecConfigSource' Lens
v1NodeSpecConfigSourceL :: Lens_' V1NodeSpec (Maybe V1NodeConfigSource)
v1NodeSpecConfigSourceL f V1NodeSpec{..} = (\v1NodeSpecConfigSource -> V1NodeSpec { v1NodeSpecConfigSource, ..} ) <$> f v1NodeSpecConfigSource
{-# INLINE v1NodeSpecConfigSourceL #-}

-- | 'v1NodeSpecExternalId' Lens
v1NodeSpecExternalIdL :: Lens_' V1NodeSpec (Maybe Text)
v1NodeSpecExternalIdL f V1NodeSpec{..} = (\v1NodeSpecExternalId -> V1NodeSpec { v1NodeSpecExternalId, ..} ) <$> f v1NodeSpecExternalId
{-# INLINE v1NodeSpecExternalIdL #-}

-- | 'v1NodeSpecPodCidr' Lens
v1NodeSpecPodCidrL :: Lens_' V1NodeSpec (Maybe Text)
v1NodeSpecPodCidrL f V1NodeSpec{..} = (\v1NodeSpecPodCidr -> V1NodeSpec { v1NodeSpecPodCidr, ..} ) <$> f v1NodeSpecPodCidr
{-# INLINE v1NodeSpecPodCidrL #-}

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

-- | 'v1NodeSpecProviderId' Lens
v1NodeSpecProviderIdL :: Lens_' V1NodeSpec (Maybe Text)
v1NodeSpecProviderIdL f V1NodeSpec{..} = (\v1NodeSpecProviderId -> V1NodeSpec { v1NodeSpecProviderId, ..} ) <$> f v1NodeSpecProviderId
{-# INLINE v1NodeSpecProviderIdL #-}

-- | 'v1NodeSpecTaints' Lens
v1NodeSpecTaintsL :: Lens_' V1NodeSpec (Maybe [V1Taint])
v1NodeSpecTaintsL f V1NodeSpec{..} = (\v1NodeSpecTaints -> V1NodeSpec { v1NodeSpecTaints, ..} ) <$> f v1NodeSpecTaints
{-# INLINE v1NodeSpecTaintsL #-}

-- | 'v1NodeSpecUnschedulable' Lens
v1NodeSpecUnschedulableL :: Lens_' V1NodeSpec (Maybe Bool)
v1NodeSpecUnschedulableL f V1NodeSpec{..} = (\v1NodeSpecUnschedulable -> V1NodeSpec { v1NodeSpecUnschedulable, ..} ) <$> f v1NodeSpecUnschedulable
{-# INLINE v1NodeSpecUnschedulableL #-}



-- * V1NodeStatus

-- | 'v1NodeStatusAddresses' Lens
v1NodeStatusAddressesL :: Lens_' V1NodeStatus (Maybe [V1NodeAddress])
v1NodeStatusAddressesL f V1NodeStatus{..} = (\v1NodeStatusAddresses -> V1NodeStatus { v1NodeStatusAddresses, ..} ) <$> f v1NodeStatusAddresses
{-# INLINE v1NodeStatusAddressesL #-}

-- | 'v1NodeStatusAllocatable' Lens
v1NodeStatusAllocatableL :: Lens_' V1NodeStatus (Maybe (Map.Map String Quantity))
v1NodeStatusAllocatableL f V1NodeStatus{..} = (\v1NodeStatusAllocatable -> V1NodeStatus { v1NodeStatusAllocatable, ..} ) <$> f v1NodeStatusAllocatable
{-# INLINE v1NodeStatusAllocatableL #-}

-- | 'v1NodeStatusCapacity' Lens
v1NodeStatusCapacityL :: Lens_' V1NodeStatus (Maybe (Map.Map String Quantity))
v1NodeStatusCapacityL f V1NodeStatus{..} = (\v1NodeStatusCapacity -> V1NodeStatus { v1NodeStatusCapacity, ..} ) <$> f v1NodeStatusCapacity
{-# INLINE v1NodeStatusCapacityL #-}

-- | 'v1NodeStatusConditions' Lens
v1NodeStatusConditionsL :: Lens_' V1NodeStatus (Maybe [V1NodeCondition])
v1NodeStatusConditionsL f V1NodeStatus{..} = (\v1NodeStatusConditions -> V1NodeStatus { v1NodeStatusConditions, ..} ) <$> f v1NodeStatusConditions
{-# INLINE v1NodeStatusConditionsL #-}

-- | 'v1NodeStatusConfig' Lens
v1NodeStatusConfigL :: Lens_' V1NodeStatus (Maybe V1NodeConfigStatus)
v1NodeStatusConfigL f V1NodeStatus{..} = (\v1NodeStatusConfig -> V1NodeStatus { v1NodeStatusConfig, ..} ) <$> f v1NodeStatusConfig
{-# INLINE v1NodeStatusConfigL #-}

-- | 'v1NodeStatusDaemonEndpoints' Lens
v1NodeStatusDaemonEndpointsL :: Lens_' V1NodeStatus (Maybe V1NodeDaemonEndpoints)
v1NodeStatusDaemonEndpointsL f V1NodeStatus{..} = (\v1NodeStatusDaemonEndpoints -> V1NodeStatus { v1NodeStatusDaemonEndpoints, ..} ) <$> f v1NodeStatusDaemonEndpoints
{-# INLINE v1NodeStatusDaemonEndpointsL #-}

-- | 'v1NodeStatusImages' Lens
v1NodeStatusImagesL :: Lens_' V1NodeStatus (Maybe [V1ContainerImage])
v1NodeStatusImagesL f V1NodeStatus{..} = (\v1NodeStatusImages -> V1NodeStatus { v1NodeStatusImages, ..} ) <$> f v1NodeStatusImages
{-# INLINE v1NodeStatusImagesL #-}

-- | 'v1NodeStatusNodeInfo' Lens
v1NodeStatusNodeInfoL :: Lens_' V1NodeStatus (Maybe V1NodeSystemInfo)
v1NodeStatusNodeInfoL f V1NodeStatus{..} = (\v1NodeStatusNodeInfo -> V1NodeStatus { v1NodeStatusNodeInfo, ..} ) <$> f v1NodeStatusNodeInfo
{-# INLINE v1NodeStatusNodeInfoL #-}

-- | 'v1NodeStatusPhase' Lens
v1NodeStatusPhaseL :: Lens_' V1NodeStatus (Maybe Text)
v1NodeStatusPhaseL f V1NodeStatus{..} = (\v1NodeStatusPhase -> V1NodeStatus { v1NodeStatusPhase, ..} ) <$> f v1NodeStatusPhase
{-# INLINE v1NodeStatusPhaseL #-}

-- | 'v1NodeStatusVolumesAttached' Lens
v1NodeStatusVolumesAttachedL :: Lens_' V1NodeStatus (Maybe [V1AttachedVolume])
v1NodeStatusVolumesAttachedL f V1NodeStatus{..} = (\v1NodeStatusVolumesAttached -> V1NodeStatus { v1NodeStatusVolumesAttached, ..} ) <$> f v1NodeStatusVolumesAttached
{-# INLINE v1NodeStatusVolumesAttachedL #-}

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



-- * V1NodeSystemInfo

-- | 'v1NodeSystemInfoArchitecture' Lens
v1NodeSystemInfoArchitectureL :: Lens_' V1NodeSystemInfo (Text)
v1NodeSystemInfoArchitectureL f V1NodeSystemInfo{..} = (\v1NodeSystemInfoArchitecture -> V1NodeSystemInfo { v1NodeSystemInfoArchitecture, ..} ) <$> f v1NodeSystemInfoArchitecture
{-# INLINE v1NodeSystemInfoArchitectureL #-}

-- | 'v1NodeSystemInfoBootId' Lens
v1NodeSystemInfoBootIdL :: Lens_' V1NodeSystemInfo (Text)
v1NodeSystemInfoBootIdL f V1NodeSystemInfo{..} = (\v1NodeSystemInfoBootId -> V1NodeSystemInfo { v1NodeSystemInfoBootId, ..} ) <$> f v1NodeSystemInfoBootId
{-# INLINE v1NodeSystemInfoBootIdL #-}

-- | 'v1NodeSystemInfoContainerRuntimeVersion' Lens
v1NodeSystemInfoContainerRuntimeVersionL :: Lens_' V1NodeSystemInfo (Text)
v1NodeSystemInfoContainerRuntimeVersionL f V1NodeSystemInfo{..} = (\v1NodeSystemInfoContainerRuntimeVersion -> V1NodeSystemInfo { v1NodeSystemInfoContainerRuntimeVersion, ..} ) <$> f v1NodeSystemInfoContainerRuntimeVersion
{-# INLINE v1NodeSystemInfoContainerRuntimeVersionL #-}

-- | 'v1NodeSystemInfoKernelVersion' Lens
v1NodeSystemInfoKernelVersionL :: Lens_' V1NodeSystemInfo (Text)
v1NodeSystemInfoKernelVersionL f V1NodeSystemInfo{..} = (\v1NodeSystemInfoKernelVersion -> V1NodeSystemInfo { v1NodeSystemInfoKernelVersion, ..} ) <$> f v1NodeSystemInfoKernelVersion
{-# INLINE v1NodeSystemInfoKernelVersionL #-}

-- | 'v1NodeSystemInfoKubeProxyVersion' Lens
v1NodeSystemInfoKubeProxyVersionL :: Lens_' V1NodeSystemInfo (Text)
v1NodeSystemInfoKubeProxyVersionL f V1NodeSystemInfo{..} = (\v1NodeSystemInfoKubeProxyVersion -> V1NodeSystemInfo { v1NodeSystemInfoKubeProxyVersion, ..} ) <$> f v1NodeSystemInfoKubeProxyVersion
{-# INLINE v1NodeSystemInfoKubeProxyVersionL #-}

-- | 'v1NodeSystemInfoKubeletVersion' Lens
v1NodeSystemInfoKubeletVersionL :: Lens_' V1NodeSystemInfo (Text)
v1NodeSystemInfoKubeletVersionL f V1NodeSystemInfo{..} = (\v1NodeSystemInfoKubeletVersion -> V1NodeSystemInfo { v1NodeSystemInfoKubeletVersion, ..} ) <$> f v1NodeSystemInfoKubeletVersion
{-# INLINE v1NodeSystemInfoKubeletVersionL #-}

-- | 'v1NodeSystemInfoMachineId' Lens
v1NodeSystemInfoMachineIdL :: Lens_' V1NodeSystemInfo (Text)
v1NodeSystemInfoMachineIdL f V1NodeSystemInfo{..} = (\v1NodeSystemInfoMachineId -> V1NodeSystemInfo { v1NodeSystemInfoMachineId, ..} ) <$> f v1NodeSystemInfoMachineId
{-# INLINE v1NodeSystemInfoMachineIdL #-}

-- | 'v1NodeSystemInfoOperatingSystem' Lens
v1NodeSystemInfoOperatingSystemL :: Lens_' V1NodeSystemInfo (Text)
v1NodeSystemInfoOperatingSystemL f V1NodeSystemInfo{..} = (\v1NodeSystemInfoOperatingSystem -> V1NodeSystemInfo { v1NodeSystemInfoOperatingSystem, ..} ) <$> f v1NodeSystemInfoOperatingSystem
{-# INLINE v1NodeSystemInfoOperatingSystemL #-}

-- | 'v1NodeSystemInfoOsImage' Lens
v1NodeSystemInfoOsImageL :: Lens_' V1NodeSystemInfo (Text)
v1NodeSystemInfoOsImageL f V1NodeSystemInfo{..} = (\v1NodeSystemInfoOsImage -> V1NodeSystemInfo { v1NodeSystemInfoOsImage, ..} ) <$> f v1NodeSystemInfoOsImage
{-# INLINE v1NodeSystemInfoOsImageL #-}

-- | 'v1NodeSystemInfoSystemUuid' Lens
v1NodeSystemInfoSystemUuidL :: Lens_' V1NodeSystemInfo (Text)
v1NodeSystemInfoSystemUuidL f V1NodeSystemInfo{..} = (\v1NodeSystemInfoSystemUuid -> V1NodeSystemInfo { v1NodeSystemInfoSystemUuid, ..} ) <$> f v1NodeSystemInfoSystemUuid
{-# INLINE v1NodeSystemInfoSystemUuidL #-}



-- * V1NonResourceAttributes

-- | 'v1NonResourceAttributesPath' Lens
v1NonResourceAttributesPathL :: Lens_' V1NonResourceAttributes (Maybe Text)
v1NonResourceAttributesPathL f V1NonResourceAttributes{..} = (\v1NonResourceAttributesPath -> V1NonResourceAttributes { v1NonResourceAttributesPath, ..} ) <$> f v1NonResourceAttributesPath
{-# INLINE v1NonResourceAttributesPathL #-}

-- | 'v1NonResourceAttributesVerb' Lens
v1NonResourceAttributesVerbL :: Lens_' V1NonResourceAttributes (Maybe Text)
v1NonResourceAttributesVerbL f V1NonResourceAttributes{..} = (\v1NonResourceAttributesVerb -> V1NonResourceAttributes { v1NonResourceAttributesVerb, ..} ) <$> f v1NonResourceAttributesVerb
{-# INLINE v1NonResourceAttributesVerbL #-}



-- * V1NonResourceRule

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

-- | 'v1NonResourceRuleVerbs' Lens
v1NonResourceRuleVerbsL :: Lens_' V1NonResourceRule ([Text])
v1NonResourceRuleVerbsL f V1NonResourceRule{..} = (\v1NonResourceRuleVerbs -> V1NonResourceRule { v1NonResourceRuleVerbs, ..} ) <$> f v1NonResourceRuleVerbs
{-# INLINE v1NonResourceRuleVerbsL #-}



-- * V1ObjectFieldSelector

-- | 'v1ObjectFieldSelectorApiVersion' Lens
v1ObjectFieldSelectorApiVersionL :: Lens_' V1ObjectFieldSelector (Maybe Text)
v1ObjectFieldSelectorApiVersionL f V1ObjectFieldSelector{..} = (\v1ObjectFieldSelectorApiVersion -> V1ObjectFieldSelector { v1ObjectFieldSelectorApiVersion, ..} ) <$> f v1ObjectFieldSelectorApiVersion
{-# INLINE v1ObjectFieldSelectorApiVersionL #-}

-- | 'v1ObjectFieldSelectorFieldPath' Lens
v1ObjectFieldSelectorFieldPathL :: Lens_' V1ObjectFieldSelector (Text)
v1ObjectFieldSelectorFieldPathL f V1ObjectFieldSelector{..} = (\v1ObjectFieldSelectorFieldPath -> V1ObjectFieldSelector { v1ObjectFieldSelectorFieldPath, ..} ) <$> f v1ObjectFieldSelectorFieldPath
{-# INLINE v1ObjectFieldSelectorFieldPathL #-}



-- * V1ObjectMeta

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

-- | 'v1ObjectMetaClusterName' Lens
v1ObjectMetaClusterNameL :: Lens_' V1ObjectMeta (Maybe Text)
v1ObjectMetaClusterNameL f V1ObjectMeta{..} = (\v1ObjectMetaClusterName -> V1ObjectMeta { v1ObjectMetaClusterName, ..} ) <$> f v1ObjectMetaClusterName
{-# INLINE v1ObjectMetaClusterNameL #-}

-- | 'v1ObjectMetaCreationTimestamp' Lens
v1ObjectMetaCreationTimestampL :: Lens_' V1ObjectMeta (Maybe DateTime)
v1ObjectMetaCreationTimestampL f V1ObjectMeta{..} = (\v1ObjectMetaCreationTimestamp -> V1ObjectMeta { v1ObjectMetaCreationTimestamp, ..} ) <$> f v1ObjectMetaCreationTimestamp
{-# INLINE v1ObjectMetaCreationTimestampL #-}

-- | 'v1ObjectMetaDeletionGracePeriodSeconds' Lens
v1ObjectMetaDeletionGracePeriodSecondsL :: Lens_' V1ObjectMeta (Maybe Integer)
v1ObjectMetaDeletionGracePeriodSecondsL f V1ObjectMeta{..} = (\v1ObjectMetaDeletionGracePeriodSeconds -> V1ObjectMeta { v1ObjectMetaDeletionGracePeriodSeconds, ..} ) <$> f v1ObjectMetaDeletionGracePeriodSeconds
{-# INLINE v1ObjectMetaDeletionGracePeriodSecondsL #-}

-- | 'v1ObjectMetaDeletionTimestamp' Lens
v1ObjectMetaDeletionTimestampL :: Lens_' V1ObjectMeta (Maybe DateTime)
v1ObjectMetaDeletionTimestampL f V1ObjectMeta{..} = (\v1ObjectMetaDeletionTimestamp -> V1ObjectMeta { v1ObjectMetaDeletionTimestamp, ..} ) <$> f v1ObjectMetaDeletionTimestamp
{-# INLINE v1ObjectMetaDeletionTimestampL #-}

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

-- | 'v1ObjectMetaGenerateName' Lens
v1ObjectMetaGenerateNameL :: Lens_' V1ObjectMeta (Maybe Text)
v1ObjectMetaGenerateNameL f V1ObjectMeta{..} = (\v1ObjectMetaGenerateName -> V1ObjectMeta { v1ObjectMetaGenerateName, ..} ) <$> f v1ObjectMetaGenerateName
{-# INLINE v1ObjectMetaGenerateNameL #-}

-- | 'v1ObjectMetaGeneration' Lens
v1ObjectMetaGenerationL :: Lens_' V1ObjectMeta (Maybe Integer)
v1ObjectMetaGenerationL f V1ObjectMeta{..} = (\v1ObjectMetaGeneration -> V1ObjectMeta { v1ObjectMetaGeneration, ..} ) <$> f v1ObjectMetaGeneration
{-# INLINE v1ObjectMetaGenerationL #-}

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

-- | 'v1ObjectMetaManagedFields' Lens
v1ObjectMetaManagedFieldsL :: Lens_' V1ObjectMeta (Maybe [V1ManagedFieldsEntry])
v1ObjectMetaManagedFieldsL f V1ObjectMeta{..} = (\v1ObjectMetaManagedFields -> V1ObjectMeta { v1ObjectMetaManagedFields, ..} ) <$> f v1ObjectMetaManagedFields
{-# INLINE v1ObjectMetaManagedFieldsL #-}

-- | 'v1ObjectMetaName' Lens
v1ObjectMetaNameL :: Lens_' V1ObjectMeta (Maybe Text)
v1ObjectMetaNameL f V1ObjectMeta{..} = (\v1ObjectMetaName -> V1ObjectMeta { v1ObjectMetaName, ..} ) <$> f v1ObjectMetaName
{-# INLINE v1ObjectMetaNameL #-}

-- | 'v1ObjectMetaNamespace' Lens
v1ObjectMetaNamespaceL :: Lens_' V1ObjectMeta (Maybe Text)
v1ObjectMetaNamespaceL f V1ObjectMeta{..} = (\v1ObjectMetaNamespace -> V1ObjectMeta { v1ObjectMetaNamespace, ..} ) <$> f v1ObjectMetaNamespace
{-# INLINE v1ObjectMetaNamespaceL #-}

-- | 'v1ObjectMetaOwnerReferences' Lens
v1ObjectMetaOwnerReferencesL :: Lens_' V1ObjectMeta (Maybe [V1OwnerReference])
v1ObjectMetaOwnerReferencesL f V1ObjectMeta{..} = (\v1ObjectMetaOwnerReferences -> V1ObjectMeta { v1ObjectMetaOwnerReferences, ..} ) <$> f v1ObjectMetaOwnerReferences
{-# INLINE v1ObjectMetaOwnerReferencesL #-}

-- | 'v1ObjectMetaResourceVersion' Lens
v1ObjectMetaResourceVersionL :: Lens_' V1ObjectMeta (Maybe Text)
v1ObjectMetaResourceVersionL f V1ObjectMeta{..} = (\v1ObjectMetaResourceVersion -> V1ObjectMeta { v1ObjectMetaResourceVersion, ..} ) <$> f v1ObjectMetaResourceVersion
{-# INLINE v1ObjectMetaResourceVersionL #-}

-- | 'v1ObjectMetaSelfLink' Lens
v1ObjectMetaSelfLinkL :: Lens_' V1ObjectMeta (Maybe Text)
v1ObjectMetaSelfLinkL f V1ObjectMeta{..} = (\v1ObjectMetaSelfLink -> V1ObjectMeta { v1ObjectMetaSelfLink, ..} ) <$> f v1ObjectMetaSelfLink
{-# INLINE v1ObjectMetaSelfLinkL #-}

-- | 'v1ObjectMetaUid' Lens
v1ObjectMetaUidL :: Lens_' V1ObjectMeta (Maybe Text)
v1ObjectMetaUidL f V1ObjectMeta{..} = (\v1ObjectMetaUid -> V1ObjectMeta { v1ObjectMetaUid, ..} ) <$> f v1ObjectMetaUid
{-# INLINE v1ObjectMetaUidL #-}



-- * V1ObjectReference

-- | 'v1ObjectReferenceApiVersion' Lens
v1ObjectReferenceApiVersionL :: Lens_' V1ObjectReference (Maybe Text)
v1ObjectReferenceApiVersionL f V1ObjectReference{..} = (\v1ObjectReferenceApiVersion -> V1ObjectReference { v1ObjectReferenceApiVersion, ..} ) <$> f v1ObjectReferenceApiVersion
{-# INLINE v1ObjectReferenceApiVersionL #-}

-- | 'v1ObjectReferenceFieldPath' Lens
v1ObjectReferenceFieldPathL :: Lens_' V1ObjectReference (Maybe Text)
v1ObjectReferenceFieldPathL f V1ObjectReference{..} = (\v1ObjectReferenceFieldPath -> V1ObjectReference { v1ObjectReferenceFieldPath, ..} ) <$> f v1ObjectReferenceFieldPath
{-# INLINE v1ObjectReferenceFieldPathL #-}

-- | 'v1ObjectReferenceKind' Lens
v1ObjectReferenceKindL :: Lens_' V1ObjectReference (Maybe Text)
v1ObjectReferenceKindL f V1ObjectReference{..} = (\v1ObjectReferenceKind -> V1ObjectReference { v1ObjectReferenceKind, ..} ) <$> f v1ObjectReferenceKind
{-# INLINE v1ObjectReferenceKindL #-}

-- | 'v1ObjectReferenceName' Lens
v1ObjectReferenceNameL :: Lens_' V1ObjectReference (Maybe Text)
v1ObjectReferenceNameL f V1ObjectReference{..} = (\v1ObjectReferenceName -> V1ObjectReference { v1ObjectReferenceName, ..} ) <$> f v1ObjectReferenceName
{-# INLINE v1ObjectReferenceNameL #-}

-- | 'v1ObjectReferenceNamespace' Lens
v1ObjectReferenceNamespaceL :: Lens_' V1ObjectReference (Maybe Text)
v1ObjectReferenceNamespaceL f V1ObjectReference{..} = (\v1ObjectReferenceNamespace -> V1ObjectReference { v1ObjectReferenceNamespace, ..} ) <$> f v1ObjectReferenceNamespace
{-# INLINE v1ObjectReferenceNamespaceL #-}

-- | 'v1ObjectReferenceResourceVersion' Lens
v1ObjectReferenceResourceVersionL :: Lens_' V1ObjectReference (Maybe Text)
v1ObjectReferenceResourceVersionL f V1ObjectReference{..} = (\v1ObjectReferenceResourceVersion -> V1ObjectReference { v1ObjectReferenceResourceVersion, ..} ) <$> f v1ObjectReferenceResourceVersion
{-# INLINE v1ObjectReferenceResourceVersionL #-}

-- | 'v1ObjectReferenceUid' Lens
v1ObjectReferenceUidL :: Lens_' V1ObjectReference (Maybe Text)
v1ObjectReferenceUidL f V1ObjectReference{..} = (\v1ObjectReferenceUid -> V1ObjectReference { v1ObjectReferenceUid, ..} ) <$> f v1ObjectReferenceUid
{-# INLINE v1ObjectReferenceUidL #-}



-- * V1Overhead

-- | 'v1OverheadPodFixed' Lens
v1OverheadPodFixedL :: Lens_' V1Overhead (Maybe (Map.Map String Quantity))
v1OverheadPodFixedL f V1Overhead{..} = (\v1OverheadPodFixed -> V1Overhead { v1OverheadPodFixed, ..} ) <$> f v1OverheadPodFixed
{-# INLINE v1OverheadPodFixedL #-}



-- * V1OwnerReference

-- | 'v1OwnerReferenceApiVersion' Lens
v1OwnerReferenceApiVersionL :: Lens_' V1OwnerReference (Text)
v1OwnerReferenceApiVersionL f V1OwnerReference{..} = (\v1OwnerReferenceApiVersion -> V1OwnerReference { v1OwnerReferenceApiVersion, ..} ) <$> f v1OwnerReferenceApiVersion
{-# INLINE v1OwnerReferenceApiVersionL #-}

-- | 'v1OwnerReferenceBlockOwnerDeletion' Lens
v1OwnerReferenceBlockOwnerDeletionL :: Lens_' V1OwnerReference (Maybe Bool)
v1OwnerReferenceBlockOwnerDeletionL f V1OwnerReference{..} = (\v1OwnerReferenceBlockOwnerDeletion -> V1OwnerReference { v1OwnerReferenceBlockOwnerDeletion, ..} ) <$> f v1OwnerReferenceBlockOwnerDeletion
{-# INLINE v1OwnerReferenceBlockOwnerDeletionL #-}

-- | 'v1OwnerReferenceController' Lens
v1OwnerReferenceControllerL :: Lens_' V1OwnerReference (Maybe Bool)
v1OwnerReferenceControllerL f V1OwnerReference{..} = (\v1OwnerReferenceController -> V1OwnerReference { v1OwnerReferenceController, ..} ) <$> f v1OwnerReferenceController
{-# INLINE v1OwnerReferenceControllerL #-}

-- | 'v1OwnerReferenceKind' Lens
v1OwnerReferenceKindL :: Lens_' V1OwnerReference (Text)
v1OwnerReferenceKindL f V1OwnerReference{..} = (\v1OwnerReferenceKind -> V1OwnerReference { v1OwnerReferenceKind, ..} ) <$> f v1OwnerReferenceKind
{-# INLINE v1OwnerReferenceKindL #-}

-- | 'v1OwnerReferenceName' Lens
v1OwnerReferenceNameL :: Lens_' V1OwnerReference (Text)
v1OwnerReferenceNameL f V1OwnerReference{..} = (\v1OwnerReferenceName -> V1OwnerReference { v1OwnerReferenceName, ..} ) <$> f v1OwnerReferenceName
{-# INLINE v1OwnerReferenceNameL #-}

-- | 'v1OwnerReferenceUid' Lens
v1OwnerReferenceUidL :: Lens_' V1OwnerReference (Text)
v1OwnerReferenceUidL f V1OwnerReference{..} = (\v1OwnerReferenceUid -> V1OwnerReference { v1OwnerReferenceUid, ..} ) <$> f v1OwnerReferenceUid
{-# INLINE v1OwnerReferenceUidL #-}



-- * V1PersistentVolume

-- | 'v1PersistentVolumeApiVersion' Lens
v1PersistentVolumeApiVersionL :: Lens_' V1PersistentVolume (Maybe Text)
v1PersistentVolumeApiVersionL f V1PersistentVolume{..} = (\v1PersistentVolumeApiVersion -> V1PersistentVolume { v1PersistentVolumeApiVersion, ..} ) <$> f v1PersistentVolumeApiVersion
{-# INLINE v1PersistentVolumeApiVersionL #-}

-- | 'v1PersistentVolumeKind' Lens
v1PersistentVolumeKindL :: Lens_' V1PersistentVolume (Maybe Text)
v1PersistentVolumeKindL f V1PersistentVolume{..} = (\v1PersistentVolumeKind -> V1PersistentVolume { v1PersistentVolumeKind, ..} ) <$> f v1PersistentVolumeKind
{-# INLINE v1PersistentVolumeKindL #-}

-- | 'v1PersistentVolumeMetadata' Lens
v1PersistentVolumeMetadataL :: Lens_' V1PersistentVolume (Maybe V1ObjectMeta)
v1PersistentVolumeMetadataL f V1PersistentVolume{..} = (\v1PersistentVolumeMetadata -> V1PersistentVolume { v1PersistentVolumeMetadata, ..} ) <$> f v1PersistentVolumeMetadata
{-# INLINE v1PersistentVolumeMetadataL #-}

-- | 'v1PersistentVolumeSpec' Lens
v1PersistentVolumeSpecL :: Lens_' V1PersistentVolume (Maybe V1PersistentVolumeSpec)
v1PersistentVolumeSpecL f V1PersistentVolume{..} = (\v1PersistentVolumeSpec -> V1PersistentVolume { v1PersistentVolumeSpec, ..} ) <$> f v1PersistentVolumeSpec
{-# INLINE v1PersistentVolumeSpecL #-}

-- | 'v1PersistentVolumeStatus' Lens
v1PersistentVolumeStatusL :: Lens_' V1PersistentVolume (Maybe V1PersistentVolumeStatus)
v1PersistentVolumeStatusL f V1PersistentVolume{..} = (\v1PersistentVolumeStatus -> V1PersistentVolume { v1PersistentVolumeStatus, ..} ) <$> f v1PersistentVolumeStatus
{-# INLINE v1PersistentVolumeStatusL #-}



-- * V1PersistentVolumeClaim

-- | 'v1PersistentVolumeClaimApiVersion' Lens
v1PersistentVolumeClaimApiVersionL :: Lens_' V1PersistentVolumeClaim (Maybe Text)
v1PersistentVolumeClaimApiVersionL f V1PersistentVolumeClaim{..} = (\v1PersistentVolumeClaimApiVersion -> V1PersistentVolumeClaim { v1PersistentVolumeClaimApiVersion, ..} ) <$> f v1PersistentVolumeClaimApiVersion
{-# INLINE v1PersistentVolumeClaimApiVersionL #-}

-- | 'v1PersistentVolumeClaimKind' Lens
v1PersistentVolumeClaimKindL :: Lens_' V1PersistentVolumeClaim (Maybe Text)
v1PersistentVolumeClaimKindL f V1PersistentVolumeClaim{..} = (\v1PersistentVolumeClaimKind -> V1PersistentVolumeClaim { v1PersistentVolumeClaimKind, ..} ) <$> f v1PersistentVolumeClaimKind
{-# INLINE v1PersistentVolumeClaimKindL #-}

-- | 'v1PersistentVolumeClaimMetadata' Lens
v1PersistentVolumeClaimMetadataL :: Lens_' V1PersistentVolumeClaim (Maybe V1ObjectMeta)
v1PersistentVolumeClaimMetadataL f V1PersistentVolumeClaim{..} = (\v1PersistentVolumeClaimMetadata -> V1PersistentVolumeClaim { v1PersistentVolumeClaimMetadata, ..} ) <$> f v1PersistentVolumeClaimMetadata
{-# INLINE v1PersistentVolumeClaimMetadataL #-}

-- | 'v1PersistentVolumeClaimSpec' Lens
v1PersistentVolumeClaimSpecL :: Lens_' V1PersistentVolumeClaim (Maybe V1PersistentVolumeClaimSpec)
v1PersistentVolumeClaimSpecL f V1PersistentVolumeClaim{..} = (\v1PersistentVolumeClaimSpec -> V1PersistentVolumeClaim { v1PersistentVolumeClaimSpec, ..} ) <$> f v1PersistentVolumeClaimSpec
{-# INLINE v1PersistentVolumeClaimSpecL #-}

-- | 'v1PersistentVolumeClaimStatus' Lens
v1PersistentVolumeClaimStatusL :: Lens_' V1PersistentVolumeClaim (Maybe V1PersistentVolumeClaimStatus)
v1PersistentVolumeClaimStatusL f V1PersistentVolumeClaim{..} = (\v1PersistentVolumeClaimStatus -> V1PersistentVolumeClaim { v1PersistentVolumeClaimStatus, ..} ) <$> f v1PersistentVolumeClaimStatus
{-# INLINE v1PersistentVolumeClaimStatusL #-}



-- * V1PersistentVolumeClaimCondition

-- | 'v1PersistentVolumeClaimConditionLastProbeTime' Lens
v1PersistentVolumeClaimConditionLastProbeTimeL :: Lens_' V1PersistentVolumeClaimCondition (Maybe DateTime)
v1PersistentVolumeClaimConditionLastProbeTimeL f V1PersistentVolumeClaimCondition{..} = (\v1PersistentVolumeClaimConditionLastProbeTime -> V1PersistentVolumeClaimCondition { v1PersistentVolumeClaimConditionLastProbeTime, ..} ) <$> f v1PersistentVolumeClaimConditionLastProbeTime
{-# INLINE v1PersistentVolumeClaimConditionLastProbeTimeL #-}

-- | 'v1PersistentVolumeClaimConditionLastTransitionTime' Lens
v1PersistentVolumeClaimConditionLastTransitionTimeL :: Lens_' V1PersistentVolumeClaimCondition (Maybe DateTime)
v1PersistentVolumeClaimConditionLastTransitionTimeL f V1PersistentVolumeClaimCondition{..} = (\v1PersistentVolumeClaimConditionLastTransitionTime -> V1PersistentVolumeClaimCondition { v1PersistentVolumeClaimConditionLastTransitionTime, ..} ) <$> f v1PersistentVolumeClaimConditionLastTransitionTime
{-# INLINE v1PersistentVolumeClaimConditionLastTransitionTimeL #-}

-- | 'v1PersistentVolumeClaimConditionMessage' Lens
v1PersistentVolumeClaimConditionMessageL :: Lens_' V1PersistentVolumeClaimCondition (Maybe Text)
v1PersistentVolumeClaimConditionMessageL f V1PersistentVolumeClaimCondition{..} = (\v1PersistentVolumeClaimConditionMessage -> V1PersistentVolumeClaimCondition { v1PersistentVolumeClaimConditionMessage, ..} ) <$> f v1PersistentVolumeClaimConditionMessage
{-# INLINE v1PersistentVolumeClaimConditionMessageL #-}

-- | 'v1PersistentVolumeClaimConditionReason' Lens
v1PersistentVolumeClaimConditionReasonL :: Lens_' V1PersistentVolumeClaimCondition (Maybe Text)
v1PersistentVolumeClaimConditionReasonL f V1PersistentVolumeClaimCondition{..} = (\v1PersistentVolumeClaimConditionReason -> V1PersistentVolumeClaimCondition { v1PersistentVolumeClaimConditionReason, ..} ) <$> f v1PersistentVolumeClaimConditionReason
{-# INLINE v1PersistentVolumeClaimConditionReasonL #-}

-- | 'v1PersistentVolumeClaimConditionStatus' Lens
v1PersistentVolumeClaimConditionStatusL :: Lens_' V1PersistentVolumeClaimCondition (Text)
v1PersistentVolumeClaimConditionStatusL f V1PersistentVolumeClaimCondition{..} = (\v1PersistentVolumeClaimConditionStatus -> V1PersistentVolumeClaimCondition { v1PersistentVolumeClaimConditionStatus, ..} ) <$> f v1PersistentVolumeClaimConditionStatus
{-# INLINE v1PersistentVolumeClaimConditionStatusL #-}

-- | 'v1PersistentVolumeClaimConditionType' Lens
v1PersistentVolumeClaimConditionTypeL :: Lens_' V1PersistentVolumeClaimCondition (Text)
v1PersistentVolumeClaimConditionTypeL f V1PersistentVolumeClaimCondition{..} = (\v1PersistentVolumeClaimConditionType -> V1PersistentVolumeClaimCondition { v1PersistentVolumeClaimConditionType, ..} ) <$> f v1PersistentVolumeClaimConditionType
{-# INLINE v1PersistentVolumeClaimConditionTypeL #-}



-- * V1PersistentVolumeClaimList

-- | 'v1PersistentVolumeClaimListApiVersion' Lens
v1PersistentVolumeClaimListApiVersionL :: Lens_' V1PersistentVolumeClaimList (Maybe Text)
v1PersistentVolumeClaimListApiVersionL f V1PersistentVolumeClaimList{..} = (\v1PersistentVolumeClaimListApiVersion -> V1PersistentVolumeClaimList { v1PersistentVolumeClaimListApiVersion, ..} ) <$> f v1PersistentVolumeClaimListApiVersion
{-# INLINE v1PersistentVolumeClaimListApiVersionL #-}

-- | 'v1PersistentVolumeClaimListItems' Lens
v1PersistentVolumeClaimListItemsL :: Lens_' V1PersistentVolumeClaimList ([V1PersistentVolumeClaim])
v1PersistentVolumeClaimListItemsL f V1PersistentVolumeClaimList{..} = (\v1PersistentVolumeClaimListItems -> V1PersistentVolumeClaimList { v1PersistentVolumeClaimListItems, ..} ) <$> f v1PersistentVolumeClaimListItems
{-# INLINE v1PersistentVolumeClaimListItemsL #-}

-- | 'v1PersistentVolumeClaimListKind' Lens
v1PersistentVolumeClaimListKindL :: Lens_' V1PersistentVolumeClaimList (Maybe Text)
v1PersistentVolumeClaimListKindL f V1PersistentVolumeClaimList{..} = (\v1PersistentVolumeClaimListKind -> V1PersistentVolumeClaimList { v1PersistentVolumeClaimListKind, ..} ) <$> f v1PersistentVolumeClaimListKind
{-# INLINE v1PersistentVolumeClaimListKindL #-}

-- | 'v1PersistentVolumeClaimListMetadata' Lens
v1PersistentVolumeClaimListMetadataL :: Lens_' V1PersistentVolumeClaimList (Maybe V1ListMeta)
v1PersistentVolumeClaimListMetadataL f V1PersistentVolumeClaimList{..} = (\v1PersistentVolumeClaimListMetadata -> V1PersistentVolumeClaimList { v1PersistentVolumeClaimListMetadata, ..} ) <$> f v1PersistentVolumeClaimListMetadata
{-# INLINE v1PersistentVolumeClaimListMetadataL #-}



-- * V1PersistentVolumeClaimSpec

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

-- | 'v1PersistentVolumeClaimSpecDataSource' Lens
v1PersistentVolumeClaimSpecDataSourceL :: Lens_' V1PersistentVolumeClaimSpec (Maybe V1TypedLocalObjectReference)
v1PersistentVolumeClaimSpecDataSourceL f V1PersistentVolumeClaimSpec{..} = (\v1PersistentVolumeClaimSpecDataSource -> V1PersistentVolumeClaimSpec { v1PersistentVolumeClaimSpecDataSource, ..} ) <$> f v1PersistentVolumeClaimSpecDataSource
{-# INLINE v1PersistentVolumeClaimSpecDataSourceL #-}

-- | 'v1PersistentVolumeClaimSpecDataSourceRef' Lens
v1PersistentVolumeClaimSpecDataSourceRefL :: Lens_' V1PersistentVolumeClaimSpec (Maybe V1TypedLocalObjectReference)
v1PersistentVolumeClaimSpecDataSourceRefL f V1PersistentVolumeClaimSpec{..} = (\v1PersistentVolumeClaimSpecDataSourceRef -> V1PersistentVolumeClaimSpec { v1PersistentVolumeClaimSpecDataSourceRef, ..} ) <$> f v1PersistentVolumeClaimSpecDataSourceRef
{-# INLINE v1PersistentVolumeClaimSpecDataSourceRefL #-}

-- | 'v1PersistentVolumeClaimSpecResources' Lens
v1PersistentVolumeClaimSpecResourcesL :: Lens_' V1PersistentVolumeClaimSpec (Maybe V1ResourceRequirements)
v1PersistentVolumeClaimSpecResourcesL f V1PersistentVolumeClaimSpec{..} = (\v1PersistentVolumeClaimSpecResources -> V1PersistentVolumeClaimSpec { v1PersistentVolumeClaimSpecResources, ..} ) <$> f v1PersistentVolumeClaimSpecResources
{-# INLINE v1PersistentVolumeClaimSpecResourcesL #-}

-- | 'v1PersistentVolumeClaimSpecSelector' Lens
v1PersistentVolumeClaimSpecSelectorL :: Lens_' V1PersistentVolumeClaimSpec (Maybe V1LabelSelector)
v1PersistentVolumeClaimSpecSelectorL f V1PersistentVolumeClaimSpec{..} = (\v1PersistentVolumeClaimSpecSelector -> V1PersistentVolumeClaimSpec { v1PersistentVolumeClaimSpecSelector, ..} ) <$> f v1PersistentVolumeClaimSpecSelector
{-# INLINE v1PersistentVolumeClaimSpecSelectorL #-}

-- | 'v1PersistentVolumeClaimSpecStorageClassName' Lens
v1PersistentVolumeClaimSpecStorageClassNameL :: Lens_' V1PersistentVolumeClaimSpec (Maybe Text)
v1PersistentVolumeClaimSpecStorageClassNameL f V1PersistentVolumeClaimSpec{..} = (\v1PersistentVolumeClaimSpecStorageClassName -> V1PersistentVolumeClaimSpec { v1PersistentVolumeClaimSpecStorageClassName, ..} ) <$> f v1PersistentVolumeClaimSpecStorageClassName
{-# INLINE v1PersistentVolumeClaimSpecStorageClassNameL #-}

-- | 'v1PersistentVolumeClaimSpecVolumeMode' Lens
v1PersistentVolumeClaimSpecVolumeModeL :: Lens_' V1PersistentVolumeClaimSpec (Maybe Text)
v1PersistentVolumeClaimSpecVolumeModeL f V1PersistentVolumeClaimSpec{..} = (\v1PersistentVolumeClaimSpecVolumeMode -> V1PersistentVolumeClaimSpec { v1PersistentVolumeClaimSpecVolumeMode, ..} ) <$> f v1PersistentVolumeClaimSpecVolumeMode
{-# INLINE v1PersistentVolumeClaimSpecVolumeModeL #-}

-- | 'v1PersistentVolumeClaimSpecVolumeName' Lens
v1PersistentVolumeClaimSpecVolumeNameL :: Lens_' V1PersistentVolumeClaimSpec (Maybe Text)
v1PersistentVolumeClaimSpecVolumeNameL f V1PersistentVolumeClaimSpec{..} = (\v1PersistentVolumeClaimSpecVolumeName -> V1PersistentVolumeClaimSpec { v1PersistentVolumeClaimSpecVolumeName, ..} ) <$> f v1PersistentVolumeClaimSpecVolumeName
{-# INLINE v1PersistentVolumeClaimSpecVolumeNameL #-}



-- * V1PersistentVolumeClaimStatus

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

-- | 'v1PersistentVolumeClaimStatusAllocatedResources' Lens
v1PersistentVolumeClaimStatusAllocatedResourcesL :: Lens_' V1PersistentVolumeClaimStatus (Maybe (Map.Map String Quantity))
v1PersistentVolumeClaimStatusAllocatedResourcesL f V1PersistentVolumeClaimStatus{..} = (\v1PersistentVolumeClaimStatusAllocatedResources -> V1PersistentVolumeClaimStatus { v1PersistentVolumeClaimStatusAllocatedResources, ..} ) <$> f v1PersistentVolumeClaimStatusAllocatedResources
{-# INLINE v1PersistentVolumeClaimStatusAllocatedResourcesL #-}

-- | 'v1PersistentVolumeClaimStatusCapacity' Lens
v1PersistentVolumeClaimStatusCapacityL :: Lens_' V1PersistentVolumeClaimStatus (Maybe (Map.Map String Quantity))
v1PersistentVolumeClaimStatusCapacityL f V1PersistentVolumeClaimStatus{..} = (\v1PersistentVolumeClaimStatusCapacity -> V1PersistentVolumeClaimStatus { v1PersistentVolumeClaimStatusCapacity, ..} ) <$> f v1PersistentVolumeClaimStatusCapacity
{-# INLINE v1PersistentVolumeClaimStatusCapacityL #-}

-- | 'v1PersistentVolumeClaimStatusConditions' Lens
v1PersistentVolumeClaimStatusConditionsL :: Lens_' V1PersistentVolumeClaimStatus (Maybe [V1PersistentVolumeClaimCondition])
v1PersistentVolumeClaimStatusConditionsL f V1PersistentVolumeClaimStatus{..} = (\v1PersistentVolumeClaimStatusConditions -> V1PersistentVolumeClaimStatus { v1PersistentVolumeClaimStatusConditions, ..} ) <$> f v1PersistentVolumeClaimStatusConditions
{-# INLINE v1PersistentVolumeClaimStatusConditionsL #-}

-- | 'v1PersistentVolumeClaimStatusPhase' Lens
v1PersistentVolumeClaimStatusPhaseL :: Lens_' V1PersistentVolumeClaimStatus (Maybe Text)
v1PersistentVolumeClaimStatusPhaseL f V1PersistentVolumeClaimStatus{..} = (\v1PersistentVolumeClaimStatusPhase -> V1PersistentVolumeClaimStatus { v1PersistentVolumeClaimStatusPhase, ..} ) <$> f v1PersistentVolumeClaimStatusPhase
{-# INLINE v1PersistentVolumeClaimStatusPhaseL #-}

-- | 'v1PersistentVolumeClaimStatusResizeStatus' Lens
v1PersistentVolumeClaimStatusResizeStatusL :: Lens_' V1PersistentVolumeClaimStatus (Maybe Text)
v1PersistentVolumeClaimStatusResizeStatusL f V1PersistentVolumeClaimStatus{..} = (\v1PersistentVolumeClaimStatusResizeStatus -> V1PersistentVolumeClaimStatus { v1PersistentVolumeClaimStatusResizeStatus, ..} ) <$> f v1PersistentVolumeClaimStatusResizeStatus
{-# INLINE v1PersistentVolumeClaimStatusResizeStatusL #-}



-- * V1PersistentVolumeClaimTemplate

-- | 'v1PersistentVolumeClaimTemplateMetadata' Lens
v1PersistentVolumeClaimTemplateMetadataL :: Lens_' V1PersistentVolumeClaimTemplate (Maybe V1ObjectMeta)
v1PersistentVolumeClaimTemplateMetadataL f V1PersistentVolumeClaimTemplate{..} = (\v1PersistentVolumeClaimTemplateMetadata -> V1PersistentVolumeClaimTemplate { v1PersistentVolumeClaimTemplateMetadata, ..} ) <$> f v1PersistentVolumeClaimTemplateMetadata
{-# INLINE v1PersistentVolumeClaimTemplateMetadataL #-}

-- | 'v1PersistentVolumeClaimTemplateSpec' Lens
v1PersistentVolumeClaimTemplateSpecL :: Lens_' V1PersistentVolumeClaimTemplate (V1PersistentVolumeClaimSpec)
v1PersistentVolumeClaimTemplateSpecL f V1PersistentVolumeClaimTemplate{..} = (\v1PersistentVolumeClaimTemplateSpec -> V1PersistentVolumeClaimTemplate { v1PersistentVolumeClaimTemplateSpec, ..} ) <$> f v1PersistentVolumeClaimTemplateSpec
{-# INLINE v1PersistentVolumeClaimTemplateSpecL #-}



-- * V1PersistentVolumeClaimVolumeSource

-- | 'v1PersistentVolumeClaimVolumeSourceClaimName' Lens
v1PersistentVolumeClaimVolumeSourceClaimNameL :: Lens_' V1PersistentVolumeClaimVolumeSource (Text)
v1PersistentVolumeClaimVolumeSourceClaimNameL f V1PersistentVolumeClaimVolumeSource{..} = (\v1PersistentVolumeClaimVolumeSourceClaimName -> V1PersistentVolumeClaimVolumeSource { v1PersistentVolumeClaimVolumeSourceClaimName, ..} ) <$> f v1PersistentVolumeClaimVolumeSourceClaimName
{-# INLINE v1PersistentVolumeClaimVolumeSourceClaimNameL #-}

-- | 'v1PersistentVolumeClaimVolumeSourceReadOnly' Lens
v1PersistentVolumeClaimVolumeSourceReadOnlyL :: Lens_' V1PersistentVolumeClaimVolumeSource (Maybe Bool)
v1PersistentVolumeClaimVolumeSourceReadOnlyL f V1PersistentVolumeClaimVolumeSource{..} = (\v1PersistentVolumeClaimVolumeSourceReadOnly -> V1PersistentVolumeClaimVolumeSource { v1PersistentVolumeClaimVolumeSourceReadOnly, ..} ) <$> f v1PersistentVolumeClaimVolumeSourceReadOnly
{-# INLINE v1PersistentVolumeClaimVolumeSourceReadOnlyL #-}



-- * V1PersistentVolumeList

-- | 'v1PersistentVolumeListApiVersion' Lens
v1PersistentVolumeListApiVersionL :: Lens_' V1PersistentVolumeList (Maybe Text)
v1PersistentVolumeListApiVersionL f V1PersistentVolumeList{..} = (\v1PersistentVolumeListApiVersion -> V1PersistentVolumeList { v1PersistentVolumeListApiVersion, ..} ) <$> f v1PersistentVolumeListApiVersion
{-# INLINE v1PersistentVolumeListApiVersionL #-}

-- | 'v1PersistentVolumeListItems' Lens
v1PersistentVolumeListItemsL :: Lens_' V1PersistentVolumeList ([V1PersistentVolume])
v1PersistentVolumeListItemsL f V1PersistentVolumeList{..} = (\v1PersistentVolumeListItems -> V1PersistentVolumeList { v1PersistentVolumeListItems, ..} ) <$> f v1PersistentVolumeListItems
{-# INLINE v1PersistentVolumeListItemsL #-}

-- | 'v1PersistentVolumeListKind' Lens
v1PersistentVolumeListKindL :: Lens_' V1PersistentVolumeList (Maybe Text)
v1PersistentVolumeListKindL f V1PersistentVolumeList{..} = (\v1PersistentVolumeListKind -> V1PersistentVolumeList { v1PersistentVolumeListKind, ..} ) <$> f v1PersistentVolumeListKind
{-# INLINE v1PersistentVolumeListKindL #-}

-- | 'v1PersistentVolumeListMetadata' Lens
v1PersistentVolumeListMetadataL :: Lens_' V1PersistentVolumeList (Maybe V1ListMeta)
v1PersistentVolumeListMetadataL f V1PersistentVolumeList{..} = (\v1PersistentVolumeListMetadata -> V1PersistentVolumeList { v1PersistentVolumeListMetadata, ..} ) <$> f v1PersistentVolumeListMetadata
{-# INLINE v1PersistentVolumeListMetadataL #-}



-- * V1PersistentVolumeSpec

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

-- | 'v1PersistentVolumeSpecAwsElasticBlockStore' Lens
v1PersistentVolumeSpecAwsElasticBlockStoreL :: Lens_' V1PersistentVolumeSpec (Maybe V1AWSElasticBlockStoreVolumeSource)
v1PersistentVolumeSpecAwsElasticBlockStoreL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecAwsElasticBlockStore -> V1PersistentVolumeSpec { v1PersistentVolumeSpecAwsElasticBlockStore, ..} ) <$> f v1PersistentVolumeSpecAwsElasticBlockStore
{-# INLINE v1PersistentVolumeSpecAwsElasticBlockStoreL #-}

-- | 'v1PersistentVolumeSpecAzureDisk' Lens
v1PersistentVolumeSpecAzureDiskL :: Lens_' V1PersistentVolumeSpec (Maybe V1AzureDiskVolumeSource)
v1PersistentVolumeSpecAzureDiskL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecAzureDisk -> V1PersistentVolumeSpec { v1PersistentVolumeSpecAzureDisk, ..} ) <$> f v1PersistentVolumeSpecAzureDisk
{-# INLINE v1PersistentVolumeSpecAzureDiskL #-}

-- | 'v1PersistentVolumeSpecAzureFile' Lens
v1PersistentVolumeSpecAzureFileL :: Lens_' V1PersistentVolumeSpec (Maybe V1AzureFilePersistentVolumeSource)
v1PersistentVolumeSpecAzureFileL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecAzureFile -> V1PersistentVolumeSpec { v1PersistentVolumeSpecAzureFile, ..} ) <$> f v1PersistentVolumeSpecAzureFile
{-# INLINE v1PersistentVolumeSpecAzureFileL #-}

-- | 'v1PersistentVolumeSpecCapacity' Lens
v1PersistentVolumeSpecCapacityL :: Lens_' V1PersistentVolumeSpec (Maybe (Map.Map String Quantity))
v1PersistentVolumeSpecCapacityL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecCapacity -> V1PersistentVolumeSpec { v1PersistentVolumeSpecCapacity, ..} ) <$> f v1PersistentVolumeSpecCapacity
{-# INLINE v1PersistentVolumeSpecCapacityL #-}

-- | 'v1PersistentVolumeSpecCephfs' Lens
v1PersistentVolumeSpecCephfsL :: Lens_' V1PersistentVolumeSpec (Maybe V1CephFSPersistentVolumeSource)
v1PersistentVolumeSpecCephfsL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecCephfs -> V1PersistentVolumeSpec { v1PersistentVolumeSpecCephfs, ..} ) <$> f v1PersistentVolumeSpecCephfs
{-# INLINE v1PersistentVolumeSpecCephfsL #-}

-- | 'v1PersistentVolumeSpecCinder' Lens
v1PersistentVolumeSpecCinderL :: Lens_' V1PersistentVolumeSpec (Maybe V1CinderPersistentVolumeSource)
v1PersistentVolumeSpecCinderL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecCinder -> V1PersistentVolumeSpec { v1PersistentVolumeSpecCinder, ..} ) <$> f v1PersistentVolumeSpecCinder
{-# INLINE v1PersistentVolumeSpecCinderL #-}

-- | 'v1PersistentVolumeSpecClaimRef' Lens
v1PersistentVolumeSpecClaimRefL :: Lens_' V1PersistentVolumeSpec (Maybe V1ObjectReference)
v1PersistentVolumeSpecClaimRefL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecClaimRef -> V1PersistentVolumeSpec { v1PersistentVolumeSpecClaimRef, ..} ) <$> f v1PersistentVolumeSpecClaimRef
{-# INLINE v1PersistentVolumeSpecClaimRefL #-}

-- | 'v1PersistentVolumeSpecCsi' Lens
v1PersistentVolumeSpecCsiL :: Lens_' V1PersistentVolumeSpec (Maybe V1CSIPersistentVolumeSource)
v1PersistentVolumeSpecCsiL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecCsi -> V1PersistentVolumeSpec { v1PersistentVolumeSpecCsi, ..} ) <$> f v1PersistentVolumeSpecCsi
{-# INLINE v1PersistentVolumeSpecCsiL #-}

-- | 'v1PersistentVolumeSpecFc' Lens
v1PersistentVolumeSpecFcL :: Lens_' V1PersistentVolumeSpec (Maybe V1FCVolumeSource)
v1PersistentVolumeSpecFcL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecFc -> V1PersistentVolumeSpec { v1PersistentVolumeSpecFc, ..} ) <$> f v1PersistentVolumeSpecFc
{-# INLINE v1PersistentVolumeSpecFcL #-}

-- | 'v1PersistentVolumeSpecFlexVolume' Lens
v1PersistentVolumeSpecFlexVolumeL :: Lens_' V1PersistentVolumeSpec (Maybe V1FlexPersistentVolumeSource)
v1PersistentVolumeSpecFlexVolumeL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecFlexVolume -> V1PersistentVolumeSpec { v1PersistentVolumeSpecFlexVolume, ..} ) <$> f v1PersistentVolumeSpecFlexVolume
{-# INLINE v1PersistentVolumeSpecFlexVolumeL #-}

-- | 'v1PersistentVolumeSpecFlocker' Lens
v1PersistentVolumeSpecFlockerL :: Lens_' V1PersistentVolumeSpec (Maybe V1FlockerVolumeSource)
v1PersistentVolumeSpecFlockerL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecFlocker -> V1PersistentVolumeSpec { v1PersistentVolumeSpecFlocker, ..} ) <$> f v1PersistentVolumeSpecFlocker
{-# INLINE v1PersistentVolumeSpecFlockerL #-}

-- | 'v1PersistentVolumeSpecGcePersistentDisk' Lens
v1PersistentVolumeSpecGcePersistentDiskL :: Lens_' V1PersistentVolumeSpec (Maybe V1GCEPersistentDiskVolumeSource)
v1PersistentVolumeSpecGcePersistentDiskL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecGcePersistentDisk -> V1PersistentVolumeSpec { v1PersistentVolumeSpecGcePersistentDisk, ..} ) <$> f v1PersistentVolumeSpecGcePersistentDisk
{-# INLINE v1PersistentVolumeSpecGcePersistentDiskL #-}

-- | 'v1PersistentVolumeSpecGlusterfs' Lens
v1PersistentVolumeSpecGlusterfsL :: Lens_' V1PersistentVolumeSpec (Maybe V1GlusterfsPersistentVolumeSource)
v1PersistentVolumeSpecGlusterfsL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecGlusterfs -> V1PersistentVolumeSpec { v1PersistentVolumeSpecGlusterfs, ..} ) <$> f v1PersistentVolumeSpecGlusterfs
{-# INLINE v1PersistentVolumeSpecGlusterfsL #-}

-- | 'v1PersistentVolumeSpecHostPath' Lens
v1PersistentVolumeSpecHostPathL :: Lens_' V1PersistentVolumeSpec (Maybe V1HostPathVolumeSource)
v1PersistentVolumeSpecHostPathL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecHostPath -> V1PersistentVolumeSpec { v1PersistentVolumeSpecHostPath, ..} ) <$> f v1PersistentVolumeSpecHostPath
{-# INLINE v1PersistentVolumeSpecHostPathL #-}

-- | 'v1PersistentVolumeSpecIscsi' Lens
v1PersistentVolumeSpecIscsiL :: Lens_' V1PersistentVolumeSpec (Maybe V1ISCSIPersistentVolumeSource)
v1PersistentVolumeSpecIscsiL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecIscsi -> V1PersistentVolumeSpec { v1PersistentVolumeSpecIscsi, ..} ) <$> f v1PersistentVolumeSpecIscsi
{-# INLINE v1PersistentVolumeSpecIscsiL #-}

-- | 'v1PersistentVolumeSpecLocal' Lens
v1PersistentVolumeSpecLocalL :: Lens_' V1PersistentVolumeSpec (Maybe V1LocalVolumeSource)
v1PersistentVolumeSpecLocalL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecLocal -> V1PersistentVolumeSpec { v1PersistentVolumeSpecLocal, ..} ) <$> f v1PersistentVolumeSpecLocal
{-# INLINE v1PersistentVolumeSpecLocalL #-}

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

-- | 'v1PersistentVolumeSpecNfs' Lens
v1PersistentVolumeSpecNfsL :: Lens_' V1PersistentVolumeSpec (Maybe V1NFSVolumeSource)
v1PersistentVolumeSpecNfsL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecNfs -> V1PersistentVolumeSpec { v1PersistentVolumeSpecNfs, ..} ) <$> f v1PersistentVolumeSpecNfs
{-# INLINE v1PersistentVolumeSpecNfsL #-}

-- | 'v1PersistentVolumeSpecNodeAffinity' Lens
v1PersistentVolumeSpecNodeAffinityL :: Lens_' V1PersistentVolumeSpec (Maybe V1VolumeNodeAffinity)
v1PersistentVolumeSpecNodeAffinityL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecNodeAffinity -> V1PersistentVolumeSpec { v1PersistentVolumeSpecNodeAffinity, ..} ) <$> f v1PersistentVolumeSpecNodeAffinity
{-# INLINE v1PersistentVolumeSpecNodeAffinityL #-}

-- | 'v1PersistentVolumeSpecPersistentVolumeReclaimPolicy' Lens
v1PersistentVolumeSpecPersistentVolumeReclaimPolicyL :: Lens_' V1PersistentVolumeSpec (Maybe Text)
v1PersistentVolumeSpecPersistentVolumeReclaimPolicyL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecPersistentVolumeReclaimPolicy -> V1PersistentVolumeSpec { v1PersistentVolumeSpecPersistentVolumeReclaimPolicy, ..} ) <$> f v1PersistentVolumeSpecPersistentVolumeReclaimPolicy
{-# INLINE v1PersistentVolumeSpecPersistentVolumeReclaimPolicyL #-}

-- | 'v1PersistentVolumeSpecPhotonPersistentDisk' Lens
v1PersistentVolumeSpecPhotonPersistentDiskL :: Lens_' V1PersistentVolumeSpec (Maybe V1PhotonPersistentDiskVolumeSource)
v1PersistentVolumeSpecPhotonPersistentDiskL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecPhotonPersistentDisk -> V1PersistentVolumeSpec { v1PersistentVolumeSpecPhotonPersistentDisk, ..} ) <$> f v1PersistentVolumeSpecPhotonPersistentDisk
{-# INLINE v1PersistentVolumeSpecPhotonPersistentDiskL #-}

-- | 'v1PersistentVolumeSpecPortworxVolume' Lens
v1PersistentVolumeSpecPortworxVolumeL :: Lens_' V1PersistentVolumeSpec (Maybe V1PortworxVolumeSource)
v1PersistentVolumeSpecPortworxVolumeL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecPortworxVolume -> V1PersistentVolumeSpec { v1PersistentVolumeSpecPortworxVolume, ..} ) <$> f v1PersistentVolumeSpecPortworxVolume
{-# INLINE v1PersistentVolumeSpecPortworxVolumeL #-}

-- | 'v1PersistentVolumeSpecQuobyte' Lens
v1PersistentVolumeSpecQuobyteL :: Lens_' V1PersistentVolumeSpec (Maybe V1QuobyteVolumeSource)
v1PersistentVolumeSpecQuobyteL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecQuobyte -> V1PersistentVolumeSpec { v1PersistentVolumeSpecQuobyte, ..} ) <$> f v1PersistentVolumeSpecQuobyte
{-# INLINE v1PersistentVolumeSpecQuobyteL #-}

-- | 'v1PersistentVolumeSpecRbd' Lens
v1PersistentVolumeSpecRbdL :: Lens_' V1PersistentVolumeSpec (Maybe V1RBDPersistentVolumeSource)
v1PersistentVolumeSpecRbdL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecRbd -> V1PersistentVolumeSpec { v1PersistentVolumeSpecRbd, ..} ) <$> f v1PersistentVolumeSpecRbd
{-# INLINE v1PersistentVolumeSpecRbdL #-}

-- | 'v1PersistentVolumeSpecScaleIo' Lens
v1PersistentVolumeSpecScaleIoL :: Lens_' V1PersistentVolumeSpec (Maybe V1ScaleIOPersistentVolumeSource)
v1PersistentVolumeSpecScaleIoL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecScaleIo -> V1PersistentVolumeSpec { v1PersistentVolumeSpecScaleIo, ..} ) <$> f v1PersistentVolumeSpecScaleIo
{-# INLINE v1PersistentVolumeSpecScaleIoL #-}

-- | 'v1PersistentVolumeSpecStorageClassName' Lens
v1PersistentVolumeSpecStorageClassNameL :: Lens_' V1PersistentVolumeSpec (Maybe Text)
v1PersistentVolumeSpecStorageClassNameL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecStorageClassName -> V1PersistentVolumeSpec { v1PersistentVolumeSpecStorageClassName, ..} ) <$> f v1PersistentVolumeSpecStorageClassName
{-# INLINE v1PersistentVolumeSpecStorageClassNameL #-}

-- | 'v1PersistentVolumeSpecStorageos' Lens
v1PersistentVolumeSpecStorageosL :: Lens_' V1PersistentVolumeSpec (Maybe V1StorageOSPersistentVolumeSource)
v1PersistentVolumeSpecStorageosL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecStorageos -> V1PersistentVolumeSpec { v1PersistentVolumeSpecStorageos, ..} ) <$> f v1PersistentVolumeSpecStorageos
{-# INLINE v1PersistentVolumeSpecStorageosL #-}

-- | 'v1PersistentVolumeSpecVolumeMode' Lens
v1PersistentVolumeSpecVolumeModeL :: Lens_' V1PersistentVolumeSpec (Maybe Text)
v1PersistentVolumeSpecVolumeModeL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecVolumeMode -> V1PersistentVolumeSpec { v1PersistentVolumeSpecVolumeMode, ..} ) <$> f v1PersistentVolumeSpecVolumeMode
{-# INLINE v1PersistentVolumeSpecVolumeModeL #-}

-- | 'v1PersistentVolumeSpecVsphereVolume' Lens
v1PersistentVolumeSpecVsphereVolumeL :: Lens_' V1PersistentVolumeSpec (Maybe V1VsphereVirtualDiskVolumeSource)
v1PersistentVolumeSpecVsphereVolumeL f V1PersistentVolumeSpec{..} = (\v1PersistentVolumeSpecVsphereVolume -> V1PersistentVolumeSpec { v1PersistentVolumeSpecVsphereVolume, ..} ) <$> f v1PersistentVolumeSpecVsphereVolume
{-# INLINE v1PersistentVolumeSpecVsphereVolumeL #-}



-- * V1PersistentVolumeStatus

-- | 'v1PersistentVolumeStatusMessage' Lens
v1PersistentVolumeStatusMessageL :: Lens_' V1PersistentVolumeStatus (Maybe Text)
v1PersistentVolumeStatusMessageL f V1PersistentVolumeStatus{..} = (\v1PersistentVolumeStatusMessage -> V1PersistentVolumeStatus { v1PersistentVolumeStatusMessage, ..} ) <$> f v1PersistentVolumeStatusMessage
{-# INLINE v1PersistentVolumeStatusMessageL #-}

-- | 'v1PersistentVolumeStatusPhase' Lens
v1PersistentVolumeStatusPhaseL :: Lens_' V1PersistentVolumeStatus (Maybe Text)
v1PersistentVolumeStatusPhaseL f V1PersistentVolumeStatus{..} = (\v1PersistentVolumeStatusPhase -> V1PersistentVolumeStatus { v1PersistentVolumeStatusPhase, ..} ) <$> f v1PersistentVolumeStatusPhase
{-# INLINE v1PersistentVolumeStatusPhaseL #-}

-- | 'v1PersistentVolumeStatusReason' Lens
v1PersistentVolumeStatusReasonL :: Lens_' V1PersistentVolumeStatus (Maybe Text)
v1PersistentVolumeStatusReasonL f V1PersistentVolumeStatus{..} = (\v1PersistentVolumeStatusReason -> V1PersistentVolumeStatus { v1PersistentVolumeStatusReason, ..} ) <$> f v1PersistentVolumeStatusReason
{-# INLINE v1PersistentVolumeStatusReasonL #-}



-- * V1PhotonPersistentDiskVolumeSource

-- | 'v1PhotonPersistentDiskVolumeSourceFsType' Lens
v1PhotonPersistentDiskVolumeSourceFsTypeL :: Lens_' V1PhotonPersistentDiskVolumeSource (Maybe Text)
v1PhotonPersistentDiskVolumeSourceFsTypeL f V1PhotonPersistentDiskVolumeSource{..} = (\v1PhotonPersistentDiskVolumeSourceFsType -> V1PhotonPersistentDiskVolumeSource { v1PhotonPersistentDiskVolumeSourceFsType, ..} ) <$> f v1PhotonPersistentDiskVolumeSourceFsType
{-# INLINE v1PhotonPersistentDiskVolumeSourceFsTypeL #-}

-- | 'v1PhotonPersistentDiskVolumeSourcePdId' Lens
v1PhotonPersistentDiskVolumeSourcePdIdL :: Lens_' V1PhotonPersistentDiskVolumeSource (Text)
v1PhotonPersistentDiskVolumeSourcePdIdL f V1PhotonPersistentDiskVolumeSource{..} = (\v1PhotonPersistentDiskVolumeSourcePdId -> V1PhotonPersistentDiskVolumeSource { v1PhotonPersistentDiskVolumeSourcePdId, ..} ) <$> f v1PhotonPersistentDiskVolumeSourcePdId
{-# INLINE v1PhotonPersistentDiskVolumeSourcePdIdL #-}



-- * V1Pod

-- | 'v1PodApiVersion' Lens
v1PodApiVersionL :: Lens_' V1Pod (Maybe Text)
v1PodApiVersionL f V1Pod{..} = (\v1PodApiVersion -> V1Pod { v1PodApiVersion, ..} ) <$> f v1PodApiVersion
{-# INLINE v1PodApiVersionL #-}

-- | 'v1PodKind' Lens
v1PodKindL :: Lens_' V1Pod (Maybe Text)
v1PodKindL f V1Pod{..} = (\v1PodKind -> V1Pod { v1PodKind, ..} ) <$> f v1PodKind
{-# INLINE v1PodKindL #-}

-- | 'v1PodMetadata' Lens
v1PodMetadataL :: Lens_' V1Pod (Maybe V1ObjectMeta)
v1PodMetadataL f V1Pod{..} = (\v1PodMetadata -> V1Pod { v1PodMetadata, ..} ) <$> f v1PodMetadata
{-# INLINE v1PodMetadataL #-}

-- | 'v1PodSpec' Lens
v1PodSpecL :: Lens_' V1Pod (Maybe V1PodSpec)
v1PodSpecL f V1Pod{..} = (\v1PodSpec -> V1Pod { v1PodSpec, ..} ) <$> f v1PodSpec
{-# INLINE v1PodSpecL #-}

-- | 'v1PodStatus' Lens
v1PodStatusL :: Lens_' V1Pod (Maybe V1PodStatus)
v1PodStatusL f V1Pod{..} = (\v1PodStatus -> V1Pod { v1PodStatus, ..} ) <$> f v1PodStatus
{-# INLINE v1PodStatusL #-}



-- * V1PodAffinity

-- | 'v1PodAffinityPreferredDuringSchedulingIgnoredDuringExecution' Lens
v1PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionL :: Lens_' V1PodAffinity (Maybe [V1WeightedPodAffinityTerm])
v1PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionL f V1PodAffinity{..} = (\v1PodAffinityPreferredDuringSchedulingIgnoredDuringExecution -> V1PodAffinity { v1PodAffinityPreferredDuringSchedulingIgnoredDuringExecution, ..} ) <$> f v1PodAffinityPreferredDuringSchedulingIgnoredDuringExecution
{-# INLINE v1PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionL #-}

-- | 'v1PodAffinityRequiredDuringSchedulingIgnoredDuringExecution' Lens
v1PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionL :: Lens_' V1PodAffinity (Maybe [V1PodAffinityTerm])
v1PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionL f V1PodAffinity{..} = (\v1PodAffinityRequiredDuringSchedulingIgnoredDuringExecution -> V1PodAffinity { v1PodAffinityRequiredDuringSchedulingIgnoredDuringExecution, ..} ) <$> f v1PodAffinityRequiredDuringSchedulingIgnoredDuringExecution
{-# INLINE v1PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionL #-}



-- * V1PodAffinityTerm

-- | 'v1PodAffinityTermLabelSelector' Lens
v1PodAffinityTermLabelSelectorL :: Lens_' V1PodAffinityTerm (Maybe V1LabelSelector)
v1PodAffinityTermLabelSelectorL f V1PodAffinityTerm{..} = (\v1PodAffinityTermLabelSelector -> V1PodAffinityTerm { v1PodAffinityTermLabelSelector, ..} ) <$> f v1PodAffinityTermLabelSelector
{-# INLINE v1PodAffinityTermLabelSelectorL #-}

-- | 'v1PodAffinityTermNamespaceSelector' Lens
v1PodAffinityTermNamespaceSelectorL :: Lens_' V1PodAffinityTerm (Maybe V1LabelSelector)
v1PodAffinityTermNamespaceSelectorL f V1PodAffinityTerm{..} = (\v1PodAffinityTermNamespaceSelector -> V1PodAffinityTerm { v1PodAffinityTermNamespaceSelector, ..} ) <$> f v1PodAffinityTermNamespaceSelector
{-# INLINE v1PodAffinityTermNamespaceSelectorL #-}

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

-- | 'v1PodAffinityTermTopologyKey' Lens
v1PodAffinityTermTopologyKeyL :: Lens_' V1PodAffinityTerm (Text)
v1PodAffinityTermTopologyKeyL f V1PodAffinityTerm{..} = (\v1PodAffinityTermTopologyKey -> V1PodAffinityTerm { v1PodAffinityTermTopologyKey, ..} ) <$> f v1PodAffinityTermTopologyKey
{-# INLINE v1PodAffinityTermTopologyKeyL #-}



-- * V1PodAntiAffinity

-- | 'v1PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution' Lens
v1PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionL :: Lens_' V1PodAntiAffinity (Maybe [V1WeightedPodAffinityTerm])
v1PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionL f V1PodAntiAffinity{..} = (\v1PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution -> V1PodAntiAffinity { v1PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution, ..} ) <$> f v1PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution
{-# INLINE v1PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionL #-}

-- | 'v1PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution' Lens
v1PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionL :: Lens_' V1PodAntiAffinity (Maybe [V1PodAffinityTerm])
v1PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionL f V1PodAntiAffinity{..} = (\v1PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution -> V1PodAntiAffinity { v1PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution, ..} ) <$> f v1PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution
{-# INLINE v1PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionL #-}



-- * V1PodCondition

-- | 'v1PodConditionLastProbeTime' Lens
v1PodConditionLastProbeTimeL :: Lens_' V1PodCondition (Maybe DateTime)
v1PodConditionLastProbeTimeL f V1PodCondition{..} = (\v1PodConditionLastProbeTime -> V1PodCondition { v1PodConditionLastProbeTime, ..} ) <$> f v1PodConditionLastProbeTime
{-# INLINE v1PodConditionLastProbeTimeL #-}

-- | 'v1PodConditionLastTransitionTime' Lens
v1PodConditionLastTransitionTimeL :: Lens_' V1PodCondition (Maybe DateTime)
v1PodConditionLastTransitionTimeL f V1PodCondition{..} = (\v1PodConditionLastTransitionTime -> V1PodCondition { v1PodConditionLastTransitionTime, ..} ) <$> f v1PodConditionLastTransitionTime
{-# INLINE v1PodConditionLastTransitionTimeL #-}

-- | 'v1PodConditionMessage' Lens
v1PodConditionMessageL :: Lens_' V1PodCondition (Maybe Text)
v1PodConditionMessageL f V1PodCondition{..} = (\v1PodConditionMessage -> V1PodCondition { v1PodConditionMessage, ..} ) <$> f v1PodConditionMessage
{-# INLINE v1PodConditionMessageL #-}

-- | 'v1PodConditionReason' Lens
v1PodConditionReasonL :: Lens_' V1PodCondition (Maybe Text)
v1PodConditionReasonL f V1PodCondition{..} = (\v1PodConditionReason -> V1PodCondition { v1PodConditionReason, ..} ) <$> f v1PodConditionReason
{-# INLINE v1PodConditionReasonL #-}

-- | 'v1PodConditionStatus' Lens
v1PodConditionStatusL :: Lens_' V1PodCondition (Text)
v1PodConditionStatusL f V1PodCondition{..} = (\v1PodConditionStatus -> V1PodCondition { v1PodConditionStatus, ..} ) <$> f v1PodConditionStatus
{-# INLINE v1PodConditionStatusL #-}

-- | 'v1PodConditionType' Lens
v1PodConditionTypeL :: Lens_' V1PodCondition (Text)
v1PodConditionTypeL f V1PodCondition{..} = (\v1PodConditionType -> V1PodCondition { v1PodConditionType, ..} ) <$> f v1PodConditionType
{-# INLINE v1PodConditionTypeL #-}



-- * V1PodDNSConfig

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

-- | 'v1PodDNSConfigOptions' Lens
v1PodDNSConfigOptionsL :: Lens_' V1PodDNSConfig (Maybe [V1PodDNSConfigOption])
v1PodDNSConfigOptionsL f V1PodDNSConfig{..} = (\v1PodDNSConfigOptions -> V1PodDNSConfig { v1PodDNSConfigOptions, ..} ) <$> f v1PodDNSConfigOptions
{-# INLINE v1PodDNSConfigOptionsL #-}

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



-- * V1PodDNSConfigOption

-- | 'v1PodDNSConfigOptionName' Lens
v1PodDNSConfigOptionNameL :: Lens_' V1PodDNSConfigOption (Maybe Text)
v1PodDNSConfigOptionNameL f V1PodDNSConfigOption{..} = (\v1PodDNSConfigOptionName -> V1PodDNSConfigOption { v1PodDNSConfigOptionName, ..} ) <$> f v1PodDNSConfigOptionName
{-# INLINE v1PodDNSConfigOptionNameL #-}

-- | 'v1PodDNSConfigOptionValue' Lens
v1PodDNSConfigOptionValueL :: Lens_' V1PodDNSConfigOption (Maybe Text)
v1PodDNSConfigOptionValueL f V1PodDNSConfigOption{..} = (\v1PodDNSConfigOptionValue -> V1PodDNSConfigOption { v1PodDNSConfigOptionValue, ..} ) <$> f v1PodDNSConfigOptionValue
{-# INLINE v1PodDNSConfigOptionValueL #-}



-- * V1PodDisruptionBudget

-- | 'v1PodDisruptionBudgetApiVersion' Lens
v1PodDisruptionBudgetApiVersionL :: Lens_' V1PodDisruptionBudget (Maybe Text)
v1PodDisruptionBudgetApiVersionL f V1PodDisruptionBudget{..} = (\v1PodDisruptionBudgetApiVersion -> V1PodDisruptionBudget { v1PodDisruptionBudgetApiVersion, ..} ) <$> f v1PodDisruptionBudgetApiVersion
{-# INLINE v1PodDisruptionBudgetApiVersionL #-}

-- | 'v1PodDisruptionBudgetKind' Lens
v1PodDisruptionBudgetKindL :: Lens_' V1PodDisruptionBudget (Maybe Text)
v1PodDisruptionBudgetKindL f V1PodDisruptionBudget{..} = (\v1PodDisruptionBudgetKind -> V1PodDisruptionBudget { v1PodDisruptionBudgetKind, ..} ) <$> f v1PodDisruptionBudgetKind
{-# INLINE v1PodDisruptionBudgetKindL #-}

-- | 'v1PodDisruptionBudgetMetadata' Lens
v1PodDisruptionBudgetMetadataL :: Lens_' V1PodDisruptionBudget (Maybe V1ObjectMeta)
v1PodDisruptionBudgetMetadataL f V1PodDisruptionBudget{..} = (\v1PodDisruptionBudgetMetadata -> V1PodDisruptionBudget { v1PodDisruptionBudgetMetadata, ..} ) <$> f v1PodDisruptionBudgetMetadata
{-# INLINE v1PodDisruptionBudgetMetadataL #-}

-- | 'v1PodDisruptionBudgetSpec' Lens
v1PodDisruptionBudgetSpecL :: Lens_' V1PodDisruptionBudget (Maybe V1PodDisruptionBudgetSpec)
v1PodDisruptionBudgetSpecL f V1PodDisruptionBudget{..} = (\v1PodDisruptionBudgetSpec -> V1PodDisruptionBudget { v1PodDisruptionBudgetSpec, ..} ) <$> f v1PodDisruptionBudgetSpec
{-# INLINE v1PodDisruptionBudgetSpecL #-}

-- | 'v1PodDisruptionBudgetStatus' Lens
v1PodDisruptionBudgetStatusL :: Lens_' V1PodDisruptionBudget (Maybe V1PodDisruptionBudgetStatus)
v1PodDisruptionBudgetStatusL f V1PodDisruptionBudget{..} = (\v1PodDisruptionBudgetStatus -> V1PodDisruptionBudget { v1PodDisruptionBudgetStatus, ..} ) <$> f v1PodDisruptionBudgetStatus
{-# INLINE v1PodDisruptionBudgetStatusL #-}



-- * V1PodDisruptionBudgetList

-- | 'v1PodDisruptionBudgetListApiVersion' Lens
v1PodDisruptionBudgetListApiVersionL :: Lens_' V1PodDisruptionBudgetList (Maybe Text)
v1PodDisruptionBudgetListApiVersionL f V1PodDisruptionBudgetList{..} = (\v1PodDisruptionBudgetListApiVersion -> V1PodDisruptionBudgetList { v1PodDisruptionBudgetListApiVersion, ..} ) <$> f v1PodDisruptionBudgetListApiVersion
{-# INLINE v1PodDisruptionBudgetListApiVersionL #-}

-- | 'v1PodDisruptionBudgetListItems' Lens
v1PodDisruptionBudgetListItemsL :: Lens_' V1PodDisruptionBudgetList ([V1PodDisruptionBudget])
v1PodDisruptionBudgetListItemsL f V1PodDisruptionBudgetList{..} = (\v1PodDisruptionBudgetListItems -> V1PodDisruptionBudgetList { v1PodDisruptionBudgetListItems, ..} ) <$> f v1PodDisruptionBudgetListItems
{-# INLINE v1PodDisruptionBudgetListItemsL #-}

-- | 'v1PodDisruptionBudgetListKind' Lens
v1PodDisruptionBudgetListKindL :: Lens_' V1PodDisruptionBudgetList (Maybe Text)
v1PodDisruptionBudgetListKindL f V1PodDisruptionBudgetList{..} = (\v1PodDisruptionBudgetListKind -> V1PodDisruptionBudgetList { v1PodDisruptionBudgetListKind, ..} ) <$> f v1PodDisruptionBudgetListKind
{-# INLINE v1PodDisruptionBudgetListKindL #-}

-- | 'v1PodDisruptionBudgetListMetadata' Lens
v1PodDisruptionBudgetListMetadataL :: Lens_' V1PodDisruptionBudgetList (Maybe V1ListMeta)
v1PodDisruptionBudgetListMetadataL f V1PodDisruptionBudgetList{..} = (\v1PodDisruptionBudgetListMetadata -> V1PodDisruptionBudgetList { v1PodDisruptionBudgetListMetadata, ..} ) <$> f v1PodDisruptionBudgetListMetadata
{-# INLINE v1PodDisruptionBudgetListMetadataL #-}



-- * V1PodDisruptionBudgetSpec

-- | 'v1PodDisruptionBudgetSpecMaxUnavailable' Lens
v1PodDisruptionBudgetSpecMaxUnavailableL :: Lens_' V1PodDisruptionBudgetSpec (Maybe IntOrString)
v1PodDisruptionBudgetSpecMaxUnavailableL f V1PodDisruptionBudgetSpec{..} = (\v1PodDisruptionBudgetSpecMaxUnavailable -> V1PodDisruptionBudgetSpec { v1PodDisruptionBudgetSpecMaxUnavailable, ..} ) <$> f v1PodDisruptionBudgetSpecMaxUnavailable
{-# INLINE v1PodDisruptionBudgetSpecMaxUnavailableL #-}

-- | 'v1PodDisruptionBudgetSpecMinAvailable' Lens
v1PodDisruptionBudgetSpecMinAvailableL :: Lens_' V1PodDisruptionBudgetSpec (Maybe IntOrString)
v1PodDisruptionBudgetSpecMinAvailableL f V1PodDisruptionBudgetSpec{..} = (\v1PodDisruptionBudgetSpecMinAvailable -> V1PodDisruptionBudgetSpec { v1PodDisruptionBudgetSpecMinAvailable, ..} ) <$> f v1PodDisruptionBudgetSpecMinAvailable
{-# INLINE v1PodDisruptionBudgetSpecMinAvailableL #-}

-- | 'v1PodDisruptionBudgetSpecSelector' Lens
v1PodDisruptionBudgetSpecSelectorL :: Lens_' V1PodDisruptionBudgetSpec (Maybe V1LabelSelector)
v1PodDisruptionBudgetSpecSelectorL f V1PodDisruptionBudgetSpec{..} = (\v1PodDisruptionBudgetSpecSelector -> V1PodDisruptionBudgetSpec { v1PodDisruptionBudgetSpecSelector, ..} ) <$> f v1PodDisruptionBudgetSpecSelector
{-# INLINE v1PodDisruptionBudgetSpecSelectorL #-}



-- * V1PodDisruptionBudgetStatus

-- | 'v1PodDisruptionBudgetStatusConditions' Lens
v1PodDisruptionBudgetStatusConditionsL :: Lens_' V1PodDisruptionBudgetStatus (Maybe [V1Condition])
v1PodDisruptionBudgetStatusConditionsL f V1PodDisruptionBudgetStatus{..} = (\v1PodDisruptionBudgetStatusConditions -> V1PodDisruptionBudgetStatus { v1PodDisruptionBudgetStatusConditions, ..} ) <$> f v1PodDisruptionBudgetStatusConditions
{-# INLINE v1PodDisruptionBudgetStatusConditionsL #-}

-- | 'v1PodDisruptionBudgetStatusCurrentHealthy' Lens
v1PodDisruptionBudgetStatusCurrentHealthyL :: Lens_' V1PodDisruptionBudgetStatus (Int)
v1PodDisruptionBudgetStatusCurrentHealthyL f V1PodDisruptionBudgetStatus{..} = (\v1PodDisruptionBudgetStatusCurrentHealthy -> V1PodDisruptionBudgetStatus { v1PodDisruptionBudgetStatusCurrentHealthy, ..} ) <$> f v1PodDisruptionBudgetStatusCurrentHealthy
{-# INLINE v1PodDisruptionBudgetStatusCurrentHealthyL #-}

-- | 'v1PodDisruptionBudgetStatusDesiredHealthy' Lens
v1PodDisruptionBudgetStatusDesiredHealthyL :: Lens_' V1PodDisruptionBudgetStatus (Int)
v1PodDisruptionBudgetStatusDesiredHealthyL f V1PodDisruptionBudgetStatus{..} = (\v1PodDisruptionBudgetStatusDesiredHealthy -> V1PodDisruptionBudgetStatus { v1PodDisruptionBudgetStatusDesiredHealthy, ..} ) <$> f v1PodDisruptionBudgetStatusDesiredHealthy
{-# INLINE v1PodDisruptionBudgetStatusDesiredHealthyL #-}

-- | 'v1PodDisruptionBudgetStatusDisruptedPods' Lens
v1PodDisruptionBudgetStatusDisruptedPodsL :: Lens_' V1PodDisruptionBudgetStatus (Maybe (Map.Map String DateTime))
v1PodDisruptionBudgetStatusDisruptedPodsL f V1PodDisruptionBudgetStatus{..} = (\v1PodDisruptionBudgetStatusDisruptedPods -> V1PodDisruptionBudgetStatus { v1PodDisruptionBudgetStatusDisruptedPods, ..} ) <$> f v1PodDisruptionBudgetStatusDisruptedPods
{-# INLINE v1PodDisruptionBudgetStatusDisruptedPodsL #-}

-- | 'v1PodDisruptionBudgetStatusDisruptionsAllowed' Lens
v1PodDisruptionBudgetStatusDisruptionsAllowedL :: Lens_' V1PodDisruptionBudgetStatus (Int)
v1PodDisruptionBudgetStatusDisruptionsAllowedL f V1PodDisruptionBudgetStatus{..} = (\v1PodDisruptionBudgetStatusDisruptionsAllowed -> V1PodDisruptionBudgetStatus { v1PodDisruptionBudgetStatusDisruptionsAllowed, ..} ) <$> f v1PodDisruptionBudgetStatusDisruptionsAllowed
{-# INLINE v1PodDisruptionBudgetStatusDisruptionsAllowedL #-}

-- | 'v1PodDisruptionBudgetStatusExpectedPods' Lens
v1PodDisruptionBudgetStatusExpectedPodsL :: Lens_' V1PodDisruptionBudgetStatus (Int)
v1PodDisruptionBudgetStatusExpectedPodsL f V1PodDisruptionBudgetStatus{..} = (\v1PodDisruptionBudgetStatusExpectedPods -> V1PodDisruptionBudgetStatus { v1PodDisruptionBudgetStatusExpectedPods, ..} ) <$> f v1PodDisruptionBudgetStatusExpectedPods
{-# INLINE v1PodDisruptionBudgetStatusExpectedPodsL #-}

-- | 'v1PodDisruptionBudgetStatusObservedGeneration' Lens
v1PodDisruptionBudgetStatusObservedGenerationL :: Lens_' V1PodDisruptionBudgetStatus (Maybe Integer)
v1PodDisruptionBudgetStatusObservedGenerationL f V1PodDisruptionBudgetStatus{..} = (\v1PodDisruptionBudgetStatusObservedGeneration -> V1PodDisruptionBudgetStatus { v1PodDisruptionBudgetStatusObservedGeneration, ..} ) <$> f v1PodDisruptionBudgetStatusObservedGeneration
{-# INLINE v1PodDisruptionBudgetStatusObservedGenerationL #-}



-- * V1PodIP

-- | 'v1PodIPIp' Lens
v1PodIPIpL :: Lens_' V1PodIP (Maybe Text)
v1PodIPIpL f V1PodIP{..} = (\v1PodIPIp -> V1PodIP { v1PodIPIp, ..} ) <$> f v1PodIPIp
{-# INLINE v1PodIPIpL #-}



-- * V1PodList

-- | 'v1PodListApiVersion' Lens
v1PodListApiVersionL :: Lens_' V1PodList (Maybe Text)
v1PodListApiVersionL f V1PodList{..} = (\v1PodListApiVersion -> V1PodList { v1PodListApiVersion, ..} ) <$> f v1PodListApiVersion
{-# INLINE v1PodListApiVersionL #-}

-- | 'v1PodListItems' Lens
v1PodListItemsL :: Lens_' V1PodList ([V1Pod])
v1PodListItemsL f V1PodList{..} = (\v1PodListItems -> V1PodList { v1PodListItems, ..} ) <$> f v1PodListItems
{-# INLINE v1PodListItemsL #-}

-- | 'v1PodListKind' Lens
v1PodListKindL :: Lens_' V1PodList (Maybe Text)
v1PodListKindL f V1PodList{..} = (\v1PodListKind -> V1PodList { v1PodListKind, ..} ) <$> f v1PodListKind
{-# INLINE v1PodListKindL #-}

-- | 'v1PodListMetadata' Lens
v1PodListMetadataL :: Lens_' V1PodList (Maybe V1ListMeta)
v1PodListMetadataL f V1PodList{..} = (\v1PodListMetadata -> V1PodList { v1PodListMetadata, ..} ) <$> f v1PodListMetadata
{-# INLINE v1PodListMetadataL #-}



-- * V1PodOS

-- | 'v1PodOSName' Lens
v1PodOSNameL :: Lens_' V1PodOS (Text)
v1PodOSNameL f V1PodOS{..} = (\v1PodOSName -> V1PodOS { v1PodOSName, ..} ) <$> f v1PodOSName
{-# INLINE v1PodOSNameL #-}



-- * V1PodReadinessGate

-- | 'v1PodReadinessGateConditionType' Lens
v1PodReadinessGateConditionTypeL :: Lens_' V1PodReadinessGate (Text)
v1PodReadinessGateConditionTypeL f V1PodReadinessGate{..} = (\v1PodReadinessGateConditionType -> V1PodReadinessGate { v1PodReadinessGateConditionType, ..} ) <$> f v1PodReadinessGateConditionType
{-# INLINE v1PodReadinessGateConditionTypeL #-}



-- * V1PodSecurityContext

-- | 'v1PodSecurityContextFsGroup' Lens
v1PodSecurityContextFsGroupL :: Lens_' V1PodSecurityContext (Maybe Integer)
v1PodSecurityContextFsGroupL f V1PodSecurityContext{..} = (\v1PodSecurityContextFsGroup -> V1PodSecurityContext { v1PodSecurityContextFsGroup, ..} ) <$> f v1PodSecurityContextFsGroup
{-# INLINE v1PodSecurityContextFsGroupL #-}

-- | 'v1PodSecurityContextFsGroupChangePolicy' Lens
v1PodSecurityContextFsGroupChangePolicyL :: Lens_' V1PodSecurityContext (Maybe Text)
v1PodSecurityContextFsGroupChangePolicyL f V1PodSecurityContext{..} = (\v1PodSecurityContextFsGroupChangePolicy -> V1PodSecurityContext { v1PodSecurityContextFsGroupChangePolicy, ..} ) <$> f v1PodSecurityContextFsGroupChangePolicy
{-# INLINE v1PodSecurityContextFsGroupChangePolicyL #-}

-- | 'v1PodSecurityContextRunAsGroup' Lens
v1PodSecurityContextRunAsGroupL :: Lens_' V1PodSecurityContext (Maybe Integer)
v1PodSecurityContextRunAsGroupL f V1PodSecurityContext{..} = (\v1PodSecurityContextRunAsGroup -> V1PodSecurityContext { v1PodSecurityContextRunAsGroup, ..} ) <$> f v1PodSecurityContextRunAsGroup
{-# INLINE v1PodSecurityContextRunAsGroupL #-}

-- | 'v1PodSecurityContextRunAsNonRoot' Lens
v1PodSecurityContextRunAsNonRootL :: Lens_' V1PodSecurityContext (Maybe Bool)
v1PodSecurityContextRunAsNonRootL f V1PodSecurityContext{..} = (\v1PodSecurityContextRunAsNonRoot -> V1PodSecurityContext { v1PodSecurityContextRunAsNonRoot, ..} ) <$> f v1PodSecurityContextRunAsNonRoot
{-# INLINE v1PodSecurityContextRunAsNonRootL #-}

-- | 'v1PodSecurityContextRunAsUser' Lens
v1PodSecurityContextRunAsUserL :: Lens_' V1PodSecurityContext (Maybe Integer)
v1PodSecurityContextRunAsUserL f V1PodSecurityContext{..} = (\v1PodSecurityContextRunAsUser -> V1PodSecurityContext { v1PodSecurityContextRunAsUser, ..} ) <$> f v1PodSecurityContextRunAsUser
{-# INLINE v1PodSecurityContextRunAsUserL #-}

-- | 'v1PodSecurityContextSeLinuxOptions' Lens
v1PodSecurityContextSeLinuxOptionsL :: Lens_' V1PodSecurityContext (Maybe V1SELinuxOptions)
v1PodSecurityContextSeLinuxOptionsL f V1PodSecurityContext{..} = (\v1PodSecurityContextSeLinuxOptions -> V1PodSecurityContext { v1PodSecurityContextSeLinuxOptions, ..} ) <$> f v1PodSecurityContextSeLinuxOptions
{-# INLINE v1PodSecurityContextSeLinuxOptionsL #-}

-- | 'v1PodSecurityContextSeccompProfile' Lens
v1PodSecurityContextSeccompProfileL :: Lens_' V1PodSecurityContext (Maybe V1SeccompProfile)
v1PodSecurityContextSeccompProfileL f V1PodSecurityContext{..} = (\v1PodSecurityContextSeccompProfile -> V1PodSecurityContext { v1PodSecurityContextSeccompProfile, ..} ) <$> f v1PodSecurityContextSeccompProfile
{-# INLINE v1PodSecurityContextSeccompProfileL #-}

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

-- | 'v1PodSecurityContextSysctls' Lens
v1PodSecurityContextSysctlsL :: Lens_' V1PodSecurityContext (Maybe [V1Sysctl])
v1PodSecurityContextSysctlsL f V1PodSecurityContext{..} = (\v1PodSecurityContextSysctls -> V1PodSecurityContext { v1PodSecurityContextSysctls, ..} ) <$> f v1PodSecurityContextSysctls
{-# INLINE v1PodSecurityContextSysctlsL #-}

-- | 'v1PodSecurityContextWindowsOptions' Lens
v1PodSecurityContextWindowsOptionsL :: Lens_' V1PodSecurityContext (Maybe V1WindowsSecurityContextOptions)
v1PodSecurityContextWindowsOptionsL f V1PodSecurityContext{..} = (\v1PodSecurityContextWindowsOptions -> V1PodSecurityContext { v1PodSecurityContextWindowsOptions, ..} ) <$> f v1PodSecurityContextWindowsOptions
{-# INLINE v1PodSecurityContextWindowsOptionsL #-}



-- * V1PodSpec

-- | 'v1PodSpecActiveDeadlineSeconds' Lens
v1PodSpecActiveDeadlineSecondsL :: Lens_' V1PodSpec (Maybe Integer)
v1PodSpecActiveDeadlineSecondsL f V1PodSpec{..} = (\v1PodSpecActiveDeadlineSeconds -> V1PodSpec { v1PodSpecActiveDeadlineSeconds, ..} ) <$> f v1PodSpecActiveDeadlineSeconds
{-# INLINE v1PodSpecActiveDeadlineSecondsL #-}

-- | 'v1PodSpecAffinity' Lens
v1PodSpecAffinityL :: Lens_' V1PodSpec (Maybe V1Affinity)
v1PodSpecAffinityL f V1PodSpec{..} = (\v1PodSpecAffinity -> V1PodSpec { v1PodSpecAffinity, ..} ) <$> f v1PodSpecAffinity
{-# INLINE v1PodSpecAffinityL #-}

-- | 'v1PodSpecAutomountServiceAccountToken' Lens
v1PodSpecAutomountServiceAccountTokenL :: Lens_' V1PodSpec (Maybe Bool)
v1PodSpecAutomountServiceAccountTokenL f V1PodSpec{..} = (\v1PodSpecAutomountServiceAccountToken -> V1PodSpec { v1PodSpecAutomountServiceAccountToken, ..} ) <$> f v1PodSpecAutomountServiceAccountToken
{-# INLINE v1PodSpecAutomountServiceAccountTokenL #-}

-- | 'v1PodSpecContainers' Lens
v1PodSpecContainersL :: Lens_' V1PodSpec ([V1Container])
v1PodSpecContainersL f V1PodSpec{..} = (\v1PodSpecContainers -> V1PodSpec { v1PodSpecContainers, ..} ) <$> f v1PodSpecContainers
{-# INLINE v1PodSpecContainersL #-}

-- | 'v1PodSpecDnsConfig' Lens
v1PodSpecDnsConfigL :: Lens_' V1PodSpec (Maybe V1PodDNSConfig)
v1PodSpecDnsConfigL f V1PodSpec{..} = (\v1PodSpecDnsConfig -> V1PodSpec { v1PodSpecDnsConfig, ..} ) <$> f v1PodSpecDnsConfig
{-# INLINE v1PodSpecDnsConfigL #-}

-- | 'v1PodSpecDnsPolicy' Lens
v1PodSpecDnsPolicyL :: Lens_' V1PodSpec (Maybe Text)
v1PodSpecDnsPolicyL f V1PodSpec{..} = (\v1PodSpecDnsPolicy -> V1PodSpec { v1PodSpecDnsPolicy, ..} ) <$> f v1PodSpecDnsPolicy
{-# INLINE v1PodSpecDnsPolicyL #-}

-- | 'v1PodSpecEnableServiceLinks' Lens
v1PodSpecEnableServiceLinksL :: Lens_' V1PodSpec (Maybe Bool)
v1PodSpecEnableServiceLinksL f V1PodSpec{..} = (\v1PodSpecEnableServiceLinks -> V1PodSpec { v1PodSpecEnableServiceLinks, ..} ) <$> f v1PodSpecEnableServiceLinks
{-# INLINE v1PodSpecEnableServiceLinksL #-}

-- | 'v1PodSpecEphemeralContainers' Lens
v1PodSpecEphemeralContainersL :: Lens_' V1PodSpec (Maybe [V1EphemeralContainer])
v1PodSpecEphemeralContainersL f V1PodSpec{..} = (\v1PodSpecEphemeralContainers -> V1PodSpec { v1PodSpecEphemeralContainers, ..} ) <$> f v1PodSpecEphemeralContainers
{-# INLINE v1PodSpecEphemeralContainersL #-}

-- | 'v1PodSpecHostAliases' Lens
v1PodSpecHostAliasesL :: Lens_' V1PodSpec (Maybe [V1HostAlias])
v1PodSpecHostAliasesL f V1PodSpec{..} = (\v1PodSpecHostAliases -> V1PodSpec { v1PodSpecHostAliases, ..} ) <$> f v1PodSpecHostAliases
{-# INLINE v1PodSpecHostAliasesL #-}

-- | 'v1PodSpecHostIpc' Lens
v1PodSpecHostIpcL :: Lens_' V1PodSpec (Maybe Bool)
v1PodSpecHostIpcL f V1PodSpec{..} = (\v1PodSpecHostIpc -> V1PodSpec { v1PodSpecHostIpc, ..} ) <$> f v1PodSpecHostIpc
{-# INLINE v1PodSpecHostIpcL #-}

-- | 'v1PodSpecHostNetwork' Lens
v1PodSpecHostNetworkL :: Lens_' V1PodSpec (Maybe Bool)
v1PodSpecHostNetworkL f V1PodSpec{..} = (\v1PodSpecHostNetwork -> V1PodSpec { v1PodSpecHostNetwork, ..} ) <$> f v1PodSpecHostNetwork
{-# INLINE v1PodSpecHostNetworkL #-}

-- | 'v1PodSpecHostPid' Lens
v1PodSpecHostPidL :: Lens_' V1PodSpec (Maybe Bool)
v1PodSpecHostPidL f V1PodSpec{..} = (\v1PodSpecHostPid -> V1PodSpec { v1PodSpecHostPid, ..} ) <$> f v1PodSpecHostPid
{-# INLINE v1PodSpecHostPidL #-}

-- | 'v1PodSpecHostname' Lens
v1PodSpecHostnameL :: Lens_' V1PodSpec (Maybe Text)
v1PodSpecHostnameL f V1PodSpec{..} = (\v1PodSpecHostname -> V1PodSpec { v1PodSpecHostname, ..} ) <$> f v1PodSpecHostname
{-# INLINE v1PodSpecHostnameL #-}

-- | 'v1PodSpecImagePullSecrets' Lens
v1PodSpecImagePullSecretsL :: Lens_' V1PodSpec (Maybe [V1LocalObjectReference])
v1PodSpecImagePullSecretsL f V1PodSpec{..} = (\v1PodSpecImagePullSecrets -> V1PodSpec { v1PodSpecImagePullSecrets, ..} ) <$> f v1PodSpecImagePullSecrets
{-# INLINE v1PodSpecImagePullSecretsL #-}

-- | 'v1PodSpecInitContainers' Lens
v1PodSpecInitContainersL :: Lens_' V1PodSpec (Maybe [V1Container])
v1PodSpecInitContainersL f V1PodSpec{..} = (\v1PodSpecInitContainers -> V1PodSpec { v1PodSpecInitContainers, ..} ) <$> f v1PodSpecInitContainers
{-# INLINE v1PodSpecInitContainersL #-}

-- | 'v1PodSpecNodeName' Lens
v1PodSpecNodeNameL :: Lens_' V1PodSpec (Maybe Text)
v1PodSpecNodeNameL f V1PodSpec{..} = (\v1PodSpecNodeName -> V1PodSpec { v1PodSpecNodeName, ..} ) <$> f v1PodSpecNodeName
{-# INLINE v1PodSpecNodeNameL #-}

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

-- | 'v1PodSpecOs' Lens
v1PodSpecOsL :: Lens_' V1PodSpec (Maybe V1PodOS)
v1PodSpecOsL f V1PodSpec{..} = (\v1PodSpecOs -> V1PodSpec { v1PodSpecOs, ..} ) <$> f v1PodSpecOs
{-# INLINE v1PodSpecOsL #-}

-- | 'v1PodSpecOverhead' Lens
v1PodSpecOverheadL :: Lens_' V1PodSpec (Maybe (Map.Map String Quantity))
v1PodSpecOverheadL f V1PodSpec{..} = (\v1PodSpecOverhead -> V1PodSpec { v1PodSpecOverhead, ..} ) <$> f v1PodSpecOverhead
{-# INLINE v1PodSpecOverheadL #-}

-- | 'v1PodSpecPreemptionPolicy' Lens
v1PodSpecPreemptionPolicyL :: Lens_' V1PodSpec (Maybe Text)
v1PodSpecPreemptionPolicyL f V1PodSpec{..} = (\v1PodSpecPreemptionPolicy -> V1PodSpec { v1PodSpecPreemptionPolicy, ..} ) <$> f v1PodSpecPreemptionPolicy
{-# INLINE v1PodSpecPreemptionPolicyL #-}

-- | 'v1PodSpecPriority' Lens
v1PodSpecPriorityL :: Lens_' V1PodSpec (Maybe Int)
v1PodSpecPriorityL f V1PodSpec{..} = (\v1PodSpecPriority -> V1PodSpec { v1PodSpecPriority, ..} ) <$> f v1PodSpecPriority
{-# INLINE v1PodSpecPriorityL #-}

-- | 'v1PodSpecPriorityClassName' Lens
v1PodSpecPriorityClassNameL :: Lens_' V1PodSpec (Maybe Text)
v1PodSpecPriorityClassNameL f V1PodSpec{..} = (\v1PodSpecPriorityClassName -> V1PodSpec { v1PodSpecPriorityClassName, ..} ) <$> f v1PodSpecPriorityClassName
{-# INLINE v1PodSpecPriorityClassNameL #-}

-- | 'v1PodSpecReadinessGates' Lens
v1PodSpecReadinessGatesL :: Lens_' V1PodSpec (Maybe [V1PodReadinessGate])
v1PodSpecReadinessGatesL f V1PodSpec{..} = (\v1PodSpecReadinessGates -> V1PodSpec { v1PodSpecReadinessGates, ..} ) <$> f v1PodSpecReadinessGates
{-# INLINE v1PodSpecReadinessGatesL #-}

-- | 'v1PodSpecRestartPolicy' Lens
v1PodSpecRestartPolicyL :: Lens_' V1PodSpec (Maybe Text)
v1PodSpecRestartPolicyL f V1PodSpec{..} = (\v1PodSpecRestartPolicy -> V1PodSpec { v1PodSpecRestartPolicy, ..} ) <$> f v1PodSpecRestartPolicy
{-# INLINE v1PodSpecRestartPolicyL #-}

-- | 'v1PodSpecRuntimeClassName' Lens
v1PodSpecRuntimeClassNameL :: Lens_' V1PodSpec (Maybe Text)
v1PodSpecRuntimeClassNameL f V1PodSpec{..} = (\v1PodSpecRuntimeClassName -> V1PodSpec { v1PodSpecRuntimeClassName, ..} ) <$> f v1PodSpecRuntimeClassName
{-# INLINE v1PodSpecRuntimeClassNameL #-}

-- | 'v1PodSpecSchedulerName' Lens
v1PodSpecSchedulerNameL :: Lens_' V1PodSpec (Maybe Text)
v1PodSpecSchedulerNameL f V1PodSpec{..} = (\v1PodSpecSchedulerName -> V1PodSpec { v1PodSpecSchedulerName, ..} ) <$> f v1PodSpecSchedulerName
{-# INLINE v1PodSpecSchedulerNameL #-}

-- | 'v1PodSpecSecurityContext' Lens
v1PodSpecSecurityContextL :: Lens_' V1PodSpec (Maybe V1PodSecurityContext)
v1PodSpecSecurityContextL f V1PodSpec{..} = (\v1PodSpecSecurityContext -> V1PodSpec { v1PodSpecSecurityContext, ..} ) <$> f v1PodSpecSecurityContext
{-# INLINE v1PodSpecSecurityContextL #-}

-- | 'v1PodSpecServiceAccount' Lens
v1PodSpecServiceAccountL :: Lens_' V1PodSpec (Maybe Text)
v1PodSpecServiceAccountL f V1PodSpec{..} = (\v1PodSpecServiceAccount -> V1PodSpec { v1PodSpecServiceAccount, ..} ) <$> f v1PodSpecServiceAccount
{-# INLINE v1PodSpecServiceAccountL #-}

-- | 'v1PodSpecServiceAccountName' Lens
v1PodSpecServiceAccountNameL :: Lens_' V1PodSpec (Maybe Text)
v1PodSpecServiceAccountNameL f V1PodSpec{..} = (\v1PodSpecServiceAccountName -> V1PodSpec { v1PodSpecServiceAccountName, ..} ) <$> f v1PodSpecServiceAccountName
{-# INLINE v1PodSpecServiceAccountNameL #-}

-- | 'v1PodSpecSetHostnameAsFqdn' Lens
v1PodSpecSetHostnameAsFqdnL :: Lens_' V1PodSpec (Maybe Bool)
v1PodSpecSetHostnameAsFqdnL f V1PodSpec{..} = (\v1PodSpecSetHostnameAsFqdn -> V1PodSpec { v1PodSpecSetHostnameAsFqdn, ..} ) <$> f v1PodSpecSetHostnameAsFqdn
{-# INLINE v1PodSpecSetHostnameAsFqdnL #-}

-- | 'v1PodSpecShareProcessNamespace' Lens
v1PodSpecShareProcessNamespaceL :: Lens_' V1PodSpec (Maybe Bool)
v1PodSpecShareProcessNamespaceL f V1PodSpec{..} = (\v1PodSpecShareProcessNamespace -> V1PodSpec { v1PodSpecShareProcessNamespace, ..} ) <$> f v1PodSpecShareProcessNamespace
{-# INLINE v1PodSpecShareProcessNamespaceL #-}

-- | 'v1PodSpecSubdomain' Lens
v1PodSpecSubdomainL :: Lens_' V1PodSpec (Maybe Text)
v1PodSpecSubdomainL f V1PodSpec{..} = (\v1PodSpecSubdomain -> V1PodSpec { v1PodSpecSubdomain, ..} ) <$> f v1PodSpecSubdomain
{-# INLINE v1PodSpecSubdomainL #-}

-- | 'v1PodSpecTerminationGracePeriodSeconds' Lens
v1PodSpecTerminationGracePeriodSecondsL :: Lens_' V1PodSpec (Maybe Integer)
v1PodSpecTerminationGracePeriodSecondsL f V1PodSpec{..} = (\v1PodSpecTerminationGracePeriodSeconds -> V1PodSpec { v1PodSpecTerminationGracePeriodSeconds, ..} ) <$> f v1PodSpecTerminationGracePeriodSeconds
{-# INLINE v1PodSpecTerminationGracePeriodSecondsL #-}

-- | 'v1PodSpecTolerations' Lens
v1PodSpecTolerationsL :: Lens_' V1PodSpec (Maybe [V1Toleration])
v1PodSpecTolerationsL f V1PodSpec{..} = (\v1PodSpecTolerations -> V1PodSpec { v1PodSpecTolerations, ..} ) <$> f v1PodSpecTolerations
{-# INLINE v1PodSpecTolerationsL #-}

-- | 'v1PodSpecTopologySpreadConstraints' Lens
v1PodSpecTopologySpreadConstraintsL :: Lens_' V1PodSpec (Maybe [V1TopologySpreadConstraint])
v1PodSpecTopologySpreadConstraintsL f V1PodSpec{..} = (\v1PodSpecTopologySpreadConstraints -> V1PodSpec { v1PodSpecTopologySpreadConstraints, ..} ) <$> f v1PodSpecTopologySpreadConstraints
{-# INLINE v1PodSpecTopologySpreadConstraintsL #-}

-- | 'v1PodSpecVolumes' Lens
v1PodSpecVolumesL :: Lens_' V1PodSpec (Maybe [V1Volume])
v1PodSpecVolumesL f V1PodSpec{..} = (\v1PodSpecVolumes -> V1PodSpec { v1PodSpecVolumes, ..} ) <$> f v1PodSpecVolumes
{-# INLINE v1PodSpecVolumesL #-}



-- * V1PodStatus

-- | 'v1PodStatusConditions' Lens
v1PodStatusConditionsL :: Lens_' V1PodStatus (Maybe [V1PodCondition])
v1PodStatusConditionsL f V1PodStatus{..} = (\v1PodStatusConditions -> V1PodStatus { v1PodStatusConditions, ..} ) <$> f v1PodStatusConditions
{-# INLINE v1PodStatusConditionsL #-}

-- | 'v1PodStatusContainerStatuses' Lens
v1PodStatusContainerStatusesL :: Lens_' V1PodStatus (Maybe [V1ContainerStatus])
v1PodStatusContainerStatusesL f V1PodStatus{..} = (\v1PodStatusContainerStatuses -> V1PodStatus { v1PodStatusContainerStatuses, ..} ) <$> f v1PodStatusContainerStatuses
{-# INLINE v1PodStatusContainerStatusesL #-}

-- | 'v1PodStatusEphemeralContainerStatuses' Lens
v1PodStatusEphemeralContainerStatusesL :: Lens_' V1PodStatus (Maybe [V1ContainerStatus])
v1PodStatusEphemeralContainerStatusesL f V1PodStatus{..} = (\v1PodStatusEphemeralContainerStatuses -> V1PodStatus { v1PodStatusEphemeralContainerStatuses, ..} ) <$> f v1PodStatusEphemeralContainerStatuses
{-# INLINE v1PodStatusEphemeralContainerStatusesL #-}

-- | 'v1PodStatusHostIp' Lens
v1PodStatusHostIpL :: Lens_' V1PodStatus (Maybe Text)
v1PodStatusHostIpL f V1PodStatus{..} = (\v1PodStatusHostIp -> V1PodStatus { v1PodStatusHostIp, ..} ) <$> f v1PodStatusHostIp
{-# INLINE v1PodStatusHostIpL #-}

-- | 'v1PodStatusInitContainerStatuses' Lens
v1PodStatusInitContainerStatusesL :: Lens_' V1PodStatus (Maybe [V1ContainerStatus])
v1PodStatusInitContainerStatusesL f V1PodStatus{..} = (\v1PodStatusInitContainerStatuses -> V1PodStatus { v1PodStatusInitContainerStatuses, ..} ) <$> f v1PodStatusInitContainerStatuses
{-# INLINE v1PodStatusInitContainerStatusesL #-}

-- | 'v1PodStatusMessage' Lens
v1PodStatusMessageL :: Lens_' V1PodStatus (Maybe Text)
v1PodStatusMessageL f V1PodStatus{..} = (\v1PodStatusMessage -> V1PodStatus { v1PodStatusMessage, ..} ) <$> f v1PodStatusMessage
{-# INLINE v1PodStatusMessageL #-}

-- | 'v1PodStatusNominatedNodeName' Lens
v1PodStatusNominatedNodeNameL :: Lens_' V1PodStatus (Maybe Text)
v1PodStatusNominatedNodeNameL f V1PodStatus{..} = (\v1PodStatusNominatedNodeName -> V1PodStatus { v1PodStatusNominatedNodeName, ..} ) <$> f v1PodStatusNominatedNodeName
{-# INLINE v1PodStatusNominatedNodeNameL #-}

-- | 'v1PodStatusPhase' Lens
v1PodStatusPhaseL :: Lens_' V1PodStatus (Maybe Text)
v1PodStatusPhaseL f V1PodStatus{..} = (\v1PodStatusPhase -> V1PodStatus { v1PodStatusPhase, ..} ) <$> f v1PodStatusPhase
{-# INLINE v1PodStatusPhaseL #-}

-- | 'v1PodStatusPodIp' Lens
v1PodStatusPodIpL :: Lens_' V1PodStatus (Maybe Text)
v1PodStatusPodIpL f V1PodStatus{..} = (\v1PodStatusPodIp -> V1PodStatus { v1PodStatusPodIp, ..} ) <$> f v1PodStatusPodIp
{-# INLINE v1PodStatusPodIpL #-}

-- | 'v1PodStatusPodIps' Lens
v1PodStatusPodIpsL :: Lens_' V1PodStatus (Maybe [V1PodIP])
v1PodStatusPodIpsL f V1PodStatus{..} = (\v1PodStatusPodIps -> V1PodStatus { v1PodStatusPodIps, ..} ) <$> f v1PodStatusPodIps
{-# INLINE v1PodStatusPodIpsL #-}

-- | 'v1PodStatusQosClass' Lens
v1PodStatusQosClassL :: Lens_' V1PodStatus (Maybe Text)
v1PodStatusQosClassL f V1PodStatus{..} = (\v1PodStatusQosClass -> V1PodStatus { v1PodStatusQosClass, ..} ) <$> f v1PodStatusQosClass
{-# INLINE v1PodStatusQosClassL #-}

-- | 'v1PodStatusReason' Lens
v1PodStatusReasonL :: Lens_' V1PodStatus (Maybe Text)
v1PodStatusReasonL f V1PodStatus{..} = (\v1PodStatusReason -> V1PodStatus { v1PodStatusReason, ..} ) <$> f v1PodStatusReason
{-# INLINE v1PodStatusReasonL #-}

-- | 'v1PodStatusStartTime' Lens
v1PodStatusStartTimeL :: Lens_' V1PodStatus (Maybe DateTime)
v1PodStatusStartTimeL f V1PodStatus{..} = (\v1PodStatusStartTime -> V1PodStatus { v1PodStatusStartTime, ..} ) <$> f v1PodStatusStartTime
{-# INLINE v1PodStatusStartTimeL #-}



-- * V1PodTemplate

-- | 'v1PodTemplateApiVersion' Lens
v1PodTemplateApiVersionL :: Lens_' V1PodTemplate (Maybe Text)
v1PodTemplateApiVersionL f V1PodTemplate{..} = (\v1PodTemplateApiVersion -> V1PodTemplate { v1PodTemplateApiVersion, ..} ) <$> f v1PodTemplateApiVersion
{-# INLINE v1PodTemplateApiVersionL #-}

-- | 'v1PodTemplateKind' Lens
v1PodTemplateKindL :: Lens_' V1PodTemplate (Maybe Text)
v1PodTemplateKindL f V1PodTemplate{..} = (\v1PodTemplateKind -> V1PodTemplate { v1PodTemplateKind, ..} ) <$> f v1PodTemplateKind
{-# INLINE v1PodTemplateKindL #-}

-- | 'v1PodTemplateMetadata' Lens
v1PodTemplateMetadataL :: Lens_' V1PodTemplate (Maybe V1ObjectMeta)
v1PodTemplateMetadataL f V1PodTemplate{..} = (\v1PodTemplateMetadata -> V1PodTemplate { v1PodTemplateMetadata, ..} ) <$> f v1PodTemplateMetadata
{-# INLINE v1PodTemplateMetadataL #-}

-- | 'v1PodTemplateTemplate' Lens
v1PodTemplateTemplateL :: Lens_' V1PodTemplate (Maybe V1PodTemplateSpec)
v1PodTemplateTemplateL f V1PodTemplate{..} = (\v1PodTemplateTemplate -> V1PodTemplate { v1PodTemplateTemplate, ..} ) <$> f v1PodTemplateTemplate
{-# INLINE v1PodTemplateTemplateL #-}



-- * V1PodTemplateList

-- | 'v1PodTemplateListApiVersion' Lens
v1PodTemplateListApiVersionL :: Lens_' V1PodTemplateList (Maybe Text)
v1PodTemplateListApiVersionL f V1PodTemplateList{..} = (\v1PodTemplateListApiVersion -> V1PodTemplateList { v1PodTemplateListApiVersion, ..} ) <$> f v1PodTemplateListApiVersion
{-# INLINE v1PodTemplateListApiVersionL #-}

-- | 'v1PodTemplateListItems' Lens
v1PodTemplateListItemsL :: Lens_' V1PodTemplateList ([V1PodTemplate])
v1PodTemplateListItemsL f V1PodTemplateList{..} = (\v1PodTemplateListItems -> V1PodTemplateList { v1PodTemplateListItems, ..} ) <$> f v1PodTemplateListItems
{-# INLINE v1PodTemplateListItemsL #-}

-- | 'v1PodTemplateListKind' Lens
v1PodTemplateListKindL :: Lens_' V1PodTemplateList (Maybe Text)
v1PodTemplateListKindL f V1PodTemplateList{..} = (\v1PodTemplateListKind -> V1PodTemplateList { v1PodTemplateListKind, ..} ) <$> f v1PodTemplateListKind
{-# INLINE v1PodTemplateListKindL #-}

-- | 'v1PodTemplateListMetadata' Lens
v1PodTemplateListMetadataL :: Lens_' V1PodTemplateList (Maybe V1ListMeta)
v1PodTemplateListMetadataL f V1PodTemplateList{..} = (\v1PodTemplateListMetadata -> V1PodTemplateList { v1PodTemplateListMetadata, ..} ) <$> f v1PodTemplateListMetadata
{-# INLINE v1PodTemplateListMetadataL #-}



-- * V1PodTemplateSpec

-- | 'v1PodTemplateSpecMetadata' Lens
v1PodTemplateSpecMetadataL :: Lens_' V1PodTemplateSpec (Maybe V1ObjectMeta)
v1PodTemplateSpecMetadataL f V1PodTemplateSpec{..} = (\v1PodTemplateSpecMetadata -> V1PodTemplateSpec { v1PodTemplateSpecMetadata, ..} ) <$> f v1PodTemplateSpecMetadata
{-# INLINE v1PodTemplateSpecMetadataL #-}

-- | 'v1PodTemplateSpecSpec' Lens
v1PodTemplateSpecSpecL :: Lens_' V1PodTemplateSpec (Maybe V1PodSpec)
v1PodTemplateSpecSpecL f V1PodTemplateSpec{..} = (\v1PodTemplateSpecSpec -> V1PodTemplateSpec { v1PodTemplateSpecSpec, ..} ) <$> f v1PodTemplateSpecSpec
{-# INLINE v1PodTemplateSpecSpecL #-}



-- * V1PolicyRule

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

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

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

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

-- | 'v1PolicyRuleVerbs' Lens
v1PolicyRuleVerbsL :: Lens_' V1PolicyRule ([Text])
v1PolicyRuleVerbsL f V1PolicyRule{..} = (\v1PolicyRuleVerbs -> V1PolicyRule { v1PolicyRuleVerbs, ..} ) <$> f v1PolicyRuleVerbs
{-# INLINE v1PolicyRuleVerbsL #-}



-- * V1PortStatus

-- | 'v1PortStatusError' Lens
v1PortStatusErrorL :: Lens_' V1PortStatus (Maybe Text)
v1PortStatusErrorL f V1PortStatus{..} = (\v1PortStatusError -> V1PortStatus { v1PortStatusError, ..} ) <$> f v1PortStatusError
{-# INLINE v1PortStatusErrorL #-}

-- | 'v1PortStatusPort' Lens
v1PortStatusPortL :: Lens_' V1PortStatus (Int)
v1PortStatusPortL f V1PortStatus{..} = (\v1PortStatusPort -> V1PortStatus { v1PortStatusPort, ..} ) <$> f v1PortStatusPort
{-# INLINE v1PortStatusPortL #-}

-- | 'v1PortStatusProtocol' Lens
v1PortStatusProtocolL :: Lens_' V1PortStatus (Text)
v1PortStatusProtocolL f V1PortStatus{..} = (\v1PortStatusProtocol -> V1PortStatus { v1PortStatusProtocol, ..} ) <$> f v1PortStatusProtocol
{-# INLINE v1PortStatusProtocolL #-}



-- * V1PortworxVolumeSource

-- | 'v1PortworxVolumeSourceFsType' Lens
v1PortworxVolumeSourceFsTypeL :: Lens_' V1PortworxVolumeSource (Maybe Text)
v1PortworxVolumeSourceFsTypeL f V1PortworxVolumeSource{..} = (\v1PortworxVolumeSourceFsType -> V1PortworxVolumeSource { v1PortworxVolumeSourceFsType, ..} ) <$> f v1PortworxVolumeSourceFsType
{-# INLINE v1PortworxVolumeSourceFsTypeL #-}

-- | 'v1PortworxVolumeSourceReadOnly' Lens
v1PortworxVolumeSourceReadOnlyL :: Lens_' V1PortworxVolumeSource (Maybe Bool)
v1PortworxVolumeSourceReadOnlyL f V1PortworxVolumeSource{..} = (\v1PortworxVolumeSourceReadOnly -> V1PortworxVolumeSource { v1PortworxVolumeSourceReadOnly, ..} ) <$> f v1PortworxVolumeSourceReadOnly
{-# INLINE v1PortworxVolumeSourceReadOnlyL #-}

-- | 'v1PortworxVolumeSourceVolumeId' Lens
v1PortworxVolumeSourceVolumeIdL :: Lens_' V1PortworxVolumeSource (Text)
v1PortworxVolumeSourceVolumeIdL f V1PortworxVolumeSource{..} = (\v1PortworxVolumeSourceVolumeId -> V1PortworxVolumeSource { v1PortworxVolumeSourceVolumeId, ..} ) <$> f v1PortworxVolumeSourceVolumeId
{-# INLINE v1PortworxVolumeSourceVolumeIdL #-}



-- * V1Preconditions

-- | 'v1PreconditionsResourceVersion' Lens
v1PreconditionsResourceVersionL :: Lens_' V1Preconditions (Maybe Text)
v1PreconditionsResourceVersionL f V1Preconditions{..} = (\v1PreconditionsResourceVersion -> V1Preconditions { v1PreconditionsResourceVersion, ..} ) <$> f v1PreconditionsResourceVersion
{-# INLINE v1PreconditionsResourceVersionL #-}

-- | 'v1PreconditionsUid' Lens
v1PreconditionsUidL :: Lens_' V1Preconditions (Maybe Text)
v1PreconditionsUidL f V1Preconditions{..} = (\v1PreconditionsUid -> V1Preconditions { v1PreconditionsUid, ..} ) <$> f v1PreconditionsUid
{-# INLINE v1PreconditionsUidL #-}



-- * V1PreferredSchedulingTerm

-- | 'v1PreferredSchedulingTermPreference' Lens
v1PreferredSchedulingTermPreferenceL :: Lens_' V1PreferredSchedulingTerm (V1NodeSelectorTerm)
v1PreferredSchedulingTermPreferenceL f V1PreferredSchedulingTerm{..} = (\v1PreferredSchedulingTermPreference -> V1PreferredSchedulingTerm { v1PreferredSchedulingTermPreference, ..} ) <$> f v1PreferredSchedulingTermPreference
{-# INLINE v1PreferredSchedulingTermPreferenceL #-}

-- | 'v1PreferredSchedulingTermWeight' Lens
v1PreferredSchedulingTermWeightL :: Lens_' V1PreferredSchedulingTerm (Int)
v1PreferredSchedulingTermWeightL f V1PreferredSchedulingTerm{..} = (\v1PreferredSchedulingTermWeight -> V1PreferredSchedulingTerm { v1PreferredSchedulingTermWeight, ..} ) <$> f v1PreferredSchedulingTermWeight
{-# INLINE v1PreferredSchedulingTermWeightL #-}



-- * V1PriorityClass

-- | 'v1PriorityClassApiVersion' Lens
v1PriorityClassApiVersionL :: Lens_' V1PriorityClass (Maybe Text)
v1PriorityClassApiVersionL f V1PriorityClass{..} = (\v1PriorityClassApiVersion -> V1PriorityClass { v1PriorityClassApiVersion, ..} ) <$> f v1PriorityClassApiVersion
{-# INLINE v1PriorityClassApiVersionL #-}

-- | 'v1PriorityClassDescription' Lens
v1PriorityClassDescriptionL :: Lens_' V1PriorityClass (Maybe Text)
v1PriorityClassDescriptionL f V1PriorityClass{..} = (\v1PriorityClassDescription -> V1PriorityClass { v1PriorityClassDescription, ..} ) <$> f v1PriorityClassDescription
{-# INLINE v1PriorityClassDescriptionL #-}

-- | 'v1PriorityClassGlobalDefault' Lens
v1PriorityClassGlobalDefaultL :: Lens_' V1PriorityClass (Maybe Bool)
v1PriorityClassGlobalDefaultL f V1PriorityClass{..} = (\v1PriorityClassGlobalDefault -> V1PriorityClass { v1PriorityClassGlobalDefault, ..} ) <$> f v1PriorityClassGlobalDefault
{-# INLINE v1PriorityClassGlobalDefaultL #-}

-- | 'v1PriorityClassKind' Lens
v1PriorityClassKindL :: Lens_' V1PriorityClass (Maybe Text)
v1PriorityClassKindL f V1PriorityClass{..} = (\v1PriorityClassKind -> V1PriorityClass { v1PriorityClassKind, ..} ) <$> f v1PriorityClassKind
{-# INLINE v1PriorityClassKindL #-}

-- | 'v1PriorityClassMetadata' Lens
v1PriorityClassMetadataL :: Lens_' V1PriorityClass (Maybe V1ObjectMeta)
v1PriorityClassMetadataL f V1PriorityClass{..} = (\v1PriorityClassMetadata -> V1PriorityClass { v1PriorityClassMetadata, ..} ) <$> f v1PriorityClassMetadata
{-# INLINE v1PriorityClassMetadataL #-}

-- | 'v1PriorityClassPreemptionPolicy' Lens
v1PriorityClassPreemptionPolicyL :: Lens_' V1PriorityClass (Maybe Text)
v1PriorityClassPreemptionPolicyL f V1PriorityClass{..} = (\v1PriorityClassPreemptionPolicy -> V1PriorityClass { v1PriorityClassPreemptionPolicy, ..} ) <$> f v1PriorityClassPreemptionPolicy
{-# INLINE v1PriorityClassPreemptionPolicyL #-}

-- | 'v1PriorityClassValue' Lens
v1PriorityClassValueL :: Lens_' V1PriorityClass (Int)
v1PriorityClassValueL f V1PriorityClass{..} = (\v1PriorityClassValue -> V1PriorityClass { v1PriorityClassValue, ..} ) <$> f v1PriorityClassValue
{-# INLINE v1PriorityClassValueL #-}



-- * V1PriorityClassList

-- | 'v1PriorityClassListApiVersion' Lens
v1PriorityClassListApiVersionL :: Lens_' V1PriorityClassList (Maybe Text)
v1PriorityClassListApiVersionL f V1PriorityClassList{..} = (\v1PriorityClassListApiVersion -> V1PriorityClassList { v1PriorityClassListApiVersion, ..} ) <$> f v1PriorityClassListApiVersion
{-# INLINE v1PriorityClassListApiVersionL #-}

-- | 'v1PriorityClassListItems' Lens
v1PriorityClassListItemsL :: Lens_' V1PriorityClassList ([V1PriorityClass])
v1PriorityClassListItemsL f V1PriorityClassList{..} = (\v1PriorityClassListItems -> V1PriorityClassList { v1PriorityClassListItems, ..} ) <$> f v1PriorityClassListItems
{-# INLINE v1PriorityClassListItemsL #-}

-- | 'v1PriorityClassListKind' Lens
v1PriorityClassListKindL :: Lens_' V1PriorityClassList (Maybe Text)
v1PriorityClassListKindL f V1PriorityClassList{..} = (\v1PriorityClassListKind -> V1PriorityClassList { v1PriorityClassListKind, ..} ) <$> f v1PriorityClassListKind
{-# INLINE v1PriorityClassListKindL #-}

-- | 'v1PriorityClassListMetadata' Lens
v1PriorityClassListMetadataL :: Lens_' V1PriorityClassList (Maybe V1ListMeta)
v1PriorityClassListMetadataL f V1PriorityClassList{..} = (\v1PriorityClassListMetadata -> V1PriorityClassList { v1PriorityClassListMetadata, ..} ) <$> f v1PriorityClassListMetadata
{-# INLINE v1PriorityClassListMetadataL #-}



-- * V1Probe

-- | 'v1ProbeExec' Lens
v1ProbeExecL :: Lens_' V1Probe (Maybe V1ExecAction)
v1ProbeExecL f V1Probe{..} = (\v1ProbeExec -> V1Probe { v1ProbeExec, ..} ) <$> f v1ProbeExec
{-# INLINE v1ProbeExecL #-}

-- | 'v1ProbeFailureThreshold' Lens
v1ProbeFailureThresholdL :: Lens_' V1Probe (Maybe Int)
v1ProbeFailureThresholdL f V1Probe{..} = (\v1ProbeFailureThreshold -> V1Probe { v1ProbeFailureThreshold, ..} ) <$> f v1ProbeFailureThreshold
{-# INLINE v1ProbeFailureThresholdL #-}

-- | 'v1ProbeGrpc' Lens
v1ProbeGrpcL :: Lens_' V1Probe (Maybe V1GRPCAction)
v1ProbeGrpcL f V1Probe{..} = (\v1ProbeGrpc -> V1Probe { v1ProbeGrpc, ..} ) <$> f v1ProbeGrpc
{-# INLINE v1ProbeGrpcL #-}

-- | 'v1ProbeHttpGet' Lens
v1ProbeHttpGetL :: Lens_' V1Probe (Maybe V1HTTPGetAction)
v1ProbeHttpGetL f V1Probe{..} = (\v1ProbeHttpGet -> V1Probe { v1ProbeHttpGet, ..} ) <$> f v1ProbeHttpGet
{-# INLINE v1ProbeHttpGetL #-}

-- | 'v1ProbeInitialDelaySeconds' Lens
v1ProbeInitialDelaySecondsL :: Lens_' V1Probe (Maybe Int)
v1ProbeInitialDelaySecondsL f V1Probe{..} = (\v1ProbeInitialDelaySeconds -> V1Probe { v1ProbeInitialDelaySeconds, ..} ) <$> f v1ProbeInitialDelaySeconds
{-# INLINE v1ProbeInitialDelaySecondsL #-}

-- | 'v1ProbePeriodSeconds' Lens
v1ProbePeriodSecondsL :: Lens_' V1Probe (Maybe Int)
v1ProbePeriodSecondsL f V1Probe{..} = (\v1ProbePeriodSeconds -> V1Probe { v1ProbePeriodSeconds, ..} ) <$> f v1ProbePeriodSeconds
{-# INLINE v1ProbePeriodSecondsL #-}

-- | 'v1ProbeSuccessThreshold' Lens
v1ProbeSuccessThresholdL :: Lens_' V1Probe (Maybe Int)
v1ProbeSuccessThresholdL f V1Probe{..} = (\v1ProbeSuccessThreshold -> V1Probe { v1ProbeSuccessThreshold, ..} ) <$> f v1ProbeSuccessThreshold
{-# INLINE v1ProbeSuccessThresholdL #-}

-- | 'v1ProbeTcpSocket' Lens
v1ProbeTcpSocketL :: Lens_' V1Probe (Maybe V1TCPSocketAction)
v1ProbeTcpSocketL f V1Probe{..} = (\v1ProbeTcpSocket -> V1Probe { v1ProbeTcpSocket, ..} ) <$> f v1ProbeTcpSocket
{-# INLINE v1ProbeTcpSocketL #-}

-- | 'v1ProbeTerminationGracePeriodSeconds' Lens
v1ProbeTerminationGracePeriodSecondsL :: Lens_' V1Probe (Maybe Integer)
v1ProbeTerminationGracePeriodSecondsL f V1Probe{..} = (\v1ProbeTerminationGracePeriodSeconds -> V1Probe { v1ProbeTerminationGracePeriodSeconds, ..} ) <$> f v1ProbeTerminationGracePeriodSeconds
{-# INLINE v1ProbeTerminationGracePeriodSecondsL #-}

-- | 'v1ProbeTimeoutSeconds' Lens
v1ProbeTimeoutSecondsL :: Lens_' V1Probe (Maybe Int)
v1ProbeTimeoutSecondsL f V1Probe{..} = (\v1ProbeTimeoutSeconds -> V1Probe { v1ProbeTimeoutSeconds, ..} ) <$> f v1ProbeTimeoutSeconds
{-# INLINE v1ProbeTimeoutSecondsL #-}



-- * V1ProjectedVolumeSource

-- | 'v1ProjectedVolumeSourceDefaultMode' Lens
v1ProjectedVolumeSourceDefaultModeL :: Lens_' V1ProjectedVolumeSource (Maybe Int)
v1ProjectedVolumeSourceDefaultModeL f V1ProjectedVolumeSource{..} = (\v1ProjectedVolumeSourceDefaultMode -> V1ProjectedVolumeSource { v1ProjectedVolumeSourceDefaultMode, ..} ) <$> f v1ProjectedVolumeSourceDefaultMode
{-# INLINE v1ProjectedVolumeSourceDefaultModeL #-}

-- | 'v1ProjectedVolumeSourceSources' Lens
v1ProjectedVolumeSourceSourcesL :: Lens_' V1ProjectedVolumeSource (Maybe [V1VolumeProjection])
v1ProjectedVolumeSourceSourcesL f V1ProjectedVolumeSource{..} = (\v1ProjectedVolumeSourceSources -> V1ProjectedVolumeSource { v1ProjectedVolumeSourceSources, ..} ) <$> f v1ProjectedVolumeSourceSources
{-# INLINE v1ProjectedVolumeSourceSourcesL #-}



-- * V1QuobyteVolumeSource

-- | 'v1QuobyteVolumeSourceGroup' Lens
v1QuobyteVolumeSourceGroupL :: Lens_' V1QuobyteVolumeSource (Maybe Text)
v1QuobyteVolumeSourceGroupL f V1QuobyteVolumeSource{..} = (\v1QuobyteVolumeSourceGroup -> V1QuobyteVolumeSource { v1QuobyteVolumeSourceGroup, ..} ) <$> f v1QuobyteVolumeSourceGroup
{-# INLINE v1QuobyteVolumeSourceGroupL #-}

-- | 'v1QuobyteVolumeSourceReadOnly' Lens
v1QuobyteVolumeSourceReadOnlyL :: Lens_' V1QuobyteVolumeSource (Maybe Bool)
v1QuobyteVolumeSourceReadOnlyL f V1QuobyteVolumeSource{..} = (\v1QuobyteVolumeSourceReadOnly -> V1QuobyteVolumeSource { v1QuobyteVolumeSourceReadOnly, ..} ) <$> f v1QuobyteVolumeSourceReadOnly
{-# INLINE v1QuobyteVolumeSourceReadOnlyL #-}

-- | 'v1QuobyteVolumeSourceRegistry' Lens
v1QuobyteVolumeSourceRegistryL :: Lens_' V1QuobyteVolumeSource (Text)
v1QuobyteVolumeSourceRegistryL f V1QuobyteVolumeSource{..} = (\v1QuobyteVolumeSourceRegistry -> V1QuobyteVolumeSource { v1QuobyteVolumeSourceRegistry, ..} ) <$> f v1QuobyteVolumeSourceRegistry
{-# INLINE v1QuobyteVolumeSourceRegistryL #-}

-- | 'v1QuobyteVolumeSourceTenant' Lens
v1QuobyteVolumeSourceTenantL :: Lens_' V1QuobyteVolumeSource (Maybe Text)
v1QuobyteVolumeSourceTenantL f V1QuobyteVolumeSource{..} = (\v1QuobyteVolumeSourceTenant -> V1QuobyteVolumeSource { v1QuobyteVolumeSourceTenant, ..} ) <$> f v1QuobyteVolumeSourceTenant
{-# INLINE v1QuobyteVolumeSourceTenantL #-}

-- | 'v1QuobyteVolumeSourceUser' Lens
v1QuobyteVolumeSourceUserL :: Lens_' V1QuobyteVolumeSource (Maybe Text)
v1QuobyteVolumeSourceUserL f V1QuobyteVolumeSource{..} = (\v1QuobyteVolumeSourceUser -> V1QuobyteVolumeSource { v1QuobyteVolumeSourceUser, ..} ) <$> f v1QuobyteVolumeSourceUser
{-# INLINE v1QuobyteVolumeSourceUserL #-}

-- | 'v1QuobyteVolumeSourceVolume' Lens
v1QuobyteVolumeSourceVolumeL :: Lens_' V1QuobyteVolumeSource (Text)
v1QuobyteVolumeSourceVolumeL f V1QuobyteVolumeSource{..} = (\v1QuobyteVolumeSourceVolume -> V1QuobyteVolumeSource { v1QuobyteVolumeSourceVolume, ..} ) <$> f v1QuobyteVolumeSourceVolume
{-# INLINE v1QuobyteVolumeSourceVolumeL #-}



-- * V1RBDPersistentVolumeSource

-- | 'v1RBDPersistentVolumeSourceFsType' Lens
v1RBDPersistentVolumeSourceFsTypeL :: Lens_' V1RBDPersistentVolumeSource (Maybe Text)
v1RBDPersistentVolumeSourceFsTypeL f V1RBDPersistentVolumeSource{..} = (\v1RBDPersistentVolumeSourceFsType -> V1RBDPersistentVolumeSource { v1RBDPersistentVolumeSourceFsType, ..} ) <$> f v1RBDPersistentVolumeSourceFsType
{-# INLINE v1RBDPersistentVolumeSourceFsTypeL #-}

-- | 'v1RBDPersistentVolumeSourceImage' Lens
v1RBDPersistentVolumeSourceImageL :: Lens_' V1RBDPersistentVolumeSource (Text)
v1RBDPersistentVolumeSourceImageL f V1RBDPersistentVolumeSource{..} = (\v1RBDPersistentVolumeSourceImage -> V1RBDPersistentVolumeSource { v1RBDPersistentVolumeSourceImage, ..} ) <$> f v1RBDPersistentVolumeSourceImage
{-# INLINE v1RBDPersistentVolumeSourceImageL #-}

-- | 'v1RBDPersistentVolumeSourceKeyring' Lens
v1RBDPersistentVolumeSourceKeyringL :: Lens_' V1RBDPersistentVolumeSource (Maybe Text)
v1RBDPersistentVolumeSourceKeyringL f V1RBDPersistentVolumeSource{..} = (\v1RBDPersistentVolumeSourceKeyring -> V1RBDPersistentVolumeSource { v1RBDPersistentVolumeSourceKeyring, ..} ) <$> f v1RBDPersistentVolumeSourceKeyring
{-# INLINE v1RBDPersistentVolumeSourceKeyringL #-}

-- | 'v1RBDPersistentVolumeSourceMonitors' Lens
v1RBDPersistentVolumeSourceMonitorsL :: Lens_' V1RBDPersistentVolumeSource ([Text])
v1RBDPersistentVolumeSourceMonitorsL f V1RBDPersistentVolumeSource{..} = (\v1RBDPersistentVolumeSourceMonitors -> V1RBDPersistentVolumeSource { v1RBDPersistentVolumeSourceMonitors, ..} ) <$> f v1RBDPersistentVolumeSourceMonitors
{-# INLINE v1RBDPersistentVolumeSourceMonitorsL #-}

-- | 'v1RBDPersistentVolumeSourcePool' Lens
v1RBDPersistentVolumeSourcePoolL :: Lens_' V1RBDPersistentVolumeSource (Maybe Text)
v1RBDPersistentVolumeSourcePoolL f V1RBDPersistentVolumeSource{..} = (\v1RBDPersistentVolumeSourcePool -> V1RBDPersistentVolumeSource { v1RBDPersistentVolumeSourcePool, ..} ) <$> f v1RBDPersistentVolumeSourcePool
{-# INLINE v1RBDPersistentVolumeSourcePoolL #-}

-- | 'v1RBDPersistentVolumeSourceReadOnly' Lens
v1RBDPersistentVolumeSourceReadOnlyL :: Lens_' V1RBDPersistentVolumeSource (Maybe Bool)
v1RBDPersistentVolumeSourceReadOnlyL f V1RBDPersistentVolumeSource{..} = (\v1RBDPersistentVolumeSourceReadOnly -> V1RBDPersistentVolumeSource { v1RBDPersistentVolumeSourceReadOnly, ..} ) <$> f v1RBDPersistentVolumeSourceReadOnly
{-# INLINE v1RBDPersistentVolumeSourceReadOnlyL #-}

-- | 'v1RBDPersistentVolumeSourceSecretRef' Lens
v1RBDPersistentVolumeSourceSecretRefL :: Lens_' V1RBDPersistentVolumeSource (Maybe V1SecretReference)
v1RBDPersistentVolumeSourceSecretRefL f V1RBDPersistentVolumeSource{..} = (\v1RBDPersistentVolumeSourceSecretRef -> V1RBDPersistentVolumeSource { v1RBDPersistentVolumeSourceSecretRef, ..} ) <$> f v1RBDPersistentVolumeSourceSecretRef
{-# INLINE v1RBDPersistentVolumeSourceSecretRefL #-}

-- | 'v1RBDPersistentVolumeSourceUser' Lens
v1RBDPersistentVolumeSourceUserL :: Lens_' V1RBDPersistentVolumeSource (Maybe Text)
v1RBDPersistentVolumeSourceUserL f V1RBDPersistentVolumeSource{..} = (\v1RBDPersistentVolumeSourceUser -> V1RBDPersistentVolumeSource { v1RBDPersistentVolumeSourceUser, ..} ) <$> f v1RBDPersistentVolumeSourceUser
{-# INLINE v1RBDPersistentVolumeSourceUserL #-}



-- * V1RBDVolumeSource

-- | 'v1RBDVolumeSourceFsType' Lens
v1RBDVolumeSourceFsTypeL :: Lens_' V1RBDVolumeSource (Maybe Text)
v1RBDVolumeSourceFsTypeL f V1RBDVolumeSource{..} = (\v1RBDVolumeSourceFsType -> V1RBDVolumeSource { v1RBDVolumeSourceFsType, ..} ) <$> f v1RBDVolumeSourceFsType
{-# INLINE v1RBDVolumeSourceFsTypeL #-}

-- | 'v1RBDVolumeSourceImage' Lens
v1RBDVolumeSourceImageL :: Lens_' V1RBDVolumeSource (Text)
v1RBDVolumeSourceImageL f V1RBDVolumeSource{..} = (\v1RBDVolumeSourceImage -> V1RBDVolumeSource { v1RBDVolumeSourceImage, ..} ) <$> f v1RBDVolumeSourceImage
{-# INLINE v1RBDVolumeSourceImageL #-}

-- | 'v1RBDVolumeSourceKeyring' Lens
v1RBDVolumeSourceKeyringL :: Lens_' V1RBDVolumeSource (Maybe Text)
v1RBDVolumeSourceKeyringL f V1RBDVolumeSource{..} = (\v1RBDVolumeSourceKeyring -> V1RBDVolumeSource { v1RBDVolumeSourceKeyring, ..} ) <$> f v1RBDVolumeSourceKeyring
{-# INLINE v1RBDVolumeSourceKeyringL #-}

-- | 'v1RBDVolumeSourceMonitors' Lens
v1RBDVolumeSourceMonitorsL :: Lens_' V1RBDVolumeSource ([Text])
v1RBDVolumeSourceMonitorsL f V1RBDVolumeSource{..} = (\v1RBDVolumeSourceMonitors -> V1RBDVolumeSource { v1RBDVolumeSourceMonitors, ..} ) <$> f v1RBDVolumeSourceMonitors
{-# INLINE v1RBDVolumeSourceMonitorsL #-}

-- | 'v1RBDVolumeSourcePool' Lens
v1RBDVolumeSourcePoolL :: Lens_' V1RBDVolumeSource (Maybe Text)
v1RBDVolumeSourcePoolL f V1RBDVolumeSource{..} = (\v1RBDVolumeSourcePool -> V1RBDVolumeSource { v1RBDVolumeSourcePool, ..} ) <$> f v1RBDVolumeSourcePool
{-# INLINE v1RBDVolumeSourcePoolL #-}

-- | 'v1RBDVolumeSourceReadOnly' Lens
v1RBDVolumeSourceReadOnlyL :: Lens_' V1RBDVolumeSource (Maybe Bool)
v1RBDVolumeSourceReadOnlyL f V1RBDVolumeSource{..} = (\v1RBDVolumeSourceReadOnly -> V1RBDVolumeSource { v1RBDVolumeSourceReadOnly, ..} ) <$> f v1RBDVolumeSourceReadOnly
{-# INLINE v1RBDVolumeSourceReadOnlyL #-}

-- | 'v1RBDVolumeSourceSecretRef' Lens
v1RBDVolumeSourceSecretRefL :: Lens_' V1RBDVolumeSource (Maybe V1LocalObjectReference)
v1RBDVolumeSourceSecretRefL f V1RBDVolumeSource{..} = (\v1RBDVolumeSourceSecretRef -> V1RBDVolumeSource { v1RBDVolumeSourceSecretRef, ..} ) <$> f v1RBDVolumeSourceSecretRef
{-# INLINE v1RBDVolumeSourceSecretRefL #-}

-- | 'v1RBDVolumeSourceUser' Lens
v1RBDVolumeSourceUserL :: Lens_' V1RBDVolumeSource (Maybe Text)
v1RBDVolumeSourceUserL f V1RBDVolumeSource{..} = (\v1RBDVolumeSourceUser -> V1RBDVolumeSource { v1RBDVolumeSourceUser, ..} ) <$> f v1RBDVolumeSourceUser
{-# INLINE v1RBDVolumeSourceUserL #-}



-- * V1ReplicaSet

-- | 'v1ReplicaSetApiVersion' Lens
v1ReplicaSetApiVersionL :: Lens_' V1ReplicaSet (Maybe Text)
v1ReplicaSetApiVersionL f V1ReplicaSet{..} = (\v1ReplicaSetApiVersion -> V1ReplicaSet { v1ReplicaSetApiVersion, ..} ) <$> f v1ReplicaSetApiVersion
{-# INLINE v1ReplicaSetApiVersionL #-}

-- | 'v1ReplicaSetKind' Lens
v1ReplicaSetKindL :: Lens_' V1ReplicaSet (Maybe Text)
v1ReplicaSetKindL f V1ReplicaSet{..} = (\v1ReplicaSetKind -> V1ReplicaSet { v1ReplicaSetKind, ..} ) <$> f v1ReplicaSetKind
{-# INLINE v1ReplicaSetKindL #-}

-- | 'v1ReplicaSetMetadata' Lens
v1ReplicaSetMetadataL :: Lens_' V1ReplicaSet (Maybe V1ObjectMeta)
v1ReplicaSetMetadataL f V1ReplicaSet{..} = (\v1ReplicaSetMetadata -> V1ReplicaSet { v1ReplicaSetMetadata, ..} ) <$> f v1ReplicaSetMetadata
{-# INLINE v1ReplicaSetMetadataL #-}

-- | 'v1ReplicaSetSpec' Lens
v1ReplicaSetSpecL :: Lens_' V1ReplicaSet (Maybe V1ReplicaSetSpec)
v1ReplicaSetSpecL f V1ReplicaSet{..} = (\v1ReplicaSetSpec -> V1ReplicaSet { v1ReplicaSetSpec, ..} ) <$> f v1ReplicaSetSpec
{-# INLINE v1ReplicaSetSpecL #-}

-- | 'v1ReplicaSetStatus' Lens
v1ReplicaSetStatusL :: Lens_' V1ReplicaSet (Maybe V1ReplicaSetStatus)
v1ReplicaSetStatusL f V1ReplicaSet{..} = (\v1ReplicaSetStatus -> V1ReplicaSet { v1ReplicaSetStatus, ..} ) <$> f v1ReplicaSetStatus
{-# INLINE v1ReplicaSetStatusL #-}



-- * V1ReplicaSetCondition

-- | 'v1ReplicaSetConditionLastTransitionTime' Lens
v1ReplicaSetConditionLastTransitionTimeL :: Lens_' V1ReplicaSetCondition (Maybe DateTime)
v1ReplicaSetConditionLastTransitionTimeL f V1ReplicaSetCondition{..} = (\v1ReplicaSetConditionLastTransitionTime -> V1ReplicaSetCondition { v1ReplicaSetConditionLastTransitionTime, ..} ) <$> f v1ReplicaSetConditionLastTransitionTime
{-# INLINE v1ReplicaSetConditionLastTransitionTimeL #-}

-- | 'v1ReplicaSetConditionMessage' Lens
v1ReplicaSetConditionMessageL :: Lens_' V1ReplicaSetCondition (Maybe Text)
v1ReplicaSetConditionMessageL f V1ReplicaSetCondition{..} = (\v1ReplicaSetConditionMessage -> V1ReplicaSetCondition { v1ReplicaSetConditionMessage, ..} ) <$> f v1ReplicaSetConditionMessage
{-# INLINE v1ReplicaSetConditionMessageL #-}

-- | 'v1ReplicaSetConditionReason' Lens
v1ReplicaSetConditionReasonL :: Lens_' V1ReplicaSetCondition (Maybe Text)
v1ReplicaSetConditionReasonL f V1ReplicaSetCondition{..} = (\v1ReplicaSetConditionReason -> V1ReplicaSetCondition { v1ReplicaSetConditionReason, ..} ) <$> f v1ReplicaSetConditionReason
{-# INLINE v1ReplicaSetConditionReasonL #-}

-- | 'v1ReplicaSetConditionStatus' Lens
v1ReplicaSetConditionStatusL :: Lens_' V1ReplicaSetCondition (Text)
v1ReplicaSetConditionStatusL f V1ReplicaSetCondition{..} = (\v1ReplicaSetConditionStatus -> V1ReplicaSetCondition { v1ReplicaSetConditionStatus, ..} ) <$> f v1ReplicaSetConditionStatus
{-# INLINE v1ReplicaSetConditionStatusL #-}

-- | 'v1ReplicaSetConditionType' Lens
v1ReplicaSetConditionTypeL :: Lens_' V1ReplicaSetCondition (Text)
v1ReplicaSetConditionTypeL f V1ReplicaSetCondition{..} = (\v1ReplicaSetConditionType -> V1ReplicaSetCondition { v1ReplicaSetConditionType, ..} ) <$> f v1ReplicaSetConditionType
{-# INLINE v1ReplicaSetConditionTypeL #-}



-- * V1ReplicaSetList

-- | 'v1ReplicaSetListApiVersion' Lens
v1ReplicaSetListApiVersionL :: Lens_' V1ReplicaSetList (Maybe Text)
v1ReplicaSetListApiVersionL f V1ReplicaSetList{..} = (\v1ReplicaSetListApiVersion -> V1ReplicaSetList { v1ReplicaSetListApiVersion, ..} ) <$> f v1ReplicaSetListApiVersion
{-# INLINE v1ReplicaSetListApiVersionL #-}

-- | 'v1ReplicaSetListItems' Lens
v1ReplicaSetListItemsL :: Lens_' V1ReplicaSetList ([V1ReplicaSet])
v1ReplicaSetListItemsL f V1ReplicaSetList{..} = (\v1ReplicaSetListItems -> V1ReplicaSetList { v1ReplicaSetListItems, ..} ) <$> f v1ReplicaSetListItems
{-# INLINE v1ReplicaSetListItemsL #-}

-- | 'v1ReplicaSetListKind' Lens
v1ReplicaSetListKindL :: Lens_' V1ReplicaSetList (Maybe Text)
v1ReplicaSetListKindL f V1ReplicaSetList{..} = (\v1ReplicaSetListKind -> V1ReplicaSetList { v1ReplicaSetListKind, ..} ) <$> f v1ReplicaSetListKind
{-# INLINE v1ReplicaSetListKindL #-}

-- | 'v1ReplicaSetListMetadata' Lens
v1ReplicaSetListMetadataL :: Lens_' V1ReplicaSetList (Maybe V1ListMeta)
v1ReplicaSetListMetadataL f V1ReplicaSetList{..} = (\v1ReplicaSetListMetadata -> V1ReplicaSetList { v1ReplicaSetListMetadata, ..} ) <$> f v1ReplicaSetListMetadata
{-# INLINE v1ReplicaSetListMetadataL #-}



-- * V1ReplicaSetSpec

-- | 'v1ReplicaSetSpecMinReadySeconds' Lens
v1ReplicaSetSpecMinReadySecondsL :: Lens_' V1ReplicaSetSpec (Maybe Int)
v1ReplicaSetSpecMinReadySecondsL f V1ReplicaSetSpec{..} = (\v1ReplicaSetSpecMinReadySeconds -> V1ReplicaSetSpec { v1ReplicaSetSpecMinReadySeconds, ..} ) <$> f v1ReplicaSetSpecMinReadySeconds
{-# INLINE v1ReplicaSetSpecMinReadySecondsL #-}

-- | 'v1ReplicaSetSpecReplicas' Lens
v1ReplicaSetSpecReplicasL :: Lens_' V1ReplicaSetSpec (Maybe Int)
v1ReplicaSetSpecReplicasL f V1ReplicaSetSpec{..} = (\v1ReplicaSetSpecReplicas -> V1ReplicaSetSpec { v1ReplicaSetSpecReplicas, ..} ) <$> f v1ReplicaSetSpecReplicas
{-# INLINE v1ReplicaSetSpecReplicasL #-}

-- | 'v1ReplicaSetSpecSelector' Lens
v1ReplicaSetSpecSelectorL :: Lens_' V1ReplicaSetSpec (V1LabelSelector)
v1ReplicaSetSpecSelectorL f V1ReplicaSetSpec{..} = (\v1ReplicaSetSpecSelector -> V1ReplicaSetSpec { v1ReplicaSetSpecSelector, ..} ) <$> f v1ReplicaSetSpecSelector
{-# INLINE v1ReplicaSetSpecSelectorL #-}

-- | 'v1ReplicaSetSpecTemplate' Lens
v1ReplicaSetSpecTemplateL :: Lens_' V1ReplicaSetSpec (Maybe V1PodTemplateSpec)
v1ReplicaSetSpecTemplateL f V1ReplicaSetSpec{..} = (\v1ReplicaSetSpecTemplate -> V1ReplicaSetSpec { v1ReplicaSetSpecTemplate, ..} ) <$> f v1ReplicaSetSpecTemplate
{-# INLINE v1ReplicaSetSpecTemplateL #-}



-- * V1ReplicaSetStatus

-- | 'v1ReplicaSetStatusAvailableReplicas' Lens
v1ReplicaSetStatusAvailableReplicasL :: Lens_' V1ReplicaSetStatus (Maybe Int)
v1ReplicaSetStatusAvailableReplicasL f V1ReplicaSetStatus{..} = (\v1ReplicaSetStatusAvailableReplicas -> V1ReplicaSetStatus { v1ReplicaSetStatusAvailableReplicas, ..} ) <$> f v1ReplicaSetStatusAvailableReplicas
{-# INLINE v1ReplicaSetStatusAvailableReplicasL #-}

-- | 'v1ReplicaSetStatusConditions' Lens
v1ReplicaSetStatusConditionsL :: Lens_' V1ReplicaSetStatus (Maybe [V1ReplicaSetCondition])
v1ReplicaSetStatusConditionsL f V1ReplicaSetStatus{..} = (\v1ReplicaSetStatusConditions -> V1ReplicaSetStatus { v1ReplicaSetStatusConditions, ..} ) <$> f v1ReplicaSetStatusConditions
{-# INLINE v1ReplicaSetStatusConditionsL #-}

-- | 'v1ReplicaSetStatusFullyLabeledReplicas' Lens
v1ReplicaSetStatusFullyLabeledReplicasL :: Lens_' V1ReplicaSetStatus (Maybe Int)
v1ReplicaSetStatusFullyLabeledReplicasL f V1ReplicaSetStatus{..} = (\v1ReplicaSetStatusFullyLabeledReplicas -> V1ReplicaSetStatus { v1ReplicaSetStatusFullyLabeledReplicas, ..} ) <$> f v1ReplicaSetStatusFullyLabeledReplicas
{-# INLINE v1ReplicaSetStatusFullyLabeledReplicasL #-}

-- | 'v1ReplicaSetStatusObservedGeneration' Lens
v1ReplicaSetStatusObservedGenerationL :: Lens_' V1ReplicaSetStatus (Maybe Integer)
v1ReplicaSetStatusObservedGenerationL f V1ReplicaSetStatus{..} = (\v1ReplicaSetStatusObservedGeneration -> V1ReplicaSetStatus { v1ReplicaSetStatusObservedGeneration, ..} ) <$> f v1ReplicaSetStatusObservedGeneration
{-# INLINE v1ReplicaSetStatusObservedGenerationL #-}

-- | 'v1ReplicaSetStatusReadyReplicas' Lens
v1ReplicaSetStatusReadyReplicasL :: Lens_' V1ReplicaSetStatus (Maybe Int)
v1ReplicaSetStatusReadyReplicasL f V1ReplicaSetStatus{..} = (\v1ReplicaSetStatusReadyReplicas -> V1ReplicaSetStatus { v1ReplicaSetStatusReadyReplicas, ..} ) <$> f v1ReplicaSetStatusReadyReplicas
{-# INLINE v1ReplicaSetStatusReadyReplicasL #-}

-- | 'v1ReplicaSetStatusReplicas' Lens
v1ReplicaSetStatusReplicasL :: Lens_' V1ReplicaSetStatus (Int)
v1ReplicaSetStatusReplicasL f V1ReplicaSetStatus{..} = (\v1ReplicaSetStatusReplicas -> V1ReplicaSetStatus { v1ReplicaSetStatusReplicas, ..} ) <$> f v1ReplicaSetStatusReplicas
{-# INLINE v1ReplicaSetStatusReplicasL #-}



-- * V1ReplicationController

-- | 'v1ReplicationControllerApiVersion' Lens
v1ReplicationControllerApiVersionL :: Lens_' V1ReplicationController (Maybe Text)
v1ReplicationControllerApiVersionL f V1ReplicationController{..} = (\v1ReplicationControllerApiVersion -> V1ReplicationController { v1ReplicationControllerApiVersion, ..} ) <$> f v1ReplicationControllerApiVersion
{-# INLINE v1ReplicationControllerApiVersionL #-}

-- | 'v1ReplicationControllerKind' Lens
v1ReplicationControllerKindL :: Lens_' V1ReplicationController (Maybe Text)
v1ReplicationControllerKindL f V1ReplicationController{..} = (\v1ReplicationControllerKind -> V1ReplicationController { v1ReplicationControllerKind, ..} ) <$> f v1ReplicationControllerKind
{-# INLINE v1ReplicationControllerKindL #-}

-- | 'v1ReplicationControllerMetadata' Lens
v1ReplicationControllerMetadataL :: Lens_' V1ReplicationController (Maybe V1ObjectMeta)
v1ReplicationControllerMetadataL f V1ReplicationController{..} = (\v1ReplicationControllerMetadata -> V1ReplicationController { v1ReplicationControllerMetadata, ..} ) <$> f v1ReplicationControllerMetadata
{-# INLINE v1ReplicationControllerMetadataL #-}

-- | 'v1ReplicationControllerSpec' Lens
v1ReplicationControllerSpecL :: Lens_' V1ReplicationController (Maybe V1ReplicationControllerSpec)
v1ReplicationControllerSpecL f V1ReplicationController{..} = (\v1ReplicationControllerSpec -> V1ReplicationController { v1ReplicationControllerSpec, ..} ) <$> f v1ReplicationControllerSpec
{-# INLINE v1ReplicationControllerSpecL #-}

-- | 'v1ReplicationControllerStatus' Lens
v1ReplicationControllerStatusL :: Lens_' V1ReplicationController (Maybe V1ReplicationControllerStatus)
v1ReplicationControllerStatusL f V1ReplicationController{..} = (\v1ReplicationControllerStatus -> V1ReplicationController { v1ReplicationControllerStatus, ..} ) <$> f v1ReplicationControllerStatus
{-# INLINE v1ReplicationControllerStatusL #-}



-- * V1ReplicationControllerCondition

-- | 'v1ReplicationControllerConditionLastTransitionTime' Lens
v1ReplicationControllerConditionLastTransitionTimeL :: Lens_' V1ReplicationControllerCondition (Maybe DateTime)
v1ReplicationControllerConditionLastTransitionTimeL f V1ReplicationControllerCondition{..} = (\v1ReplicationControllerConditionLastTransitionTime -> V1ReplicationControllerCondition { v1ReplicationControllerConditionLastTransitionTime, ..} ) <$> f v1ReplicationControllerConditionLastTransitionTime
{-# INLINE v1ReplicationControllerConditionLastTransitionTimeL #-}

-- | 'v1ReplicationControllerConditionMessage' Lens
v1ReplicationControllerConditionMessageL :: Lens_' V1ReplicationControllerCondition (Maybe Text)
v1ReplicationControllerConditionMessageL f V1ReplicationControllerCondition{..} = (\v1ReplicationControllerConditionMessage -> V1ReplicationControllerCondition { v1ReplicationControllerConditionMessage, ..} ) <$> f v1ReplicationControllerConditionMessage
{-# INLINE v1ReplicationControllerConditionMessageL #-}

-- | 'v1ReplicationControllerConditionReason' Lens
v1ReplicationControllerConditionReasonL :: Lens_' V1ReplicationControllerCondition (Maybe Text)
v1ReplicationControllerConditionReasonL f V1ReplicationControllerCondition{..} = (\v1ReplicationControllerConditionReason -> V1ReplicationControllerCondition { v1ReplicationControllerConditionReason, ..} ) <$> f v1ReplicationControllerConditionReason
{-# INLINE v1ReplicationControllerConditionReasonL #-}

-- | 'v1ReplicationControllerConditionStatus' Lens
v1ReplicationControllerConditionStatusL :: Lens_' V1ReplicationControllerCondition (Text)
v1ReplicationControllerConditionStatusL f V1ReplicationControllerCondition{..} = (\v1ReplicationControllerConditionStatus -> V1ReplicationControllerCondition { v1ReplicationControllerConditionStatus, ..} ) <$> f v1ReplicationControllerConditionStatus
{-# INLINE v1ReplicationControllerConditionStatusL #-}

-- | 'v1ReplicationControllerConditionType' Lens
v1ReplicationControllerConditionTypeL :: Lens_' V1ReplicationControllerCondition (Text)
v1ReplicationControllerConditionTypeL f V1ReplicationControllerCondition{..} = (\v1ReplicationControllerConditionType -> V1ReplicationControllerCondition { v1ReplicationControllerConditionType, ..} ) <$> f v1ReplicationControllerConditionType
{-# INLINE v1ReplicationControllerConditionTypeL #-}



-- * V1ReplicationControllerList

-- | 'v1ReplicationControllerListApiVersion' Lens
v1ReplicationControllerListApiVersionL :: Lens_' V1ReplicationControllerList (Maybe Text)
v1ReplicationControllerListApiVersionL f V1ReplicationControllerList{..} = (\v1ReplicationControllerListApiVersion -> V1ReplicationControllerList { v1ReplicationControllerListApiVersion, ..} ) <$> f v1ReplicationControllerListApiVersion
{-# INLINE v1ReplicationControllerListApiVersionL #-}

-- | 'v1ReplicationControllerListItems' Lens
v1ReplicationControllerListItemsL :: Lens_' V1ReplicationControllerList ([V1ReplicationController])
v1ReplicationControllerListItemsL f V1ReplicationControllerList{..} = (\v1ReplicationControllerListItems -> V1ReplicationControllerList { v1ReplicationControllerListItems, ..} ) <$> f v1ReplicationControllerListItems
{-# INLINE v1ReplicationControllerListItemsL #-}

-- | 'v1ReplicationControllerListKind' Lens
v1ReplicationControllerListKindL :: Lens_' V1ReplicationControllerList (Maybe Text)
v1ReplicationControllerListKindL f V1ReplicationControllerList{..} = (\v1ReplicationControllerListKind -> V1ReplicationControllerList { v1ReplicationControllerListKind, ..} ) <$> f v1ReplicationControllerListKind
{-# INLINE v1ReplicationControllerListKindL #-}

-- | 'v1ReplicationControllerListMetadata' Lens
v1ReplicationControllerListMetadataL :: Lens_' V1ReplicationControllerList (Maybe V1ListMeta)
v1ReplicationControllerListMetadataL f V1ReplicationControllerList{..} = (\v1ReplicationControllerListMetadata -> V1ReplicationControllerList { v1ReplicationControllerListMetadata, ..} ) <$> f v1ReplicationControllerListMetadata
{-# INLINE v1ReplicationControllerListMetadataL #-}



-- * V1ReplicationControllerSpec

-- | 'v1ReplicationControllerSpecMinReadySeconds' Lens
v1ReplicationControllerSpecMinReadySecondsL :: Lens_' V1ReplicationControllerSpec (Maybe Int)
v1ReplicationControllerSpecMinReadySecondsL f V1ReplicationControllerSpec{..} = (\v1ReplicationControllerSpecMinReadySeconds -> V1ReplicationControllerSpec { v1ReplicationControllerSpecMinReadySeconds, ..} ) <$> f v1ReplicationControllerSpecMinReadySeconds
{-# INLINE v1ReplicationControllerSpecMinReadySecondsL #-}

-- | 'v1ReplicationControllerSpecReplicas' Lens
v1ReplicationControllerSpecReplicasL :: Lens_' V1ReplicationControllerSpec (Maybe Int)
v1ReplicationControllerSpecReplicasL f V1ReplicationControllerSpec{..} = (\v1ReplicationControllerSpecReplicas -> V1ReplicationControllerSpec { v1ReplicationControllerSpecReplicas, ..} ) <$> f v1ReplicationControllerSpecReplicas
{-# INLINE v1ReplicationControllerSpecReplicasL #-}

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

-- | 'v1ReplicationControllerSpecTemplate' Lens
v1ReplicationControllerSpecTemplateL :: Lens_' V1ReplicationControllerSpec (Maybe V1PodTemplateSpec)
v1ReplicationControllerSpecTemplateL f V1ReplicationControllerSpec{..} = (\v1ReplicationControllerSpecTemplate -> V1ReplicationControllerSpec { v1ReplicationControllerSpecTemplate, ..} ) <$> f v1ReplicationControllerSpecTemplate
{-# INLINE v1ReplicationControllerSpecTemplateL #-}



-- * V1ReplicationControllerStatus

-- | 'v1ReplicationControllerStatusAvailableReplicas' Lens
v1ReplicationControllerStatusAvailableReplicasL :: Lens_' V1ReplicationControllerStatus (Maybe Int)
v1ReplicationControllerStatusAvailableReplicasL f V1ReplicationControllerStatus{..} = (\v1ReplicationControllerStatusAvailableReplicas -> V1ReplicationControllerStatus { v1ReplicationControllerStatusAvailableReplicas, ..} ) <$> f v1ReplicationControllerStatusAvailableReplicas
{-# INLINE v1ReplicationControllerStatusAvailableReplicasL #-}

-- | 'v1ReplicationControllerStatusConditions' Lens
v1ReplicationControllerStatusConditionsL :: Lens_' V1ReplicationControllerStatus (Maybe [V1ReplicationControllerCondition])
v1ReplicationControllerStatusConditionsL f V1ReplicationControllerStatus{..} = (\v1ReplicationControllerStatusConditions -> V1ReplicationControllerStatus { v1ReplicationControllerStatusConditions, ..} ) <$> f v1ReplicationControllerStatusConditions
{-# INLINE v1ReplicationControllerStatusConditionsL #-}

-- | 'v1ReplicationControllerStatusFullyLabeledReplicas' Lens
v1ReplicationControllerStatusFullyLabeledReplicasL :: Lens_' V1ReplicationControllerStatus (Maybe Int)
v1ReplicationControllerStatusFullyLabeledReplicasL f V1ReplicationControllerStatus{..} = (\v1ReplicationControllerStatusFullyLabeledReplicas -> V1ReplicationControllerStatus { v1ReplicationControllerStatusFullyLabeledReplicas, ..} ) <$> f v1ReplicationControllerStatusFullyLabeledReplicas
{-# INLINE v1ReplicationControllerStatusFullyLabeledReplicasL #-}

-- | 'v1ReplicationControllerStatusObservedGeneration' Lens
v1ReplicationControllerStatusObservedGenerationL :: Lens_' V1ReplicationControllerStatus (Maybe Integer)
v1ReplicationControllerStatusObservedGenerationL f V1ReplicationControllerStatus{..} = (\v1ReplicationControllerStatusObservedGeneration -> V1ReplicationControllerStatus { v1ReplicationControllerStatusObservedGeneration, ..} ) <$> f v1ReplicationControllerStatusObservedGeneration
{-# INLINE v1ReplicationControllerStatusObservedGenerationL #-}

-- | 'v1ReplicationControllerStatusReadyReplicas' Lens
v1ReplicationControllerStatusReadyReplicasL :: Lens_' V1ReplicationControllerStatus (Maybe Int)
v1ReplicationControllerStatusReadyReplicasL f V1ReplicationControllerStatus{..} = (\v1ReplicationControllerStatusReadyReplicas -> V1ReplicationControllerStatus { v1ReplicationControllerStatusReadyReplicas, ..} ) <$> f v1ReplicationControllerStatusReadyReplicas
{-# INLINE v1ReplicationControllerStatusReadyReplicasL #-}

-- | 'v1ReplicationControllerStatusReplicas' Lens
v1ReplicationControllerStatusReplicasL :: Lens_' V1ReplicationControllerStatus (Int)
v1ReplicationControllerStatusReplicasL f V1ReplicationControllerStatus{..} = (\v1ReplicationControllerStatusReplicas -> V1ReplicationControllerStatus { v1ReplicationControllerStatusReplicas, ..} ) <$> f v1ReplicationControllerStatusReplicas
{-# INLINE v1ReplicationControllerStatusReplicasL #-}



-- * V1ResourceAttributes

-- | 'v1ResourceAttributesGroup' Lens
v1ResourceAttributesGroupL :: Lens_' V1ResourceAttributes (Maybe Text)
v1ResourceAttributesGroupL f V1ResourceAttributes{..} = (\v1ResourceAttributesGroup -> V1ResourceAttributes { v1ResourceAttributesGroup, ..} ) <$> f v1ResourceAttributesGroup
{-# INLINE v1ResourceAttributesGroupL #-}

-- | 'v1ResourceAttributesName' Lens
v1ResourceAttributesNameL :: Lens_' V1ResourceAttributes (Maybe Text)
v1ResourceAttributesNameL f V1ResourceAttributes{..} = (\v1ResourceAttributesName -> V1ResourceAttributes { v1ResourceAttributesName, ..} ) <$> f v1ResourceAttributesName
{-# INLINE v1ResourceAttributesNameL #-}

-- | 'v1ResourceAttributesNamespace' Lens
v1ResourceAttributesNamespaceL :: Lens_' V1ResourceAttributes (Maybe Text)
v1ResourceAttributesNamespaceL f V1ResourceAttributes{..} = (\v1ResourceAttributesNamespace -> V1ResourceAttributes { v1ResourceAttributesNamespace, ..} ) <$> f v1ResourceAttributesNamespace
{-# INLINE v1ResourceAttributesNamespaceL #-}

-- | 'v1ResourceAttributesResource' Lens
v1ResourceAttributesResourceL :: Lens_' V1ResourceAttributes (Maybe Text)
v1ResourceAttributesResourceL f V1ResourceAttributes{..} = (\v1ResourceAttributesResource -> V1ResourceAttributes { v1ResourceAttributesResource, ..} ) <$> f v1ResourceAttributesResource
{-# INLINE v1ResourceAttributesResourceL #-}

-- | 'v1ResourceAttributesSubresource' Lens
v1ResourceAttributesSubresourceL :: Lens_' V1ResourceAttributes (Maybe Text)
v1ResourceAttributesSubresourceL f V1ResourceAttributes{..} = (\v1ResourceAttributesSubresource -> V1ResourceAttributes { v1ResourceAttributesSubresource, ..} ) <$> f v1ResourceAttributesSubresource
{-# INLINE v1ResourceAttributesSubresourceL #-}

-- | 'v1ResourceAttributesVerb' Lens
v1ResourceAttributesVerbL :: Lens_' V1ResourceAttributes (Maybe Text)
v1ResourceAttributesVerbL f V1ResourceAttributes{..} = (\v1ResourceAttributesVerb -> V1ResourceAttributes { v1ResourceAttributesVerb, ..} ) <$> f v1ResourceAttributesVerb
{-# INLINE v1ResourceAttributesVerbL #-}

-- | 'v1ResourceAttributesVersion' Lens
v1ResourceAttributesVersionL :: Lens_' V1ResourceAttributes (Maybe Text)
v1ResourceAttributesVersionL f V1ResourceAttributes{..} = (\v1ResourceAttributesVersion -> V1ResourceAttributes { v1ResourceAttributesVersion, ..} ) <$> f v1ResourceAttributesVersion
{-# INLINE v1ResourceAttributesVersionL #-}



-- * V1ResourceFieldSelector

-- | 'v1ResourceFieldSelectorContainerName' Lens
v1ResourceFieldSelectorContainerNameL :: Lens_' V1ResourceFieldSelector (Maybe Text)
v1ResourceFieldSelectorContainerNameL f V1ResourceFieldSelector{..} = (\v1ResourceFieldSelectorContainerName -> V1ResourceFieldSelector { v1ResourceFieldSelectorContainerName, ..} ) <$> f v1ResourceFieldSelectorContainerName
{-# INLINE v1ResourceFieldSelectorContainerNameL #-}

-- | 'v1ResourceFieldSelectorDivisor' Lens
v1ResourceFieldSelectorDivisorL :: Lens_' V1ResourceFieldSelector (Maybe Quantity)
v1ResourceFieldSelectorDivisorL f V1ResourceFieldSelector{..} = (\v1ResourceFieldSelectorDivisor -> V1ResourceFieldSelector { v1ResourceFieldSelectorDivisor, ..} ) <$> f v1ResourceFieldSelectorDivisor
{-# INLINE v1ResourceFieldSelectorDivisorL #-}

-- | 'v1ResourceFieldSelectorResource' Lens
v1ResourceFieldSelectorResourceL :: Lens_' V1ResourceFieldSelector (Text)
v1ResourceFieldSelectorResourceL f V1ResourceFieldSelector{..} = (\v1ResourceFieldSelectorResource -> V1ResourceFieldSelector { v1ResourceFieldSelectorResource, ..} ) <$> f v1ResourceFieldSelectorResource
{-# INLINE v1ResourceFieldSelectorResourceL #-}



-- * V1ResourceQuota

-- | 'v1ResourceQuotaApiVersion' Lens
v1ResourceQuotaApiVersionL :: Lens_' V1ResourceQuota (Maybe Text)
v1ResourceQuotaApiVersionL f V1ResourceQuota{..} = (\v1ResourceQuotaApiVersion -> V1ResourceQuota { v1ResourceQuotaApiVersion, ..} ) <$> f v1ResourceQuotaApiVersion
{-# INLINE v1ResourceQuotaApiVersionL #-}

-- | 'v1ResourceQuotaKind' Lens
v1ResourceQuotaKindL :: Lens_' V1ResourceQuota (Maybe Text)
v1ResourceQuotaKindL f V1ResourceQuota{..} = (\v1ResourceQuotaKind -> V1ResourceQuota { v1ResourceQuotaKind, ..} ) <$> f v1ResourceQuotaKind
{-# INLINE v1ResourceQuotaKindL #-}

-- | 'v1ResourceQuotaMetadata' Lens
v1ResourceQuotaMetadataL :: Lens_' V1ResourceQuota (Maybe V1ObjectMeta)
v1ResourceQuotaMetadataL f V1ResourceQuota{..} = (\v1ResourceQuotaMetadata -> V1ResourceQuota { v1ResourceQuotaMetadata, ..} ) <$> f v1ResourceQuotaMetadata
{-# INLINE v1ResourceQuotaMetadataL #-}

-- | 'v1ResourceQuotaSpec' Lens
v1ResourceQuotaSpecL :: Lens_' V1ResourceQuota (Maybe V1ResourceQuotaSpec)
v1ResourceQuotaSpecL f V1ResourceQuota{..} = (\v1ResourceQuotaSpec -> V1ResourceQuota { v1ResourceQuotaSpec, ..} ) <$> f v1ResourceQuotaSpec
{-# INLINE v1ResourceQuotaSpecL #-}

-- | 'v1ResourceQuotaStatus' Lens
v1ResourceQuotaStatusL :: Lens_' V1ResourceQuota (Maybe V1ResourceQuotaStatus)
v1ResourceQuotaStatusL f V1ResourceQuota{..} = (\v1ResourceQuotaStatus -> V1ResourceQuota { v1ResourceQuotaStatus, ..} ) <$> f v1ResourceQuotaStatus
{-# INLINE v1ResourceQuotaStatusL #-}



-- * V1ResourceQuotaList

-- | 'v1ResourceQuotaListApiVersion' Lens
v1ResourceQuotaListApiVersionL :: Lens_' V1ResourceQuotaList (Maybe Text)
v1ResourceQuotaListApiVersionL f V1ResourceQuotaList{..} = (\v1ResourceQuotaListApiVersion -> V1ResourceQuotaList { v1ResourceQuotaListApiVersion, ..} ) <$> f v1ResourceQuotaListApiVersion
{-# INLINE v1ResourceQuotaListApiVersionL #-}

-- | 'v1ResourceQuotaListItems' Lens
v1ResourceQuotaListItemsL :: Lens_' V1ResourceQuotaList ([V1ResourceQuota])
v1ResourceQuotaListItemsL f V1ResourceQuotaList{..} = (\v1ResourceQuotaListItems -> V1ResourceQuotaList { v1ResourceQuotaListItems, ..} ) <$> f v1ResourceQuotaListItems
{-# INLINE v1ResourceQuotaListItemsL #-}

-- | 'v1ResourceQuotaListKind' Lens
v1ResourceQuotaListKindL :: Lens_' V1ResourceQuotaList (Maybe Text)
v1ResourceQuotaListKindL f V1ResourceQuotaList{..} = (\v1ResourceQuotaListKind -> V1ResourceQuotaList { v1ResourceQuotaListKind, ..} ) <$> f v1ResourceQuotaListKind
{-# INLINE v1ResourceQuotaListKindL #-}

-- | 'v1ResourceQuotaListMetadata' Lens
v1ResourceQuotaListMetadataL :: Lens_' V1ResourceQuotaList (Maybe V1ListMeta)
v1ResourceQuotaListMetadataL f V1ResourceQuotaList{..} = (\v1ResourceQuotaListMetadata -> V1ResourceQuotaList { v1ResourceQuotaListMetadata, ..} ) <$> f v1ResourceQuotaListMetadata
{-# INLINE v1ResourceQuotaListMetadataL #-}



-- * V1ResourceQuotaSpec

-- | 'v1ResourceQuotaSpecHard' Lens
v1ResourceQuotaSpecHardL :: Lens_' V1ResourceQuotaSpec (Maybe (Map.Map String Quantity))
v1ResourceQuotaSpecHardL f V1ResourceQuotaSpec{..} = (\v1ResourceQuotaSpecHard -> V1ResourceQuotaSpec { v1ResourceQuotaSpecHard, ..} ) <$> f v1ResourceQuotaSpecHard
{-# INLINE v1ResourceQuotaSpecHardL #-}

-- | 'v1ResourceQuotaSpecScopeSelector' Lens
v1ResourceQuotaSpecScopeSelectorL :: Lens_' V1ResourceQuotaSpec (Maybe V1ScopeSelector)
v1ResourceQuotaSpecScopeSelectorL f V1ResourceQuotaSpec{..} = (\v1ResourceQuotaSpecScopeSelector -> V1ResourceQuotaSpec { v1ResourceQuotaSpecScopeSelector, ..} ) <$> f v1ResourceQuotaSpecScopeSelector
{-# INLINE v1ResourceQuotaSpecScopeSelectorL #-}

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



-- * V1ResourceQuotaStatus

-- | 'v1ResourceQuotaStatusHard' Lens
v1ResourceQuotaStatusHardL :: Lens_' V1ResourceQuotaStatus (Maybe (Map.Map String Quantity))
v1ResourceQuotaStatusHardL f V1ResourceQuotaStatus{..} = (\v1ResourceQuotaStatusHard -> V1ResourceQuotaStatus { v1ResourceQuotaStatusHard, ..} ) <$> f v1ResourceQuotaStatusHard
{-# INLINE v1ResourceQuotaStatusHardL #-}

-- | 'v1ResourceQuotaStatusUsed' Lens
v1ResourceQuotaStatusUsedL :: Lens_' V1ResourceQuotaStatus (Maybe (Map.Map String Quantity))
v1ResourceQuotaStatusUsedL f V1ResourceQuotaStatus{..} = (\v1ResourceQuotaStatusUsed -> V1ResourceQuotaStatus { v1ResourceQuotaStatusUsed, ..} ) <$> f v1ResourceQuotaStatusUsed
{-# INLINE v1ResourceQuotaStatusUsedL #-}



-- * V1ResourceRequirements

-- | 'v1ResourceRequirementsLimits' Lens
v1ResourceRequirementsLimitsL :: Lens_' V1ResourceRequirements (Maybe (Map.Map String Quantity))
v1ResourceRequirementsLimitsL f V1ResourceRequirements{..} = (\v1ResourceRequirementsLimits -> V1ResourceRequirements { v1ResourceRequirementsLimits, ..} ) <$> f v1ResourceRequirementsLimits
{-# INLINE v1ResourceRequirementsLimitsL #-}

-- | 'v1ResourceRequirementsRequests' Lens
v1ResourceRequirementsRequestsL :: Lens_' V1ResourceRequirements (Maybe (Map.Map String Quantity))
v1ResourceRequirementsRequestsL f V1ResourceRequirements{..} = (\v1ResourceRequirementsRequests -> V1ResourceRequirements { v1ResourceRequirementsRequests, ..} ) <$> f v1ResourceRequirementsRequests
{-# INLINE v1ResourceRequirementsRequestsL #-}



-- * V1ResourceRule

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

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

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

-- | 'v1ResourceRuleVerbs' Lens
v1ResourceRuleVerbsL :: Lens_' V1ResourceRule ([Text])
v1ResourceRuleVerbsL f V1ResourceRule{..} = (\v1ResourceRuleVerbs -> V1ResourceRule { v1ResourceRuleVerbs, ..} ) <$> f v1ResourceRuleVerbs
{-# INLINE v1ResourceRuleVerbsL #-}



-- * V1Role

-- | 'v1RoleApiVersion' Lens
v1RoleApiVersionL :: Lens_' V1Role (Maybe Text)
v1RoleApiVersionL f V1Role{..} = (\v1RoleApiVersion -> V1Role { v1RoleApiVersion, ..} ) <$> f v1RoleApiVersion
{-# INLINE v1RoleApiVersionL #-}

-- | 'v1RoleKind' Lens
v1RoleKindL :: Lens_' V1Role (Maybe Text)
v1RoleKindL f V1Role{..} = (\v1RoleKind -> V1Role { v1RoleKind, ..} ) <$> f v1RoleKind
{-# INLINE v1RoleKindL #-}

-- | 'v1RoleMetadata' Lens
v1RoleMetadataL :: Lens_' V1Role (Maybe V1ObjectMeta)
v1RoleMetadataL f V1Role{..} = (\v1RoleMetadata -> V1Role { v1RoleMetadata, ..} ) <$> f v1RoleMetadata
{-# INLINE v1RoleMetadataL #-}

-- | 'v1RoleRules' Lens
v1RoleRulesL :: Lens_' V1Role (Maybe [V1PolicyRule])
v1RoleRulesL f V1Role{..} = (\v1RoleRules -> V1Role { v1RoleRules, ..} ) <$> f v1RoleRules
{-# INLINE v1RoleRulesL #-}



-- * V1RoleBinding

-- | 'v1RoleBindingApiVersion' Lens
v1RoleBindingApiVersionL :: Lens_' V1RoleBinding (Maybe Text)
v1RoleBindingApiVersionL f V1RoleBinding{..} = (\v1RoleBindingApiVersion -> V1RoleBinding { v1RoleBindingApiVersion, ..} ) <$> f v1RoleBindingApiVersion
{-# INLINE v1RoleBindingApiVersionL #-}

-- | 'v1RoleBindingKind' Lens
v1RoleBindingKindL :: Lens_' V1RoleBinding (Maybe Text)
v1RoleBindingKindL f V1RoleBinding{..} = (\v1RoleBindingKind -> V1RoleBinding { v1RoleBindingKind, ..} ) <$> f v1RoleBindingKind
{-# INLINE v1RoleBindingKindL #-}

-- | 'v1RoleBindingMetadata' Lens
v1RoleBindingMetadataL :: Lens_' V1RoleBinding (Maybe V1ObjectMeta)
v1RoleBindingMetadataL f V1RoleBinding{..} = (\v1RoleBindingMetadata -> V1RoleBinding { v1RoleBindingMetadata, ..} ) <$> f v1RoleBindingMetadata
{-# INLINE v1RoleBindingMetadataL #-}

-- | 'v1RoleBindingRoleRef' Lens
v1RoleBindingRoleRefL :: Lens_' V1RoleBinding (V1RoleRef)
v1RoleBindingRoleRefL f V1RoleBinding{..} = (\v1RoleBindingRoleRef -> V1RoleBinding { v1RoleBindingRoleRef, ..} ) <$> f v1RoleBindingRoleRef
{-# INLINE v1RoleBindingRoleRefL #-}

-- | 'v1RoleBindingSubjects' Lens
v1RoleBindingSubjectsL :: Lens_' V1RoleBinding (Maybe [V1Subject])
v1RoleBindingSubjectsL f V1RoleBinding{..} = (\v1RoleBindingSubjects -> V1RoleBinding { v1RoleBindingSubjects, ..} ) <$> f v1RoleBindingSubjects
{-# INLINE v1RoleBindingSubjectsL #-}



-- * V1RoleBindingList

-- | 'v1RoleBindingListApiVersion' Lens
v1RoleBindingListApiVersionL :: Lens_' V1RoleBindingList (Maybe Text)
v1RoleBindingListApiVersionL f V1RoleBindingList{..} = (\v1RoleBindingListApiVersion -> V1RoleBindingList { v1RoleBindingListApiVersion, ..} ) <$> f v1RoleBindingListApiVersion
{-# INLINE v1RoleBindingListApiVersionL #-}

-- | 'v1RoleBindingListItems' Lens
v1RoleBindingListItemsL :: Lens_' V1RoleBindingList ([V1RoleBinding])
v1RoleBindingListItemsL f V1RoleBindingList{..} = (\v1RoleBindingListItems -> V1RoleBindingList { v1RoleBindingListItems, ..} ) <$> f v1RoleBindingListItems
{-# INLINE v1RoleBindingListItemsL #-}

-- | 'v1RoleBindingListKind' Lens
v1RoleBindingListKindL :: Lens_' V1RoleBindingList (Maybe Text)
v1RoleBindingListKindL f V1RoleBindingList{..} = (\v1RoleBindingListKind -> V1RoleBindingList { v1RoleBindingListKind, ..} ) <$> f v1RoleBindingListKind
{-# INLINE v1RoleBindingListKindL #-}

-- | 'v1RoleBindingListMetadata' Lens
v1RoleBindingListMetadataL :: Lens_' V1RoleBindingList (Maybe V1ListMeta)
v1RoleBindingListMetadataL f V1RoleBindingList{..} = (\v1RoleBindingListMetadata -> V1RoleBindingList { v1RoleBindingListMetadata, ..} ) <$> f v1RoleBindingListMetadata
{-# INLINE v1RoleBindingListMetadataL #-}



-- * V1RoleList

-- | 'v1RoleListApiVersion' Lens
v1RoleListApiVersionL :: Lens_' V1RoleList (Maybe Text)
v1RoleListApiVersionL f V1RoleList{..} = (\v1RoleListApiVersion -> V1RoleList { v1RoleListApiVersion, ..} ) <$> f v1RoleListApiVersion
{-# INLINE v1RoleListApiVersionL #-}

-- | 'v1RoleListItems' Lens
v1RoleListItemsL :: Lens_' V1RoleList ([V1Role])
v1RoleListItemsL f V1RoleList{..} = (\v1RoleListItems -> V1RoleList { v1RoleListItems, ..} ) <$> f v1RoleListItems
{-# INLINE v1RoleListItemsL #-}

-- | 'v1RoleListKind' Lens
v1RoleListKindL :: Lens_' V1RoleList (Maybe Text)
v1RoleListKindL f V1RoleList{..} = (\v1RoleListKind -> V1RoleList { v1RoleListKind, ..} ) <$> f v1RoleListKind
{-# INLINE v1RoleListKindL #-}

-- | 'v1RoleListMetadata' Lens
v1RoleListMetadataL :: Lens_' V1RoleList (Maybe V1ListMeta)
v1RoleListMetadataL f V1RoleList{..} = (\v1RoleListMetadata -> V1RoleList { v1RoleListMetadata, ..} ) <$> f v1RoleListMetadata
{-# INLINE v1RoleListMetadataL #-}



-- * V1RoleRef

-- | 'v1RoleRefApiGroup' Lens
v1RoleRefApiGroupL :: Lens_' V1RoleRef (Text)
v1RoleRefApiGroupL f V1RoleRef{..} = (\v1RoleRefApiGroup -> V1RoleRef { v1RoleRefApiGroup, ..} ) <$> f v1RoleRefApiGroup
{-# INLINE v1RoleRefApiGroupL #-}

-- | 'v1RoleRefKind' Lens
v1RoleRefKindL :: Lens_' V1RoleRef (Text)
v1RoleRefKindL f V1RoleRef{..} = (\v1RoleRefKind -> V1RoleRef { v1RoleRefKind, ..} ) <$> f v1RoleRefKind
{-# INLINE v1RoleRefKindL #-}

-- | 'v1RoleRefName' Lens
v1RoleRefNameL :: Lens_' V1RoleRef (Text)
v1RoleRefNameL f V1RoleRef{..} = (\v1RoleRefName -> V1RoleRef { v1RoleRefName, ..} ) <$> f v1RoleRefName
{-# INLINE v1RoleRefNameL #-}



-- * V1RollingUpdateDaemonSet

-- | 'v1RollingUpdateDaemonSetMaxSurge' Lens
v1RollingUpdateDaemonSetMaxSurgeL :: Lens_' V1RollingUpdateDaemonSet (Maybe IntOrString)
v1RollingUpdateDaemonSetMaxSurgeL f V1RollingUpdateDaemonSet{..} = (\v1RollingUpdateDaemonSetMaxSurge -> V1RollingUpdateDaemonSet { v1RollingUpdateDaemonSetMaxSurge, ..} ) <$> f v1RollingUpdateDaemonSetMaxSurge
{-# INLINE v1RollingUpdateDaemonSetMaxSurgeL #-}

-- | 'v1RollingUpdateDaemonSetMaxUnavailable' Lens
v1RollingUpdateDaemonSetMaxUnavailableL :: Lens_' V1RollingUpdateDaemonSet (Maybe IntOrString)
v1RollingUpdateDaemonSetMaxUnavailableL f V1RollingUpdateDaemonSet{..} = (\v1RollingUpdateDaemonSetMaxUnavailable -> V1RollingUpdateDaemonSet { v1RollingUpdateDaemonSetMaxUnavailable, ..} ) <$> f v1RollingUpdateDaemonSetMaxUnavailable
{-# INLINE v1RollingUpdateDaemonSetMaxUnavailableL #-}



-- * V1RollingUpdateDeployment

-- | 'v1RollingUpdateDeploymentMaxSurge' Lens
v1RollingUpdateDeploymentMaxSurgeL :: Lens_' V1RollingUpdateDeployment (Maybe IntOrString)
v1RollingUpdateDeploymentMaxSurgeL f V1RollingUpdateDeployment{..} = (\v1RollingUpdateDeploymentMaxSurge -> V1RollingUpdateDeployment { v1RollingUpdateDeploymentMaxSurge, ..} ) <$> f v1RollingUpdateDeploymentMaxSurge
{-# INLINE v1RollingUpdateDeploymentMaxSurgeL #-}

-- | 'v1RollingUpdateDeploymentMaxUnavailable' Lens
v1RollingUpdateDeploymentMaxUnavailableL :: Lens_' V1RollingUpdateDeployment (Maybe IntOrString)
v1RollingUpdateDeploymentMaxUnavailableL f V1RollingUpdateDeployment{..} = (\v1RollingUpdateDeploymentMaxUnavailable -> V1RollingUpdateDeployment { v1RollingUpdateDeploymentMaxUnavailable, ..} ) <$> f v1RollingUpdateDeploymentMaxUnavailable
{-# INLINE v1RollingUpdateDeploymentMaxUnavailableL #-}



-- * V1RollingUpdateStatefulSetStrategy

-- | 'v1RollingUpdateStatefulSetStrategyPartition' Lens
v1RollingUpdateStatefulSetStrategyPartitionL :: Lens_' V1RollingUpdateStatefulSetStrategy (Maybe Int)
v1RollingUpdateStatefulSetStrategyPartitionL f V1RollingUpdateStatefulSetStrategy{..} = (\v1RollingUpdateStatefulSetStrategyPartition -> V1RollingUpdateStatefulSetStrategy { v1RollingUpdateStatefulSetStrategyPartition, ..} ) <$> f v1RollingUpdateStatefulSetStrategyPartition
{-# INLINE v1RollingUpdateStatefulSetStrategyPartitionL #-}



-- * V1RuleWithOperations

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

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

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

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

-- | 'v1RuleWithOperationsScope' Lens
v1RuleWithOperationsScopeL :: Lens_' V1RuleWithOperations (Maybe Text)
v1RuleWithOperationsScopeL f V1RuleWithOperations{..} = (\v1RuleWithOperationsScope -> V1RuleWithOperations { v1RuleWithOperationsScope, ..} ) <$> f v1RuleWithOperationsScope
{-# INLINE v1RuleWithOperationsScopeL #-}



-- * V1RuntimeClass

-- | 'v1RuntimeClassApiVersion' Lens
v1RuntimeClassApiVersionL :: Lens_' V1RuntimeClass (Maybe Text)
v1RuntimeClassApiVersionL f V1RuntimeClass{..} = (\v1RuntimeClassApiVersion -> V1RuntimeClass { v1RuntimeClassApiVersion, ..} ) <$> f v1RuntimeClassApiVersion
{-# INLINE v1RuntimeClassApiVersionL #-}

-- | 'v1RuntimeClassHandler' Lens
v1RuntimeClassHandlerL :: Lens_' V1RuntimeClass (Text)
v1RuntimeClassHandlerL f V1RuntimeClass{..} = (\v1RuntimeClassHandler -> V1RuntimeClass { v1RuntimeClassHandler, ..} ) <$> f v1RuntimeClassHandler
{-# INLINE v1RuntimeClassHandlerL #-}

-- | 'v1RuntimeClassKind' Lens
v1RuntimeClassKindL :: Lens_' V1RuntimeClass (Maybe Text)
v1RuntimeClassKindL f V1RuntimeClass{..} = (\v1RuntimeClassKind -> V1RuntimeClass { v1RuntimeClassKind, ..} ) <$> f v1RuntimeClassKind
{-# INLINE v1RuntimeClassKindL #-}

-- | 'v1RuntimeClassMetadata' Lens
v1RuntimeClassMetadataL :: Lens_' V1RuntimeClass (Maybe V1ObjectMeta)
v1RuntimeClassMetadataL f V1RuntimeClass{..} = (\v1RuntimeClassMetadata -> V1RuntimeClass { v1RuntimeClassMetadata, ..} ) <$> f v1RuntimeClassMetadata
{-# INLINE v1RuntimeClassMetadataL #-}

-- | 'v1RuntimeClassOverhead' Lens
v1RuntimeClassOverheadL :: Lens_' V1RuntimeClass (Maybe V1Overhead)
v1RuntimeClassOverheadL f V1RuntimeClass{..} = (\v1RuntimeClassOverhead -> V1RuntimeClass { v1RuntimeClassOverhead, ..} ) <$> f v1RuntimeClassOverhead
{-# INLINE v1RuntimeClassOverheadL #-}

-- | 'v1RuntimeClassScheduling' Lens
v1RuntimeClassSchedulingL :: Lens_' V1RuntimeClass (Maybe V1Scheduling)
v1RuntimeClassSchedulingL f V1RuntimeClass{..} = (\v1RuntimeClassScheduling -> V1RuntimeClass { v1RuntimeClassScheduling, ..} ) <$> f v1RuntimeClassScheduling
{-# INLINE v1RuntimeClassSchedulingL #-}



-- * V1RuntimeClassList

-- | 'v1RuntimeClassListApiVersion' Lens
v1RuntimeClassListApiVersionL :: Lens_' V1RuntimeClassList (Maybe Text)
v1RuntimeClassListApiVersionL f V1RuntimeClassList{..} = (\v1RuntimeClassListApiVersion -> V1RuntimeClassList { v1RuntimeClassListApiVersion, ..} ) <$> f v1RuntimeClassListApiVersion
{-# INLINE v1RuntimeClassListApiVersionL #-}

-- | 'v1RuntimeClassListItems' Lens
v1RuntimeClassListItemsL :: Lens_' V1RuntimeClassList ([V1RuntimeClass])
v1RuntimeClassListItemsL f V1RuntimeClassList{..} = (\v1RuntimeClassListItems -> V1RuntimeClassList { v1RuntimeClassListItems, ..} ) <$> f v1RuntimeClassListItems
{-# INLINE v1RuntimeClassListItemsL #-}

-- | 'v1RuntimeClassListKind' Lens
v1RuntimeClassListKindL :: Lens_' V1RuntimeClassList (Maybe Text)
v1RuntimeClassListKindL f V1RuntimeClassList{..} = (\v1RuntimeClassListKind -> V1RuntimeClassList { v1RuntimeClassListKind, ..} ) <$> f v1RuntimeClassListKind
{-# INLINE v1RuntimeClassListKindL #-}

-- | 'v1RuntimeClassListMetadata' Lens
v1RuntimeClassListMetadataL :: Lens_' V1RuntimeClassList (Maybe V1ListMeta)
v1RuntimeClassListMetadataL f V1RuntimeClassList{..} = (\v1RuntimeClassListMetadata -> V1RuntimeClassList { v1RuntimeClassListMetadata, ..} ) <$> f v1RuntimeClassListMetadata
{-# INLINE v1RuntimeClassListMetadataL #-}



-- * V1SELinuxOptions

-- | 'v1SELinuxOptionsLevel' Lens
v1SELinuxOptionsLevelL :: Lens_' V1SELinuxOptions (Maybe Text)
v1SELinuxOptionsLevelL f V1SELinuxOptions{..} = (\v1SELinuxOptionsLevel -> V1SELinuxOptions { v1SELinuxOptionsLevel, ..} ) <$> f v1SELinuxOptionsLevel
{-# INLINE v1SELinuxOptionsLevelL #-}

-- | 'v1SELinuxOptionsRole' Lens
v1SELinuxOptionsRoleL :: Lens_' V1SELinuxOptions (Maybe Text)
v1SELinuxOptionsRoleL f V1SELinuxOptions{..} = (\v1SELinuxOptionsRole -> V1SELinuxOptions { v1SELinuxOptionsRole, ..} ) <$> f v1SELinuxOptionsRole
{-# INLINE v1SELinuxOptionsRoleL #-}

-- | 'v1SELinuxOptionsType' Lens
v1SELinuxOptionsTypeL :: Lens_' V1SELinuxOptions (Maybe Text)
v1SELinuxOptionsTypeL f V1SELinuxOptions{..} = (\v1SELinuxOptionsType -> V1SELinuxOptions { v1SELinuxOptionsType, ..} ) <$> f v1SELinuxOptionsType
{-# INLINE v1SELinuxOptionsTypeL #-}

-- | 'v1SELinuxOptionsUser' Lens
v1SELinuxOptionsUserL :: Lens_' V1SELinuxOptions (Maybe Text)
v1SELinuxOptionsUserL f V1SELinuxOptions{..} = (\v1SELinuxOptionsUser -> V1SELinuxOptions { v1SELinuxOptionsUser, ..} ) <$> f v1SELinuxOptionsUser
{-# INLINE v1SELinuxOptionsUserL #-}



-- * V1Scale

-- | 'v1ScaleApiVersion' Lens
v1ScaleApiVersionL :: Lens_' V1Scale (Maybe Text)
v1ScaleApiVersionL f V1Scale{..} = (\v1ScaleApiVersion -> V1Scale { v1ScaleApiVersion, ..} ) <$> f v1ScaleApiVersion
{-# INLINE v1ScaleApiVersionL #-}

-- | 'v1ScaleKind' Lens
v1ScaleKindL :: Lens_' V1Scale (Maybe Text)
v1ScaleKindL f V1Scale{..} = (\v1ScaleKind -> V1Scale { v1ScaleKind, ..} ) <$> f v1ScaleKind
{-# INLINE v1ScaleKindL #-}

-- | 'v1ScaleMetadata' Lens
v1ScaleMetadataL :: Lens_' V1Scale (Maybe V1ObjectMeta)
v1ScaleMetadataL f V1Scale{..} = (\v1ScaleMetadata -> V1Scale { v1ScaleMetadata, ..} ) <$> f v1ScaleMetadata
{-# INLINE v1ScaleMetadataL #-}

-- | 'v1ScaleSpec' Lens
v1ScaleSpecL :: Lens_' V1Scale (Maybe V1ScaleSpec)
v1ScaleSpecL f V1Scale{..} = (\v1ScaleSpec -> V1Scale { v1ScaleSpec, ..} ) <$> f v1ScaleSpec
{-# INLINE v1ScaleSpecL #-}

-- | 'v1ScaleStatus' Lens
v1ScaleStatusL :: Lens_' V1Scale (Maybe V1ScaleStatus)
v1ScaleStatusL f V1Scale{..} = (\v1ScaleStatus -> V1Scale { v1ScaleStatus, ..} ) <$> f v1ScaleStatus
{-# INLINE v1ScaleStatusL #-}



-- * V1ScaleIOPersistentVolumeSource

-- | 'v1ScaleIOPersistentVolumeSourceFsType' Lens
v1ScaleIOPersistentVolumeSourceFsTypeL :: Lens_' V1ScaleIOPersistentVolumeSource (Maybe Text)
v1ScaleIOPersistentVolumeSourceFsTypeL f V1ScaleIOPersistentVolumeSource{..} = (\v1ScaleIOPersistentVolumeSourceFsType -> V1ScaleIOPersistentVolumeSource { v1ScaleIOPersistentVolumeSourceFsType, ..} ) <$> f v1ScaleIOPersistentVolumeSourceFsType
{-# INLINE v1ScaleIOPersistentVolumeSourceFsTypeL #-}

-- | 'v1ScaleIOPersistentVolumeSourceGateway' Lens
v1ScaleIOPersistentVolumeSourceGatewayL :: Lens_' V1ScaleIOPersistentVolumeSource (Text)
v1ScaleIOPersistentVolumeSourceGatewayL f V1ScaleIOPersistentVolumeSource{..} = (\v1ScaleIOPersistentVolumeSourceGateway -> V1ScaleIOPersistentVolumeSource { v1ScaleIOPersistentVolumeSourceGateway, ..} ) <$> f v1ScaleIOPersistentVolumeSourceGateway
{-# INLINE v1ScaleIOPersistentVolumeSourceGatewayL #-}

-- | 'v1ScaleIOPersistentVolumeSourceProtectionDomain' Lens
v1ScaleIOPersistentVolumeSourceProtectionDomainL :: Lens_' V1ScaleIOPersistentVolumeSource (Maybe Text)
v1ScaleIOPersistentVolumeSourceProtectionDomainL f V1ScaleIOPersistentVolumeSource{..} = (\v1ScaleIOPersistentVolumeSourceProtectionDomain -> V1ScaleIOPersistentVolumeSource { v1ScaleIOPersistentVolumeSourceProtectionDomain, ..} ) <$> f v1ScaleIOPersistentVolumeSourceProtectionDomain
{-# INLINE v1ScaleIOPersistentVolumeSourceProtectionDomainL #-}

-- | 'v1ScaleIOPersistentVolumeSourceReadOnly' Lens
v1ScaleIOPersistentVolumeSourceReadOnlyL :: Lens_' V1ScaleIOPersistentVolumeSource (Maybe Bool)
v1ScaleIOPersistentVolumeSourceReadOnlyL f V1ScaleIOPersistentVolumeSource{..} = (\v1ScaleIOPersistentVolumeSourceReadOnly -> V1ScaleIOPersistentVolumeSource { v1ScaleIOPersistentVolumeSourceReadOnly, ..} ) <$> f v1ScaleIOPersistentVolumeSourceReadOnly
{-# INLINE v1ScaleIOPersistentVolumeSourceReadOnlyL #-}

-- | 'v1ScaleIOPersistentVolumeSourceSecretRef' Lens
v1ScaleIOPersistentVolumeSourceSecretRefL :: Lens_' V1ScaleIOPersistentVolumeSource (V1SecretReference)
v1ScaleIOPersistentVolumeSourceSecretRefL f V1ScaleIOPersistentVolumeSource{..} = (\v1ScaleIOPersistentVolumeSourceSecretRef -> V1ScaleIOPersistentVolumeSource { v1ScaleIOPersistentVolumeSourceSecretRef, ..} ) <$> f v1ScaleIOPersistentVolumeSourceSecretRef
{-# INLINE v1ScaleIOPersistentVolumeSourceSecretRefL #-}

-- | 'v1ScaleIOPersistentVolumeSourceSslEnabled' Lens
v1ScaleIOPersistentVolumeSourceSslEnabledL :: Lens_' V1ScaleIOPersistentVolumeSource (Maybe Bool)
v1ScaleIOPersistentVolumeSourceSslEnabledL f V1ScaleIOPersistentVolumeSource{..} = (\v1ScaleIOPersistentVolumeSourceSslEnabled -> V1ScaleIOPersistentVolumeSource { v1ScaleIOPersistentVolumeSourceSslEnabled, ..} ) <$> f v1ScaleIOPersistentVolumeSourceSslEnabled
{-# INLINE v1ScaleIOPersistentVolumeSourceSslEnabledL #-}

-- | 'v1ScaleIOPersistentVolumeSourceStorageMode' Lens
v1ScaleIOPersistentVolumeSourceStorageModeL :: Lens_' V1ScaleIOPersistentVolumeSource (Maybe Text)
v1ScaleIOPersistentVolumeSourceStorageModeL f V1ScaleIOPersistentVolumeSource{..} = (\v1ScaleIOPersistentVolumeSourceStorageMode -> V1ScaleIOPersistentVolumeSource { v1ScaleIOPersistentVolumeSourceStorageMode, ..} ) <$> f v1ScaleIOPersistentVolumeSourceStorageMode
{-# INLINE v1ScaleIOPersistentVolumeSourceStorageModeL #-}

-- | 'v1ScaleIOPersistentVolumeSourceStoragePool' Lens
v1ScaleIOPersistentVolumeSourceStoragePoolL :: Lens_' V1ScaleIOPersistentVolumeSource (Maybe Text)
v1ScaleIOPersistentVolumeSourceStoragePoolL f V1ScaleIOPersistentVolumeSource{..} = (\v1ScaleIOPersistentVolumeSourceStoragePool -> V1ScaleIOPersistentVolumeSource { v1ScaleIOPersistentVolumeSourceStoragePool, ..} ) <$> f v1ScaleIOPersistentVolumeSourceStoragePool
{-# INLINE v1ScaleIOPersistentVolumeSourceStoragePoolL #-}

-- | 'v1ScaleIOPersistentVolumeSourceSystem' Lens
v1ScaleIOPersistentVolumeSourceSystemL :: Lens_' V1ScaleIOPersistentVolumeSource (Text)
v1ScaleIOPersistentVolumeSourceSystemL f V1ScaleIOPersistentVolumeSource{..} = (\v1ScaleIOPersistentVolumeSourceSystem -> V1ScaleIOPersistentVolumeSource { v1ScaleIOPersistentVolumeSourceSystem, ..} ) <$> f v1ScaleIOPersistentVolumeSourceSystem
{-# INLINE v1ScaleIOPersistentVolumeSourceSystemL #-}

-- | 'v1ScaleIOPersistentVolumeSourceVolumeName' Lens
v1ScaleIOPersistentVolumeSourceVolumeNameL :: Lens_' V1ScaleIOPersistentVolumeSource (Maybe Text)
v1ScaleIOPersistentVolumeSourceVolumeNameL f V1ScaleIOPersistentVolumeSource{..} = (\v1ScaleIOPersistentVolumeSourceVolumeName -> V1ScaleIOPersistentVolumeSource { v1ScaleIOPersistentVolumeSourceVolumeName, ..} ) <$> f v1ScaleIOPersistentVolumeSourceVolumeName
{-# INLINE v1ScaleIOPersistentVolumeSourceVolumeNameL #-}



-- * V1ScaleIOVolumeSource

-- | 'v1ScaleIOVolumeSourceFsType' Lens
v1ScaleIOVolumeSourceFsTypeL :: Lens_' V1ScaleIOVolumeSource (Maybe Text)
v1ScaleIOVolumeSourceFsTypeL f V1ScaleIOVolumeSource{..} = (\v1ScaleIOVolumeSourceFsType -> V1ScaleIOVolumeSource { v1ScaleIOVolumeSourceFsType, ..} ) <$> f v1ScaleIOVolumeSourceFsType
{-# INLINE v1ScaleIOVolumeSourceFsTypeL #-}

-- | 'v1ScaleIOVolumeSourceGateway' Lens
v1ScaleIOVolumeSourceGatewayL :: Lens_' V1ScaleIOVolumeSource (Text)
v1ScaleIOVolumeSourceGatewayL f V1ScaleIOVolumeSource{..} = (\v1ScaleIOVolumeSourceGateway -> V1ScaleIOVolumeSource { v1ScaleIOVolumeSourceGateway, ..} ) <$> f v1ScaleIOVolumeSourceGateway
{-# INLINE v1ScaleIOVolumeSourceGatewayL #-}

-- | 'v1ScaleIOVolumeSourceProtectionDomain' Lens
v1ScaleIOVolumeSourceProtectionDomainL :: Lens_' V1ScaleIOVolumeSource (Maybe Text)
v1ScaleIOVolumeSourceProtectionDomainL f V1ScaleIOVolumeSource{..} = (\v1ScaleIOVolumeSourceProtectionDomain -> V1ScaleIOVolumeSource { v1ScaleIOVolumeSourceProtectionDomain, ..} ) <$> f v1ScaleIOVolumeSourceProtectionDomain
{-# INLINE v1ScaleIOVolumeSourceProtectionDomainL #-}

-- | 'v1ScaleIOVolumeSourceReadOnly' Lens
v1ScaleIOVolumeSourceReadOnlyL :: Lens_' V1ScaleIOVolumeSource (Maybe Bool)
v1ScaleIOVolumeSourceReadOnlyL f V1ScaleIOVolumeSource{..} = (\v1ScaleIOVolumeSourceReadOnly -> V1ScaleIOVolumeSource { v1ScaleIOVolumeSourceReadOnly, ..} ) <$> f v1ScaleIOVolumeSourceReadOnly
{-# INLINE v1ScaleIOVolumeSourceReadOnlyL #-}

-- | 'v1ScaleIOVolumeSourceSecretRef' Lens
v1ScaleIOVolumeSourceSecretRefL :: Lens_' V1ScaleIOVolumeSource (V1LocalObjectReference)
v1ScaleIOVolumeSourceSecretRefL f V1ScaleIOVolumeSource{..} = (\v1ScaleIOVolumeSourceSecretRef -> V1ScaleIOVolumeSource { v1ScaleIOVolumeSourceSecretRef, ..} ) <$> f v1ScaleIOVolumeSourceSecretRef
{-# INLINE v1ScaleIOVolumeSourceSecretRefL #-}

-- | 'v1ScaleIOVolumeSourceSslEnabled' Lens
v1ScaleIOVolumeSourceSslEnabledL :: Lens_' V1ScaleIOVolumeSource (Maybe Bool)
v1ScaleIOVolumeSourceSslEnabledL f V1ScaleIOVolumeSource{..} = (\v1ScaleIOVolumeSourceSslEnabled -> V1ScaleIOVolumeSource { v1ScaleIOVolumeSourceSslEnabled, ..} ) <$> f v1ScaleIOVolumeSourceSslEnabled
{-# INLINE v1ScaleIOVolumeSourceSslEnabledL #-}

-- | 'v1ScaleIOVolumeSourceStorageMode' Lens
v1ScaleIOVolumeSourceStorageModeL :: Lens_' V1ScaleIOVolumeSource (Maybe Text)
v1ScaleIOVolumeSourceStorageModeL f V1ScaleIOVolumeSource{..} = (\v1ScaleIOVolumeSourceStorageMode -> V1ScaleIOVolumeSource { v1ScaleIOVolumeSourceStorageMode, ..} ) <$> f v1ScaleIOVolumeSourceStorageMode
{-# INLINE v1ScaleIOVolumeSourceStorageModeL #-}

-- | 'v1ScaleIOVolumeSourceStoragePool' Lens
v1ScaleIOVolumeSourceStoragePoolL :: Lens_' V1ScaleIOVolumeSource (Maybe Text)
v1ScaleIOVolumeSourceStoragePoolL f V1ScaleIOVolumeSource{..} = (\v1ScaleIOVolumeSourceStoragePool -> V1ScaleIOVolumeSource { v1ScaleIOVolumeSourceStoragePool, ..} ) <$> f v1ScaleIOVolumeSourceStoragePool
{-# INLINE v1ScaleIOVolumeSourceStoragePoolL #-}

-- | 'v1ScaleIOVolumeSourceSystem' Lens
v1ScaleIOVolumeSourceSystemL :: Lens_' V1ScaleIOVolumeSource (Text)
v1ScaleIOVolumeSourceSystemL f V1ScaleIOVolumeSource{..} = (\v1ScaleIOVolumeSourceSystem -> V1ScaleIOVolumeSource { v1ScaleIOVolumeSourceSystem, ..} ) <$> f v1ScaleIOVolumeSourceSystem
{-# INLINE v1ScaleIOVolumeSourceSystemL #-}

-- | 'v1ScaleIOVolumeSourceVolumeName' Lens
v1ScaleIOVolumeSourceVolumeNameL :: Lens_' V1ScaleIOVolumeSource (Maybe Text)
v1ScaleIOVolumeSourceVolumeNameL f V1ScaleIOVolumeSource{..} = (\v1ScaleIOVolumeSourceVolumeName -> V1ScaleIOVolumeSource { v1ScaleIOVolumeSourceVolumeName, ..} ) <$> f v1ScaleIOVolumeSourceVolumeName
{-# INLINE v1ScaleIOVolumeSourceVolumeNameL #-}



-- * V1ScaleSpec

-- | 'v1ScaleSpecReplicas' Lens
v1ScaleSpecReplicasL :: Lens_' V1ScaleSpec (Maybe Int)
v1ScaleSpecReplicasL f V1ScaleSpec{..} = (\v1ScaleSpecReplicas -> V1ScaleSpec { v1ScaleSpecReplicas, ..} ) <$> f v1ScaleSpecReplicas
{-# INLINE v1ScaleSpecReplicasL #-}



-- * V1ScaleStatus

-- | 'v1ScaleStatusReplicas' Lens
v1ScaleStatusReplicasL :: Lens_' V1ScaleStatus (Int)
v1ScaleStatusReplicasL f V1ScaleStatus{..} = (\v1ScaleStatusReplicas -> V1ScaleStatus { v1ScaleStatusReplicas, ..} ) <$> f v1ScaleStatusReplicas
{-# INLINE v1ScaleStatusReplicasL #-}

-- | 'v1ScaleStatusSelector' Lens
v1ScaleStatusSelectorL :: Lens_' V1ScaleStatus (Maybe Text)
v1ScaleStatusSelectorL f V1ScaleStatus{..} = (\v1ScaleStatusSelector -> V1ScaleStatus { v1ScaleStatusSelector, ..} ) <$> f v1ScaleStatusSelector
{-# INLINE v1ScaleStatusSelectorL #-}



-- * V1Scheduling

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

-- | 'v1SchedulingTolerations' Lens
v1SchedulingTolerationsL :: Lens_' V1Scheduling (Maybe [V1Toleration])
v1SchedulingTolerationsL f V1Scheduling{..} = (\v1SchedulingTolerations -> V1Scheduling { v1SchedulingTolerations, ..} ) <$> f v1SchedulingTolerations
{-# INLINE v1SchedulingTolerationsL #-}



-- * V1ScopeSelector

-- | 'v1ScopeSelectorMatchExpressions' Lens
v1ScopeSelectorMatchExpressionsL :: Lens_' V1ScopeSelector (Maybe [V1ScopedResourceSelectorRequirement])
v1ScopeSelectorMatchExpressionsL f V1ScopeSelector{..} = (\v1ScopeSelectorMatchExpressions -> V1ScopeSelector { v1ScopeSelectorMatchExpressions, ..} ) <$> f v1ScopeSelectorMatchExpressions
{-# INLINE v1ScopeSelectorMatchExpressionsL #-}



-- * V1ScopedResourceSelectorRequirement

-- | 'v1ScopedResourceSelectorRequirementOperator' Lens
v1ScopedResourceSelectorRequirementOperatorL :: Lens_' V1ScopedResourceSelectorRequirement (Text)
v1ScopedResourceSelectorRequirementOperatorL f V1ScopedResourceSelectorRequirement{..} = (\v1ScopedResourceSelectorRequirementOperator -> V1ScopedResourceSelectorRequirement { v1ScopedResourceSelectorRequirementOperator, ..} ) <$> f v1ScopedResourceSelectorRequirementOperator
{-# INLINE v1ScopedResourceSelectorRequirementOperatorL #-}

-- | 'v1ScopedResourceSelectorRequirementScopeName' Lens
v1ScopedResourceSelectorRequirementScopeNameL :: Lens_' V1ScopedResourceSelectorRequirement (Text)
v1ScopedResourceSelectorRequirementScopeNameL f V1ScopedResourceSelectorRequirement{..} = (\v1ScopedResourceSelectorRequirementScopeName -> V1ScopedResourceSelectorRequirement { v1ScopedResourceSelectorRequirementScopeName, ..} ) <$> f v1ScopedResourceSelectorRequirementScopeName
{-# INLINE v1ScopedResourceSelectorRequirementScopeNameL #-}

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



-- * V1SeccompProfile

-- | 'v1SeccompProfileLocalhostProfile' Lens
v1SeccompProfileLocalhostProfileL :: Lens_' V1SeccompProfile (Maybe Text)
v1SeccompProfileLocalhostProfileL f V1SeccompProfile{..} = (\v1SeccompProfileLocalhostProfile -> V1SeccompProfile { v1SeccompProfileLocalhostProfile, ..} ) <$> f v1SeccompProfileLocalhostProfile
{-# INLINE v1SeccompProfileLocalhostProfileL #-}

-- | 'v1SeccompProfileType' Lens
v1SeccompProfileTypeL :: Lens_' V1SeccompProfile (Text)
v1SeccompProfileTypeL f V1SeccompProfile{..} = (\v1SeccompProfileType -> V1SeccompProfile { v1SeccompProfileType, ..} ) <$> f v1SeccompProfileType
{-# INLINE v1SeccompProfileTypeL #-}



-- * V1Secret

-- | 'v1SecretApiVersion' Lens
v1SecretApiVersionL :: Lens_' V1Secret (Maybe Text)
v1SecretApiVersionL f V1Secret{..} = (\v1SecretApiVersion -> V1Secret { v1SecretApiVersion, ..} ) <$> f v1SecretApiVersion
{-# INLINE v1SecretApiVersionL #-}

-- | 'v1SecretData' Lens
v1SecretDataL :: Lens_' V1Secret (Maybe (Map.Map String ByteArray))
v1SecretDataL f V1Secret{..} = (\v1SecretData -> V1Secret { v1SecretData, ..} ) <$> f v1SecretData
{-# INLINE v1SecretDataL #-}

-- | 'v1SecretImmutable' Lens
v1SecretImmutableL :: Lens_' V1Secret (Maybe Bool)
v1SecretImmutableL f V1Secret{..} = (\v1SecretImmutable -> V1Secret { v1SecretImmutable, ..} ) <$> f v1SecretImmutable
{-# INLINE v1SecretImmutableL #-}

-- | 'v1SecretKind' Lens
v1SecretKindL :: Lens_' V1Secret (Maybe Text)
v1SecretKindL f V1Secret{..} = (\v1SecretKind -> V1Secret { v1SecretKind, ..} ) <$> f v1SecretKind
{-# INLINE v1SecretKindL #-}

-- | 'v1SecretMetadata' Lens
v1SecretMetadataL :: Lens_' V1Secret (Maybe V1ObjectMeta)
v1SecretMetadataL f V1Secret{..} = (\v1SecretMetadata -> V1Secret { v1SecretMetadata, ..} ) <$> f v1SecretMetadata
{-# INLINE v1SecretMetadataL #-}

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

-- | 'v1SecretType' Lens
v1SecretTypeL :: Lens_' V1Secret (Maybe Text)
v1SecretTypeL f V1Secret{..} = (\v1SecretType -> V1Secret { v1SecretType, ..} ) <$> f v1SecretType
{-# INLINE v1SecretTypeL #-}



-- * V1SecretEnvSource

-- | 'v1SecretEnvSourceName' Lens
v1SecretEnvSourceNameL :: Lens_' V1SecretEnvSource (Maybe Text)
v1SecretEnvSourceNameL f V1SecretEnvSource{..} = (\v1SecretEnvSourceName -> V1SecretEnvSource { v1SecretEnvSourceName, ..} ) <$> f v1SecretEnvSourceName
{-# INLINE v1SecretEnvSourceNameL #-}

-- | 'v1SecretEnvSourceOptional' Lens
v1SecretEnvSourceOptionalL :: Lens_' V1SecretEnvSource (Maybe Bool)
v1SecretEnvSourceOptionalL f V1SecretEnvSource{..} = (\v1SecretEnvSourceOptional -> V1SecretEnvSource { v1SecretEnvSourceOptional, ..} ) <$> f v1SecretEnvSourceOptional
{-# INLINE v1SecretEnvSourceOptionalL #-}



-- * V1SecretKeySelector

-- | 'v1SecretKeySelectorKey' Lens
v1SecretKeySelectorKeyL :: Lens_' V1SecretKeySelector (Text)
v1SecretKeySelectorKeyL f V1SecretKeySelector{..} = (\v1SecretKeySelectorKey -> V1SecretKeySelector { v1SecretKeySelectorKey, ..} ) <$> f v1SecretKeySelectorKey
{-# INLINE v1SecretKeySelectorKeyL #-}

-- | 'v1SecretKeySelectorName' Lens
v1SecretKeySelectorNameL :: Lens_' V1SecretKeySelector (Maybe Text)
v1SecretKeySelectorNameL f V1SecretKeySelector{..} = (\v1SecretKeySelectorName -> V1SecretKeySelector { v1SecretKeySelectorName, ..} ) <$> f v1SecretKeySelectorName
{-# INLINE v1SecretKeySelectorNameL #-}

-- | 'v1SecretKeySelectorOptional' Lens
v1SecretKeySelectorOptionalL :: Lens_' V1SecretKeySelector (Maybe Bool)
v1SecretKeySelectorOptionalL f V1SecretKeySelector{..} = (\v1SecretKeySelectorOptional -> V1SecretKeySelector { v1SecretKeySelectorOptional, ..} ) <$> f v1SecretKeySelectorOptional
{-# INLINE v1SecretKeySelectorOptionalL #-}



-- * V1SecretList

-- | 'v1SecretListApiVersion' Lens
v1SecretListApiVersionL :: Lens_' V1SecretList (Maybe Text)
v1SecretListApiVersionL f V1SecretList{..} = (\v1SecretListApiVersion -> V1SecretList { v1SecretListApiVersion, ..} ) <$> f v1SecretListApiVersion
{-# INLINE v1SecretListApiVersionL #-}

-- | 'v1SecretListItems' Lens
v1SecretListItemsL :: Lens_' V1SecretList ([V1Secret])
v1SecretListItemsL f V1SecretList{..} = (\v1SecretListItems -> V1SecretList { v1SecretListItems, ..} ) <$> f v1SecretListItems
{-# INLINE v1SecretListItemsL #-}

-- | 'v1SecretListKind' Lens
v1SecretListKindL :: Lens_' V1SecretList (Maybe Text)
v1SecretListKindL f V1SecretList{..} = (\v1SecretListKind -> V1SecretList { v1SecretListKind, ..} ) <$> f v1SecretListKind
{-# INLINE v1SecretListKindL #-}

-- | 'v1SecretListMetadata' Lens
v1SecretListMetadataL :: Lens_' V1SecretList (Maybe V1ListMeta)
v1SecretListMetadataL f V1SecretList{..} = (\v1SecretListMetadata -> V1SecretList { v1SecretListMetadata, ..} ) <$> f v1SecretListMetadata
{-# INLINE v1SecretListMetadataL #-}



-- * V1SecretProjection

-- | 'v1SecretProjectionItems' Lens
v1SecretProjectionItemsL :: Lens_' V1SecretProjection (Maybe [V1KeyToPath])
v1SecretProjectionItemsL f V1SecretProjection{..} = (\v1SecretProjectionItems -> V1SecretProjection { v1SecretProjectionItems, ..} ) <$> f v1SecretProjectionItems
{-# INLINE v1SecretProjectionItemsL #-}

-- | 'v1SecretProjectionName' Lens
v1SecretProjectionNameL :: Lens_' V1SecretProjection (Maybe Text)
v1SecretProjectionNameL f V1SecretProjection{..} = (\v1SecretProjectionName -> V1SecretProjection { v1SecretProjectionName, ..} ) <$> f v1SecretProjectionName
{-# INLINE v1SecretProjectionNameL #-}

-- | 'v1SecretProjectionOptional' Lens
v1SecretProjectionOptionalL :: Lens_' V1SecretProjection (Maybe Bool)
v1SecretProjectionOptionalL f V1SecretProjection{..} = (\v1SecretProjectionOptional -> V1SecretProjection { v1SecretProjectionOptional, ..} ) <$> f v1SecretProjectionOptional
{-# INLINE v1SecretProjectionOptionalL #-}



-- * V1SecretReference

-- | 'v1SecretReferenceName' Lens
v1SecretReferenceNameL :: Lens_' V1SecretReference (Maybe Text)
v1SecretReferenceNameL f V1SecretReference{..} = (\v1SecretReferenceName -> V1SecretReference { v1SecretReferenceName, ..} ) <$> f v1SecretReferenceName
{-# INLINE v1SecretReferenceNameL #-}

-- | 'v1SecretReferenceNamespace' Lens
v1SecretReferenceNamespaceL :: Lens_' V1SecretReference (Maybe Text)
v1SecretReferenceNamespaceL f V1SecretReference{..} = (\v1SecretReferenceNamespace -> V1SecretReference { v1SecretReferenceNamespace, ..} ) <$> f v1SecretReferenceNamespace
{-# INLINE v1SecretReferenceNamespaceL #-}



-- * V1SecretVolumeSource

-- | 'v1SecretVolumeSourceDefaultMode' Lens
v1SecretVolumeSourceDefaultModeL :: Lens_' V1SecretVolumeSource (Maybe Int)
v1SecretVolumeSourceDefaultModeL f V1SecretVolumeSource{..} = (\v1SecretVolumeSourceDefaultMode -> V1SecretVolumeSource { v1SecretVolumeSourceDefaultMode, ..} ) <$> f v1SecretVolumeSourceDefaultMode
{-# INLINE v1SecretVolumeSourceDefaultModeL #-}

-- | 'v1SecretVolumeSourceItems' Lens
v1SecretVolumeSourceItemsL :: Lens_' V1SecretVolumeSource (Maybe [V1KeyToPath])
v1SecretVolumeSourceItemsL f V1SecretVolumeSource{..} = (\v1SecretVolumeSourceItems -> V1SecretVolumeSource { v1SecretVolumeSourceItems, ..} ) <$> f v1SecretVolumeSourceItems
{-# INLINE v1SecretVolumeSourceItemsL #-}

-- | 'v1SecretVolumeSourceOptional' Lens
v1SecretVolumeSourceOptionalL :: Lens_' V1SecretVolumeSource (Maybe Bool)
v1SecretVolumeSourceOptionalL f V1SecretVolumeSource{..} = (\v1SecretVolumeSourceOptional -> V1SecretVolumeSource { v1SecretVolumeSourceOptional, ..} ) <$> f v1SecretVolumeSourceOptional
{-# INLINE v1SecretVolumeSourceOptionalL #-}

-- | 'v1SecretVolumeSourceSecretName' Lens
v1SecretVolumeSourceSecretNameL :: Lens_' V1SecretVolumeSource (Maybe Text)
v1SecretVolumeSourceSecretNameL f V1SecretVolumeSource{..} = (\v1SecretVolumeSourceSecretName -> V1SecretVolumeSource { v1SecretVolumeSourceSecretName, ..} ) <$> f v1SecretVolumeSourceSecretName
{-# INLINE v1SecretVolumeSourceSecretNameL #-}



-- * V1SecurityContext

-- | 'v1SecurityContextAllowPrivilegeEscalation' Lens
v1SecurityContextAllowPrivilegeEscalationL :: Lens_' V1SecurityContext (Maybe Bool)
v1SecurityContextAllowPrivilegeEscalationL f V1SecurityContext{..} = (\v1SecurityContextAllowPrivilegeEscalation -> V1SecurityContext { v1SecurityContextAllowPrivilegeEscalation, ..} ) <$> f v1SecurityContextAllowPrivilegeEscalation
{-# INLINE v1SecurityContextAllowPrivilegeEscalationL #-}

-- | 'v1SecurityContextCapabilities' Lens
v1SecurityContextCapabilitiesL :: Lens_' V1SecurityContext (Maybe V1Capabilities)
v1SecurityContextCapabilitiesL f V1SecurityContext{..} = (\v1SecurityContextCapabilities -> V1SecurityContext { v1SecurityContextCapabilities, ..} ) <$> f v1SecurityContextCapabilities
{-# INLINE v1SecurityContextCapabilitiesL #-}

-- | 'v1SecurityContextPrivileged' Lens
v1SecurityContextPrivilegedL :: Lens_' V1SecurityContext (Maybe Bool)
v1SecurityContextPrivilegedL f V1SecurityContext{..} = (\v1SecurityContextPrivileged -> V1SecurityContext { v1SecurityContextPrivileged, ..} ) <$> f v1SecurityContextPrivileged
{-# INLINE v1SecurityContextPrivilegedL #-}

-- | 'v1SecurityContextProcMount' Lens
v1SecurityContextProcMountL :: Lens_' V1SecurityContext (Maybe Text)
v1SecurityContextProcMountL f V1SecurityContext{..} = (\v1SecurityContextProcMount -> V1SecurityContext { v1SecurityContextProcMount, ..} ) <$> f v1SecurityContextProcMount
{-# INLINE v1SecurityContextProcMountL #-}

-- | 'v1SecurityContextReadOnlyRootFilesystem' Lens
v1SecurityContextReadOnlyRootFilesystemL :: Lens_' V1SecurityContext (Maybe Bool)
v1SecurityContextReadOnlyRootFilesystemL f V1SecurityContext{..} = (\v1SecurityContextReadOnlyRootFilesystem -> V1SecurityContext { v1SecurityContextReadOnlyRootFilesystem, ..} ) <$> f v1SecurityContextReadOnlyRootFilesystem
{-# INLINE v1SecurityContextReadOnlyRootFilesystemL #-}

-- | 'v1SecurityContextRunAsGroup' Lens
v1SecurityContextRunAsGroupL :: Lens_' V1SecurityContext (Maybe Integer)
v1SecurityContextRunAsGroupL f V1SecurityContext{..} = (\v1SecurityContextRunAsGroup -> V1SecurityContext { v1SecurityContextRunAsGroup, ..} ) <$> f v1SecurityContextRunAsGroup
{-# INLINE v1SecurityContextRunAsGroupL #-}

-- | 'v1SecurityContextRunAsNonRoot' Lens
v1SecurityContextRunAsNonRootL :: Lens_' V1SecurityContext (Maybe Bool)
v1SecurityContextRunAsNonRootL f V1SecurityContext{..} = (\v1SecurityContextRunAsNonRoot -> V1SecurityContext { v1SecurityContextRunAsNonRoot, ..} ) <$> f v1SecurityContextRunAsNonRoot
{-# INLINE v1SecurityContextRunAsNonRootL #-}

-- | 'v1SecurityContextRunAsUser' Lens
v1SecurityContextRunAsUserL :: Lens_' V1SecurityContext (Maybe Integer)
v1SecurityContextRunAsUserL f V1SecurityContext{..} = (\v1SecurityContextRunAsUser -> V1SecurityContext { v1SecurityContextRunAsUser, ..} ) <$> f v1SecurityContextRunAsUser
{-# INLINE v1SecurityContextRunAsUserL #-}

-- | 'v1SecurityContextSeLinuxOptions' Lens
v1SecurityContextSeLinuxOptionsL :: Lens_' V1SecurityContext (Maybe V1SELinuxOptions)
v1SecurityContextSeLinuxOptionsL f V1SecurityContext{..} = (\v1SecurityContextSeLinuxOptions -> V1SecurityContext { v1SecurityContextSeLinuxOptions, ..} ) <$> f v1SecurityContextSeLinuxOptions
{-# INLINE v1SecurityContextSeLinuxOptionsL #-}

-- | 'v1SecurityContextSeccompProfile' Lens
v1SecurityContextSeccompProfileL :: Lens_' V1SecurityContext (Maybe V1SeccompProfile)
v1SecurityContextSeccompProfileL f V1SecurityContext{..} = (\v1SecurityContextSeccompProfile -> V1SecurityContext { v1SecurityContextSeccompProfile, ..} ) <$> f v1SecurityContextSeccompProfile
{-# INLINE v1SecurityContextSeccompProfileL #-}

-- | 'v1SecurityContextWindowsOptions' Lens
v1SecurityContextWindowsOptionsL :: Lens_' V1SecurityContext (Maybe V1WindowsSecurityContextOptions)
v1SecurityContextWindowsOptionsL f V1SecurityContext{..} = (\v1SecurityContextWindowsOptions -> V1SecurityContext { v1SecurityContextWindowsOptions, ..} ) <$> f v1SecurityContextWindowsOptions
{-# INLINE v1SecurityContextWindowsOptionsL #-}



-- * V1SelfSubjectAccessReview

-- | 'v1SelfSubjectAccessReviewApiVersion' Lens
v1SelfSubjectAccessReviewApiVersionL :: Lens_' V1SelfSubjectAccessReview (Maybe Text)
v1SelfSubjectAccessReviewApiVersionL f V1SelfSubjectAccessReview{..} = (\v1SelfSubjectAccessReviewApiVersion -> V1SelfSubjectAccessReview { v1SelfSubjectAccessReviewApiVersion, ..} ) <$> f v1SelfSubjectAccessReviewApiVersion
{-# INLINE v1SelfSubjectAccessReviewApiVersionL #-}

-- | 'v1SelfSubjectAccessReviewKind' Lens
v1SelfSubjectAccessReviewKindL :: Lens_' V1SelfSubjectAccessReview (Maybe Text)
v1SelfSubjectAccessReviewKindL f V1SelfSubjectAccessReview{..} = (\v1SelfSubjectAccessReviewKind -> V1SelfSubjectAccessReview { v1SelfSubjectAccessReviewKind, ..} ) <$> f v1SelfSubjectAccessReviewKind
{-# INLINE v1SelfSubjectAccessReviewKindL #-}

-- | 'v1SelfSubjectAccessReviewMetadata' Lens
v1SelfSubjectAccessReviewMetadataL :: Lens_' V1SelfSubjectAccessReview (Maybe V1ObjectMeta)
v1SelfSubjectAccessReviewMetadataL f V1SelfSubjectAccessReview{..} = (\v1SelfSubjectAccessReviewMetadata -> V1SelfSubjectAccessReview { v1SelfSubjectAccessReviewMetadata, ..} ) <$> f v1SelfSubjectAccessReviewMetadata
{-# INLINE v1SelfSubjectAccessReviewMetadataL #-}

-- | 'v1SelfSubjectAccessReviewSpec' Lens
v1SelfSubjectAccessReviewSpecL :: Lens_' V1SelfSubjectAccessReview (V1SelfSubjectAccessReviewSpec)
v1SelfSubjectAccessReviewSpecL f V1SelfSubjectAccessReview{..} = (\v1SelfSubjectAccessReviewSpec -> V1SelfSubjectAccessReview { v1SelfSubjectAccessReviewSpec, ..} ) <$> f v1SelfSubjectAccessReviewSpec
{-# INLINE v1SelfSubjectAccessReviewSpecL #-}

-- | 'v1SelfSubjectAccessReviewStatus' Lens
v1SelfSubjectAccessReviewStatusL :: Lens_' V1SelfSubjectAccessReview (Maybe V1SubjectAccessReviewStatus)
v1SelfSubjectAccessReviewStatusL f V1SelfSubjectAccessReview{..} = (\v1SelfSubjectAccessReviewStatus -> V1SelfSubjectAccessReview { v1SelfSubjectAccessReviewStatus, ..} ) <$> f v1SelfSubjectAccessReviewStatus
{-# INLINE v1SelfSubjectAccessReviewStatusL #-}



-- * V1SelfSubjectAccessReviewSpec

-- | 'v1SelfSubjectAccessReviewSpecNonResourceAttributes' Lens
v1SelfSubjectAccessReviewSpecNonResourceAttributesL :: Lens_' V1SelfSubjectAccessReviewSpec (Maybe V1NonResourceAttributes)
v1SelfSubjectAccessReviewSpecNonResourceAttributesL f V1SelfSubjectAccessReviewSpec{..} = (\v1SelfSubjectAccessReviewSpecNonResourceAttributes -> V1SelfSubjectAccessReviewSpec { v1SelfSubjectAccessReviewSpecNonResourceAttributes, ..} ) <$> f v1SelfSubjectAccessReviewSpecNonResourceAttributes
{-# INLINE v1SelfSubjectAccessReviewSpecNonResourceAttributesL #-}

-- | 'v1SelfSubjectAccessReviewSpecResourceAttributes' Lens
v1SelfSubjectAccessReviewSpecResourceAttributesL :: Lens_' V1SelfSubjectAccessReviewSpec (Maybe V1ResourceAttributes)
v1SelfSubjectAccessReviewSpecResourceAttributesL f V1SelfSubjectAccessReviewSpec{..} = (\v1SelfSubjectAccessReviewSpecResourceAttributes -> V1SelfSubjectAccessReviewSpec { v1SelfSubjectAccessReviewSpecResourceAttributes, ..} ) <$> f v1SelfSubjectAccessReviewSpecResourceAttributes
{-# INLINE v1SelfSubjectAccessReviewSpecResourceAttributesL #-}



-- * V1SelfSubjectRulesReview

-- | 'v1SelfSubjectRulesReviewApiVersion' Lens
v1SelfSubjectRulesReviewApiVersionL :: Lens_' V1SelfSubjectRulesReview (Maybe Text)
v1SelfSubjectRulesReviewApiVersionL f V1SelfSubjectRulesReview{..} = (\v1SelfSubjectRulesReviewApiVersion -> V1SelfSubjectRulesReview { v1SelfSubjectRulesReviewApiVersion, ..} ) <$> f v1SelfSubjectRulesReviewApiVersion
{-# INLINE v1SelfSubjectRulesReviewApiVersionL #-}

-- | 'v1SelfSubjectRulesReviewKind' Lens
v1SelfSubjectRulesReviewKindL :: Lens_' V1SelfSubjectRulesReview (Maybe Text)
v1SelfSubjectRulesReviewKindL f V1SelfSubjectRulesReview{..} = (\v1SelfSubjectRulesReviewKind -> V1SelfSubjectRulesReview { v1SelfSubjectRulesReviewKind, ..} ) <$> f v1SelfSubjectRulesReviewKind
{-# INLINE v1SelfSubjectRulesReviewKindL #-}

-- | 'v1SelfSubjectRulesReviewMetadata' Lens
v1SelfSubjectRulesReviewMetadataL :: Lens_' V1SelfSubjectRulesReview (Maybe V1ObjectMeta)
v1SelfSubjectRulesReviewMetadataL f V1SelfSubjectRulesReview{..} = (\v1SelfSubjectRulesReviewMetadata -> V1SelfSubjectRulesReview { v1SelfSubjectRulesReviewMetadata, ..} ) <$> f v1SelfSubjectRulesReviewMetadata
{-# INLINE v1SelfSubjectRulesReviewMetadataL #-}

-- | 'v1SelfSubjectRulesReviewSpec' Lens
v1SelfSubjectRulesReviewSpecL :: Lens_' V1SelfSubjectRulesReview (V1SelfSubjectRulesReviewSpec)
v1SelfSubjectRulesReviewSpecL f V1SelfSubjectRulesReview{..} = (\v1SelfSubjectRulesReviewSpec -> V1SelfSubjectRulesReview { v1SelfSubjectRulesReviewSpec, ..} ) <$> f v1SelfSubjectRulesReviewSpec
{-# INLINE v1SelfSubjectRulesReviewSpecL #-}

-- | 'v1SelfSubjectRulesReviewStatus' Lens
v1SelfSubjectRulesReviewStatusL :: Lens_' V1SelfSubjectRulesReview (Maybe V1SubjectRulesReviewStatus)
v1SelfSubjectRulesReviewStatusL f V1SelfSubjectRulesReview{..} = (\v1SelfSubjectRulesReviewStatus -> V1SelfSubjectRulesReview { v1SelfSubjectRulesReviewStatus, ..} ) <$> f v1SelfSubjectRulesReviewStatus
{-# INLINE v1SelfSubjectRulesReviewStatusL #-}



-- * V1SelfSubjectRulesReviewSpec

-- | 'v1SelfSubjectRulesReviewSpecNamespace' Lens
v1SelfSubjectRulesReviewSpecNamespaceL :: Lens_' V1SelfSubjectRulesReviewSpec (Maybe Text)
v1SelfSubjectRulesReviewSpecNamespaceL f V1SelfSubjectRulesReviewSpec{..} = (\v1SelfSubjectRulesReviewSpecNamespace -> V1SelfSubjectRulesReviewSpec { v1SelfSubjectRulesReviewSpecNamespace, ..} ) <$> f v1SelfSubjectRulesReviewSpecNamespace
{-# INLINE v1SelfSubjectRulesReviewSpecNamespaceL #-}



-- * V1ServerAddressByClientCIDR

-- | 'v1ServerAddressByClientCIDRClientCidr' Lens
v1ServerAddressByClientCIDRClientCidrL :: Lens_' V1ServerAddressByClientCIDR (Text)
v1ServerAddressByClientCIDRClientCidrL f V1ServerAddressByClientCIDR{..} = (\v1ServerAddressByClientCIDRClientCidr -> V1ServerAddressByClientCIDR { v1ServerAddressByClientCIDRClientCidr, ..} ) <$> f v1ServerAddressByClientCIDRClientCidr
{-# INLINE v1ServerAddressByClientCIDRClientCidrL #-}

-- | 'v1ServerAddressByClientCIDRServerAddress' Lens
v1ServerAddressByClientCIDRServerAddressL :: Lens_' V1ServerAddressByClientCIDR (Text)
v1ServerAddressByClientCIDRServerAddressL f V1ServerAddressByClientCIDR{..} = (\v1ServerAddressByClientCIDRServerAddress -> V1ServerAddressByClientCIDR { v1ServerAddressByClientCIDRServerAddress, ..} ) <$> f v1ServerAddressByClientCIDRServerAddress
{-# INLINE v1ServerAddressByClientCIDRServerAddressL #-}



-- * V1Service

-- | 'v1ServiceApiVersion' Lens
v1ServiceApiVersionL :: Lens_' V1Service (Maybe Text)
v1ServiceApiVersionL f V1Service{..} = (\v1ServiceApiVersion -> V1Service { v1ServiceApiVersion, ..} ) <$> f v1ServiceApiVersion
{-# INLINE v1ServiceApiVersionL #-}

-- | 'v1ServiceKind' Lens
v1ServiceKindL :: Lens_' V1Service (Maybe Text)
v1ServiceKindL f V1Service{..} = (\v1ServiceKind -> V1Service { v1ServiceKind, ..} ) <$> f v1ServiceKind
{-# INLINE v1ServiceKindL #-}

-- | 'v1ServiceMetadata' Lens
v1ServiceMetadataL :: Lens_' V1Service (Maybe V1ObjectMeta)
v1ServiceMetadataL f V1Service{..} = (\v1ServiceMetadata -> V1Service { v1ServiceMetadata, ..} ) <$> f v1ServiceMetadata
{-# INLINE v1ServiceMetadataL #-}

-- | 'v1ServiceSpec' Lens
v1ServiceSpecL :: Lens_' V1Service (Maybe V1ServiceSpec)
v1ServiceSpecL f V1Service{..} = (\v1ServiceSpec -> V1Service { v1ServiceSpec, ..} ) <$> f v1ServiceSpec
{-# INLINE v1ServiceSpecL #-}

-- | 'v1ServiceStatus' Lens
v1ServiceStatusL :: Lens_' V1Service (Maybe V1ServiceStatus)
v1ServiceStatusL f V1Service{..} = (\v1ServiceStatus -> V1Service { v1ServiceStatus, ..} ) <$> f v1ServiceStatus
{-# INLINE v1ServiceStatusL #-}



-- * V1ServiceAccount

-- | 'v1ServiceAccountApiVersion' Lens
v1ServiceAccountApiVersionL :: Lens_' V1ServiceAccount (Maybe Text)
v1ServiceAccountApiVersionL f V1ServiceAccount{..} = (\v1ServiceAccountApiVersion -> V1ServiceAccount { v1ServiceAccountApiVersion, ..} ) <$> f v1ServiceAccountApiVersion
{-# INLINE v1ServiceAccountApiVersionL #-}

-- | 'v1ServiceAccountAutomountServiceAccountToken' Lens
v1ServiceAccountAutomountServiceAccountTokenL :: Lens_' V1ServiceAccount (Maybe Bool)
v1ServiceAccountAutomountServiceAccountTokenL f V1ServiceAccount{..} = (\v1ServiceAccountAutomountServiceAccountToken -> V1ServiceAccount { v1ServiceAccountAutomountServiceAccountToken, ..} ) <$> f v1ServiceAccountAutomountServiceAccountToken
{-# INLINE v1ServiceAccountAutomountServiceAccountTokenL #-}

-- | 'v1ServiceAccountImagePullSecrets' Lens
v1ServiceAccountImagePullSecretsL :: Lens_' V1ServiceAccount (Maybe [V1LocalObjectReference])
v1ServiceAccountImagePullSecretsL f V1ServiceAccount{..} = (\v1ServiceAccountImagePullSecrets -> V1ServiceAccount { v1ServiceAccountImagePullSecrets, ..} ) <$> f v1ServiceAccountImagePullSecrets
{-# INLINE v1ServiceAccountImagePullSecretsL #-}

-- | 'v1ServiceAccountKind' Lens
v1ServiceAccountKindL :: Lens_' V1ServiceAccount (Maybe Text)
v1ServiceAccountKindL f V1ServiceAccount{..} = (\v1ServiceAccountKind -> V1ServiceAccount { v1ServiceAccountKind, ..} ) <$> f v1ServiceAccountKind
{-# INLINE v1ServiceAccountKindL #-}

-- | 'v1ServiceAccountMetadata' Lens
v1ServiceAccountMetadataL :: Lens_' V1ServiceAccount (Maybe V1ObjectMeta)
v1ServiceAccountMetadataL f V1ServiceAccount{..} = (\v1ServiceAccountMetadata -> V1ServiceAccount { v1ServiceAccountMetadata, ..} ) <$> f v1ServiceAccountMetadata
{-# INLINE v1ServiceAccountMetadataL #-}

-- | 'v1ServiceAccountSecrets' Lens
v1ServiceAccountSecretsL :: Lens_' V1ServiceAccount (Maybe [V1ObjectReference])
v1ServiceAccountSecretsL f V1ServiceAccount{..} = (\v1ServiceAccountSecrets -> V1ServiceAccount { v1ServiceAccountSecrets, ..} ) <$> f v1ServiceAccountSecrets
{-# INLINE v1ServiceAccountSecretsL #-}



-- * V1ServiceAccountList

-- | 'v1ServiceAccountListApiVersion' Lens
v1ServiceAccountListApiVersionL :: Lens_' V1ServiceAccountList (Maybe Text)
v1ServiceAccountListApiVersionL f V1ServiceAccountList{..} = (\v1ServiceAccountListApiVersion -> V1ServiceAccountList { v1ServiceAccountListApiVersion, ..} ) <$> f v1ServiceAccountListApiVersion
{-# INLINE v1ServiceAccountListApiVersionL #-}

-- | 'v1ServiceAccountListItems' Lens
v1ServiceAccountListItemsL :: Lens_' V1ServiceAccountList ([V1ServiceAccount])
v1ServiceAccountListItemsL f V1ServiceAccountList{..} = (\v1ServiceAccountListItems -> V1ServiceAccountList { v1ServiceAccountListItems, ..} ) <$> f v1ServiceAccountListItems
{-# INLINE v1ServiceAccountListItemsL #-}

-- | 'v1ServiceAccountListKind' Lens
v1ServiceAccountListKindL :: Lens_' V1ServiceAccountList (Maybe Text)
v1ServiceAccountListKindL f V1ServiceAccountList{..} = (\v1ServiceAccountListKind -> V1ServiceAccountList { v1ServiceAccountListKind, ..} ) <$> f v1ServiceAccountListKind
{-# INLINE v1ServiceAccountListKindL #-}

-- | 'v1ServiceAccountListMetadata' Lens
v1ServiceAccountListMetadataL :: Lens_' V1ServiceAccountList (Maybe V1ListMeta)
v1ServiceAccountListMetadataL f V1ServiceAccountList{..} = (\v1ServiceAccountListMetadata -> V1ServiceAccountList { v1ServiceAccountListMetadata, ..} ) <$> f v1ServiceAccountListMetadata
{-# INLINE v1ServiceAccountListMetadataL #-}



-- * V1ServiceAccountTokenProjection

-- | 'v1ServiceAccountTokenProjectionAudience' Lens
v1ServiceAccountTokenProjectionAudienceL :: Lens_' V1ServiceAccountTokenProjection (Maybe Text)
v1ServiceAccountTokenProjectionAudienceL f V1ServiceAccountTokenProjection{..} = (\v1ServiceAccountTokenProjectionAudience -> V1ServiceAccountTokenProjection { v1ServiceAccountTokenProjectionAudience, ..} ) <$> f v1ServiceAccountTokenProjectionAudience
{-# INLINE v1ServiceAccountTokenProjectionAudienceL #-}

-- | 'v1ServiceAccountTokenProjectionExpirationSeconds' Lens
v1ServiceAccountTokenProjectionExpirationSecondsL :: Lens_' V1ServiceAccountTokenProjection (Maybe Integer)
v1ServiceAccountTokenProjectionExpirationSecondsL f V1ServiceAccountTokenProjection{..} = (\v1ServiceAccountTokenProjectionExpirationSeconds -> V1ServiceAccountTokenProjection { v1ServiceAccountTokenProjectionExpirationSeconds, ..} ) <$> f v1ServiceAccountTokenProjectionExpirationSeconds
{-# INLINE v1ServiceAccountTokenProjectionExpirationSecondsL #-}

-- | 'v1ServiceAccountTokenProjectionPath' Lens
v1ServiceAccountTokenProjectionPathL :: Lens_' V1ServiceAccountTokenProjection (Text)
v1ServiceAccountTokenProjectionPathL f V1ServiceAccountTokenProjection{..} = (\v1ServiceAccountTokenProjectionPath -> V1ServiceAccountTokenProjection { v1ServiceAccountTokenProjectionPath, ..} ) <$> f v1ServiceAccountTokenProjectionPath
{-# INLINE v1ServiceAccountTokenProjectionPathL #-}



-- * V1ServiceBackendPort

-- | 'v1ServiceBackendPortName' Lens
v1ServiceBackendPortNameL :: Lens_' V1ServiceBackendPort (Maybe Text)
v1ServiceBackendPortNameL f V1ServiceBackendPort{..} = (\v1ServiceBackendPortName -> V1ServiceBackendPort { v1ServiceBackendPortName, ..} ) <$> f v1ServiceBackendPortName
{-# INLINE v1ServiceBackendPortNameL #-}

-- | 'v1ServiceBackendPortNumber' Lens
v1ServiceBackendPortNumberL :: Lens_' V1ServiceBackendPort (Maybe Int)
v1ServiceBackendPortNumberL f V1ServiceBackendPort{..} = (\v1ServiceBackendPortNumber -> V1ServiceBackendPort { v1ServiceBackendPortNumber, ..} ) <$> f v1ServiceBackendPortNumber
{-# INLINE v1ServiceBackendPortNumberL #-}



-- * V1ServiceList

-- | 'v1ServiceListApiVersion' Lens
v1ServiceListApiVersionL :: Lens_' V1ServiceList (Maybe Text)
v1ServiceListApiVersionL f V1ServiceList{..} = (\v1ServiceListApiVersion -> V1ServiceList { v1ServiceListApiVersion, ..} ) <$> f v1ServiceListApiVersion
{-# INLINE v1ServiceListApiVersionL #-}

-- | 'v1ServiceListItems' Lens
v1ServiceListItemsL :: Lens_' V1ServiceList ([V1Service])
v1ServiceListItemsL f V1ServiceList{..} = (\v1ServiceListItems -> V1ServiceList { v1ServiceListItems, ..} ) <$> f v1ServiceListItems
{-# INLINE v1ServiceListItemsL #-}

-- | 'v1ServiceListKind' Lens
v1ServiceListKindL :: Lens_' V1ServiceList (Maybe Text)
v1ServiceListKindL f V1ServiceList{..} = (\v1ServiceListKind -> V1ServiceList { v1ServiceListKind, ..} ) <$> f v1ServiceListKind
{-# INLINE v1ServiceListKindL #-}

-- | 'v1ServiceListMetadata' Lens
v1ServiceListMetadataL :: Lens_' V1ServiceList (Maybe V1ListMeta)
v1ServiceListMetadataL f V1ServiceList{..} = (\v1ServiceListMetadata -> V1ServiceList { v1ServiceListMetadata, ..} ) <$> f v1ServiceListMetadata
{-# INLINE v1ServiceListMetadataL #-}



-- * V1ServicePort

-- | 'v1ServicePortAppProtocol' Lens
v1ServicePortAppProtocolL :: Lens_' V1ServicePort (Maybe Text)
v1ServicePortAppProtocolL f V1ServicePort{..} = (\v1ServicePortAppProtocol -> V1ServicePort { v1ServicePortAppProtocol, ..} ) <$> f v1ServicePortAppProtocol
{-# INLINE v1ServicePortAppProtocolL #-}

-- | 'v1ServicePortName' Lens
v1ServicePortNameL :: Lens_' V1ServicePort (Maybe Text)
v1ServicePortNameL f V1ServicePort{..} = (\v1ServicePortName -> V1ServicePort { v1ServicePortName, ..} ) <$> f v1ServicePortName
{-# INLINE v1ServicePortNameL #-}

-- | 'v1ServicePortNodePort' Lens
v1ServicePortNodePortL :: Lens_' V1ServicePort (Maybe Int)
v1ServicePortNodePortL f V1ServicePort{..} = (\v1ServicePortNodePort -> V1ServicePort { v1ServicePortNodePort, ..} ) <$> f v1ServicePortNodePort
{-# INLINE v1ServicePortNodePortL #-}

-- | 'v1ServicePortPort' Lens
v1ServicePortPortL :: Lens_' V1ServicePort (Int)
v1ServicePortPortL f V1ServicePort{..} = (\v1ServicePortPort -> V1ServicePort { v1ServicePortPort, ..} ) <$> f v1ServicePortPort
{-# INLINE v1ServicePortPortL #-}

-- | 'v1ServicePortProtocol' Lens
v1ServicePortProtocolL :: Lens_' V1ServicePort (Maybe Text)
v1ServicePortProtocolL f V1ServicePort{..} = (\v1ServicePortProtocol -> V1ServicePort { v1ServicePortProtocol, ..} ) <$> f v1ServicePortProtocol
{-# INLINE v1ServicePortProtocolL #-}

-- | 'v1ServicePortTargetPort' Lens
v1ServicePortTargetPortL :: Lens_' V1ServicePort (Maybe IntOrString)
v1ServicePortTargetPortL f V1ServicePort{..} = (\v1ServicePortTargetPort -> V1ServicePort { v1ServicePortTargetPort, ..} ) <$> f v1ServicePortTargetPort
{-# INLINE v1ServicePortTargetPortL #-}



-- * V1ServiceSpec

-- | 'v1ServiceSpecAllocateLoadBalancerNodePorts' Lens
v1ServiceSpecAllocateLoadBalancerNodePortsL :: Lens_' V1ServiceSpec (Maybe Bool)
v1ServiceSpecAllocateLoadBalancerNodePortsL f V1ServiceSpec{..} = (\v1ServiceSpecAllocateLoadBalancerNodePorts -> V1ServiceSpec { v1ServiceSpecAllocateLoadBalancerNodePorts, ..} ) <$> f v1ServiceSpecAllocateLoadBalancerNodePorts
{-# INLINE v1ServiceSpecAllocateLoadBalancerNodePortsL #-}

-- | 'v1ServiceSpecClusterIp' Lens
v1ServiceSpecClusterIpL :: Lens_' V1ServiceSpec (Maybe Text)
v1ServiceSpecClusterIpL f V1ServiceSpec{..} = (\v1ServiceSpecClusterIp -> V1ServiceSpec { v1ServiceSpecClusterIp, ..} ) <$> f v1ServiceSpecClusterIp
{-# INLINE v1ServiceSpecClusterIpL #-}

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

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

-- | 'v1ServiceSpecExternalName' Lens
v1ServiceSpecExternalNameL :: Lens_' V1ServiceSpec (Maybe Text)
v1ServiceSpecExternalNameL f V1ServiceSpec{..} = (\v1ServiceSpecExternalName -> V1ServiceSpec { v1ServiceSpecExternalName, ..} ) <$> f v1ServiceSpecExternalName
{-# INLINE v1ServiceSpecExternalNameL #-}

-- | 'v1ServiceSpecExternalTrafficPolicy' Lens
v1ServiceSpecExternalTrafficPolicyL :: Lens_' V1ServiceSpec (Maybe Text)
v1ServiceSpecExternalTrafficPolicyL f V1ServiceSpec{..} = (\v1ServiceSpecExternalTrafficPolicy -> V1ServiceSpec { v1ServiceSpecExternalTrafficPolicy, ..} ) <$> f v1ServiceSpecExternalTrafficPolicy
{-# INLINE v1ServiceSpecExternalTrafficPolicyL #-}

-- | 'v1ServiceSpecHealthCheckNodePort' Lens
v1ServiceSpecHealthCheckNodePortL :: Lens_' V1ServiceSpec (Maybe Int)
v1ServiceSpecHealthCheckNodePortL f V1ServiceSpec{..} = (\v1ServiceSpecHealthCheckNodePort -> V1ServiceSpec { v1ServiceSpecHealthCheckNodePort, ..} ) <$> f v1ServiceSpecHealthCheckNodePort
{-# INLINE v1ServiceSpecHealthCheckNodePortL #-}

-- | 'v1ServiceSpecInternalTrafficPolicy' Lens
v1ServiceSpecInternalTrafficPolicyL :: Lens_' V1ServiceSpec (Maybe Text)
v1ServiceSpecInternalTrafficPolicyL f V1ServiceSpec{..} = (\v1ServiceSpecInternalTrafficPolicy -> V1ServiceSpec { v1ServiceSpecInternalTrafficPolicy, ..} ) <$> f v1ServiceSpecInternalTrafficPolicy
{-# INLINE v1ServiceSpecInternalTrafficPolicyL #-}

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

-- | 'v1ServiceSpecIpFamilyPolicy' Lens
v1ServiceSpecIpFamilyPolicyL :: Lens_' V1ServiceSpec (Maybe Text)
v1ServiceSpecIpFamilyPolicyL f V1ServiceSpec{..} = (\v1ServiceSpecIpFamilyPolicy -> V1ServiceSpec { v1ServiceSpecIpFamilyPolicy, ..} ) <$> f v1ServiceSpecIpFamilyPolicy
{-# INLINE v1ServiceSpecIpFamilyPolicyL #-}

-- | 'v1ServiceSpecLoadBalancerClass' Lens
v1ServiceSpecLoadBalancerClassL :: Lens_' V1ServiceSpec (Maybe Text)
v1ServiceSpecLoadBalancerClassL f V1ServiceSpec{..} = (\v1ServiceSpecLoadBalancerClass -> V1ServiceSpec { v1ServiceSpecLoadBalancerClass, ..} ) <$> f v1ServiceSpecLoadBalancerClass
{-# INLINE v1ServiceSpecLoadBalancerClassL #-}

-- | 'v1ServiceSpecLoadBalancerIp' Lens
v1ServiceSpecLoadBalancerIpL :: Lens_' V1ServiceSpec (Maybe Text)
v1ServiceSpecLoadBalancerIpL f V1ServiceSpec{..} = (\v1ServiceSpecLoadBalancerIp -> V1ServiceSpec { v1ServiceSpecLoadBalancerIp, ..} ) <$> f v1ServiceSpecLoadBalancerIp
{-# INLINE v1ServiceSpecLoadBalancerIpL #-}

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

-- | 'v1ServiceSpecPorts' Lens
v1ServiceSpecPortsL :: Lens_' V1ServiceSpec (Maybe [V1ServicePort])
v1ServiceSpecPortsL f V1ServiceSpec{..} = (\v1ServiceSpecPorts -> V1ServiceSpec { v1ServiceSpecPorts, ..} ) <$> f v1ServiceSpecPorts
{-# INLINE v1ServiceSpecPortsL #-}

-- | 'v1ServiceSpecPublishNotReadyAddresses' Lens
v1ServiceSpecPublishNotReadyAddressesL :: Lens_' V1ServiceSpec (Maybe Bool)
v1ServiceSpecPublishNotReadyAddressesL f V1ServiceSpec{..} = (\v1ServiceSpecPublishNotReadyAddresses -> V1ServiceSpec { v1ServiceSpecPublishNotReadyAddresses, ..} ) <$> f v1ServiceSpecPublishNotReadyAddresses
{-# INLINE v1ServiceSpecPublishNotReadyAddressesL #-}

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

-- | 'v1ServiceSpecSessionAffinity' Lens
v1ServiceSpecSessionAffinityL :: Lens_' V1ServiceSpec (Maybe Text)
v1ServiceSpecSessionAffinityL f V1ServiceSpec{..} = (\v1ServiceSpecSessionAffinity -> V1ServiceSpec { v1ServiceSpecSessionAffinity, ..} ) <$> f v1ServiceSpecSessionAffinity
{-# INLINE v1ServiceSpecSessionAffinityL #-}

-- | 'v1ServiceSpecSessionAffinityConfig' Lens
v1ServiceSpecSessionAffinityConfigL :: Lens_' V1ServiceSpec (Maybe V1SessionAffinityConfig)
v1ServiceSpecSessionAffinityConfigL f V1ServiceSpec{..} = (\v1ServiceSpecSessionAffinityConfig -> V1ServiceSpec { v1ServiceSpecSessionAffinityConfig, ..} ) <$> f v1ServiceSpecSessionAffinityConfig
{-# INLINE v1ServiceSpecSessionAffinityConfigL #-}

-- | 'v1ServiceSpecType' Lens
v1ServiceSpecTypeL :: Lens_' V1ServiceSpec (Maybe Text)
v1ServiceSpecTypeL f V1ServiceSpec{..} = (\v1ServiceSpecType -> V1ServiceSpec { v1ServiceSpecType, ..} ) <$> f v1ServiceSpecType
{-# INLINE v1ServiceSpecTypeL #-}



-- * V1ServiceStatus

-- | 'v1ServiceStatusConditions' Lens
v1ServiceStatusConditionsL :: Lens_' V1ServiceStatus (Maybe [V1Condition])
v1ServiceStatusConditionsL f V1ServiceStatus{..} = (\v1ServiceStatusConditions -> V1ServiceStatus { v1ServiceStatusConditions, ..} ) <$> f v1ServiceStatusConditions
{-# INLINE v1ServiceStatusConditionsL #-}

-- | 'v1ServiceStatusLoadBalancer' Lens
v1ServiceStatusLoadBalancerL :: Lens_' V1ServiceStatus (Maybe V1LoadBalancerStatus)
v1ServiceStatusLoadBalancerL f V1ServiceStatus{..} = (\v1ServiceStatusLoadBalancer -> V1ServiceStatus { v1ServiceStatusLoadBalancer, ..} ) <$> f v1ServiceStatusLoadBalancer
{-# INLINE v1ServiceStatusLoadBalancerL #-}



-- * V1SessionAffinityConfig

-- | 'v1SessionAffinityConfigClientIp' Lens
v1SessionAffinityConfigClientIpL :: Lens_' V1SessionAffinityConfig (Maybe V1ClientIPConfig)
v1SessionAffinityConfigClientIpL f V1SessionAffinityConfig{..} = (\v1SessionAffinityConfigClientIp -> V1SessionAffinityConfig { v1SessionAffinityConfigClientIp, ..} ) <$> f v1SessionAffinityConfigClientIp
{-# INLINE v1SessionAffinityConfigClientIpL #-}



-- * V1StatefulSet

-- | 'v1StatefulSetApiVersion' Lens
v1StatefulSetApiVersionL :: Lens_' V1StatefulSet (Maybe Text)
v1StatefulSetApiVersionL f V1StatefulSet{..} = (\v1StatefulSetApiVersion -> V1StatefulSet { v1StatefulSetApiVersion, ..} ) <$> f v1StatefulSetApiVersion
{-# INLINE v1StatefulSetApiVersionL #-}

-- | 'v1StatefulSetKind' Lens
v1StatefulSetKindL :: Lens_' V1StatefulSet (Maybe Text)
v1StatefulSetKindL f V1StatefulSet{..} = (\v1StatefulSetKind -> V1StatefulSet { v1StatefulSetKind, ..} ) <$> f v1StatefulSetKind
{-# INLINE v1StatefulSetKindL #-}

-- | 'v1StatefulSetMetadata' Lens
v1StatefulSetMetadataL :: Lens_' V1StatefulSet (Maybe V1ObjectMeta)
v1StatefulSetMetadataL f V1StatefulSet{..} = (\v1StatefulSetMetadata -> V1StatefulSet { v1StatefulSetMetadata, ..} ) <$> f v1StatefulSetMetadata
{-# INLINE v1StatefulSetMetadataL #-}

-- | 'v1StatefulSetSpec' Lens
v1StatefulSetSpecL :: Lens_' V1StatefulSet (Maybe V1StatefulSetSpec)
v1StatefulSetSpecL f V1StatefulSet{..} = (\v1StatefulSetSpec -> V1StatefulSet { v1StatefulSetSpec, ..} ) <$> f v1StatefulSetSpec
{-# INLINE v1StatefulSetSpecL #-}

-- | 'v1StatefulSetStatus' Lens
v1StatefulSetStatusL :: Lens_' V1StatefulSet (Maybe V1StatefulSetStatus)
v1StatefulSetStatusL f V1StatefulSet{..} = (\v1StatefulSetStatus -> V1StatefulSet { v1StatefulSetStatus, ..} ) <$> f v1StatefulSetStatus
{-# INLINE v1StatefulSetStatusL #-}



-- * V1StatefulSetCondition

-- | 'v1StatefulSetConditionLastTransitionTime' Lens
v1StatefulSetConditionLastTransitionTimeL :: Lens_' V1StatefulSetCondition (Maybe DateTime)
v1StatefulSetConditionLastTransitionTimeL f V1StatefulSetCondition{..} = (\v1StatefulSetConditionLastTransitionTime -> V1StatefulSetCondition { v1StatefulSetConditionLastTransitionTime, ..} ) <$> f v1StatefulSetConditionLastTransitionTime
{-# INLINE v1StatefulSetConditionLastTransitionTimeL #-}

-- | 'v1StatefulSetConditionMessage' Lens
v1StatefulSetConditionMessageL :: Lens_' V1StatefulSetCondition (Maybe Text)
v1StatefulSetConditionMessageL f V1StatefulSetCondition{..} = (\v1StatefulSetConditionMessage -> V1StatefulSetCondition { v1StatefulSetConditionMessage, ..} ) <$> f v1StatefulSetConditionMessage
{-# INLINE v1StatefulSetConditionMessageL #-}

-- | 'v1StatefulSetConditionReason' Lens
v1StatefulSetConditionReasonL :: Lens_' V1StatefulSetCondition (Maybe Text)
v1StatefulSetConditionReasonL f V1StatefulSetCondition{..} = (\v1StatefulSetConditionReason -> V1StatefulSetCondition { v1StatefulSetConditionReason, ..} ) <$> f v1StatefulSetConditionReason
{-# INLINE v1StatefulSetConditionReasonL #-}

-- | 'v1StatefulSetConditionStatus' Lens
v1StatefulSetConditionStatusL :: Lens_' V1StatefulSetCondition (Text)
v1StatefulSetConditionStatusL f V1StatefulSetCondition{..} = (\v1StatefulSetConditionStatus -> V1StatefulSetCondition { v1StatefulSetConditionStatus, ..} ) <$> f v1StatefulSetConditionStatus
{-# INLINE v1StatefulSetConditionStatusL #-}

-- | 'v1StatefulSetConditionType' Lens
v1StatefulSetConditionTypeL :: Lens_' V1StatefulSetCondition (Text)
v1StatefulSetConditionTypeL f V1StatefulSetCondition{..} = (\v1StatefulSetConditionType -> V1StatefulSetCondition { v1StatefulSetConditionType, ..} ) <$> f v1StatefulSetConditionType
{-# INLINE v1StatefulSetConditionTypeL #-}



-- * V1StatefulSetList

-- | 'v1StatefulSetListApiVersion' Lens
v1StatefulSetListApiVersionL :: Lens_' V1StatefulSetList (Maybe Text)
v1StatefulSetListApiVersionL f V1StatefulSetList{..} = (\v1StatefulSetListApiVersion -> V1StatefulSetList { v1StatefulSetListApiVersion, ..} ) <$> f v1StatefulSetListApiVersion
{-# INLINE v1StatefulSetListApiVersionL #-}

-- | 'v1StatefulSetListItems' Lens
v1StatefulSetListItemsL :: Lens_' V1StatefulSetList ([V1StatefulSet])
v1StatefulSetListItemsL f V1StatefulSetList{..} = (\v1StatefulSetListItems -> V1StatefulSetList { v1StatefulSetListItems, ..} ) <$> f v1StatefulSetListItems
{-# INLINE v1StatefulSetListItemsL #-}

-- | 'v1StatefulSetListKind' Lens
v1StatefulSetListKindL :: Lens_' V1StatefulSetList (Maybe Text)
v1StatefulSetListKindL f V1StatefulSetList{..} = (\v1StatefulSetListKind -> V1StatefulSetList { v1StatefulSetListKind, ..} ) <$> f v1StatefulSetListKind
{-# INLINE v1StatefulSetListKindL #-}

-- | 'v1StatefulSetListMetadata' Lens
v1StatefulSetListMetadataL :: Lens_' V1StatefulSetList (Maybe V1ListMeta)
v1StatefulSetListMetadataL f V1StatefulSetList{..} = (\v1StatefulSetListMetadata -> V1StatefulSetList { v1StatefulSetListMetadata, ..} ) <$> f v1StatefulSetListMetadata
{-# INLINE v1StatefulSetListMetadataL #-}



-- * V1StatefulSetPersistentVolumeClaimRetentionPolicy

-- | 'v1StatefulSetPersistentVolumeClaimRetentionPolicyWhenDeleted' Lens
v1StatefulSetPersistentVolumeClaimRetentionPolicyWhenDeletedL :: Lens_' V1StatefulSetPersistentVolumeClaimRetentionPolicy (Maybe Text)
v1StatefulSetPersistentVolumeClaimRetentionPolicyWhenDeletedL f V1StatefulSetPersistentVolumeClaimRetentionPolicy{..} = (\v1StatefulSetPersistentVolumeClaimRetentionPolicyWhenDeleted -> V1StatefulSetPersistentVolumeClaimRetentionPolicy { v1StatefulSetPersistentVolumeClaimRetentionPolicyWhenDeleted, ..} ) <$> f v1StatefulSetPersistentVolumeClaimRetentionPolicyWhenDeleted
{-# INLINE v1StatefulSetPersistentVolumeClaimRetentionPolicyWhenDeletedL #-}

-- | 'v1StatefulSetPersistentVolumeClaimRetentionPolicyWhenScaled' Lens
v1StatefulSetPersistentVolumeClaimRetentionPolicyWhenScaledL :: Lens_' V1StatefulSetPersistentVolumeClaimRetentionPolicy (Maybe Text)
v1StatefulSetPersistentVolumeClaimRetentionPolicyWhenScaledL f V1StatefulSetPersistentVolumeClaimRetentionPolicy{..} = (\v1StatefulSetPersistentVolumeClaimRetentionPolicyWhenScaled -> V1StatefulSetPersistentVolumeClaimRetentionPolicy { v1StatefulSetPersistentVolumeClaimRetentionPolicyWhenScaled, ..} ) <$> f v1StatefulSetPersistentVolumeClaimRetentionPolicyWhenScaled
{-# INLINE v1StatefulSetPersistentVolumeClaimRetentionPolicyWhenScaledL #-}



-- * V1StatefulSetSpec

-- | 'v1StatefulSetSpecMinReadySeconds' Lens
v1StatefulSetSpecMinReadySecondsL :: Lens_' V1StatefulSetSpec (Maybe Int)
v1StatefulSetSpecMinReadySecondsL f V1StatefulSetSpec{..} = (\v1StatefulSetSpecMinReadySeconds -> V1StatefulSetSpec { v1StatefulSetSpecMinReadySeconds, ..} ) <$> f v1StatefulSetSpecMinReadySeconds
{-# INLINE v1StatefulSetSpecMinReadySecondsL #-}

-- | 'v1StatefulSetSpecPersistentVolumeClaimRetentionPolicy' Lens
v1StatefulSetSpecPersistentVolumeClaimRetentionPolicyL :: Lens_' V1StatefulSetSpec (Maybe V1StatefulSetPersistentVolumeClaimRetentionPolicy)
v1StatefulSetSpecPersistentVolumeClaimRetentionPolicyL f V1StatefulSetSpec{..} = (\v1StatefulSetSpecPersistentVolumeClaimRetentionPolicy -> V1StatefulSetSpec { v1StatefulSetSpecPersistentVolumeClaimRetentionPolicy, ..} ) <$> f v1StatefulSetSpecPersistentVolumeClaimRetentionPolicy
{-# INLINE v1StatefulSetSpecPersistentVolumeClaimRetentionPolicyL #-}

-- | 'v1StatefulSetSpecPodManagementPolicy' Lens
v1StatefulSetSpecPodManagementPolicyL :: Lens_' V1StatefulSetSpec (Maybe Text)
v1StatefulSetSpecPodManagementPolicyL f V1StatefulSetSpec{..} = (\v1StatefulSetSpecPodManagementPolicy -> V1StatefulSetSpec { v1StatefulSetSpecPodManagementPolicy, ..} ) <$> f v1StatefulSetSpecPodManagementPolicy
{-# INLINE v1StatefulSetSpecPodManagementPolicyL #-}

-- | 'v1StatefulSetSpecReplicas' Lens
v1StatefulSetSpecReplicasL :: Lens_' V1StatefulSetSpec (Maybe Int)
v1StatefulSetSpecReplicasL f V1StatefulSetSpec{..} = (\v1StatefulSetSpecReplicas -> V1StatefulSetSpec { v1StatefulSetSpecReplicas, ..} ) <$> f v1StatefulSetSpecReplicas
{-# INLINE v1StatefulSetSpecReplicasL #-}

-- | 'v1StatefulSetSpecRevisionHistoryLimit' Lens
v1StatefulSetSpecRevisionHistoryLimitL :: Lens_' V1StatefulSetSpec (Maybe Int)
v1StatefulSetSpecRevisionHistoryLimitL f V1StatefulSetSpec{..} = (\v1StatefulSetSpecRevisionHistoryLimit -> V1StatefulSetSpec { v1StatefulSetSpecRevisionHistoryLimit, ..} ) <$> f v1StatefulSetSpecRevisionHistoryLimit
{-# INLINE v1StatefulSetSpecRevisionHistoryLimitL #-}

-- | 'v1StatefulSetSpecSelector' Lens
v1StatefulSetSpecSelectorL :: Lens_' V1StatefulSetSpec (V1LabelSelector)
v1StatefulSetSpecSelectorL f V1StatefulSetSpec{..} = (\v1StatefulSetSpecSelector -> V1StatefulSetSpec { v1StatefulSetSpecSelector, ..} ) <$> f v1StatefulSetSpecSelector
{-# INLINE v1StatefulSetSpecSelectorL #-}

-- | 'v1StatefulSetSpecServiceName' Lens
v1StatefulSetSpecServiceNameL :: Lens_' V1StatefulSetSpec (Text)
v1StatefulSetSpecServiceNameL f V1StatefulSetSpec{..} = (\v1StatefulSetSpecServiceName -> V1StatefulSetSpec { v1StatefulSetSpecServiceName, ..} ) <$> f v1StatefulSetSpecServiceName
{-# INLINE v1StatefulSetSpecServiceNameL #-}

-- | 'v1StatefulSetSpecTemplate' Lens
v1StatefulSetSpecTemplateL :: Lens_' V1StatefulSetSpec (V1PodTemplateSpec)
v1StatefulSetSpecTemplateL f V1StatefulSetSpec{..} = (\v1StatefulSetSpecTemplate -> V1StatefulSetSpec { v1StatefulSetSpecTemplate, ..} ) <$> f v1StatefulSetSpecTemplate
{-# INLINE v1StatefulSetSpecTemplateL #-}

-- | 'v1StatefulSetSpecUpdateStrategy' Lens
v1StatefulSetSpecUpdateStrategyL :: Lens_' V1StatefulSetSpec (Maybe V1StatefulSetUpdateStrategy)
v1StatefulSetSpecUpdateStrategyL f V1StatefulSetSpec{..} = (\v1StatefulSetSpecUpdateStrategy -> V1StatefulSetSpec { v1StatefulSetSpecUpdateStrategy, ..} ) <$> f v1StatefulSetSpecUpdateStrategy
{-# INLINE v1StatefulSetSpecUpdateStrategyL #-}

-- | 'v1StatefulSetSpecVolumeClaimTemplates' Lens
v1StatefulSetSpecVolumeClaimTemplatesL :: Lens_' V1StatefulSetSpec (Maybe [V1PersistentVolumeClaim])
v1StatefulSetSpecVolumeClaimTemplatesL f V1StatefulSetSpec{..} = (\v1StatefulSetSpecVolumeClaimTemplates -> V1StatefulSetSpec { v1StatefulSetSpecVolumeClaimTemplates, ..} ) <$> f v1StatefulSetSpecVolumeClaimTemplates
{-# INLINE v1StatefulSetSpecVolumeClaimTemplatesL #-}



-- * V1StatefulSetStatus

-- | 'v1StatefulSetStatusAvailableReplicas' Lens
v1StatefulSetStatusAvailableReplicasL :: Lens_' V1StatefulSetStatus (Maybe Int)
v1StatefulSetStatusAvailableReplicasL f V1StatefulSetStatus{..} = (\v1StatefulSetStatusAvailableReplicas -> V1StatefulSetStatus { v1StatefulSetStatusAvailableReplicas, ..} ) <$> f v1StatefulSetStatusAvailableReplicas
{-# INLINE v1StatefulSetStatusAvailableReplicasL #-}

-- | 'v1StatefulSetStatusCollisionCount' Lens
v1StatefulSetStatusCollisionCountL :: Lens_' V1StatefulSetStatus (Maybe Int)
v1StatefulSetStatusCollisionCountL f V1StatefulSetStatus{..} = (\v1StatefulSetStatusCollisionCount -> V1StatefulSetStatus { v1StatefulSetStatusCollisionCount, ..} ) <$> f v1StatefulSetStatusCollisionCount
{-# INLINE v1StatefulSetStatusCollisionCountL #-}

-- | 'v1StatefulSetStatusConditions' Lens
v1StatefulSetStatusConditionsL :: Lens_' V1StatefulSetStatus (Maybe [V1StatefulSetCondition])
v1StatefulSetStatusConditionsL f V1StatefulSetStatus{..} = (\v1StatefulSetStatusConditions -> V1StatefulSetStatus { v1StatefulSetStatusConditions, ..} ) <$> f v1StatefulSetStatusConditions
{-# INLINE v1StatefulSetStatusConditionsL #-}

-- | 'v1StatefulSetStatusCurrentReplicas' Lens
v1StatefulSetStatusCurrentReplicasL :: Lens_' V1StatefulSetStatus (Maybe Int)
v1StatefulSetStatusCurrentReplicasL f V1StatefulSetStatus{..} = (\v1StatefulSetStatusCurrentReplicas -> V1StatefulSetStatus { v1StatefulSetStatusCurrentReplicas, ..} ) <$> f v1StatefulSetStatusCurrentReplicas
{-# INLINE v1StatefulSetStatusCurrentReplicasL #-}

-- | 'v1StatefulSetStatusCurrentRevision' Lens
v1StatefulSetStatusCurrentRevisionL :: Lens_' V1StatefulSetStatus (Maybe Text)
v1StatefulSetStatusCurrentRevisionL f V1StatefulSetStatus{..} = (\v1StatefulSetStatusCurrentRevision -> V1StatefulSetStatus { v1StatefulSetStatusCurrentRevision, ..} ) <$> f v1StatefulSetStatusCurrentRevision
{-# INLINE v1StatefulSetStatusCurrentRevisionL #-}

-- | 'v1StatefulSetStatusObservedGeneration' Lens
v1StatefulSetStatusObservedGenerationL :: Lens_' V1StatefulSetStatus (Maybe Integer)
v1StatefulSetStatusObservedGenerationL f V1StatefulSetStatus{..} = (\v1StatefulSetStatusObservedGeneration -> V1StatefulSetStatus { v1StatefulSetStatusObservedGeneration, ..} ) <$> f v1StatefulSetStatusObservedGeneration
{-# INLINE v1StatefulSetStatusObservedGenerationL #-}

-- | 'v1StatefulSetStatusReadyReplicas' Lens
v1StatefulSetStatusReadyReplicasL :: Lens_' V1StatefulSetStatus (Maybe Int)
v1StatefulSetStatusReadyReplicasL f V1StatefulSetStatus{..} = (\v1StatefulSetStatusReadyReplicas -> V1StatefulSetStatus { v1StatefulSetStatusReadyReplicas, ..} ) <$> f v1StatefulSetStatusReadyReplicas
{-# INLINE v1StatefulSetStatusReadyReplicasL #-}

-- | 'v1StatefulSetStatusReplicas' Lens
v1StatefulSetStatusReplicasL :: Lens_' V1StatefulSetStatus (Int)
v1StatefulSetStatusReplicasL f V1StatefulSetStatus{..} = (\v1StatefulSetStatusReplicas -> V1StatefulSetStatus { v1StatefulSetStatusReplicas, ..} ) <$> f v1StatefulSetStatusReplicas
{-# INLINE v1StatefulSetStatusReplicasL #-}

-- | 'v1StatefulSetStatusUpdateRevision' Lens
v1StatefulSetStatusUpdateRevisionL :: Lens_' V1StatefulSetStatus (Maybe Text)
v1StatefulSetStatusUpdateRevisionL f V1StatefulSetStatus{..} = (\v1StatefulSetStatusUpdateRevision -> V1StatefulSetStatus { v1StatefulSetStatusUpdateRevision, ..} ) <$> f v1StatefulSetStatusUpdateRevision
{-# INLINE v1StatefulSetStatusUpdateRevisionL #-}

-- | 'v1StatefulSetStatusUpdatedReplicas' Lens
v1StatefulSetStatusUpdatedReplicasL :: Lens_' V1StatefulSetStatus (Maybe Int)
v1StatefulSetStatusUpdatedReplicasL f V1StatefulSetStatus{..} = (\v1StatefulSetStatusUpdatedReplicas -> V1StatefulSetStatus { v1StatefulSetStatusUpdatedReplicas, ..} ) <$> f v1StatefulSetStatusUpdatedReplicas
{-# INLINE v1StatefulSetStatusUpdatedReplicasL #-}



-- * V1StatefulSetUpdateStrategy

-- | 'v1StatefulSetUpdateStrategyRollingUpdate' Lens
v1StatefulSetUpdateStrategyRollingUpdateL :: Lens_' V1StatefulSetUpdateStrategy (Maybe V1RollingUpdateStatefulSetStrategy)
v1StatefulSetUpdateStrategyRollingUpdateL f V1StatefulSetUpdateStrategy{..} = (\v1StatefulSetUpdateStrategyRollingUpdate -> V1StatefulSetUpdateStrategy { v1StatefulSetUpdateStrategyRollingUpdate, ..} ) <$> f v1StatefulSetUpdateStrategyRollingUpdate
{-# INLINE v1StatefulSetUpdateStrategyRollingUpdateL #-}

-- | 'v1StatefulSetUpdateStrategyType' Lens
v1StatefulSetUpdateStrategyTypeL :: Lens_' V1StatefulSetUpdateStrategy (Maybe Text)
v1StatefulSetUpdateStrategyTypeL f V1StatefulSetUpdateStrategy{..} = (\v1StatefulSetUpdateStrategyType -> V1StatefulSetUpdateStrategy { v1StatefulSetUpdateStrategyType, ..} ) <$> f v1StatefulSetUpdateStrategyType
{-# INLINE v1StatefulSetUpdateStrategyTypeL #-}



-- * V1Status

-- | 'v1StatusApiVersion' Lens
v1StatusApiVersionL :: Lens_' V1Status (Maybe Text)
v1StatusApiVersionL f V1Status{..} = (\v1StatusApiVersion -> V1Status { v1StatusApiVersion, ..} ) <$> f v1StatusApiVersion
{-# INLINE v1StatusApiVersionL #-}

-- | 'v1StatusCode' Lens
v1StatusCodeL :: Lens_' V1Status (Maybe Int)
v1StatusCodeL f V1Status{..} = (\v1StatusCode -> V1Status { v1StatusCode, ..} ) <$> f v1StatusCode
{-# INLINE v1StatusCodeL #-}

-- | 'v1StatusDetails' Lens
v1StatusDetailsL :: Lens_' V1Status (Maybe V1StatusDetails)
v1StatusDetailsL f V1Status{..} = (\v1StatusDetails -> V1Status { v1StatusDetails, ..} ) <$> f v1StatusDetails
{-# INLINE v1StatusDetailsL #-}

-- | 'v1StatusKind' Lens
v1StatusKindL :: Lens_' V1Status (Maybe Text)
v1StatusKindL f V1Status{..} = (\v1StatusKind -> V1Status { v1StatusKind, ..} ) <$> f v1StatusKind
{-# INLINE v1StatusKindL #-}

-- | 'v1StatusMessage' Lens
v1StatusMessageL :: Lens_' V1Status (Maybe Text)
v1StatusMessageL f V1Status{..} = (\v1StatusMessage -> V1Status { v1StatusMessage, ..} ) <$> f v1StatusMessage
{-# INLINE v1StatusMessageL #-}

-- | 'v1StatusMetadata' Lens
v1StatusMetadataL :: Lens_' V1Status (Maybe V1ListMeta)
v1StatusMetadataL f V1Status{..} = (\v1StatusMetadata -> V1Status { v1StatusMetadata, ..} ) <$> f v1StatusMetadata
{-# INLINE v1StatusMetadataL #-}

-- | 'v1StatusReason' Lens
v1StatusReasonL :: Lens_' V1Status (Maybe Text)
v1StatusReasonL f V1Status{..} = (\v1StatusReason -> V1Status { v1StatusReason, ..} ) <$> f v1StatusReason
{-# INLINE v1StatusReasonL #-}

-- | 'v1StatusStatus' Lens
v1StatusStatusL :: Lens_' V1Status (Maybe Text)
v1StatusStatusL f V1Status{..} = (\v1StatusStatus -> V1Status { v1StatusStatus, ..} ) <$> f v1StatusStatus
{-# INLINE v1StatusStatusL #-}



-- * V1StatusCause

-- | 'v1StatusCauseField' Lens
v1StatusCauseFieldL :: Lens_' V1StatusCause (Maybe Text)
v1StatusCauseFieldL f V1StatusCause{..} = (\v1StatusCauseField -> V1StatusCause { v1StatusCauseField, ..} ) <$> f v1StatusCauseField
{-# INLINE v1StatusCauseFieldL #-}

-- | 'v1StatusCauseMessage' Lens
v1StatusCauseMessageL :: Lens_' V1StatusCause (Maybe Text)
v1StatusCauseMessageL f V1StatusCause{..} = (\v1StatusCauseMessage -> V1StatusCause { v1StatusCauseMessage, ..} ) <$> f v1StatusCauseMessage
{-# INLINE v1StatusCauseMessageL #-}

-- | 'v1StatusCauseReason' Lens
v1StatusCauseReasonL :: Lens_' V1StatusCause (Maybe Text)
v1StatusCauseReasonL f V1StatusCause{..} = (\v1StatusCauseReason -> V1StatusCause { v1StatusCauseReason, ..} ) <$> f v1StatusCauseReason
{-# INLINE v1StatusCauseReasonL #-}



-- * V1StatusDetails

-- | 'v1StatusDetailsCauses' Lens
v1StatusDetailsCausesL :: Lens_' V1StatusDetails (Maybe [V1StatusCause])
v1StatusDetailsCausesL f V1StatusDetails{..} = (\v1StatusDetailsCauses -> V1StatusDetails { v1StatusDetailsCauses, ..} ) <$> f v1StatusDetailsCauses
{-# INLINE v1StatusDetailsCausesL #-}

-- | 'v1StatusDetailsGroup' Lens
v1StatusDetailsGroupL :: Lens_' V1StatusDetails (Maybe Text)
v1StatusDetailsGroupL f V1StatusDetails{..} = (\v1StatusDetailsGroup -> V1StatusDetails { v1StatusDetailsGroup, ..} ) <$> f v1StatusDetailsGroup
{-# INLINE v1StatusDetailsGroupL #-}

-- | 'v1StatusDetailsKind' Lens
v1StatusDetailsKindL :: Lens_' V1StatusDetails (Maybe Text)
v1StatusDetailsKindL f V1StatusDetails{..} = (\v1StatusDetailsKind -> V1StatusDetails { v1StatusDetailsKind, ..} ) <$> f v1StatusDetailsKind
{-# INLINE v1StatusDetailsKindL #-}

-- | 'v1StatusDetailsName' Lens
v1StatusDetailsNameL :: Lens_' V1StatusDetails (Maybe Text)
v1StatusDetailsNameL f V1StatusDetails{..} = (\v1StatusDetailsName -> V1StatusDetails { v1StatusDetailsName, ..} ) <$> f v1StatusDetailsName
{-# INLINE v1StatusDetailsNameL #-}

-- | 'v1StatusDetailsRetryAfterSeconds' Lens
v1StatusDetailsRetryAfterSecondsL :: Lens_' V1StatusDetails (Maybe Int)
v1StatusDetailsRetryAfterSecondsL f V1StatusDetails{..} = (\v1StatusDetailsRetryAfterSeconds -> V1StatusDetails { v1StatusDetailsRetryAfterSeconds, ..} ) <$> f v1StatusDetailsRetryAfterSeconds
{-# INLINE v1StatusDetailsRetryAfterSecondsL #-}

-- | 'v1StatusDetailsUid' Lens
v1StatusDetailsUidL :: Lens_' V1StatusDetails (Maybe Text)
v1StatusDetailsUidL f V1StatusDetails{..} = (\v1StatusDetailsUid -> V1StatusDetails { v1StatusDetailsUid, ..} ) <$> f v1StatusDetailsUid
{-# INLINE v1StatusDetailsUidL #-}



-- * V1StorageClass

-- | 'v1StorageClassAllowVolumeExpansion' Lens
v1StorageClassAllowVolumeExpansionL :: Lens_' V1StorageClass (Maybe Bool)
v1StorageClassAllowVolumeExpansionL f V1StorageClass{..} = (\v1StorageClassAllowVolumeExpansion -> V1StorageClass { v1StorageClassAllowVolumeExpansion, ..} ) <$> f v1StorageClassAllowVolumeExpansion
{-# INLINE v1StorageClassAllowVolumeExpansionL #-}

-- | 'v1StorageClassAllowedTopologies' Lens
v1StorageClassAllowedTopologiesL :: Lens_' V1StorageClass (Maybe [V1TopologySelectorTerm])
v1StorageClassAllowedTopologiesL f V1StorageClass{..} = (\v1StorageClassAllowedTopologies -> V1StorageClass { v1StorageClassAllowedTopologies, ..} ) <$> f v1StorageClassAllowedTopologies
{-# INLINE v1StorageClassAllowedTopologiesL #-}

-- | 'v1StorageClassApiVersion' Lens
v1StorageClassApiVersionL :: Lens_' V1StorageClass (Maybe Text)
v1StorageClassApiVersionL f V1StorageClass{..} = (\v1StorageClassApiVersion -> V1StorageClass { v1StorageClassApiVersion, ..} ) <$> f v1StorageClassApiVersion
{-# INLINE v1StorageClassApiVersionL #-}

-- | 'v1StorageClassKind' Lens
v1StorageClassKindL :: Lens_' V1StorageClass (Maybe Text)
v1StorageClassKindL f V1StorageClass{..} = (\v1StorageClassKind -> V1StorageClass { v1StorageClassKind, ..} ) <$> f v1StorageClassKind
{-# INLINE v1StorageClassKindL #-}

-- | 'v1StorageClassMetadata' Lens
v1StorageClassMetadataL :: Lens_' V1StorageClass (Maybe V1ObjectMeta)
v1StorageClassMetadataL f V1StorageClass{..} = (\v1StorageClassMetadata -> V1StorageClass { v1StorageClassMetadata, ..} ) <$> f v1StorageClassMetadata
{-# INLINE v1StorageClassMetadataL #-}

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

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

-- | 'v1StorageClassProvisioner' Lens
v1StorageClassProvisionerL :: Lens_' V1StorageClass (Text)
v1StorageClassProvisionerL f V1StorageClass{..} = (\v1StorageClassProvisioner -> V1StorageClass { v1StorageClassProvisioner, ..} ) <$> f v1StorageClassProvisioner
{-# INLINE v1StorageClassProvisionerL #-}

-- | 'v1StorageClassReclaimPolicy' Lens
v1StorageClassReclaimPolicyL :: Lens_' V1StorageClass (Maybe Text)
v1StorageClassReclaimPolicyL f V1StorageClass{..} = (\v1StorageClassReclaimPolicy -> V1StorageClass { v1StorageClassReclaimPolicy, ..} ) <$> f v1StorageClassReclaimPolicy
{-# INLINE v1StorageClassReclaimPolicyL #-}

-- | 'v1StorageClassVolumeBindingMode' Lens
v1StorageClassVolumeBindingModeL :: Lens_' V1StorageClass (Maybe Text)
v1StorageClassVolumeBindingModeL f V1StorageClass{..} = (\v1StorageClassVolumeBindingMode -> V1StorageClass { v1StorageClassVolumeBindingMode, ..} ) <$> f v1StorageClassVolumeBindingMode
{-# INLINE v1StorageClassVolumeBindingModeL #-}



-- * V1StorageClassList

-- | 'v1StorageClassListApiVersion' Lens
v1StorageClassListApiVersionL :: Lens_' V1StorageClassList (Maybe Text)
v1StorageClassListApiVersionL f V1StorageClassList{..} = (\v1StorageClassListApiVersion -> V1StorageClassList { v1StorageClassListApiVersion, ..} ) <$> f v1StorageClassListApiVersion
{-# INLINE v1StorageClassListApiVersionL #-}

-- | 'v1StorageClassListItems' Lens
v1StorageClassListItemsL :: Lens_' V1StorageClassList ([V1StorageClass])
v1StorageClassListItemsL f V1StorageClassList{..} = (\v1StorageClassListItems -> V1StorageClassList { v1StorageClassListItems, ..} ) <$> f v1StorageClassListItems
{-# INLINE v1StorageClassListItemsL #-}

-- | 'v1StorageClassListKind' Lens
v1StorageClassListKindL :: Lens_' V1StorageClassList (Maybe Text)
v1StorageClassListKindL f V1StorageClassList{..} = (\v1StorageClassListKind -> V1StorageClassList { v1StorageClassListKind, ..} ) <$> f v1StorageClassListKind
{-# INLINE v1StorageClassListKindL #-}

-- | 'v1StorageClassListMetadata' Lens
v1StorageClassListMetadataL :: Lens_' V1StorageClassList (Maybe V1ListMeta)
v1StorageClassListMetadataL f V1StorageClassList{..} = (\v1StorageClassListMetadata -> V1StorageClassList { v1StorageClassListMetadata, ..} ) <$> f v1StorageClassListMetadata
{-# INLINE v1StorageClassListMetadataL #-}



-- * V1StorageOSPersistentVolumeSource

-- | 'v1StorageOSPersistentVolumeSourceFsType' Lens
v1StorageOSPersistentVolumeSourceFsTypeL :: Lens_' V1StorageOSPersistentVolumeSource (Maybe Text)
v1StorageOSPersistentVolumeSourceFsTypeL f V1StorageOSPersistentVolumeSource{..} = (\v1StorageOSPersistentVolumeSourceFsType -> V1StorageOSPersistentVolumeSource { v1StorageOSPersistentVolumeSourceFsType, ..} ) <$> f v1StorageOSPersistentVolumeSourceFsType
{-# INLINE v1StorageOSPersistentVolumeSourceFsTypeL #-}

-- | 'v1StorageOSPersistentVolumeSourceReadOnly' Lens
v1StorageOSPersistentVolumeSourceReadOnlyL :: Lens_' V1StorageOSPersistentVolumeSource (Maybe Bool)
v1StorageOSPersistentVolumeSourceReadOnlyL f V1StorageOSPersistentVolumeSource{..} = (\v1StorageOSPersistentVolumeSourceReadOnly -> V1StorageOSPersistentVolumeSource { v1StorageOSPersistentVolumeSourceReadOnly, ..} ) <$> f v1StorageOSPersistentVolumeSourceReadOnly
{-# INLINE v1StorageOSPersistentVolumeSourceReadOnlyL #-}

-- | 'v1StorageOSPersistentVolumeSourceSecretRef' Lens
v1StorageOSPersistentVolumeSourceSecretRefL :: Lens_' V1StorageOSPersistentVolumeSource (Maybe V1ObjectReference)
v1StorageOSPersistentVolumeSourceSecretRefL f V1StorageOSPersistentVolumeSource{..} = (\v1StorageOSPersistentVolumeSourceSecretRef -> V1StorageOSPersistentVolumeSource { v1StorageOSPersistentVolumeSourceSecretRef, ..} ) <$> f v1StorageOSPersistentVolumeSourceSecretRef
{-# INLINE v1StorageOSPersistentVolumeSourceSecretRefL #-}

-- | 'v1StorageOSPersistentVolumeSourceVolumeName' Lens
v1StorageOSPersistentVolumeSourceVolumeNameL :: Lens_' V1StorageOSPersistentVolumeSource (Maybe Text)
v1StorageOSPersistentVolumeSourceVolumeNameL f V1StorageOSPersistentVolumeSource{..} = (\v1StorageOSPersistentVolumeSourceVolumeName -> V1StorageOSPersistentVolumeSource { v1StorageOSPersistentVolumeSourceVolumeName, ..} ) <$> f v1StorageOSPersistentVolumeSourceVolumeName
{-# INLINE v1StorageOSPersistentVolumeSourceVolumeNameL #-}

-- | 'v1StorageOSPersistentVolumeSourceVolumeNamespace' Lens
v1StorageOSPersistentVolumeSourceVolumeNamespaceL :: Lens_' V1StorageOSPersistentVolumeSource (Maybe Text)
v1StorageOSPersistentVolumeSourceVolumeNamespaceL f V1StorageOSPersistentVolumeSource{..} = (\v1StorageOSPersistentVolumeSourceVolumeNamespace -> V1StorageOSPersistentVolumeSource { v1StorageOSPersistentVolumeSourceVolumeNamespace, ..} ) <$> f v1StorageOSPersistentVolumeSourceVolumeNamespace
{-# INLINE v1StorageOSPersistentVolumeSourceVolumeNamespaceL #-}



-- * V1StorageOSVolumeSource

-- | 'v1StorageOSVolumeSourceFsType' Lens
v1StorageOSVolumeSourceFsTypeL :: Lens_' V1StorageOSVolumeSource (Maybe Text)
v1StorageOSVolumeSourceFsTypeL f V1StorageOSVolumeSource{..} = (\v1StorageOSVolumeSourceFsType -> V1StorageOSVolumeSource { v1StorageOSVolumeSourceFsType, ..} ) <$> f v1StorageOSVolumeSourceFsType
{-# INLINE v1StorageOSVolumeSourceFsTypeL #-}

-- | 'v1StorageOSVolumeSourceReadOnly' Lens
v1StorageOSVolumeSourceReadOnlyL :: Lens_' V1StorageOSVolumeSource (Maybe Bool)
v1StorageOSVolumeSourceReadOnlyL f V1StorageOSVolumeSource{..} = (\v1StorageOSVolumeSourceReadOnly -> V1StorageOSVolumeSource { v1StorageOSVolumeSourceReadOnly, ..} ) <$> f v1StorageOSVolumeSourceReadOnly
{-# INLINE v1StorageOSVolumeSourceReadOnlyL #-}

-- | 'v1StorageOSVolumeSourceSecretRef' Lens
v1StorageOSVolumeSourceSecretRefL :: Lens_' V1StorageOSVolumeSource (Maybe V1LocalObjectReference)
v1StorageOSVolumeSourceSecretRefL f V1StorageOSVolumeSource{..} = (\v1StorageOSVolumeSourceSecretRef -> V1StorageOSVolumeSource { v1StorageOSVolumeSourceSecretRef, ..} ) <$> f v1StorageOSVolumeSourceSecretRef
{-# INLINE v1StorageOSVolumeSourceSecretRefL #-}

-- | 'v1StorageOSVolumeSourceVolumeName' Lens
v1StorageOSVolumeSourceVolumeNameL :: Lens_' V1StorageOSVolumeSource (Maybe Text)
v1StorageOSVolumeSourceVolumeNameL f V1StorageOSVolumeSource{..} = (\v1StorageOSVolumeSourceVolumeName -> V1StorageOSVolumeSource { v1StorageOSVolumeSourceVolumeName, ..} ) <$> f v1StorageOSVolumeSourceVolumeName
{-# INLINE v1StorageOSVolumeSourceVolumeNameL #-}

-- | 'v1StorageOSVolumeSourceVolumeNamespace' Lens
v1StorageOSVolumeSourceVolumeNamespaceL :: Lens_' V1StorageOSVolumeSource (Maybe Text)
v1StorageOSVolumeSourceVolumeNamespaceL f V1StorageOSVolumeSource{..} = (\v1StorageOSVolumeSourceVolumeNamespace -> V1StorageOSVolumeSource { v1StorageOSVolumeSourceVolumeNamespace, ..} ) <$> f v1StorageOSVolumeSourceVolumeNamespace
{-# INLINE v1StorageOSVolumeSourceVolumeNamespaceL #-}



-- * V1Subject

-- | 'v1SubjectApiGroup' Lens
v1SubjectApiGroupL :: Lens_' V1Subject (Maybe Text)
v1SubjectApiGroupL f V1Subject{..} = (\v1SubjectApiGroup -> V1Subject { v1SubjectApiGroup, ..} ) <$> f v1SubjectApiGroup
{-# INLINE v1SubjectApiGroupL #-}

-- | 'v1SubjectKind' Lens
v1SubjectKindL :: Lens_' V1Subject (Text)
v1SubjectKindL f V1Subject{..} = (\v1SubjectKind -> V1Subject { v1SubjectKind, ..} ) <$> f v1SubjectKind
{-# INLINE v1SubjectKindL #-}

-- | 'v1SubjectName' Lens
v1SubjectNameL :: Lens_' V1Subject (Text)
v1SubjectNameL f V1Subject{..} = (\v1SubjectName -> V1Subject { v1SubjectName, ..} ) <$> f v1SubjectName
{-# INLINE v1SubjectNameL #-}

-- | 'v1SubjectNamespace' Lens
v1SubjectNamespaceL :: Lens_' V1Subject (Maybe Text)
v1SubjectNamespaceL f V1Subject{..} = (\v1SubjectNamespace -> V1Subject { v1SubjectNamespace, ..} ) <$> f v1SubjectNamespace
{-# INLINE v1SubjectNamespaceL #-}



-- * V1SubjectAccessReview

-- | 'v1SubjectAccessReviewApiVersion' Lens
v1SubjectAccessReviewApiVersionL :: Lens_' V1SubjectAccessReview (Maybe Text)
v1SubjectAccessReviewApiVersionL f V1SubjectAccessReview{..} = (\v1SubjectAccessReviewApiVersion -> V1SubjectAccessReview { v1SubjectAccessReviewApiVersion, ..} ) <$> f v1SubjectAccessReviewApiVersion
{-# INLINE v1SubjectAccessReviewApiVersionL #-}

-- | 'v1SubjectAccessReviewKind' Lens
v1SubjectAccessReviewKindL :: Lens_' V1SubjectAccessReview (Maybe Text)
v1SubjectAccessReviewKindL f V1SubjectAccessReview{..} = (\v1SubjectAccessReviewKind -> V1SubjectAccessReview { v1SubjectAccessReviewKind, ..} ) <$> f v1SubjectAccessReviewKind
{-# INLINE v1SubjectAccessReviewKindL #-}

-- | 'v1SubjectAccessReviewMetadata' Lens
v1SubjectAccessReviewMetadataL :: Lens_' V1SubjectAccessReview (Maybe V1ObjectMeta)
v1SubjectAccessReviewMetadataL f V1SubjectAccessReview{..} = (\v1SubjectAccessReviewMetadata -> V1SubjectAccessReview { v1SubjectAccessReviewMetadata, ..} ) <$> f v1SubjectAccessReviewMetadata
{-# INLINE v1SubjectAccessReviewMetadataL #-}

-- | 'v1SubjectAccessReviewSpec' Lens
v1SubjectAccessReviewSpecL :: Lens_' V1SubjectAccessReview (V1SubjectAccessReviewSpec)
v1SubjectAccessReviewSpecL f V1SubjectAccessReview{..} = (\v1SubjectAccessReviewSpec -> V1SubjectAccessReview { v1SubjectAccessReviewSpec, ..} ) <$> f v1SubjectAccessReviewSpec
{-# INLINE v1SubjectAccessReviewSpecL #-}

-- | 'v1SubjectAccessReviewStatus' Lens
v1SubjectAccessReviewStatusL :: Lens_' V1SubjectAccessReview (Maybe V1SubjectAccessReviewStatus)
v1SubjectAccessReviewStatusL f V1SubjectAccessReview{..} = (\v1SubjectAccessReviewStatus -> V1SubjectAccessReview { v1SubjectAccessReviewStatus, ..} ) <$> f v1SubjectAccessReviewStatus
{-# INLINE v1SubjectAccessReviewStatusL #-}



-- * V1SubjectAccessReviewSpec

-- | 'v1SubjectAccessReviewSpecExtra' Lens
v1SubjectAccessReviewSpecExtraL :: Lens_' V1SubjectAccessReviewSpec (Maybe (Map.Map String [Text]))
v1SubjectAccessReviewSpecExtraL f V1SubjectAccessReviewSpec{..} = (\v1SubjectAccessReviewSpecExtra -> V1SubjectAccessReviewSpec { v1SubjectAccessReviewSpecExtra, ..} ) <$> f v1SubjectAccessReviewSpecExtra
{-# INLINE v1SubjectAccessReviewSpecExtraL #-}

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

-- | 'v1SubjectAccessReviewSpecNonResourceAttributes' Lens
v1SubjectAccessReviewSpecNonResourceAttributesL :: Lens_' V1SubjectAccessReviewSpec (Maybe V1NonResourceAttributes)
v1SubjectAccessReviewSpecNonResourceAttributesL f V1SubjectAccessReviewSpec{..} = (\v1SubjectAccessReviewSpecNonResourceAttributes -> V1SubjectAccessReviewSpec { v1SubjectAccessReviewSpecNonResourceAttributes, ..} ) <$> f v1SubjectAccessReviewSpecNonResourceAttributes
{-# INLINE v1SubjectAccessReviewSpecNonResourceAttributesL #-}

-- | 'v1SubjectAccessReviewSpecResourceAttributes' Lens
v1SubjectAccessReviewSpecResourceAttributesL :: Lens_' V1SubjectAccessReviewSpec (Maybe V1ResourceAttributes)
v1SubjectAccessReviewSpecResourceAttributesL f V1SubjectAccessReviewSpec{..} = (\v1SubjectAccessReviewSpecResourceAttributes -> V1SubjectAccessReviewSpec { v1SubjectAccessReviewSpecResourceAttributes, ..} ) <$> f v1SubjectAccessReviewSpecResourceAttributes
{-# INLINE v1SubjectAccessReviewSpecResourceAttributesL #-}

-- | 'v1SubjectAccessReviewSpecUid' Lens
v1SubjectAccessReviewSpecUidL :: Lens_' V1SubjectAccessReviewSpec (Maybe Text)
v1SubjectAccessReviewSpecUidL f V1SubjectAccessReviewSpec{..} = (\v1SubjectAccessReviewSpecUid -> V1SubjectAccessReviewSpec { v1SubjectAccessReviewSpecUid, ..} ) <$> f v1SubjectAccessReviewSpecUid
{-# INLINE v1SubjectAccessReviewSpecUidL #-}

-- | 'v1SubjectAccessReviewSpecUser' Lens
v1SubjectAccessReviewSpecUserL :: Lens_' V1SubjectAccessReviewSpec (Maybe Text)
v1SubjectAccessReviewSpecUserL f V1SubjectAccessReviewSpec{..} = (\v1SubjectAccessReviewSpecUser -> V1SubjectAccessReviewSpec { v1SubjectAccessReviewSpecUser, ..} ) <$> f v1SubjectAccessReviewSpecUser
{-# INLINE v1SubjectAccessReviewSpecUserL #-}



-- * V1SubjectAccessReviewStatus

-- | 'v1SubjectAccessReviewStatusAllowed' Lens
v1SubjectAccessReviewStatusAllowedL :: Lens_' V1SubjectAccessReviewStatus (Bool)
v1SubjectAccessReviewStatusAllowedL f V1SubjectAccessReviewStatus{..} = (\v1SubjectAccessReviewStatusAllowed -> V1SubjectAccessReviewStatus { v1SubjectAccessReviewStatusAllowed, ..} ) <$> f v1SubjectAccessReviewStatusAllowed
{-# INLINE v1SubjectAccessReviewStatusAllowedL #-}

-- | 'v1SubjectAccessReviewStatusDenied' Lens
v1SubjectAccessReviewStatusDeniedL :: Lens_' V1SubjectAccessReviewStatus (Maybe Bool)
v1SubjectAccessReviewStatusDeniedL f V1SubjectAccessReviewStatus{..} = (\v1SubjectAccessReviewStatusDenied -> V1SubjectAccessReviewStatus { v1SubjectAccessReviewStatusDenied, ..} ) <$> f v1SubjectAccessReviewStatusDenied
{-# INLINE v1SubjectAccessReviewStatusDeniedL #-}

-- | 'v1SubjectAccessReviewStatusEvaluationError' Lens
v1SubjectAccessReviewStatusEvaluationErrorL :: Lens_' V1SubjectAccessReviewStatus (Maybe Text)
v1SubjectAccessReviewStatusEvaluationErrorL f V1SubjectAccessReviewStatus{..} = (\v1SubjectAccessReviewStatusEvaluationError -> V1SubjectAccessReviewStatus { v1SubjectAccessReviewStatusEvaluationError, ..} ) <$> f v1SubjectAccessReviewStatusEvaluationError
{-# INLINE v1SubjectAccessReviewStatusEvaluationErrorL #-}

-- | 'v1SubjectAccessReviewStatusReason' Lens
v1SubjectAccessReviewStatusReasonL :: Lens_' V1SubjectAccessReviewStatus (Maybe Text)
v1SubjectAccessReviewStatusReasonL f V1SubjectAccessReviewStatus{..} = (\v1SubjectAccessReviewStatusReason -> V1SubjectAccessReviewStatus { v1SubjectAccessReviewStatusReason, ..} ) <$> f v1SubjectAccessReviewStatusReason
{-# INLINE v1SubjectAccessReviewStatusReasonL #-}



-- * V1SubjectRulesReviewStatus

-- | 'v1SubjectRulesReviewStatusEvaluationError' Lens
v1SubjectRulesReviewStatusEvaluationErrorL :: Lens_' V1SubjectRulesReviewStatus (Maybe Text)
v1SubjectRulesReviewStatusEvaluationErrorL f V1SubjectRulesReviewStatus{..} = (\v1SubjectRulesReviewStatusEvaluationError -> V1SubjectRulesReviewStatus { v1SubjectRulesReviewStatusEvaluationError, ..} ) <$> f v1SubjectRulesReviewStatusEvaluationError
{-# INLINE v1SubjectRulesReviewStatusEvaluationErrorL #-}

-- | 'v1SubjectRulesReviewStatusIncomplete' Lens
v1SubjectRulesReviewStatusIncompleteL :: Lens_' V1SubjectRulesReviewStatus (Bool)
v1SubjectRulesReviewStatusIncompleteL f V1SubjectRulesReviewStatus{..} = (\v1SubjectRulesReviewStatusIncomplete -> V1SubjectRulesReviewStatus { v1SubjectRulesReviewStatusIncomplete, ..} ) <$> f v1SubjectRulesReviewStatusIncomplete
{-# INLINE v1SubjectRulesReviewStatusIncompleteL #-}

-- | 'v1SubjectRulesReviewStatusNonResourceRules' Lens
v1SubjectRulesReviewStatusNonResourceRulesL :: Lens_' V1SubjectRulesReviewStatus ([V1NonResourceRule])
v1SubjectRulesReviewStatusNonResourceRulesL f V1SubjectRulesReviewStatus{..} = (\v1SubjectRulesReviewStatusNonResourceRules -> V1SubjectRulesReviewStatus { v1SubjectRulesReviewStatusNonResourceRules, ..} ) <$> f v1SubjectRulesReviewStatusNonResourceRules
{-# INLINE v1SubjectRulesReviewStatusNonResourceRulesL #-}

-- | 'v1SubjectRulesReviewStatusResourceRules' Lens
v1SubjectRulesReviewStatusResourceRulesL :: Lens_' V1SubjectRulesReviewStatus ([V1ResourceRule])
v1SubjectRulesReviewStatusResourceRulesL f V1SubjectRulesReviewStatus{..} = (\v1SubjectRulesReviewStatusResourceRules -> V1SubjectRulesReviewStatus { v1SubjectRulesReviewStatusResourceRules, ..} ) <$> f v1SubjectRulesReviewStatusResourceRules
{-# INLINE v1SubjectRulesReviewStatusResourceRulesL #-}



-- * V1Sysctl

-- | 'v1SysctlName' Lens
v1SysctlNameL :: Lens_' V1Sysctl (Text)
v1SysctlNameL f V1Sysctl{..} = (\v1SysctlName -> V1Sysctl { v1SysctlName, ..} ) <$> f v1SysctlName
{-# INLINE v1SysctlNameL #-}

-- | 'v1SysctlValue' Lens
v1SysctlValueL :: Lens_' V1Sysctl (Text)
v1SysctlValueL f V1Sysctl{..} = (\v1SysctlValue -> V1Sysctl { v1SysctlValue, ..} ) <$> f v1SysctlValue
{-# INLINE v1SysctlValueL #-}



-- * V1TCPSocketAction

-- | 'v1TCPSocketActionHost' Lens
v1TCPSocketActionHostL :: Lens_' V1TCPSocketAction (Maybe Text)
v1TCPSocketActionHostL f V1TCPSocketAction{..} = (\v1TCPSocketActionHost -> V1TCPSocketAction { v1TCPSocketActionHost, ..} ) <$> f v1TCPSocketActionHost
{-# INLINE v1TCPSocketActionHostL #-}

-- | 'v1TCPSocketActionPort' Lens
v1TCPSocketActionPortL :: Lens_' V1TCPSocketAction (IntOrString)
v1TCPSocketActionPortL f V1TCPSocketAction{..} = (\v1TCPSocketActionPort -> V1TCPSocketAction { v1TCPSocketActionPort, ..} ) <$> f v1TCPSocketActionPort
{-# INLINE v1TCPSocketActionPortL #-}



-- * V1Taint

-- | 'v1TaintEffect' Lens
v1TaintEffectL :: Lens_' V1Taint (Text)
v1TaintEffectL f V1Taint{..} = (\v1TaintEffect -> V1Taint { v1TaintEffect, ..} ) <$> f v1TaintEffect
{-# INLINE v1TaintEffectL #-}

-- | 'v1TaintKey' Lens
v1TaintKeyL :: Lens_' V1Taint (Text)
v1TaintKeyL f V1Taint{..} = (\v1TaintKey -> V1Taint { v1TaintKey, ..} ) <$> f v1TaintKey
{-# INLINE v1TaintKeyL #-}

-- | 'v1TaintTimeAdded' Lens
v1TaintTimeAddedL :: Lens_' V1Taint (Maybe DateTime)
v1TaintTimeAddedL f V1Taint{..} = (\v1TaintTimeAdded -> V1Taint { v1TaintTimeAdded, ..} ) <$> f v1TaintTimeAdded
{-# INLINE v1TaintTimeAddedL #-}

-- | 'v1TaintValue' Lens
v1TaintValueL :: Lens_' V1Taint (Maybe Text)
v1TaintValueL f V1Taint{..} = (\v1TaintValue -> V1Taint { v1TaintValue, ..} ) <$> f v1TaintValue
{-# INLINE v1TaintValueL #-}



-- * V1TokenRequestSpec

-- | 'v1TokenRequestSpecAudiences' Lens
v1TokenRequestSpecAudiencesL :: Lens_' V1TokenRequestSpec ([Text])
v1TokenRequestSpecAudiencesL f V1TokenRequestSpec{..} = (\v1TokenRequestSpecAudiences -> V1TokenRequestSpec { v1TokenRequestSpecAudiences, ..} ) <$> f v1TokenRequestSpecAudiences
{-# INLINE v1TokenRequestSpecAudiencesL #-}

-- | 'v1TokenRequestSpecBoundObjectRef' Lens
v1TokenRequestSpecBoundObjectRefL :: Lens_' V1TokenRequestSpec (Maybe V1BoundObjectReference)
v1TokenRequestSpecBoundObjectRefL f V1TokenRequestSpec{..} = (\v1TokenRequestSpecBoundObjectRef -> V1TokenRequestSpec { v1TokenRequestSpecBoundObjectRef, ..} ) <$> f v1TokenRequestSpecBoundObjectRef
{-# INLINE v1TokenRequestSpecBoundObjectRefL #-}

-- | 'v1TokenRequestSpecExpirationSeconds' Lens
v1TokenRequestSpecExpirationSecondsL :: Lens_' V1TokenRequestSpec (Maybe Integer)
v1TokenRequestSpecExpirationSecondsL f V1TokenRequestSpec{..} = (\v1TokenRequestSpecExpirationSeconds -> V1TokenRequestSpec { v1TokenRequestSpecExpirationSeconds, ..} ) <$> f v1TokenRequestSpecExpirationSeconds
{-# INLINE v1TokenRequestSpecExpirationSecondsL #-}



-- * V1TokenRequestStatus

-- | 'v1TokenRequestStatusExpirationTimestamp' Lens
v1TokenRequestStatusExpirationTimestampL :: Lens_' V1TokenRequestStatus (DateTime)
v1TokenRequestStatusExpirationTimestampL f V1TokenRequestStatus{..} = (\v1TokenRequestStatusExpirationTimestamp -> V1TokenRequestStatus { v1TokenRequestStatusExpirationTimestamp, ..} ) <$> f v1TokenRequestStatusExpirationTimestamp
{-# INLINE v1TokenRequestStatusExpirationTimestampL #-}

-- | 'v1TokenRequestStatusToken' Lens
v1TokenRequestStatusTokenL :: Lens_' V1TokenRequestStatus (Text)
v1TokenRequestStatusTokenL f V1TokenRequestStatus{..} = (\v1TokenRequestStatusToken -> V1TokenRequestStatus { v1TokenRequestStatusToken, ..} ) <$> f v1TokenRequestStatusToken
{-# INLINE v1TokenRequestStatusTokenL #-}



-- * V1TokenReview

-- | 'v1TokenReviewApiVersion' Lens
v1TokenReviewApiVersionL :: Lens_' V1TokenReview (Maybe Text)
v1TokenReviewApiVersionL f V1TokenReview{..} = (\v1TokenReviewApiVersion -> V1TokenReview { v1TokenReviewApiVersion, ..} ) <$> f v1TokenReviewApiVersion
{-# INLINE v1TokenReviewApiVersionL #-}

-- | 'v1TokenReviewKind' Lens
v1TokenReviewKindL :: Lens_' V1TokenReview (Maybe Text)
v1TokenReviewKindL f V1TokenReview{..} = (\v1TokenReviewKind -> V1TokenReview { v1TokenReviewKind, ..} ) <$> f v1TokenReviewKind
{-# INLINE v1TokenReviewKindL #-}

-- | 'v1TokenReviewMetadata' Lens
v1TokenReviewMetadataL :: Lens_' V1TokenReview (Maybe V1ObjectMeta)
v1TokenReviewMetadataL f V1TokenReview{..} = (\v1TokenReviewMetadata -> V1TokenReview { v1TokenReviewMetadata, ..} ) <$> f v1TokenReviewMetadata
{-# INLINE v1TokenReviewMetadataL #-}

-- | 'v1TokenReviewSpec' Lens
v1TokenReviewSpecL :: Lens_' V1TokenReview (V1TokenReviewSpec)
v1TokenReviewSpecL f V1TokenReview{..} = (\v1TokenReviewSpec -> V1TokenReview { v1TokenReviewSpec, ..} ) <$> f v1TokenReviewSpec
{-# INLINE v1TokenReviewSpecL #-}

-- | 'v1TokenReviewStatus' Lens
v1TokenReviewStatusL :: Lens_' V1TokenReview (Maybe V1TokenReviewStatus)
v1TokenReviewStatusL f V1TokenReview{..} = (\v1TokenReviewStatus -> V1TokenReview { v1TokenReviewStatus, ..} ) <$> f v1TokenReviewStatus
{-# INLINE v1TokenReviewStatusL #-}



-- * V1TokenReviewSpec

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

-- | 'v1TokenReviewSpecToken' Lens
v1TokenReviewSpecTokenL :: Lens_' V1TokenReviewSpec (Maybe Text)
v1TokenReviewSpecTokenL f V1TokenReviewSpec{..} = (\v1TokenReviewSpecToken -> V1TokenReviewSpec { v1TokenReviewSpecToken, ..} ) <$> f v1TokenReviewSpecToken
{-# INLINE v1TokenReviewSpecTokenL #-}



-- * V1TokenReviewStatus

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

-- | 'v1TokenReviewStatusAuthenticated' Lens
v1TokenReviewStatusAuthenticatedL :: Lens_' V1TokenReviewStatus (Maybe Bool)
v1TokenReviewStatusAuthenticatedL f V1TokenReviewStatus{..} = (\v1TokenReviewStatusAuthenticated -> V1TokenReviewStatus { v1TokenReviewStatusAuthenticated, ..} ) <$> f v1TokenReviewStatusAuthenticated
{-# INLINE v1TokenReviewStatusAuthenticatedL #-}

-- | 'v1TokenReviewStatusError' Lens
v1TokenReviewStatusErrorL :: Lens_' V1TokenReviewStatus (Maybe Text)
v1TokenReviewStatusErrorL f V1TokenReviewStatus{..} = (\v1TokenReviewStatusError -> V1TokenReviewStatus { v1TokenReviewStatusError, ..} ) <$> f v1TokenReviewStatusError
{-# INLINE v1TokenReviewStatusErrorL #-}

-- | 'v1TokenReviewStatusUser' Lens
v1TokenReviewStatusUserL :: Lens_' V1TokenReviewStatus (Maybe V1UserInfo)
v1TokenReviewStatusUserL f V1TokenReviewStatus{..} = (\v1TokenReviewStatusUser -> V1TokenReviewStatus { v1TokenReviewStatusUser, ..} ) <$> f v1TokenReviewStatusUser
{-# INLINE v1TokenReviewStatusUserL #-}



-- * V1Toleration

-- | 'v1TolerationEffect' Lens
v1TolerationEffectL :: Lens_' V1Toleration (Maybe Text)
v1TolerationEffectL f V1Toleration{..} = (\v1TolerationEffect -> V1Toleration { v1TolerationEffect, ..} ) <$> f v1TolerationEffect
{-# INLINE v1TolerationEffectL #-}

-- | 'v1TolerationKey' Lens
v1TolerationKeyL :: Lens_' V1Toleration (Maybe Text)
v1TolerationKeyL f V1Toleration{..} = (\v1TolerationKey -> V1Toleration { v1TolerationKey, ..} ) <$> f v1TolerationKey
{-# INLINE v1TolerationKeyL #-}

-- | 'v1TolerationOperator' Lens
v1TolerationOperatorL :: Lens_' V1Toleration (Maybe Text)
v1TolerationOperatorL f V1Toleration{..} = (\v1TolerationOperator -> V1Toleration { v1TolerationOperator, ..} ) <$> f v1TolerationOperator
{-# INLINE v1TolerationOperatorL #-}

-- | 'v1TolerationTolerationSeconds' Lens
v1TolerationTolerationSecondsL :: Lens_' V1Toleration (Maybe Integer)
v1TolerationTolerationSecondsL f V1Toleration{..} = (\v1TolerationTolerationSeconds -> V1Toleration { v1TolerationTolerationSeconds, ..} ) <$> f v1TolerationTolerationSeconds
{-# INLINE v1TolerationTolerationSecondsL #-}

-- | 'v1TolerationValue' Lens
v1TolerationValueL :: Lens_' V1Toleration (Maybe Text)
v1TolerationValueL f V1Toleration{..} = (\v1TolerationValue -> V1Toleration { v1TolerationValue, ..} ) <$> f v1TolerationValue
{-# INLINE v1TolerationValueL #-}



-- * V1TopologySelectorLabelRequirement

-- | 'v1TopologySelectorLabelRequirementKey' Lens
v1TopologySelectorLabelRequirementKeyL :: Lens_' V1TopologySelectorLabelRequirement (Text)
v1TopologySelectorLabelRequirementKeyL f V1TopologySelectorLabelRequirement{..} = (\v1TopologySelectorLabelRequirementKey -> V1TopologySelectorLabelRequirement { v1TopologySelectorLabelRequirementKey, ..} ) <$> f v1TopologySelectorLabelRequirementKey
{-# INLINE v1TopologySelectorLabelRequirementKeyL #-}

-- | 'v1TopologySelectorLabelRequirementValues' Lens
v1TopologySelectorLabelRequirementValuesL :: Lens_' V1TopologySelectorLabelRequirement ([Text])
v1TopologySelectorLabelRequirementValuesL f V1TopologySelectorLabelRequirement{..} = (\v1TopologySelectorLabelRequirementValues -> V1TopologySelectorLabelRequirement { v1TopologySelectorLabelRequirementValues, ..} ) <$> f v1TopologySelectorLabelRequirementValues
{-# INLINE v1TopologySelectorLabelRequirementValuesL #-}



-- * V1TopologySelectorTerm

-- | 'v1TopologySelectorTermMatchLabelExpressions' Lens
v1TopologySelectorTermMatchLabelExpressionsL :: Lens_' V1TopologySelectorTerm (Maybe [V1TopologySelectorLabelRequirement])
v1TopologySelectorTermMatchLabelExpressionsL f V1TopologySelectorTerm{..} = (\v1TopologySelectorTermMatchLabelExpressions -> V1TopologySelectorTerm { v1TopologySelectorTermMatchLabelExpressions, ..} ) <$> f v1TopologySelectorTermMatchLabelExpressions
{-# INLINE v1TopologySelectorTermMatchLabelExpressionsL #-}



-- * V1TopologySpreadConstraint

-- | 'v1TopologySpreadConstraintLabelSelector' Lens
v1TopologySpreadConstraintLabelSelectorL :: Lens_' V1TopologySpreadConstraint (Maybe V1LabelSelector)
v1TopologySpreadConstraintLabelSelectorL f V1TopologySpreadConstraint{..} = (\v1TopologySpreadConstraintLabelSelector -> V1TopologySpreadConstraint { v1TopologySpreadConstraintLabelSelector, ..} ) <$> f v1TopologySpreadConstraintLabelSelector
{-# INLINE v1TopologySpreadConstraintLabelSelectorL #-}

-- | 'v1TopologySpreadConstraintMaxSkew' Lens
v1TopologySpreadConstraintMaxSkewL :: Lens_' V1TopologySpreadConstraint (Int)
v1TopologySpreadConstraintMaxSkewL f V1TopologySpreadConstraint{..} = (\v1TopologySpreadConstraintMaxSkew -> V1TopologySpreadConstraint { v1TopologySpreadConstraintMaxSkew, ..} ) <$> f v1TopologySpreadConstraintMaxSkew
{-# INLINE v1TopologySpreadConstraintMaxSkewL #-}

-- | 'v1TopologySpreadConstraintTopologyKey' Lens
v1TopologySpreadConstraintTopologyKeyL :: Lens_' V1TopologySpreadConstraint (Text)
v1TopologySpreadConstraintTopologyKeyL f V1TopologySpreadConstraint{..} = (\v1TopologySpreadConstraintTopologyKey -> V1TopologySpreadConstraint { v1TopologySpreadConstraintTopologyKey, ..} ) <$> f v1TopologySpreadConstraintTopologyKey
{-# INLINE v1TopologySpreadConstraintTopologyKeyL #-}

-- | 'v1TopologySpreadConstraintWhenUnsatisfiable' Lens
v1TopologySpreadConstraintWhenUnsatisfiableL :: Lens_' V1TopologySpreadConstraint (Text)
v1TopologySpreadConstraintWhenUnsatisfiableL f V1TopologySpreadConstraint{..} = (\v1TopologySpreadConstraintWhenUnsatisfiable -> V1TopologySpreadConstraint { v1TopologySpreadConstraintWhenUnsatisfiable, ..} ) <$> f v1TopologySpreadConstraintWhenUnsatisfiable
{-# INLINE v1TopologySpreadConstraintWhenUnsatisfiableL #-}



-- * V1TypedLocalObjectReference

-- | 'v1TypedLocalObjectReferenceApiGroup' Lens
v1TypedLocalObjectReferenceApiGroupL :: Lens_' V1TypedLocalObjectReference (Maybe Text)
v1TypedLocalObjectReferenceApiGroupL f V1TypedLocalObjectReference{..} = (\v1TypedLocalObjectReferenceApiGroup -> V1TypedLocalObjectReference { v1TypedLocalObjectReferenceApiGroup, ..} ) <$> f v1TypedLocalObjectReferenceApiGroup
{-# INLINE v1TypedLocalObjectReferenceApiGroupL #-}

-- | 'v1TypedLocalObjectReferenceKind' Lens
v1TypedLocalObjectReferenceKindL :: Lens_' V1TypedLocalObjectReference (Text)
v1TypedLocalObjectReferenceKindL f V1TypedLocalObjectReference{..} = (\v1TypedLocalObjectReferenceKind -> V1TypedLocalObjectReference { v1TypedLocalObjectReferenceKind, ..} ) <$> f v1TypedLocalObjectReferenceKind
{-# INLINE v1TypedLocalObjectReferenceKindL #-}

-- | 'v1TypedLocalObjectReferenceName' Lens
v1TypedLocalObjectReferenceNameL :: Lens_' V1TypedLocalObjectReference (Text)
v1TypedLocalObjectReferenceNameL f V1TypedLocalObjectReference{..} = (\v1TypedLocalObjectReferenceName -> V1TypedLocalObjectReference { v1TypedLocalObjectReferenceName, ..} ) <$> f v1TypedLocalObjectReferenceName
{-# INLINE v1TypedLocalObjectReferenceNameL #-}



-- * V1UncountedTerminatedPods

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

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



-- * V1UserInfo

-- | 'v1UserInfoExtra' Lens
v1UserInfoExtraL :: Lens_' V1UserInfo (Maybe (Map.Map String [Text]))
v1UserInfoExtraL f V1UserInfo{..} = (\v1UserInfoExtra -> V1UserInfo { v1UserInfoExtra, ..} ) <$> f v1UserInfoExtra
{-# INLINE v1UserInfoExtraL #-}

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

-- | 'v1UserInfoUid' Lens
v1UserInfoUidL :: Lens_' V1UserInfo (Maybe Text)
v1UserInfoUidL f V1UserInfo{..} = (\v1UserInfoUid -> V1UserInfo { v1UserInfoUid, ..} ) <$> f v1UserInfoUid
{-# INLINE v1UserInfoUidL #-}

-- | 'v1UserInfoUsername' Lens
v1UserInfoUsernameL :: Lens_' V1UserInfo (Maybe Text)
v1UserInfoUsernameL f V1UserInfo{..} = (\v1UserInfoUsername -> V1UserInfo { v1UserInfoUsername, ..} ) <$> f v1UserInfoUsername
{-# INLINE v1UserInfoUsernameL #-}



-- * V1ValidatingWebhook

-- | 'v1ValidatingWebhookAdmissionReviewVersions' Lens
v1ValidatingWebhookAdmissionReviewVersionsL :: Lens_' V1ValidatingWebhook ([Text])
v1ValidatingWebhookAdmissionReviewVersionsL f V1ValidatingWebhook{..} = (\v1ValidatingWebhookAdmissionReviewVersions -> V1ValidatingWebhook { v1ValidatingWebhookAdmissionReviewVersions, ..} ) <$> f v1ValidatingWebhookAdmissionReviewVersions
{-# INLINE v1ValidatingWebhookAdmissionReviewVersionsL #-}

-- | 'v1ValidatingWebhookClientConfig' Lens
v1ValidatingWebhookClientConfigL :: Lens_' V1ValidatingWebhook (AdmissionregistrationV1WebhookClientConfig)
v1ValidatingWebhookClientConfigL f V1ValidatingWebhook{..} = (\v1ValidatingWebhookClientConfig -> V1ValidatingWebhook { v1ValidatingWebhookClientConfig, ..} ) <$> f v1ValidatingWebhookClientConfig
{-# INLINE v1ValidatingWebhookClientConfigL #-}

-- | 'v1ValidatingWebhookFailurePolicy' Lens
v1ValidatingWebhookFailurePolicyL :: Lens_' V1ValidatingWebhook (Maybe Text)
v1ValidatingWebhookFailurePolicyL f V1ValidatingWebhook{..} = (\v1ValidatingWebhookFailurePolicy -> V1ValidatingWebhook { v1ValidatingWebhookFailurePolicy, ..} ) <$> f v1ValidatingWebhookFailurePolicy
{-# INLINE v1ValidatingWebhookFailurePolicyL #-}

-- | 'v1ValidatingWebhookMatchPolicy' Lens
v1ValidatingWebhookMatchPolicyL :: Lens_' V1ValidatingWebhook (Maybe Text)
v1ValidatingWebhookMatchPolicyL f V1ValidatingWebhook{..} = (\v1ValidatingWebhookMatchPolicy -> V1ValidatingWebhook { v1ValidatingWebhookMatchPolicy, ..} ) <$> f v1ValidatingWebhookMatchPolicy
{-# INLINE v1ValidatingWebhookMatchPolicyL #-}

-- | 'v1ValidatingWebhookName' Lens
v1ValidatingWebhookNameL :: Lens_' V1ValidatingWebhook (Text)
v1ValidatingWebhookNameL f V1ValidatingWebhook{..} = (\v1ValidatingWebhookName -> V1ValidatingWebhook { v1ValidatingWebhookName, ..} ) <$> f v1ValidatingWebhookName
{-# INLINE v1ValidatingWebhookNameL #-}

-- | 'v1ValidatingWebhookNamespaceSelector' Lens
v1ValidatingWebhookNamespaceSelectorL :: Lens_' V1ValidatingWebhook (Maybe V1LabelSelector)
v1ValidatingWebhookNamespaceSelectorL f V1ValidatingWebhook{..} = (\v1ValidatingWebhookNamespaceSelector -> V1ValidatingWebhook { v1ValidatingWebhookNamespaceSelector, ..} ) <$> f v1ValidatingWebhookNamespaceSelector
{-# INLINE v1ValidatingWebhookNamespaceSelectorL #-}

-- | 'v1ValidatingWebhookObjectSelector' Lens
v1ValidatingWebhookObjectSelectorL :: Lens_' V1ValidatingWebhook (Maybe V1LabelSelector)
v1ValidatingWebhookObjectSelectorL f V1ValidatingWebhook{..} = (\v1ValidatingWebhookObjectSelector -> V1ValidatingWebhook { v1ValidatingWebhookObjectSelector, ..} ) <$> f v1ValidatingWebhookObjectSelector
{-# INLINE v1ValidatingWebhookObjectSelectorL #-}

-- | 'v1ValidatingWebhookRules' Lens
v1ValidatingWebhookRulesL :: Lens_' V1ValidatingWebhook (Maybe [V1RuleWithOperations])
v1ValidatingWebhookRulesL f V1ValidatingWebhook{..} = (\v1ValidatingWebhookRules -> V1ValidatingWebhook { v1ValidatingWebhookRules, ..} ) <$> f v1ValidatingWebhookRules
{-# INLINE v1ValidatingWebhookRulesL #-}

-- | 'v1ValidatingWebhookSideEffects' Lens
v1ValidatingWebhookSideEffectsL :: Lens_' V1ValidatingWebhook (Text)
v1ValidatingWebhookSideEffectsL f V1ValidatingWebhook{..} = (\v1ValidatingWebhookSideEffects -> V1ValidatingWebhook { v1ValidatingWebhookSideEffects, ..} ) <$> f v1ValidatingWebhookSideEffects
{-# INLINE v1ValidatingWebhookSideEffectsL #-}

-- | 'v1ValidatingWebhookTimeoutSeconds' Lens
v1ValidatingWebhookTimeoutSecondsL :: Lens_' V1ValidatingWebhook (Maybe Int)
v1ValidatingWebhookTimeoutSecondsL f V1ValidatingWebhook{..} = (\v1ValidatingWebhookTimeoutSeconds -> V1ValidatingWebhook { v1ValidatingWebhookTimeoutSeconds, ..} ) <$> f v1ValidatingWebhookTimeoutSeconds
{-# INLINE v1ValidatingWebhookTimeoutSecondsL #-}



-- * V1ValidatingWebhookConfiguration

-- | 'v1ValidatingWebhookConfigurationApiVersion' Lens
v1ValidatingWebhookConfigurationApiVersionL :: Lens_' V1ValidatingWebhookConfiguration (Maybe Text)
v1ValidatingWebhookConfigurationApiVersionL f V1ValidatingWebhookConfiguration{..} = (\v1ValidatingWebhookConfigurationApiVersion -> V1ValidatingWebhookConfiguration { v1ValidatingWebhookConfigurationApiVersion, ..} ) <$> f v1ValidatingWebhookConfigurationApiVersion
{-# INLINE v1ValidatingWebhookConfigurationApiVersionL #-}

-- | 'v1ValidatingWebhookConfigurationKind' Lens
v1ValidatingWebhookConfigurationKindL :: Lens_' V1ValidatingWebhookConfiguration (Maybe Text)
v1ValidatingWebhookConfigurationKindL f V1ValidatingWebhookConfiguration{..} = (\v1ValidatingWebhookConfigurationKind -> V1ValidatingWebhookConfiguration { v1ValidatingWebhookConfigurationKind, ..} ) <$> f v1ValidatingWebhookConfigurationKind
{-# INLINE v1ValidatingWebhookConfigurationKindL #-}

-- | 'v1ValidatingWebhookConfigurationMetadata' Lens
v1ValidatingWebhookConfigurationMetadataL :: Lens_' V1ValidatingWebhookConfiguration (Maybe V1ObjectMeta)
v1ValidatingWebhookConfigurationMetadataL f V1ValidatingWebhookConfiguration{..} = (\v1ValidatingWebhookConfigurationMetadata -> V1ValidatingWebhookConfiguration { v1ValidatingWebhookConfigurationMetadata, ..} ) <$> f v1ValidatingWebhookConfigurationMetadata
{-# INLINE v1ValidatingWebhookConfigurationMetadataL #-}

-- | 'v1ValidatingWebhookConfigurationWebhooks' Lens
v1ValidatingWebhookConfigurationWebhooksL :: Lens_' V1ValidatingWebhookConfiguration (Maybe [V1ValidatingWebhook])
v1ValidatingWebhookConfigurationWebhooksL f V1ValidatingWebhookConfiguration{..} = (\v1ValidatingWebhookConfigurationWebhooks -> V1ValidatingWebhookConfiguration { v1ValidatingWebhookConfigurationWebhooks, ..} ) <$> f v1ValidatingWebhookConfigurationWebhooks
{-# INLINE v1ValidatingWebhookConfigurationWebhooksL #-}



-- * V1ValidatingWebhookConfigurationList

-- | 'v1ValidatingWebhookConfigurationListApiVersion' Lens
v1ValidatingWebhookConfigurationListApiVersionL :: Lens_' V1ValidatingWebhookConfigurationList (Maybe Text)
v1ValidatingWebhookConfigurationListApiVersionL f V1ValidatingWebhookConfigurationList{..} = (\v1ValidatingWebhookConfigurationListApiVersion -> V1ValidatingWebhookConfigurationList { v1ValidatingWebhookConfigurationListApiVersion, ..} ) <$> f v1ValidatingWebhookConfigurationListApiVersion
{-# INLINE v1ValidatingWebhookConfigurationListApiVersionL #-}

-- | 'v1ValidatingWebhookConfigurationListItems' Lens
v1ValidatingWebhookConfigurationListItemsL :: Lens_' V1ValidatingWebhookConfigurationList ([V1ValidatingWebhookConfiguration])
v1ValidatingWebhookConfigurationListItemsL f V1ValidatingWebhookConfigurationList{..} = (\v1ValidatingWebhookConfigurationListItems -> V1ValidatingWebhookConfigurationList { v1ValidatingWebhookConfigurationListItems, ..} ) <$> f v1ValidatingWebhookConfigurationListItems
{-# INLINE v1ValidatingWebhookConfigurationListItemsL #-}

-- | 'v1ValidatingWebhookConfigurationListKind' Lens
v1ValidatingWebhookConfigurationListKindL :: Lens_' V1ValidatingWebhookConfigurationList (Maybe Text)
v1ValidatingWebhookConfigurationListKindL f V1ValidatingWebhookConfigurationList{..} = (\v1ValidatingWebhookConfigurationListKind -> V1ValidatingWebhookConfigurationList { v1ValidatingWebhookConfigurationListKind, ..} ) <$> f v1ValidatingWebhookConfigurationListKind
{-# INLINE v1ValidatingWebhookConfigurationListKindL #-}

-- | 'v1ValidatingWebhookConfigurationListMetadata' Lens
v1ValidatingWebhookConfigurationListMetadataL :: Lens_' V1ValidatingWebhookConfigurationList (Maybe V1ListMeta)
v1ValidatingWebhookConfigurationListMetadataL f V1ValidatingWebhookConfigurationList{..} = (\v1ValidatingWebhookConfigurationListMetadata -> V1ValidatingWebhookConfigurationList { v1ValidatingWebhookConfigurationListMetadata, ..} ) <$> f v1ValidatingWebhookConfigurationListMetadata
{-# INLINE v1ValidatingWebhookConfigurationListMetadataL #-}



-- * V1ValidationRule

-- | 'v1ValidationRuleMessage' Lens
v1ValidationRuleMessageL :: Lens_' V1ValidationRule (Maybe Text)
v1ValidationRuleMessageL f V1ValidationRule{..} = (\v1ValidationRuleMessage -> V1ValidationRule { v1ValidationRuleMessage, ..} ) <$> f v1ValidationRuleMessage
{-# INLINE v1ValidationRuleMessageL #-}

-- | 'v1ValidationRuleRule' Lens
v1ValidationRuleRuleL :: Lens_' V1ValidationRule (Text)
v1ValidationRuleRuleL f V1ValidationRule{..} = (\v1ValidationRuleRule -> V1ValidationRule { v1ValidationRuleRule, ..} ) <$> f v1ValidationRuleRule
{-# INLINE v1ValidationRuleRuleL #-}



-- * V1Volume

-- | 'v1VolumeAwsElasticBlockStore' Lens
v1VolumeAwsElasticBlockStoreL :: Lens_' V1Volume (Maybe V1AWSElasticBlockStoreVolumeSource)
v1VolumeAwsElasticBlockStoreL f V1Volume{..} = (\v1VolumeAwsElasticBlockStore -> V1Volume { v1VolumeAwsElasticBlockStore, ..} ) <$> f v1VolumeAwsElasticBlockStore
{-# INLINE v1VolumeAwsElasticBlockStoreL #-}

-- | 'v1VolumeAzureDisk' Lens
v1VolumeAzureDiskL :: Lens_' V1Volume (Maybe V1AzureDiskVolumeSource)
v1VolumeAzureDiskL f V1Volume{..} = (\v1VolumeAzureDisk -> V1Volume { v1VolumeAzureDisk, ..} ) <$> f v1VolumeAzureDisk
{-# INLINE v1VolumeAzureDiskL #-}

-- | 'v1VolumeAzureFile' Lens
v1VolumeAzureFileL :: Lens_' V1Volume (Maybe V1AzureFileVolumeSource)
v1VolumeAzureFileL f V1Volume{..} = (\v1VolumeAzureFile -> V1Volume { v1VolumeAzureFile, ..} ) <$> f v1VolumeAzureFile
{-# INLINE v1VolumeAzureFileL #-}

-- | 'v1VolumeCephfs' Lens
v1VolumeCephfsL :: Lens_' V1Volume (Maybe V1CephFSVolumeSource)
v1VolumeCephfsL f V1Volume{..} = (\v1VolumeCephfs -> V1Volume { v1VolumeCephfs, ..} ) <$> f v1VolumeCephfs
{-# INLINE v1VolumeCephfsL #-}

-- | 'v1VolumeCinder' Lens
v1VolumeCinderL :: Lens_' V1Volume (Maybe V1CinderVolumeSource)
v1VolumeCinderL f V1Volume{..} = (\v1VolumeCinder -> V1Volume { v1VolumeCinder, ..} ) <$> f v1VolumeCinder
{-# INLINE v1VolumeCinderL #-}

-- | 'v1VolumeConfigMap' Lens
v1VolumeConfigMapL :: Lens_' V1Volume (Maybe V1ConfigMapVolumeSource)
v1VolumeConfigMapL f V1Volume{..} = (\v1VolumeConfigMap -> V1Volume { v1VolumeConfigMap, ..} ) <$> f v1VolumeConfigMap
{-# INLINE v1VolumeConfigMapL #-}

-- | 'v1VolumeCsi' Lens
v1VolumeCsiL :: Lens_' V1Volume (Maybe V1CSIVolumeSource)
v1VolumeCsiL f V1Volume{..} = (\v1VolumeCsi -> V1Volume { v1VolumeCsi, ..} ) <$> f v1VolumeCsi
{-# INLINE v1VolumeCsiL #-}

-- | 'v1VolumeDownwardApi' Lens
v1VolumeDownwardApiL :: Lens_' V1Volume (Maybe V1DownwardAPIVolumeSource)
v1VolumeDownwardApiL f V1Volume{..} = (\v1VolumeDownwardApi -> V1Volume { v1VolumeDownwardApi, ..} ) <$> f v1VolumeDownwardApi
{-# INLINE v1VolumeDownwardApiL #-}

-- | 'v1VolumeEmptyDir' Lens
v1VolumeEmptyDirL :: Lens_' V1Volume (Maybe V1EmptyDirVolumeSource)
v1VolumeEmptyDirL f V1Volume{..} = (\v1VolumeEmptyDir -> V1Volume { v1VolumeEmptyDir, ..} ) <$> f v1VolumeEmptyDir
{-# INLINE v1VolumeEmptyDirL #-}

-- | 'v1VolumeEphemeral' Lens
v1VolumeEphemeralL :: Lens_' V1Volume (Maybe V1EphemeralVolumeSource)
v1VolumeEphemeralL f V1Volume{..} = (\v1VolumeEphemeral -> V1Volume { v1VolumeEphemeral, ..} ) <$> f v1VolumeEphemeral
{-# INLINE v1VolumeEphemeralL #-}

-- | 'v1VolumeFc' Lens
v1VolumeFcL :: Lens_' V1Volume (Maybe V1FCVolumeSource)
v1VolumeFcL f V1Volume{..} = (\v1VolumeFc -> V1Volume { v1VolumeFc, ..} ) <$> f v1VolumeFc
{-# INLINE v1VolumeFcL #-}

-- | 'v1VolumeFlexVolume' Lens
v1VolumeFlexVolumeL :: Lens_' V1Volume (Maybe V1FlexVolumeSource)
v1VolumeFlexVolumeL f V1Volume{..} = (\v1VolumeFlexVolume -> V1Volume { v1VolumeFlexVolume, ..} ) <$> f v1VolumeFlexVolume
{-# INLINE v1VolumeFlexVolumeL #-}

-- | 'v1VolumeFlocker' Lens
v1VolumeFlockerL :: Lens_' V1Volume (Maybe V1FlockerVolumeSource)
v1VolumeFlockerL f V1Volume{..} = (\v1VolumeFlocker -> V1Volume { v1VolumeFlocker, ..} ) <$> f v1VolumeFlocker
{-# INLINE v1VolumeFlockerL #-}

-- | 'v1VolumeGcePersistentDisk' Lens
v1VolumeGcePersistentDiskL :: Lens_' V1Volume (Maybe V1GCEPersistentDiskVolumeSource)
v1VolumeGcePersistentDiskL f V1Volume{..} = (\v1VolumeGcePersistentDisk -> V1Volume { v1VolumeGcePersistentDisk, ..} ) <$> f v1VolumeGcePersistentDisk
{-# INLINE v1VolumeGcePersistentDiskL #-}

-- | 'v1VolumeGitRepo' Lens
v1VolumeGitRepoL :: Lens_' V1Volume (Maybe V1GitRepoVolumeSource)
v1VolumeGitRepoL f V1Volume{..} = (\v1VolumeGitRepo -> V1Volume { v1VolumeGitRepo, ..} ) <$> f v1VolumeGitRepo
{-# INLINE v1VolumeGitRepoL #-}

-- | 'v1VolumeGlusterfs' Lens
v1VolumeGlusterfsL :: Lens_' V1Volume (Maybe V1GlusterfsVolumeSource)
v1VolumeGlusterfsL f V1Volume{..} = (\v1VolumeGlusterfs -> V1Volume { v1VolumeGlusterfs, ..} ) <$> f v1VolumeGlusterfs
{-# INLINE v1VolumeGlusterfsL #-}

-- | 'v1VolumeHostPath' Lens
v1VolumeHostPathL :: Lens_' V1Volume (Maybe V1HostPathVolumeSource)
v1VolumeHostPathL f V1Volume{..} = (\v1VolumeHostPath -> V1Volume { v1VolumeHostPath, ..} ) <$> f v1VolumeHostPath
{-# INLINE v1VolumeHostPathL #-}

-- | 'v1VolumeIscsi' Lens
v1VolumeIscsiL :: Lens_' V1Volume (Maybe V1ISCSIVolumeSource)
v1VolumeIscsiL f V1Volume{..} = (\v1VolumeIscsi -> V1Volume { v1VolumeIscsi, ..} ) <$> f v1VolumeIscsi
{-# INLINE v1VolumeIscsiL #-}

-- | 'v1VolumeName' Lens
v1VolumeNameL :: Lens_' V1Volume (Text)
v1VolumeNameL f V1Volume{..} = (\v1VolumeName -> V1Volume { v1VolumeName, ..} ) <$> f v1VolumeName
{-# INLINE v1VolumeNameL #-}

-- | 'v1VolumeNfs' Lens
v1VolumeNfsL :: Lens_' V1Volume (Maybe V1NFSVolumeSource)
v1VolumeNfsL f V1Volume{..} = (\v1VolumeNfs -> V1Volume { v1VolumeNfs, ..} ) <$> f v1VolumeNfs
{-# INLINE v1VolumeNfsL #-}

-- | 'v1VolumePersistentVolumeClaim' Lens
v1VolumePersistentVolumeClaimL :: Lens_' V1Volume (Maybe V1PersistentVolumeClaimVolumeSource)
v1VolumePersistentVolumeClaimL f V1Volume{..} = (\v1VolumePersistentVolumeClaim -> V1Volume { v1VolumePersistentVolumeClaim, ..} ) <$> f v1VolumePersistentVolumeClaim
{-# INLINE v1VolumePersistentVolumeClaimL #-}

-- | 'v1VolumePhotonPersistentDisk' Lens
v1VolumePhotonPersistentDiskL :: Lens_' V1Volume (Maybe V1PhotonPersistentDiskVolumeSource)
v1VolumePhotonPersistentDiskL f V1Volume{..} = (\v1VolumePhotonPersistentDisk -> V1Volume { v1VolumePhotonPersistentDisk, ..} ) <$> f v1VolumePhotonPersistentDisk
{-# INLINE v1VolumePhotonPersistentDiskL #-}

-- | 'v1VolumePortworxVolume' Lens
v1VolumePortworxVolumeL :: Lens_' V1Volume (Maybe V1PortworxVolumeSource)
v1VolumePortworxVolumeL f V1Volume{..} = (\v1VolumePortworxVolume -> V1Volume { v1VolumePortworxVolume, ..} ) <$> f v1VolumePortworxVolume
{-# INLINE v1VolumePortworxVolumeL #-}

-- | 'v1VolumeProjected' Lens
v1VolumeProjectedL :: Lens_' V1Volume (Maybe V1ProjectedVolumeSource)
v1VolumeProjectedL f V1Volume{..} = (\v1VolumeProjected -> V1Volume { v1VolumeProjected, ..} ) <$> f v1VolumeProjected
{-# INLINE v1VolumeProjectedL #-}

-- | 'v1VolumeQuobyte' Lens
v1VolumeQuobyteL :: Lens_' V1Volume (Maybe V1QuobyteVolumeSource)
v1VolumeQuobyteL f V1Volume{..} = (\v1VolumeQuobyte -> V1Volume { v1VolumeQuobyte, ..} ) <$> f v1VolumeQuobyte
{-# INLINE v1VolumeQuobyteL #-}

-- | 'v1VolumeRbd' Lens
v1VolumeRbdL :: Lens_' V1Volume (Maybe V1RBDVolumeSource)
v1VolumeRbdL f V1Volume{..} = (\v1VolumeRbd -> V1Volume { v1VolumeRbd, ..} ) <$> f v1VolumeRbd
{-# INLINE v1VolumeRbdL #-}

-- | 'v1VolumeScaleIo' Lens
v1VolumeScaleIoL :: Lens_' V1Volume (Maybe V1ScaleIOVolumeSource)
v1VolumeScaleIoL f V1Volume{..} = (\v1VolumeScaleIo -> V1Volume { v1VolumeScaleIo, ..} ) <$> f v1VolumeScaleIo
{-# INLINE v1VolumeScaleIoL #-}

-- | 'v1VolumeSecret' Lens
v1VolumeSecretL :: Lens_' V1Volume (Maybe V1SecretVolumeSource)
v1VolumeSecretL f V1Volume{..} = (\v1VolumeSecret -> V1Volume { v1VolumeSecret, ..} ) <$> f v1VolumeSecret
{-# INLINE v1VolumeSecretL #-}

-- | 'v1VolumeStorageos' Lens
v1VolumeStorageosL :: Lens_' V1Volume (Maybe V1StorageOSVolumeSource)
v1VolumeStorageosL f V1Volume{..} = (\v1VolumeStorageos -> V1Volume { v1VolumeStorageos, ..} ) <$> f v1VolumeStorageos
{-# INLINE v1VolumeStorageosL #-}

-- | 'v1VolumeVsphereVolume' Lens
v1VolumeVsphereVolumeL :: Lens_' V1Volume (Maybe V1VsphereVirtualDiskVolumeSource)
v1VolumeVsphereVolumeL f V1Volume{..} = (\v1VolumeVsphereVolume -> V1Volume { v1VolumeVsphereVolume, ..} ) <$> f v1VolumeVsphereVolume
{-# INLINE v1VolumeVsphereVolumeL #-}



-- * V1VolumeAttachment

-- | 'v1VolumeAttachmentApiVersion' Lens
v1VolumeAttachmentApiVersionL :: Lens_' V1VolumeAttachment (Maybe Text)
v1VolumeAttachmentApiVersionL f V1VolumeAttachment{..} = (\v1VolumeAttachmentApiVersion -> V1VolumeAttachment { v1VolumeAttachmentApiVersion, ..} ) <$> f v1VolumeAttachmentApiVersion
{-# INLINE v1VolumeAttachmentApiVersionL #-}

-- | 'v1VolumeAttachmentKind' Lens
v1VolumeAttachmentKindL :: Lens_' V1VolumeAttachment (Maybe Text)
v1VolumeAttachmentKindL f V1VolumeAttachment{..} = (\v1VolumeAttachmentKind -> V1VolumeAttachment { v1VolumeAttachmentKind, ..} ) <$> f v1VolumeAttachmentKind
{-# INLINE v1VolumeAttachmentKindL #-}

-- | 'v1VolumeAttachmentMetadata' Lens
v1VolumeAttachmentMetadataL :: Lens_' V1VolumeAttachment (Maybe V1ObjectMeta)
v1VolumeAttachmentMetadataL f V1VolumeAttachment{..} = (\v1VolumeAttachmentMetadata -> V1VolumeAttachment { v1VolumeAttachmentMetadata, ..} ) <$> f v1VolumeAttachmentMetadata
{-# INLINE v1VolumeAttachmentMetadataL #-}

-- | 'v1VolumeAttachmentSpec' Lens
v1VolumeAttachmentSpecL :: Lens_' V1VolumeAttachment (V1VolumeAttachmentSpec)
v1VolumeAttachmentSpecL f V1VolumeAttachment{..} = (\v1VolumeAttachmentSpec -> V1VolumeAttachment { v1VolumeAttachmentSpec, ..} ) <$> f v1VolumeAttachmentSpec
{-# INLINE v1VolumeAttachmentSpecL #-}

-- | 'v1VolumeAttachmentStatus' Lens
v1VolumeAttachmentStatusL :: Lens_' V1VolumeAttachment (Maybe V1VolumeAttachmentStatus)
v1VolumeAttachmentStatusL f V1VolumeAttachment{..} = (\v1VolumeAttachmentStatus -> V1VolumeAttachment { v1VolumeAttachmentStatus, ..} ) <$> f v1VolumeAttachmentStatus
{-# INLINE v1VolumeAttachmentStatusL #-}



-- * V1VolumeAttachmentList

-- | 'v1VolumeAttachmentListApiVersion' Lens
v1VolumeAttachmentListApiVersionL :: Lens_' V1VolumeAttachmentList (Maybe Text)
v1VolumeAttachmentListApiVersionL f V1VolumeAttachmentList{..} = (\v1VolumeAttachmentListApiVersion -> V1VolumeAttachmentList { v1VolumeAttachmentListApiVersion, ..} ) <$> f v1VolumeAttachmentListApiVersion
{-# INLINE v1VolumeAttachmentListApiVersionL #-}

-- | 'v1VolumeAttachmentListItems' Lens
v1VolumeAttachmentListItemsL :: Lens_' V1VolumeAttachmentList ([V1VolumeAttachment])
v1VolumeAttachmentListItemsL f V1VolumeAttachmentList{..} = (\v1VolumeAttachmentListItems -> V1VolumeAttachmentList { v1VolumeAttachmentListItems, ..} ) <$> f v1VolumeAttachmentListItems
{-# INLINE v1VolumeAttachmentListItemsL #-}

-- | 'v1VolumeAttachmentListKind' Lens
v1VolumeAttachmentListKindL :: Lens_' V1VolumeAttachmentList (Maybe Text)
v1VolumeAttachmentListKindL f V1VolumeAttachmentList{..} = (\v1VolumeAttachmentListKind -> V1VolumeAttachmentList { v1VolumeAttachmentListKind, ..} ) <$> f v1VolumeAttachmentListKind
{-# INLINE v1VolumeAttachmentListKindL #-}

-- | 'v1VolumeAttachmentListMetadata' Lens
v1VolumeAttachmentListMetadataL :: Lens_' V1VolumeAttachmentList (Maybe V1ListMeta)
v1VolumeAttachmentListMetadataL f V1VolumeAttachmentList{..} = (\v1VolumeAttachmentListMetadata -> V1VolumeAttachmentList { v1VolumeAttachmentListMetadata, ..} ) <$> f v1VolumeAttachmentListMetadata
{-# INLINE v1VolumeAttachmentListMetadataL #-}



-- * V1VolumeAttachmentSource

-- | 'v1VolumeAttachmentSourceInlineVolumeSpec' Lens
v1VolumeAttachmentSourceInlineVolumeSpecL :: Lens_' V1VolumeAttachmentSource (Maybe V1PersistentVolumeSpec)
v1VolumeAttachmentSourceInlineVolumeSpecL f V1VolumeAttachmentSource{..} = (\v1VolumeAttachmentSourceInlineVolumeSpec -> V1VolumeAttachmentSource { v1VolumeAttachmentSourceInlineVolumeSpec, ..} ) <$> f v1VolumeAttachmentSourceInlineVolumeSpec
{-# INLINE v1VolumeAttachmentSourceInlineVolumeSpecL #-}

-- | 'v1VolumeAttachmentSourcePersistentVolumeName' Lens
v1VolumeAttachmentSourcePersistentVolumeNameL :: Lens_' V1VolumeAttachmentSource (Maybe Text)
v1VolumeAttachmentSourcePersistentVolumeNameL f V1VolumeAttachmentSource{..} = (\v1VolumeAttachmentSourcePersistentVolumeName -> V1VolumeAttachmentSource { v1VolumeAttachmentSourcePersistentVolumeName, ..} ) <$> f v1VolumeAttachmentSourcePersistentVolumeName
{-# INLINE v1VolumeAttachmentSourcePersistentVolumeNameL #-}



-- * V1VolumeAttachmentSpec

-- | 'v1VolumeAttachmentSpecAttacher' Lens
v1VolumeAttachmentSpecAttacherL :: Lens_' V1VolumeAttachmentSpec (Text)
v1VolumeAttachmentSpecAttacherL f V1VolumeAttachmentSpec{..} = (\v1VolumeAttachmentSpecAttacher -> V1VolumeAttachmentSpec { v1VolumeAttachmentSpecAttacher, ..} ) <$> f v1VolumeAttachmentSpecAttacher
{-# INLINE v1VolumeAttachmentSpecAttacherL #-}

-- | 'v1VolumeAttachmentSpecNodeName' Lens
v1VolumeAttachmentSpecNodeNameL :: Lens_' V1VolumeAttachmentSpec (Text)
v1VolumeAttachmentSpecNodeNameL f V1VolumeAttachmentSpec{..} = (\v1VolumeAttachmentSpecNodeName -> V1VolumeAttachmentSpec { v1VolumeAttachmentSpecNodeName, ..} ) <$> f v1VolumeAttachmentSpecNodeName
{-# INLINE v1VolumeAttachmentSpecNodeNameL #-}

-- | 'v1VolumeAttachmentSpecSource' Lens
v1VolumeAttachmentSpecSourceL :: Lens_' V1VolumeAttachmentSpec (V1VolumeAttachmentSource)
v1VolumeAttachmentSpecSourceL f V1VolumeAttachmentSpec{..} = (\v1VolumeAttachmentSpecSource -> V1VolumeAttachmentSpec { v1VolumeAttachmentSpecSource, ..} ) <$> f v1VolumeAttachmentSpecSource
{-# INLINE v1VolumeAttachmentSpecSourceL #-}



-- * V1VolumeAttachmentStatus

-- | 'v1VolumeAttachmentStatusAttachError' Lens
v1VolumeAttachmentStatusAttachErrorL :: Lens_' V1VolumeAttachmentStatus (Maybe V1VolumeError)
v1VolumeAttachmentStatusAttachErrorL f V1VolumeAttachmentStatus{..} = (\v1VolumeAttachmentStatusAttachError -> V1VolumeAttachmentStatus { v1VolumeAttachmentStatusAttachError, ..} ) <$> f v1VolumeAttachmentStatusAttachError
{-# INLINE v1VolumeAttachmentStatusAttachErrorL #-}

-- | 'v1VolumeAttachmentStatusAttached' Lens
v1VolumeAttachmentStatusAttachedL :: Lens_' V1VolumeAttachmentStatus (Bool)
v1VolumeAttachmentStatusAttachedL f V1VolumeAttachmentStatus{..} = (\v1VolumeAttachmentStatusAttached -> V1VolumeAttachmentStatus { v1VolumeAttachmentStatusAttached, ..} ) <$> f v1VolumeAttachmentStatusAttached
{-# INLINE v1VolumeAttachmentStatusAttachedL #-}

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

-- | 'v1VolumeAttachmentStatusDetachError' Lens
v1VolumeAttachmentStatusDetachErrorL :: Lens_' V1VolumeAttachmentStatus (Maybe V1VolumeError)
v1VolumeAttachmentStatusDetachErrorL f V1VolumeAttachmentStatus{..} = (\v1VolumeAttachmentStatusDetachError -> V1VolumeAttachmentStatus { v1VolumeAttachmentStatusDetachError, ..} ) <$> f v1VolumeAttachmentStatusDetachError
{-# INLINE v1VolumeAttachmentStatusDetachErrorL #-}



-- * V1VolumeDevice

-- | 'v1VolumeDeviceDevicePath' Lens
v1VolumeDeviceDevicePathL :: Lens_' V1VolumeDevice (Text)
v1VolumeDeviceDevicePathL f V1VolumeDevice{..} = (\v1VolumeDeviceDevicePath -> V1VolumeDevice { v1VolumeDeviceDevicePath, ..} ) <$> f v1VolumeDeviceDevicePath
{-# INLINE v1VolumeDeviceDevicePathL #-}

-- | 'v1VolumeDeviceName' Lens
v1VolumeDeviceNameL :: Lens_' V1VolumeDevice (Text)
v1VolumeDeviceNameL f V1VolumeDevice{..} = (\v1VolumeDeviceName -> V1VolumeDevice { v1VolumeDeviceName, ..} ) <$> f v1VolumeDeviceName
{-# INLINE v1VolumeDeviceNameL #-}



-- * V1VolumeError

-- | 'v1VolumeErrorMessage' Lens
v1VolumeErrorMessageL :: Lens_' V1VolumeError (Maybe Text)
v1VolumeErrorMessageL f V1VolumeError{..} = (\v1VolumeErrorMessage -> V1VolumeError { v1VolumeErrorMessage, ..} ) <$> f v1VolumeErrorMessage
{-# INLINE v1VolumeErrorMessageL #-}

-- | 'v1VolumeErrorTime' Lens
v1VolumeErrorTimeL :: Lens_' V1VolumeError (Maybe DateTime)
v1VolumeErrorTimeL f V1VolumeError{..} = (\v1VolumeErrorTime -> V1VolumeError { v1VolumeErrorTime, ..} ) <$> f v1VolumeErrorTime
{-# INLINE v1VolumeErrorTimeL #-}



-- * V1VolumeMount

-- | 'v1VolumeMountMountPath' Lens
v1VolumeMountMountPathL :: Lens_' V1VolumeMount (Text)
v1VolumeMountMountPathL f V1VolumeMount{..} = (\v1VolumeMountMountPath -> V1VolumeMount { v1VolumeMountMountPath, ..} ) <$> f v1VolumeMountMountPath
{-# INLINE v1VolumeMountMountPathL #-}

-- | 'v1VolumeMountMountPropagation' Lens
v1VolumeMountMountPropagationL :: Lens_' V1VolumeMount (Maybe Text)
v1VolumeMountMountPropagationL f V1VolumeMount{..} = (\v1VolumeMountMountPropagation -> V1VolumeMount { v1VolumeMountMountPropagation, ..} ) <$> f v1VolumeMountMountPropagation
{-# INLINE v1VolumeMountMountPropagationL #-}

-- | 'v1VolumeMountName' Lens
v1VolumeMountNameL :: Lens_' V1VolumeMount (Text)
v1VolumeMountNameL f V1VolumeMount{..} = (\v1VolumeMountName -> V1VolumeMount { v1VolumeMountName, ..} ) <$> f v1VolumeMountName
{-# INLINE v1VolumeMountNameL #-}

-- | 'v1VolumeMountReadOnly' Lens
v1VolumeMountReadOnlyL :: Lens_' V1VolumeMount (Maybe Bool)
v1VolumeMountReadOnlyL f V1VolumeMount{..} = (\v1VolumeMountReadOnly -> V1VolumeMount { v1VolumeMountReadOnly, ..} ) <$> f v1VolumeMountReadOnly
{-# INLINE v1VolumeMountReadOnlyL #-}

-- | 'v1VolumeMountSubPath' Lens
v1VolumeMountSubPathL :: Lens_' V1VolumeMount (Maybe Text)
v1VolumeMountSubPathL f V1VolumeMount{..} = (\v1VolumeMountSubPath -> V1VolumeMount { v1VolumeMountSubPath, ..} ) <$> f v1VolumeMountSubPath
{-# INLINE v1VolumeMountSubPathL #-}

-- | 'v1VolumeMountSubPathExpr' Lens
v1VolumeMountSubPathExprL :: Lens_' V1VolumeMount (Maybe Text)
v1VolumeMountSubPathExprL f V1VolumeMount{..} = (\v1VolumeMountSubPathExpr -> V1VolumeMount { v1VolumeMountSubPathExpr, ..} ) <$> f v1VolumeMountSubPathExpr
{-# INLINE v1VolumeMountSubPathExprL #-}



-- * V1VolumeNodeAffinity

-- | 'v1VolumeNodeAffinityRequired' Lens
v1VolumeNodeAffinityRequiredL :: Lens_' V1VolumeNodeAffinity (Maybe V1NodeSelector)
v1VolumeNodeAffinityRequiredL f V1VolumeNodeAffinity{..} = (\v1VolumeNodeAffinityRequired -> V1VolumeNodeAffinity { v1VolumeNodeAffinityRequired, ..} ) <$> f v1VolumeNodeAffinityRequired
{-# INLINE v1VolumeNodeAffinityRequiredL #-}



-- * V1VolumeNodeResources

-- | 'v1VolumeNodeResourcesCount' Lens
v1VolumeNodeResourcesCountL :: Lens_' V1VolumeNodeResources (Maybe Int)
v1VolumeNodeResourcesCountL f V1VolumeNodeResources{..} = (\v1VolumeNodeResourcesCount -> V1VolumeNodeResources { v1VolumeNodeResourcesCount, ..} ) <$> f v1VolumeNodeResourcesCount
{-# INLINE v1VolumeNodeResourcesCountL #-}



-- * V1VolumeProjection

-- | 'v1VolumeProjectionConfigMap' Lens
v1VolumeProjectionConfigMapL :: Lens_' V1VolumeProjection (Maybe V1ConfigMapProjection)
v1VolumeProjectionConfigMapL f V1VolumeProjection{..} = (\v1VolumeProjectionConfigMap -> V1VolumeProjection { v1VolumeProjectionConfigMap, ..} ) <$> f v1VolumeProjectionConfigMap
{-# INLINE v1VolumeProjectionConfigMapL #-}

-- | 'v1VolumeProjectionDownwardApi' Lens
v1VolumeProjectionDownwardApiL :: Lens_' V1VolumeProjection (Maybe V1DownwardAPIProjection)
v1VolumeProjectionDownwardApiL f V1VolumeProjection{..} = (\v1VolumeProjectionDownwardApi -> V1VolumeProjection { v1VolumeProjectionDownwardApi, ..} ) <$> f v1VolumeProjectionDownwardApi
{-# INLINE v1VolumeProjectionDownwardApiL #-}

-- | 'v1VolumeProjectionSecret' Lens
v1VolumeProjectionSecretL :: Lens_' V1VolumeProjection (Maybe V1SecretProjection)
v1VolumeProjectionSecretL f V1VolumeProjection{..} = (\v1VolumeProjectionSecret -> V1VolumeProjection { v1VolumeProjectionSecret, ..} ) <$> f v1VolumeProjectionSecret
{-# INLINE v1VolumeProjectionSecretL #-}

-- | 'v1VolumeProjectionServiceAccountToken' Lens
v1VolumeProjectionServiceAccountTokenL :: Lens_' V1VolumeProjection (Maybe V1ServiceAccountTokenProjection)
v1VolumeProjectionServiceAccountTokenL f V1VolumeProjection{..} = (\v1VolumeProjectionServiceAccountToken -> V1VolumeProjection { v1VolumeProjectionServiceAccountToken, ..} ) <$> f v1VolumeProjectionServiceAccountToken
{-# INLINE v1VolumeProjectionServiceAccountTokenL #-}



-- * V1VsphereVirtualDiskVolumeSource

-- | 'v1VsphereVirtualDiskVolumeSourceFsType' Lens
v1VsphereVirtualDiskVolumeSourceFsTypeL :: Lens_' V1VsphereVirtualDiskVolumeSource (Maybe Text)
v1VsphereVirtualDiskVolumeSourceFsTypeL f V1VsphereVirtualDiskVolumeSource{..} = (\v1VsphereVirtualDiskVolumeSourceFsType -> V1VsphereVirtualDiskVolumeSource { v1VsphereVirtualDiskVolumeSourceFsType, ..} ) <$> f v1VsphereVirtualDiskVolumeSourceFsType
{-# INLINE v1VsphereVirtualDiskVolumeSourceFsTypeL #-}

-- | 'v1VsphereVirtualDiskVolumeSourceStoragePolicyId' Lens
v1VsphereVirtualDiskVolumeSourceStoragePolicyIdL :: Lens_' V1VsphereVirtualDiskVolumeSource (Maybe Text)
v1VsphereVirtualDiskVolumeSourceStoragePolicyIdL f V1VsphereVirtualDiskVolumeSource{..} = (\v1VsphereVirtualDiskVolumeSourceStoragePolicyId -> V1VsphereVirtualDiskVolumeSource { v1VsphereVirtualDiskVolumeSourceStoragePolicyId, ..} ) <$> f v1VsphereVirtualDiskVolumeSourceStoragePolicyId
{-# INLINE v1VsphereVirtualDiskVolumeSourceStoragePolicyIdL #-}

-- | 'v1VsphereVirtualDiskVolumeSourceStoragePolicyName' Lens
v1VsphereVirtualDiskVolumeSourceStoragePolicyNameL :: Lens_' V1VsphereVirtualDiskVolumeSource (Maybe Text)
v1VsphereVirtualDiskVolumeSourceStoragePolicyNameL f V1VsphereVirtualDiskVolumeSource{..} = (\v1VsphereVirtualDiskVolumeSourceStoragePolicyName -> V1VsphereVirtualDiskVolumeSource { v1VsphereVirtualDiskVolumeSourceStoragePolicyName, ..} ) <$> f v1VsphereVirtualDiskVolumeSourceStoragePolicyName
{-# INLINE v1VsphereVirtualDiskVolumeSourceStoragePolicyNameL #-}

-- | 'v1VsphereVirtualDiskVolumeSourceVolumePath' Lens
v1VsphereVirtualDiskVolumeSourceVolumePathL :: Lens_' V1VsphereVirtualDiskVolumeSource (Text)
v1VsphereVirtualDiskVolumeSourceVolumePathL f V1VsphereVirtualDiskVolumeSource{..} = (\v1VsphereVirtualDiskVolumeSourceVolumePath -> V1VsphereVirtualDiskVolumeSource { v1VsphereVirtualDiskVolumeSourceVolumePath, ..} ) <$> f v1VsphereVirtualDiskVolumeSourceVolumePath
{-# INLINE v1VsphereVirtualDiskVolumeSourceVolumePathL #-}



-- * V1WatchEvent

-- | 'v1WatchEventObject' Lens
v1WatchEventObjectL :: Lens_' V1WatchEvent (A.Value)
v1WatchEventObjectL f V1WatchEvent{..} = (\v1WatchEventObject -> V1WatchEvent { v1WatchEventObject, ..} ) <$> f v1WatchEventObject
{-# INLINE v1WatchEventObjectL #-}

-- | 'v1WatchEventType' Lens
v1WatchEventTypeL :: Lens_' V1WatchEvent (Text)
v1WatchEventTypeL f V1WatchEvent{..} = (\v1WatchEventType -> V1WatchEvent { v1WatchEventType, ..} ) <$> f v1WatchEventType
{-# INLINE v1WatchEventTypeL #-}



-- * V1WebhookConversion

-- | 'v1WebhookConversionClientConfig' Lens
v1WebhookConversionClientConfigL :: Lens_' V1WebhookConversion (Maybe ApiextensionsV1WebhookClientConfig)
v1WebhookConversionClientConfigL f V1WebhookConversion{..} = (\v1WebhookConversionClientConfig -> V1WebhookConversion { v1WebhookConversionClientConfig, ..} ) <$> f v1WebhookConversionClientConfig
{-# INLINE v1WebhookConversionClientConfigL #-}

-- | 'v1WebhookConversionConversionReviewVersions' Lens
v1WebhookConversionConversionReviewVersionsL :: Lens_' V1WebhookConversion ([Text])
v1WebhookConversionConversionReviewVersionsL f V1WebhookConversion{..} = (\v1WebhookConversionConversionReviewVersions -> V1WebhookConversion { v1WebhookConversionConversionReviewVersions, ..} ) <$> f v1WebhookConversionConversionReviewVersions
{-# INLINE v1WebhookConversionConversionReviewVersionsL #-}



-- * V1WeightedPodAffinityTerm

-- | 'v1WeightedPodAffinityTermPodAffinityTerm' Lens
v1WeightedPodAffinityTermPodAffinityTermL :: Lens_' V1WeightedPodAffinityTerm (V1PodAffinityTerm)
v1WeightedPodAffinityTermPodAffinityTermL f V1WeightedPodAffinityTerm{..} = (\v1WeightedPodAffinityTermPodAffinityTerm -> V1WeightedPodAffinityTerm { v1WeightedPodAffinityTermPodAffinityTerm, ..} ) <$> f v1WeightedPodAffinityTermPodAffinityTerm
{-# INLINE v1WeightedPodAffinityTermPodAffinityTermL #-}

-- | 'v1WeightedPodAffinityTermWeight' Lens
v1WeightedPodAffinityTermWeightL :: Lens_' V1WeightedPodAffinityTerm (Int)
v1WeightedPodAffinityTermWeightL f V1WeightedPodAffinityTerm{..} = (\v1WeightedPodAffinityTermWeight -> V1WeightedPodAffinityTerm { v1WeightedPodAffinityTermWeight, ..} ) <$> f v1WeightedPodAffinityTermWeight
{-# INLINE v1WeightedPodAffinityTermWeightL #-}



-- * V1WindowsSecurityContextOptions

-- | 'v1WindowsSecurityContextOptionsGmsaCredentialSpec' Lens
v1WindowsSecurityContextOptionsGmsaCredentialSpecL :: Lens_' V1WindowsSecurityContextOptions (Maybe Text)
v1WindowsSecurityContextOptionsGmsaCredentialSpecL f V1WindowsSecurityContextOptions{..} = (\v1WindowsSecurityContextOptionsGmsaCredentialSpec -> V1WindowsSecurityContextOptions { v1WindowsSecurityContextOptionsGmsaCredentialSpec, ..} ) <$> f v1WindowsSecurityContextOptionsGmsaCredentialSpec
{-# INLINE v1WindowsSecurityContextOptionsGmsaCredentialSpecL #-}

-- | 'v1WindowsSecurityContextOptionsGmsaCredentialSpecName' Lens
v1WindowsSecurityContextOptionsGmsaCredentialSpecNameL :: Lens_' V1WindowsSecurityContextOptions (Maybe Text)
v1WindowsSecurityContextOptionsGmsaCredentialSpecNameL f V1WindowsSecurityContextOptions{..} = (\v1WindowsSecurityContextOptionsGmsaCredentialSpecName -> V1WindowsSecurityContextOptions { v1WindowsSecurityContextOptionsGmsaCredentialSpecName, ..} ) <$> f v1WindowsSecurityContextOptionsGmsaCredentialSpecName
{-# INLINE v1WindowsSecurityContextOptionsGmsaCredentialSpecNameL #-}

-- | 'v1WindowsSecurityContextOptionsHostProcess' Lens
v1WindowsSecurityContextOptionsHostProcessL :: Lens_' V1WindowsSecurityContextOptions (Maybe Bool)
v1WindowsSecurityContextOptionsHostProcessL f V1WindowsSecurityContextOptions{..} = (\v1WindowsSecurityContextOptionsHostProcess -> V1WindowsSecurityContextOptions { v1WindowsSecurityContextOptionsHostProcess, ..} ) <$> f v1WindowsSecurityContextOptionsHostProcess
{-# INLINE v1WindowsSecurityContextOptionsHostProcessL #-}

-- | 'v1WindowsSecurityContextOptionsRunAsUserName' Lens
v1WindowsSecurityContextOptionsRunAsUserNameL :: Lens_' V1WindowsSecurityContextOptions (Maybe Text)
v1WindowsSecurityContextOptionsRunAsUserNameL f V1WindowsSecurityContextOptions{..} = (\v1WindowsSecurityContextOptionsRunAsUserName -> V1WindowsSecurityContextOptions { v1WindowsSecurityContextOptionsRunAsUserName, ..} ) <$> f v1WindowsSecurityContextOptionsRunAsUserName
{-# INLINE v1WindowsSecurityContextOptionsRunAsUserNameL #-}



-- * V1alpha1CSIStorageCapacity

-- | 'v1alpha1CSIStorageCapacityApiVersion' Lens
v1alpha1CSIStorageCapacityApiVersionL :: Lens_' V1alpha1CSIStorageCapacity (Maybe Text)
v1alpha1CSIStorageCapacityApiVersionL f V1alpha1CSIStorageCapacity{..} = (\v1alpha1CSIStorageCapacityApiVersion -> V1alpha1CSIStorageCapacity { v1alpha1CSIStorageCapacityApiVersion, ..} ) <$> f v1alpha1CSIStorageCapacityApiVersion
{-# INLINE v1alpha1CSIStorageCapacityApiVersionL #-}

-- | 'v1alpha1CSIStorageCapacityCapacity' Lens
v1alpha1CSIStorageCapacityCapacityL :: Lens_' V1alpha1CSIStorageCapacity (Maybe Quantity)
v1alpha1CSIStorageCapacityCapacityL f V1alpha1CSIStorageCapacity{..} = (\v1alpha1CSIStorageCapacityCapacity -> V1alpha1CSIStorageCapacity { v1alpha1CSIStorageCapacityCapacity, ..} ) <$> f v1alpha1CSIStorageCapacityCapacity
{-# INLINE v1alpha1CSIStorageCapacityCapacityL #-}

-- | 'v1alpha1CSIStorageCapacityKind' Lens
v1alpha1CSIStorageCapacityKindL :: Lens_' V1alpha1CSIStorageCapacity (Maybe Text)
v1alpha1CSIStorageCapacityKindL f V1alpha1CSIStorageCapacity{..} = (\v1alpha1CSIStorageCapacityKind -> V1alpha1CSIStorageCapacity { v1alpha1CSIStorageCapacityKind, ..} ) <$> f v1alpha1CSIStorageCapacityKind
{-# INLINE v1alpha1CSIStorageCapacityKindL #-}

-- | 'v1alpha1CSIStorageCapacityMaximumVolumeSize' Lens
v1alpha1CSIStorageCapacityMaximumVolumeSizeL :: Lens_' V1alpha1CSIStorageCapacity (Maybe Quantity)
v1alpha1CSIStorageCapacityMaximumVolumeSizeL f V1alpha1CSIStorageCapacity{..} = (\v1alpha1CSIStorageCapacityMaximumVolumeSize -> V1alpha1CSIStorageCapacity { v1alpha1CSIStorageCapacityMaximumVolumeSize, ..} ) <$> f v1alpha1CSIStorageCapacityMaximumVolumeSize
{-# INLINE v1alpha1CSIStorageCapacityMaximumVolumeSizeL #-}

-- | 'v1alpha1CSIStorageCapacityMetadata' Lens
v1alpha1CSIStorageCapacityMetadataL :: Lens_' V1alpha1CSIStorageCapacity (Maybe V1ObjectMeta)
v1alpha1CSIStorageCapacityMetadataL f V1alpha1CSIStorageCapacity{..} = (\v1alpha1CSIStorageCapacityMetadata -> V1alpha1CSIStorageCapacity { v1alpha1CSIStorageCapacityMetadata, ..} ) <$> f v1alpha1CSIStorageCapacityMetadata
{-# INLINE v1alpha1CSIStorageCapacityMetadataL #-}

-- | 'v1alpha1CSIStorageCapacityNodeTopology' Lens
v1alpha1CSIStorageCapacityNodeTopologyL :: Lens_' V1alpha1CSIStorageCapacity (Maybe V1LabelSelector)
v1alpha1CSIStorageCapacityNodeTopologyL f V1alpha1CSIStorageCapacity{..} = (\v1alpha1CSIStorageCapacityNodeTopology -> V1alpha1CSIStorageCapacity { v1alpha1CSIStorageCapacityNodeTopology, ..} ) <$> f v1alpha1CSIStorageCapacityNodeTopology
{-# INLINE v1alpha1CSIStorageCapacityNodeTopologyL #-}

-- | 'v1alpha1CSIStorageCapacityStorageClassName' Lens
v1alpha1CSIStorageCapacityStorageClassNameL :: Lens_' V1alpha1CSIStorageCapacity (Text)
v1alpha1CSIStorageCapacityStorageClassNameL f V1alpha1CSIStorageCapacity{..} = (\v1alpha1CSIStorageCapacityStorageClassName -> V1alpha1CSIStorageCapacity { v1alpha1CSIStorageCapacityStorageClassName, ..} ) <$> f v1alpha1CSIStorageCapacityStorageClassName
{-# INLINE v1alpha1CSIStorageCapacityStorageClassNameL #-}



-- * V1alpha1CSIStorageCapacityList

-- | 'v1alpha1CSIStorageCapacityListApiVersion' Lens
v1alpha1CSIStorageCapacityListApiVersionL :: Lens_' V1alpha1CSIStorageCapacityList (Maybe Text)
v1alpha1CSIStorageCapacityListApiVersionL f V1alpha1CSIStorageCapacityList{..} = (\v1alpha1CSIStorageCapacityListApiVersion -> V1alpha1CSIStorageCapacityList { v1alpha1CSIStorageCapacityListApiVersion, ..} ) <$> f v1alpha1CSIStorageCapacityListApiVersion
{-# INLINE v1alpha1CSIStorageCapacityListApiVersionL #-}

-- | 'v1alpha1CSIStorageCapacityListItems' Lens
v1alpha1CSIStorageCapacityListItemsL :: Lens_' V1alpha1CSIStorageCapacityList ([V1alpha1CSIStorageCapacity])
v1alpha1CSIStorageCapacityListItemsL f V1alpha1CSIStorageCapacityList{..} = (\v1alpha1CSIStorageCapacityListItems -> V1alpha1CSIStorageCapacityList { v1alpha1CSIStorageCapacityListItems, ..} ) <$> f v1alpha1CSIStorageCapacityListItems
{-# INLINE v1alpha1CSIStorageCapacityListItemsL #-}

-- | 'v1alpha1CSIStorageCapacityListKind' Lens
v1alpha1CSIStorageCapacityListKindL :: Lens_' V1alpha1CSIStorageCapacityList (Maybe Text)
v1alpha1CSIStorageCapacityListKindL f V1alpha1CSIStorageCapacityList{..} = (\v1alpha1CSIStorageCapacityListKind -> V1alpha1CSIStorageCapacityList { v1alpha1CSIStorageCapacityListKind, ..} ) <$> f v1alpha1CSIStorageCapacityListKind
{-# INLINE v1alpha1CSIStorageCapacityListKindL #-}

-- | 'v1alpha1CSIStorageCapacityListMetadata' Lens
v1alpha1CSIStorageCapacityListMetadataL :: Lens_' V1alpha1CSIStorageCapacityList (Maybe V1ListMeta)
v1alpha1CSIStorageCapacityListMetadataL f V1alpha1CSIStorageCapacityList{..} = (\v1alpha1CSIStorageCapacityListMetadata -> V1alpha1CSIStorageCapacityList { v1alpha1CSIStorageCapacityListMetadata, ..} ) <$> f v1alpha1CSIStorageCapacityListMetadata
{-# INLINE v1alpha1CSIStorageCapacityListMetadataL #-}



-- * V1alpha1Overhead

-- | 'v1alpha1OverheadPodFixed' Lens
v1alpha1OverheadPodFixedL :: Lens_' V1alpha1Overhead (Maybe (Map.Map String Quantity))
v1alpha1OverheadPodFixedL f V1alpha1Overhead{..} = (\v1alpha1OverheadPodFixed -> V1alpha1Overhead { v1alpha1OverheadPodFixed, ..} ) <$> f v1alpha1OverheadPodFixed
{-# INLINE v1alpha1OverheadPodFixedL #-}



-- * V1alpha1RuntimeClass

-- | 'v1alpha1RuntimeClassApiVersion' Lens
v1alpha1RuntimeClassApiVersionL :: Lens_' V1alpha1RuntimeClass (Maybe Text)
v1alpha1RuntimeClassApiVersionL f V1alpha1RuntimeClass{..} = (\v1alpha1RuntimeClassApiVersion -> V1alpha1RuntimeClass { v1alpha1RuntimeClassApiVersion, ..} ) <$> f v1alpha1RuntimeClassApiVersion
{-# INLINE v1alpha1RuntimeClassApiVersionL #-}

-- | 'v1alpha1RuntimeClassKind' Lens
v1alpha1RuntimeClassKindL :: Lens_' V1alpha1RuntimeClass (Maybe Text)
v1alpha1RuntimeClassKindL f V1alpha1RuntimeClass{..} = (\v1alpha1RuntimeClassKind -> V1alpha1RuntimeClass { v1alpha1RuntimeClassKind, ..} ) <$> f v1alpha1RuntimeClassKind
{-# INLINE v1alpha1RuntimeClassKindL #-}

-- | 'v1alpha1RuntimeClassMetadata' Lens
v1alpha1RuntimeClassMetadataL :: Lens_' V1alpha1RuntimeClass (Maybe V1ObjectMeta)
v1alpha1RuntimeClassMetadataL f V1alpha1RuntimeClass{..} = (\v1alpha1RuntimeClassMetadata -> V1alpha1RuntimeClass { v1alpha1RuntimeClassMetadata, ..} ) <$> f v1alpha1RuntimeClassMetadata
{-# INLINE v1alpha1RuntimeClassMetadataL #-}

-- | 'v1alpha1RuntimeClassSpec' Lens
v1alpha1RuntimeClassSpecL :: Lens_' V1alpha1RuntimeClass (V1alpha1RuntimeClassSpec)
v1alpha1RuntimeClassSpecL f V1alpha1RuntimeClass{..} = (\v1alpha1RuntimeClassSpec -> V1alpha1RuntimeClass { v1alpha1RuntimeClassSpec, ..} ) <$> f v1alpha1RuntimeClassSpec
{-# INLINE v1alpha1RuntimeClassSpecL #-}



-- * V1alpha1RuntimeClassList

-- | 'v1alpha1RuntimeClassListApiVersion' Lens
v1alpha1RuntimeClassListApiVersionL :: Lens_' V1alpha1RuntimeClassList (Maybe Text)
v1alpha1RuntimeClassListApiVersionL f V1alpha1RuntimeClassList{..} = (\v1alpha1RuntimeClassListApiVersion -> V1alpha1RuntimeClassList { v1alpha1RuntimeClassListApiVersion, ..} ) <$> f v1alpha1RuntimeClassListApiVersion
{-# INLINE v1alpha1RuntimeClassListApiVersionL #-}

-- | 'v1alpha1RuntimeClassListItems' Lens
v1alpha1RuntimeClassListItemsL :: Lens_' V1alpha1RuntimeClassList ([V1alpha1RuntimeClass])
v1alpha1RuntimeClassListItemsL f V1alpha1RuntimeClassList{..} = (\v1alpha1RuntimeClassListItems -> V1alpha1RuntimeClassList { v1alpha1RuntimeClassListItems, ..} ) <$> f v1alpha1RuntimeClassListItems
{-# INLINE v1alpha1RuntimeClassListItemsL #-}

-- | 'v1alpha1RuntimeClassListKind' Lens
v1alpha1RuntimeClassListKindL :: Lens_' V1alpha1RuntimeClassList (Maybe Text)
v1alpha1RuntimeClassListKindL f V1alpha1RuntimeClassList{..} = (\v1alpha1RuntimeClassListKind -> V1alpha1RuntimeClassList { v1alpha1RuntimeClassListKind, ..} ) <$> f v1alpha1RuntimeClassListKind
{-# INLINE v1alpha1RuntimeClassListKindL #-}

-- | 'v1alpha1RuntimeClassListMetadata' Lens
v1alpha1RuntimeClassListMetadataL :: Lens_' V1alpha1RuntimeClassList (Maybe V1ListMeta)
v1alpha1RuntimeClassListMetadataL f V1alpha1RuntimeClassList{..} = (\v1alpha1RuntimeClassListMetadata -> V1alpha1RuntimeClassList { v1alpha1RuntimeClassListMetadata, ..} ) <$> f v1alpha1RuntimeClassListMetadata
{-# INLINE v1alpha1RuntimeClassListMetadataL #-}



-- * V1alpha1RuntimeClassSpec

-- | 'v1alpha1RuntimeClassSpecOverhead' Lens
v1alpha1RuntimeClassSpecOverheadL :: Lens_' V1alpha1RuntimeClassSpec (Maybe V1alpha1Overhead)
v1alpha1RuntimeClassSpecOverheadL f V1alpha1RuntimeClassSpec{..} = (\v1alpha1RuntimeClassSpecOverhead -> V1alpha1RuntimeClassSpec { v1alpha1RuntimeClassSpecOverhead, ..} ) <$> f v1alpha1RuntimeClassSpecOverhead
{-# INLINE v1alpha1RuntimeClassSpecOverheadL #-}

-- | 'v1alpha1RuntimeClassSpecRuntimeHandler' Lens
v1alpha1RuntimeClassSpecRuntimeHandlerL :: Lens_' V1alpha1RuntimeClassSpec (Text)
v1alpha1RuntimeClassSpecRuntimeHandlerL f V1alpha1RuntimeClassSpec{..} = (\v1alpha1RuntimeClassSpecRuntimeHandler -> V1alpha1RuntimeClassSpec { v1alpha1RuntimeClassSpecRuntimeHandler, ..} ) <$> f v1alpha1RuntimeClassSpecRuntimeHandler
{-# INLINE v1alpha1RuntimeClassSpecRuntimeHandlerL #-}

-- | 'v1alpha1RuntimeClassSpecScheduling' Lens
v1alpha1RuntimeClassSpecSchedulingL :: Lens_' V1alpha1RuntimeClassSpec (Maybe V1alpha1Scheduling)
v1alpha1RuntimeClassSpecSchedulingL f V1alpha1RuntimeClassSpec{..} = (\v1alpha1RuntimeClassSpecScheduling -> V1alpha1RuntimeClassSpec { v1alpha1RuntimeClassSpecScheduling, ..} ) <$> f v1alpha1RuntimeClassSpecScheduling
{-# INLINE v1alpha1RuntimeClassSpecSchedulingL #-}



-- * V1alpha1Scheduling

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

-- | 'v1alpha1SchedulingTolerations' Lens
v1alpha1SchedulingTolerationsL :: Lens_' V1alpha1Scheduling (Maybe [V1Toleration])
v1alpha1SchedulingTolerationsL f V1alpha1Scheduling{..} = (\v1alpha1SchedulingTolerations -> V1alpha1Scheduling { v1alpha1SchedulingTolerations, ..} ) <$> f v1alpha1SchedulingTolerations
{-# INLINE v1alpha1SchedulingTolerationsL #-}



-- * V1alpha1ServerStorageVersion

-- | 'v1alpha1ServerStorageVersionApiServerId' Lens
v1alpha1ServerStorageVersionApiServerIdL :: Lens_' V1alpha1ServerStorageVersion (Maybe Text)
v1alpha1ServerStorageVersionApiServerIdL f V1alpha1ServerStorageVersion{..} = (\v1alpha1ServerStorageVersionApiServerId -> V1alpha1ServerStorageVersion { v1alpha1ServerStorageVersionApiServerId, ..} ) <$> f v1alpha1ServerStorageVersionApiServerId
{-# INLINE v1alpha1ServerStorageVersionApiServerIdL #-}

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

-- | 'v1alpha1ServerStorageVersionEncodingVersion' Lens
v1alpha1ServerStorageVersionEncodingVersionL :: Lens_' V1alpha1ServerStorageVersion (Maybe Text)
v1alpha1ServerStorageVersionEncodingVersionL f V1alpha1ServerStorageVersion{..} = (\v1alpha1ServerStorageVersionEncodingVersion -> V1alpha1ServerStorageVersion { v1alpha1ServerStorageVersionEncodingVersion, ..} ) <$> f v1alpha1ServerStorageVersionEncodingVersion
{-# INLINE v1alpha1ServerStorageVersionEncodingVersionL #-}



-- * V1alpha1StorageVersion

-- | 'v1alpha1StorageVersionApiVersion' Lens
v1alpha1StorageVersionApiVersionL :: Lens_' V1alpha1StorageVersion (Maybe Text)
v1alpha1StorageVersionApiVersionL f V1alpha1StorageVersion{..} = (\v1alpha1StorageVersionApiVersion -> V1alpha1StorageVersion { v1alpha1StorageVersionApiVersion, ..} ) <$> f v1alpha1StorageVersionApiVersion
{-# INLINE v1alpha1StorageVersionApiVersionL #-}

-- | 'v1alpha1StorageVersionKind' Lens
v1alpha1StorageVersionKindL :: Lens_' V1alpha1StorageVersion (Maybe Text)
v1alpha1StorageVersionKindL f V1alpha1StorageVersion{..} = (\v1alpha1StorageVersionKind -> V1alpha1StorageVersion { v1alpha1StorageVersionKind, ..} ) <$> f v1alpha1StorageVersionKind
{-# INLINE v1alpha1StorageVersionKindL #-}

-- | 'v1alpha1StorageVersionMetadata' Lens
v1alpha1StorageVersionMetadataL :: Lens_' V1alpha1StorageVersion (Maybe V1ObjectMeta)
v1alpha1StorageVersionMetadataL f V1alpha1StorageVersion{..} = (\v1alpha1StorageVersionMetadata -> V1alpha1StorageVersion { v1alpha1StorageVersionMetadata, ..} ) <$> f v1alpha1StorageVersionMetadata
{-# INLINE v1alpha1StorageVersionMetadataL #-}

-- | 'v1alpha1StorageVersionSpec' Lens
v1alpha1StorageVersionSpecL :: Lens_' V1alpha1StorageVersion (A.Value)
v1alpha1StorageVersionSpecL f V1alpha1StorageVersion{..} = (\v1alpha1StorageVersionSpec -> V1alpha1StorageVersion { v1alpha1StorageVersionSpec, ..} ) <$> f v1alpha1StorageVersionSpec
{-# INLINE v1alpha1StorageVersionSpecL #-}

-- | 'v1alpha1StorageVersionStatus' Lens
v1alpha1StorageVersionStatusL :: Lens_' V1alpha1StorageVersion (V1alpha1StorageVersionStatus)
v1alpha1StorageVersionStatusL f V1alpha1StorageVersion{..} = (\v1alpha1StorageVersionStatus -> V1alpha1StorageVersion { v1alpha1StorageVersionStatus, ..} ) <$> f v1alpha1StorageVersionStatus
{-# INLINE v1alpha1StorageVersionStatusL #-}



-- * V1alpha1StorageVersionCondition

-- | 'v1alpha1StorageVersionConditionLastTransitionTime' Lens
v1alpha1StorageVersionConditionLastTransitionTimeL :: Lens_' V1alpha1StorageVersionCondition (Maybe DateTime)
v1alpha1StorageVersionConditionLastTransitionTimeL f V1alpha1StorageVersionCondition{..} = (\v1alpha1StorageVersionConditionLastTransitionTime -> V1alpha1StorageVersionCondition { v1alpha1StorageVersionConditionLastTransitionTime, ..} ) <$> f v1alpha1StorageVersionConditionLastTransitionTime
{-# INLINE v1alpha1StorageVersionConditionLastTransitionTimeL #-}

-- | 'v1alpha1StorageVersionConditionMessage' Lens
v1alpha1StorageVersionConditionMessageL :: Lens_' V1alpha1StorageVersionCondition (Maybe Text)
v1alpha1StorageVersionConditionMessageL f V1alpha1StorageVersionCondition{..} = (\v1alpha1StorageVersionConditionMessage -> V1alpha1StorageVersionCondition { v1alpha1StorageVersionConditionMessage, ..} ) <$> f v1alpha1StorageVersionConditionMessage
{-# INLINE v1alpha1StorageVersionConditionMessageL #-}

-- | 'v1alpha1StorageVersionConditionObservedGeneration' Lens
v1alpha1StorageVersionConditionObservedGenerationL :: Lens_' V1alpha1StorageVersionCondition (Maybe Integer)
v1alpha1StorageVersionConditionObservedGenerationL f V1alpha1StorageVersionCondition{..} = (\v1alpha1StorageVersionConditionObservedGeneration -> V1alpha1StorageVersionCondition { v1alpha1StorageVersionConditionObservedGeneration, ..} ) <$> f v1alpha1StorageVersionConditionObservedGeneration
{-# INLINE v1alpha1StorageVersionConditionObservedGenerationL #-}

-- | 'v1alpha1StorageVersionConditionReason' Lens
v1alpha1StorageVersionConditionReasonL :: Lens_' V1alpha1StorageVersionCondition (Text)
v1alpha1StorageVersionConditionReasonL f V1alpha1StorageVersionCondition{..} = (\v1alpha1StorageVersionConditionReason -> V1alpha1StorageVersionCondition { v1alpha1StorageVersionConditionReason, ..} ) <$> f v1alpha1StorageVersionConditionReason
{-# INLINE v1alpha1StorageVersionConditionReasonL #-}

-- | 'v1alpha1StorageVersionConditionStatus' Lens
v1alpha1StorageVersionConditionStatusL :: Lens_' V1alpha1StorageVersionCondition (Text)
v1alpha1StorageVersionConditionStatusL f V1alpha1StorageVersionCondition{..} = (\v1alpha1StorageVersionConditionStatus -> V1alpha1StorageVersionCondition { v1alpha1StorageVersionConditionStatus, ..} ) <$> f v1alpha1StorageVersionConditionStatus
{-# INLINE v1alpha1StorageVersionConditionStatusL #-}

-- | 'v1alpha1StorageVersionConditionType' Lens
v1alpha1StorageVersionConditionTypeL :: Lens_' V1alpha1StorageVersionCondition (Text)
v1alpha1StorageVersionConditionTypeL f V1alpha1StorageVersionCondition{..} = (\v1alpha1StorageVersionConditionType -> V1alpha1StorageVersionCondition { v1alpha1StorageVersionConditionType, ..} ) <$> f v1alpha1StorageVersionConditionType
{-# INLINE v1alpha1StorageVersionConditionTypeL #-}



-- * V1alpha1StorageVersionList

-- | 'v1alpha1StorageVersionListApiVersion' Lens
v1alpha1StorageVersionListApiVersionL :: Lens_' V1alpha1StorageVersionList (Maybe Text)
v1alpha1StorageVersionListApiVersionL f V1alpha1StorageVersionList{..} = (\v1alpha1StorageVersionListApiVersion -> V1alpha1StorageVersionList { v1alpha1StorageVersionListApiVersion, ..} ) <$> f v1alpha1StorageVersionListApiVersion
{-# INLINE v1alpha1StorageVersionListApiVersionL #-}

-- | 'v1alpha1StorageVersionListItems' Lens
v1alpha1StorageVersionListItemsL :: Lens_' V1alpha1StorageVersionList ([V1alpha1StorageVersion])
v1alpha1StorageVersionListItemsL f V1alpha1StorageVersionList{..} = (\v1alpha1StorageVersionListItems -> V1alpha1StorageVersionList { v1alpha1StorageVersionListItems, ..} ) <$> f v1alpha1StorageVersionListItems
{-# INLINE v1alpha1StorageVersionListItemsL #-}

-- | 'v1alpha1StorageVersionListKind' Lens
v1alpha1StorageVersionListKindL :: Lens_' V1alpha1StorageVersionList (Maybe Text)
v1alpha1StorageVersionListKindL f V1alpha1StorageVersionList{..} = (\v1alpha1StorageVersionListKind -> V1alpha1StorageVersionList { v1alpha1StorageVersionListKind, ..} ) <$> f v1alpha1StorageVersionListKind
{-# INLINE v1alpha1StorageVersionListKindL #-}

-- | 'v1alpha1StorageVersionListMetadata' Lens
v1alpha1StorageVersionListMetadataL :: Lens_' V1alpha1StorageVersionList (Maybe V1ListMeta)
v1alpha1StorageVersionListMetadataL f V1alpha1StorageVersionList{..} = (\v1alpha1StorageVersionListMetadata -> V1alpha1StorageVersionList { v1alpha1StorageVersionListMetadata, ..} ) <$> f v1alpha1StorageVersionListMetadata
{-# INLINE v1alpha1StorageVersionListMetadataL #-}



-- * V1alpha1StorageVersionStatus

-- | 'v1alpha1StorageVersionStatusCommonEncodingVersion' Lens
v1alpha1StorageVersionStatusCommonEncodingVersionL :: Lens_' V1alpha1StorageVersionStatus (Maybe Text)
v1alpha1StorageVersionStatusCommonEncodingVersionL f V1alpha1StorageVersionStatus{..} = (\v1alpha1StorageVersionStatusCommonEncodingVersion -> V1alpha1StorageVersionStatus { v1alpha1StorageVersionStatusCommonEncodingVersion, ..} ) <$> f v1alpha1StorageVersionStatusCommonEncodingVersion
{-# INLINE v1alpha1StorageVersionStatusCommonEncodingVersionL #-}

-- | 'v1alpha1StorageVersionStatusConditions' Lens
v1alpha1StorageVersionStatusConditionsL :: Lens_' V1alpha1StorageVersionStatus (Maybe [V1alpha1StorageVersionCondition])
v1alpha1StorageVersionStatusConditionsL f V1alpha1StorageVersionStatus{..} = (\v1alpha1StorageVersionStatusConditions -> V1alpha1StorageVersionStatus { v1alpha1StorageVersionStatusConditions, ..} ) <$> f v1alpha1StorageVersionStatusConditions
{-# INLINE v1alpha1StorageVersionStatusConditionsL #-}

-- | 'v1alpha1StorageVersionStatusStorageVersions' Lens
v1alpha1StorageVersionStatusStorageVersionsL :: Lens_' V1alpha1StorageVersionStatus (Maybe [V1alpha1ServerStorageVersion])
v1alpha1StorageVersionStatusStorageVersionsL f V1alpha1StorageVersionStatus{..} = (\v1alpha1StorageVersionStatusStorageVersions -> V1alpha1StorageVersionStatus { v1alpha1StorageVersionStatusStorageVersions, ..} ) <$> f v1alpha1StorageVersionStatusStorageVersions
{-# INLINE v1alpha1StorageVersionStatusStorageVersionsL #-}



-- * V1beta1AllowedCSIDriver

-- | 'v1beta1AllowedCSIDriverName' Lens
v1beta1AllowedCSIDriverNameL :: Lens_' V1beta1AllowedCSIDriver (Text)
v1beta1AllowedCSIDriverNameL f V1beta1AllowedCSIDriver{..} = (\v1beta1AllowedCSIDriverName -> V1beta1AllowedCSIDriver { v1beta1AllowedCSIDriverName, ..} ) <$> f v1beta1AllowedCSIDriverName
{-# INLINE v1beta1AllowedCSIDriverNameL #-}



-- * V1beta1AllowedFlexVolume

-- | 'v1beta1AllowedFlexVolumeDriver' Lens
v1beta1AllowedFlexVolumeDriverL :: Lens_' V1beta1AllowedFlexVolume (Text)
v1beta1AllowedFlexVolumeDriverL f V1beta1AllowedFlexVolume{..} = (\v1beta1AllowedFlexVolumeDriver -> V1beta1AllowedFlexVolume { v1beta1AllowedFlexVolumeDriver, ..} ) <$> f v1beta1AllowedFlexVolumeDriver
{-# INLINE v1beta1AllowedFlexVolumeDriverL #-}



-- * V1beta1AllowedHostPath

-- | 'v1beta1AllowedHostPathPathPrefix' Lens
v1beta1AllowedHostPathPathPrefixL :: Lens_' V1beta1AllowedHostPath (Maybe Text)
v1beta1AllowedHostPathPathPrefixL f V1beta1AllowedHostPath{..} = (\v1beta1AllowedHostPathPathPrefix -> V1beta1AllowedHostPath { v1beta1AllowedHostPathPathPrefix, ..} ) <$> f v1beta1AllowedHostPathPathPrefix
{-# INLINE v1beta1AllowedHostPathPathPrefixL #-}

-- | 'v1beta1AllowedHostPathReadOnly' Lens
v1beta1AllowedHostPathReadOnlyL :: Lens_' V1beta1AllowedHostPath (Maybe Bool)
v1beta1AllowedHostPathReadOnlyL f V1beta1AllowedHostPath{..} = (\v1beta1AllowedHostPathReadOnly -> V1beta1AllowedHostPath { v1beta1AllowedHostPathReadOnly, ..} ) <$> f v1beta1AllowedHostPathReadOnly
{-# INLINE v1beta1AllowedHostPathReadOnlyL #-}



-- * V1beta1CSIStorageCapacity

-- | 'v1beta1CSIStorageCapacityApiVersion' Lens
v1beta1CSIStorageCapacityApiVersionL :: Lens_' V1beta1CSIStorageCapacity (Maybe Text)
v1beta1CSIStorageCapacityApiVersionL f V1beta1CSIStorageCapacity{..} = (\v1beta1CSIStorageCapacityApiVersion -> V1beta1CSIStorageCapacity { v1beta1CSIStorageCapacityApiVersion, ..} ) <$> f v1beta1CSIStorageCapacityApiVersion
{-# INLINE v1beta1CSIStorageCapacityApiVersionL #-}

-- | 'v1beta1CSIStorageCapacityCapacity' Lens
v1beta1CSIStorageCapacityCapacityL :: Lens_' V1beta1CSIStorageCapacity (Maybe Quantity)
v1beta1CSIStorageCapacityCapacityL f V1beta1CSIStorageCapacity{..} = (\v1beta1CSIStorageCapacityCapacity -> V1beta1CSIStorageCapacity { v1beta1CSIStorageCapacityCapacity, ..} ) <$> f v1beta1CSIStorageCapacityCapacity
{-# INLINE v1beta1CSIStorageCapacityCapacityL #-}

-- | 'v1beta1CSIStorageCapacityKind' Lens
v1beta1CSIStorageCapacityKindL :: Lens_' V1beta1CSIStorageCapacity (Maybe Text)
v1beta1CSIStorageCapacityKindL f V1beta1CSIStorageCapacity{..} = (\v1beta1CSIStorageCapacityKind -> V1beta1CSIStorageCapacity { v1beta1CSIStorageCapacityKind, ..} ) <$> f v1beta1CSIStorageCapacityKind
{-# INLINE v1beta1CSIStorageCapacityKindL #-}

-- | 'v1beta1CSIStorageCapacityMaximumVolumeSize' Lens
v1beta1CSIStorageCapacityMaximumVolumeSizeL :: Lens_' V1beta1CSIStorageCapacity (Maybe Quantity)
v1beta1CSIStorageCapacityMaximumVolumeSizeL f V1beta1CSIStorageCapacity{..} = (\v1beta1CSIStorageCapacityMaximumVolumeSize -> V1beta1CSIStorageCapacity { v1beta1CSIStorageCapacityMaximumVolumeSize, ..} ) <$> f v1beta1CSIStorageCapacityMaximumVolumeSize
{-# INLINE v1beta1CSIStorageCapacityMaximumVolumeSizeL #-}

-- | 'v1beta1CSIStorageCapacityMetadata' Lens
v1beta1CSIStorageCapacityMetadataL :: Lens_' V1beta1CSIStorageCapacity (Maybe V1ObjectMeta)
v1beta1CSIStorageCapacityMetadataL f V1beta1CSIStorageCapacity{..} = (\v1beta1CSIStorageCapacityMetadata -> V1beta1CSIStorageCapacity { v1beta1CSIStorageCapacityMetadata, ..} ) <$> f v1beta1CSIStorageCapacityMetadata
{-# INLINE v1beta1CSIStorageCapacityMetadataL #-}

-- | 'v1beta1CSIStorageCapacityNodeTopology' Lens
v1beta1CSIStorageCapacityNodeTopologyL :: Lens_' V1beta1CSIStorageCapacity (Maybe V1LabelSelector)
v1beta1CSIStorageCapacityNodeTopologyL f V1beta1CSIStorageCapacity{..} = (\v1beta1CSIStorageCapacityNodeTopology -> V1beta1CSIStorageCapacity { v1beta1CSIStorageCapacityNodeTopology, ..} ) <$> f v1beta1CSIStorageCapacityNodeTopology
{-# INLINE v1beta1CSIStorageCapacityNodeTopologyL #-}

-- | 'v1beta1CSIStorageCapacityStorageClassName' Lens
v1beta1CSIStorageCapacityStorageClassNameL :: Lens_' V1beta1CSIStorageCapacity (Text)
v1beta1CSIStorageCapacityStorageClassNameL f V1beta1CSIStorageCapacity{..} = (\v1beta1CSIStorageCapacityStorageClassName -> V1beta1CSIStorageCapacity { v1beta1CSIStorageCapacityStorageClassName, ..} ) <$> f v1beta1CSIStorageCapacityStorageClassName
{-# INLINE v1beta1CSIStorageCapacityStorageClassNameL #-}



-- * V1beta1CSIStorageCapacityList

-- | 'v1beta1CSIStorageCapacityListApiVersion' Lens
v1beta1CSIStorageCapacityListApiVersionL :: Lens_' V1beta1CSIStorageCapacityList (Maybe Text)
v1beta1CSIStorageCapacityListApiVersionL f V1beta1CSIStorageCapacityList{..} = (\v1beta1CSIStorageCapacityListApiVersion -> V1beta1CSIStorageCapacityList { v1beta1CSIStorageCapacityListApiVersion, ..} ) <$> f v1beta1CSIStorageCapacityListApiVersion
{-# INLINE v1beta1CSIStorageCapacityListApiVersionL #-}

-- | 'v1beta1CSIStorageCapacityListItems' Lens
v1beta1CSIStorageCapacityListItemsL :: Lens_' V1beta1CSIStorageCapacityList ([V1beta1CSIStorageCapacity])
v1beta1CSIStorageCapacityListItemsL f V1beta1CSIStorageCapacityList{..} = (\v1beta1CSIStorageCapacityListItems -> V1beta1CSIStorageCapacityList { v1beta1CSIStorageCapacityListItems, ..} ) <$> f v1beta1CSIStorageCapacityListItems
{-# INLINE v1beta1CSIStorageCapacityListItemsL #-}

-- | 'v1beta1CSIStorageCapacityListKind' Lens
v1beta1CSIStorageCapacityListKindL :: Lens_' V1beta1CSIStorageCapacityList (Maybe Text)
v1beta1CSIStorageCapacityListKindL f V1beta1CSIStorageCapacityList{..} = (\v1beta1CSIStorageCapacityListKind -> V1beta1CSIStorageCapacityList { v1beta1CSIStorageCapacityListKind, ..} ) <$> f v1beta1CSIStorageCapacityListKind
{-# INLINE v1beta1CSIStorageCapacityListKindL #-}

-- | 'v1beta1CSIStorageCapacityListMetadata' Lens
v1beta1CSIStorageCapacityListMetadataL :: Lens_' V1beta1CSIStorageCapacityList (Maybe V1ListMeta)
v1beta1CSIStorageCapacityListMetadataL f V1beta1CSIStorageCapacityList{..} = (\v1beta1CSIStorageCapacityListMetadata -> V1beta1CSIStorageCapacityList { v1beta1CSIStorageCapacityListMetadata, ..} ) <$> f v1beta1CSIStorageCapacityListMetadata
{-# INLINE v1beta1CSIStorageCapacityListMetadataL #-}



-- * V1beta1CronJob

-- | 'v1beta1CronJobApiVersion' Lens
v1beta1CronJobApiVersionL :: Lens_' V1beta1CronJob (Maybe Text)
v1beta1CronJobApiVersionL f V1beta1CronJob{..} = (\v1beta1CronJobApiVersion -> V1beta1CronJob { v1beta1CronJobApiVersion, ..} ) <$> f v1beta1CronJobApiVersion
{-# INLINE v1beta1CronJobApiVersionL #-}

-- | 'v1beta1CronJobKind' Lens
v1beta1CronJobKindL :: Lens_' V1beta1CronJob (Maybe Text)
v1beta1CronJobKindL f V1beta1CronJob{..} = (\v1beta1CronJobKind -> V1beta1CronJob { v1beta1CronJobKind, ..} ) <$> f v1beta1CronJobKind
{-# INLINE v1beta1CronJobKindL #-}

-- | 'v1beta1CronJobMetadata' Lens
v1beta1CronJobMetadataL :: Lens_' V1beta1CronJob (Maybe V1ObjectMeta)
v1beta1CronJobMetadataL f V1beta1CronJob{..} = (\v1beta1CronJobMetadata -> V1beta1CronJob { v1beta1CronJobMetadata, ..} ) <$> f v1beta1CronJobMetadata
{-# INLINE v1beta1CronJobMetadataL #-}

-- | 'v1beta1CronJobSpec' Lens
v1beta1CronJobSpecL :: Lens_' V1beta1CronJob (Maybe V1beta1CronJobSpec)
v1beta1CronJobSpecL f V1beta1CronJob{..} = (\v1beta1CronJobSpec -> V1beta1CronJob { v1beta1CronJobSpec, ..} ) <$> f v1beta1CronJobSpec
{-# INLINE v1beta1CronJobSpecL #-}

-- | 'v1beta1CronJobStatus' Lens
v1beta1CronJobStatusL :: Lens_' V1beta1CronJob (Maybe V1beta1CronJobStatus)
v1beta1CronJobStatusL f V1beta1CronJob{..} = (\v1beta1CronJobStatus -> V1beta1CronJob { v1beta1CronJobStatus, ..} ) <$> f v1beta1CronJobStatus
{-# INLINE v1beta1CronJobStatusL #-}



-- * V1beta1CronJobList

-- | 'v1beta1CronJobListApiVersion' Lens
v1beta1CronJobListApiVersionL :: Lens_' V1beta1CronJobList (Maybe Text)
v1beta1CronJobListApiVersionL f V1beta1CronJobList{..} = (\v1beta1CronJobListApiVersion -> V1beta1CronJobList { v1beta1CronJobListApiVersion, ..} ) <$> f v1beta1CronJobListApiVersion
{-# INLINE v1beta1CronJobListApiVersionL #-}

-- | 'v1beta1CronJobListItems' Lens
v1beta1CronJobListItemsL :: Lens_' V1beta1CronJobList ([V1beta1CronJob])
v1beta1CronJobListItemsL f V1beta1CronJobList{..} = (\v1beta1CronJobListItems -> V1beta1CronJobList { v1beta1CronJobListItems, ..} ) <$> f v1beta1CronJobListItems
{-# INLINE v1beta1CronJobListItemsL #-}

-- | 'v1beta1CronJobListKind' Lens
v1beta1CronJobListKindL :: Lens_' V1beta1CronJobList (Maybe Text)
v1beta1CronJobListKindL f V1beta1CronJobList{..} = (\v1beta1CronJobListKind -> V1beta1CronJobList { v1beta1CronJobListKind, ..} ) <$> f v1beta1CronJobListKind
{-# INLINE v1beta1CronJobListKindL #-}

-- | 'v1beta1CronJobListMetadata' Lens
v1beta1CronJobListMetadataL :: Lens_' V1beta1CronJobList (Maybe V1ListMeta)
v1beta1CronJobListMetadataL f V1beta1CronJobList{..} = (\v1beta1CronJobListMetadata -> V1beta1CronJobList { v1beta1CronJobListMetadata, ..} ) <$> f v1beta1CronJobListMetadata
{-# INLINE v1beta1CronJobListMetadataL #-}



-- * V1beta1CronJobSpec

-- | 'v1beta1CronJobSpecConcurrencyPolicy' Lens
v1beta1CronJobSpecConcurrencyPolicyL :: Lens_' V1beta1CronJobSpec (Maybe Text)
v1beta1CronJobSpecConcurrencyPolicyL f V1beta1CronJobSpec{..} = (\v1beta1CronJobSpecConcurrencyPolicy -> V1beta1CronJobSpec { v1beta1CronJobSpecConcurrencyPolicy, ..} ) <$> f v1beta1CronJobSpecConcurrencyPolicy
{-# INLINE v1beta1CronJobSpecConcurrencyPolicyL #-}

-- | 'v1beta1CronJobSpecFailedJobsHistoryLimit' Lens
v1beta1CronJobSpecFailedJobsHistoryLimitL :: Lens_' V1beta1CronJobSpec (Maybe Int)
v1beta1CronJobSpecFailedJobsHistoryLimitL f V1beta1CronJobSpec{..} = (\v1beta1CronJobSpecFailedJobsHistoryLimit -> V1beta1CronJobSpec { v1beta1CronJobSpecFailedJobsHistoryLimit, ..} ) <$> f v1beta1CronJobSpecFailedJobsHistoryLimit
{-# INLINE v1beta1CronJobSpecFailedJobsHistoryLimitL #-}

-- | 'v1beta1CronJobSpecJobTemplate' Lens
v1beta1CronJobSpecJobTemplateL :: Lens_' V1beta1CronJobSpec (V1beta1JobTemplateSpec)
v1beta1CronJobSpecJobTemplateL f V1beta1CronJobSpec{..} = (\v1beta1CronJobSpecJobTemplate -> V1beta1CronJobSpec { v1beta1CronJobSpecJobTemplate, ..} ) <$> f v1beta1CronJobSpecJobTemplate
{-# INLINE v1beta1CronJobSpecJobTemplateL #-}

-- | 'v1beta1CronJobSpecSchedule' Lens
v1beta1CronJobSpecScheduleL :: Lens_' V1beta1CronJobSpec (Text)
v1beta1CronJobSpecScheduleL f V1beta1CronJobSpec{..} = (\v1beta1CronJobSpecSchedule -> V1beta1CronJobSpec { v1beta1CronJobSpecSchedule, ..} ) <$> f v1beta1CronJobSpecSchedule
{-# INLINE v1beta1CronJobSpecScheduleL #-}

-- | 'v1beta1CronJobSpecStartingDeadlineSeconds' Lens
v1beta1CronJobSpecStartingDeadlineSecondsL :: Lens_' V1beta1CronJobSpec (Maybe Integer)
v1beta1CronJobSpecStartingDeadlineSecondsL f V1beta1CronJobSpec{..} = (\v1beta1CronJobSpecStartingDeadlineSeconds -> V1beta1CronJobSpec { v1beta1CronJobSpecStartingDeadlineSeconds, ..} ) <$> f v1beta1CronJobSpecStartingDeadlineSeconds
{-# INLINE v1beta1CronJobSpecStartingDeadlineSecondsL #-}

-- | 'v1beta1CronJobSpecSuccessfulJobsHistoryLimit' Lens
v1beta1CronJobSpecSuccessfulJobsHistoryLimitL :: Lens_' V1beta1CronJobSpec (Maybe Int)
v1beta1CronJobSpecSuccessfulJobsHistoryLimitL f V1beta1CronJobSpec{..} = (\v1beta1CronJobSpecSuccessfulJobsHistoryLimit -> V1beta1CronJobSpec { v1beta1CronJobSpecSuccessfulJobsHistoryLimit, ..} ) <$> f v1beta1CronJobSpecSuccessfulJobsHistoryLimit
{-# INLINE v1beta1CronJobSpecSuccessfulJobsHistoryLimitL #-}

-- | 'v1beta1CronJobSpecSuspend' Lens
v1beta1CronJobSpecSuspendL :: Lens_' V1beta1CronJobSpec (Maybe Bool)
v1beta1CronJobSpecSuspendL f V1beta1CronJobSpec{..} = (\v1beta1CronJobSpecSuspend -> V1beta1CronJobSpec { v1beta1CronJobSpecSuspend, ..} ) <$> f v1beta1CronJobSpecSuspend
{-# INLINE v1beta1CronJobSpecSuspendL #-}



-- * V1beta1CronJobStatus

-- | 'v1beta1CronJobStatusActive' Lens
v1beta1CronJobStatusActiveL :: Lens_' V1beta1CronJobStatus (Maybe [V1ObjectReference])
v1beta1CronJobStatusActiveL f V1beta1CronJobStatus{..} = (\v1beta1CronJobStatusActive -> V1beta1CronJobStatus { v1beta1CronJobStatusActive, ..} ) <$> f v1beta1CronJobStatusActive
{-# INLINE v1beta1CronJobStatusActiveL #-}

-- | 'v1beta1CronJobStatusLastScheduleTime' Lens
v1beta1CronJobStatusLastScheduleTimeL :: Lens_' V1beta1CronJobStatus (Maybe DateTime)
v1beta1CronJobStatusLastScheduleTimeL f V1beta1CronJobStatus{..} = (\v1beta1CronJobStatusLastScheduleTime -> V1beta1CronJobStatus { v1beta1CronJobStatusLastScheduleTime, ..} ) <$> f v1beta1CronJobStatusLastScheduleTime
{-# INLINE v1beta1CronJobStatusLastScheduleTimeL #-}

-- | 'v1beta1CronJobStatusLastSuccessfulTime' Lens
v1beta1CronJobStatusLastSuccessfulTimeL :: Lens_' V1beta1CronJobStatus (Maybe DateTime)
v1beta1CronJobStatusLastSuccessfulTimeL f V1beta1CronJobStatus{..} = (\v1beta1CronJobStatusLastSuccessfulTime -> V1beta1CronJobStatus { v1beta1CronJobStatusLastSuccessfulTime, ..} ) <$> f v1beta1CronJobStatusLastSuccessfulTime
{-# INLINE v1beta1CronJobStatusLastSuccessfulTimeL #-}



-- * V1beta1Endpoint

-- | 'v1beta1EndpointAddresses' Lens
v1beta1EndpointAddressesL :: Lens_' V1beta1Endpoint ([Text])
v1beta1EndpointAddressesL f V1beta1Endpoint{..} = (\v1beta1EndpointAddresses -> V1beta1Endpoint { v1beta1EndpointAddresses, ..} ) <$> f v1beta1EndpointAddresses
{-# INLINE v1beta1EndpointAddressesL #-}

-- | 'v1beta1EndpointConditions' Lens
v1beta1EndpointConditionsL :: Lens_' V1beta1Endpoint (Maybe V1beta1EndpointConditions)
v1beta1EndpointConditionsL f V1beta1Endpoint{..} = (\v1beta1EndpointConditions -> V1beta1Endpoint { v1beta1EndpointConditions, ..} ) <$> f v1beta1EndpointConditions
{-# INLINE v1beta1EndpointConditionsL #-}

-- | 'v1beta1EndpointHints' Lens
v1beta1EndpointHintsL :: Lens_' V1beta1Endpoint (Maybe V1beta1EndpointHints)
v1beta1EndpointHintsL f V1beta1Endpoint{..} = (\v1beta1EndpointHints -> V1beta1Endpoint { v1beta1EndpointHints, ..} ) <$> f v1beta1EndpointHints
{-# INLINE v1beta1EndpointHintsL #-}

-- | 'v1beta1EndpointHostname' Lens
v1beta1EndpointHostnameL :: Lens_' V1beta1Endpoint (Maybe Text)
v1beta1EndpointHostnameL f V1beta1Endpoint{..} = (\v1beta1EndpointHostname -> V1beta1Endpoint { v1beta1EndpointHostname, ..} ) <$> f v1beta1EndpointHostname
{-# INLINE v1beta1EndpointHostnameL #-}

-- | 'v1beta1EndpointNodeName' Lens
v1beta1EndpointNodeNameL :: Lens_' V1beta1Endpoint (Maybe Text)
v1beta1EndpointNodeNameL f V1beta1Endpoint{..} = (\v1beta1EndpointNodeName -> V1beta1Endpoint { v1beta1EndpointNodeName, ..} ) <$> f v1beta1EndpointNodeName
{-# INLINE v1beta1EndpointNodeNameL #-}

-- | 'v1beta1EndpointTargetRef' Lens
v1beta1EndpointTargetRefL :: Lens_' V1beta1Endpoint (Maybe V1ObjectReference)
v1beta1EndpointTargetRefL f V1beta1Endpoint{..} = (\v1beta1EndpointTargetRef -> V1beta1Endpoint { v1beta1EndpointTargetRef, ..} ) <$> f v1beta1EndpointTargetRef
{-# INLINE v1beta1EndpointTargetRefL #-}

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



-- * V1beta1EndpointConditions

-- | 'v1beta1EndpointConditionsReady' Lens
v1beta1EndpointConditionsReadyL :: Lens_' V1beta1EndpointConditions (Maybe Bool)
v1beta1EndpointConditionsReadyL f V1beta1EndpointConditions{..} = (\v1beta1EndpointConditionsReady -> V1beta1EndpointConditions { v1beta1EndpointConditionsReady, ..} ) <$> f v1beta1EndpointConditionsReady
{-# INLINE v1beta1EndpointConditionsReadyL #-}

-- | 'v1beta1EndpointConditionsServing' Lens
v1beta1EndpointConditionsServingL :: Lens_' V1beta1EndpointConditions (Maybe Bool)
v1beta1EndpointConditionsServingL f V1beta1EndpointConditions{..} = (\v1beta1EndpointConditionsServing -> V1beta1EndpointConditions { v1beta1EndpointConditionsServing, ..} ) <$> f v1beta1EndpointConditionsServing
{-# INLINE v1beta1EndpointConditionsServingL #-}

-- | 'v1beta1EndpointConditionsTerminating' Lens
v1beta1EndpointConditionsTerminatingL :: Lens_' V1beta1EndpointConditions (Maybe Bool)
v1beta1EndpointConditionsTerminatingL f V1beta1EndpointConditions{..} = (\v1beta1EndpointConditionsTerminating -> V1beta1EndpointConditions { v1beta1EndpointConditionsTerminating, ..} ) <$> f v1beta1EndpointConditionsTerminating
{-# INLINE v1beta1EndpointConditionsTerminatingL #-}



-- * V1beta1EndpointHints

-- | 'v1beta1EndpointHintsForZones' Lens
v1beta1EndpointHintsForZonesL :: Lens_' V1beta1EndpointHints (Maybe [V1beta1ForZone])
v1beta1EndpointHintsForZonesL f V1beta1EndpointHints{..} = (\v1beta1EndpointHintsForZones -> V1beta1EndpointHints { v1beta1EndpointHintsForZones, ..} ) <$> f v1beta1EndpointHintsForZones
{-# INLINE v1beta1EndpointHintsForZonesL #-}



-- * V1beta1EndpointPort

-- | 'v1beta1EndpointPortAppProtocol' Lens
v1beta1EndpointPortAppProtocolL :: Lens_' V1beta1EndpointPort (Maybe Text)
v1beta1EndpointPortAppProtocolL f V1beta1EndpointPort{..} = (\v1beta1EndpointPortAppProtocol -> V1beta1EndpointPort { v1beta1EndpointPortAppProtocol, ..} ) <$> f v1beta1EndpointPortAppProtocol
{-# INLINE v1beta1EndpointPortAppProtocolL #-}

-- | 'v1beta1EndpointPortName' Lens
v1beta1EndpointPortNameL :: Lens_' V1beta1EndpointPort (Maybe Text)
v1beta1EndpointPortNameL f V1beta1EndpointPort{..} = (\v1beta1EndpointPortName -> V1beta1EndpointPort { v1beta1EndpointPortName, ..} ) <$> f v1beta1EndpointPortName
{-# INLINE v1beta1EndpointPortNameL #-}

-- | 'v1beta1EndpointPortPort' Lens
v1beta1EndpointPortPortL :: Lens_' V1beta1EndpointPort (Maybe Int)
v1beta1EndpointPortPortL f V1beta1EndpointPort{..} = (\v1beta1EndpointPortPort -> V1beta1EndpointPort { v1beta1EndpointPortPort, ..} ) <$> f v1beta1EndpointPortPort
{-# INLINE v1beta1EndpointPortPortL #-}

-- | 'v1beta1EndpointPortProtocol' Lens
v1beta1EndpointPortProtocolL :: Lens_' V1beta1EndpointPort (Maybe Text)
v1beta1EndpointPortProtocolL f V1beta1EndpointPort{..} = (\v1beta1EndpointPortProtocol -> V1beta1EndpointPort { v1beta1EndpointPortProtocol, ..} ) <$> f v1beta1EndpointPortProtocol
{-# INLINE v1beta1EndpointPortProtocolL #-}



-- * V1beta1EndpointSlice

-- | 'v1beta1EndpointSliceAddressType' Lens
v1beta1EndpointSliceAddressTypeL :: Lens_' V1beta1EndpointSlice (Text)
v1beta1EndpointSliceAddressTypeL f V1beta1EndpointSlice{..} = (\v1beta1EndpointSliceAddressType -> V1beta1EndpointSlice { v1beta1EndpointSliceAddressType, ..} ) <$> f v1beta1EndpointSliceAddressType
{-# INLINE v1beta1EndpointSliceAddressTypeL #-}

-- | 'v1beta1EndpointSliceApiVersion' Lens
v1beta1EndpointSliceApiVersionL :: Lens_' V1beta1EndpointSlice (Maybe Text)
v1beta1EndpointSliceApiVersionL f V1beta1EndpointSlice{..} = (\v1beta1EndpointSliceApiVersion -> V1beta1EndpointSlice { v1beta1EndpointSliceApiVersion, ..} ) <$> f v1beta1EndpointSliceApiVersion
{-# INLINE v1beta1EndpointSliceApiVersionL #-}

-- | 'v1beta1EndpointSliceEndpoints' Lens
v1beta1EndpointSliceEndpointsL :: Lens_' V1beta1EndpointSlice ([V1beta1Endpoint])
v1beta1EndpointSliceEndpointsL f V1beta1EndpointSlice{..} = (\v1beta1EndpointSliceEndpoints -> V1beta1EndpointSlice { v1beta1EndpointSliceEndpoints, ..} ) <$> f v1beta1EndpointSliceEndpoints
{-# INLINE v1beta1EndpointSliceEndpointsL #-}

-- | 'v1beta1EndpointSliceKind' Lens
v1beta1EndpointSliceKindL :: Lens_' V1beta1EndpointSlice (Maybe Text)
v1beta1EndpointSliceKindL f V1beta1EndpointSlice{..} = (\v1beta1EndpointSliceKind -> V1beta1EndpointSlice { v1beta1EndpointSliceKind, ..} ) <$> f v1beta1EndpointSliceKind
{-# INLINE v1beta1EndpointSliceKindL #-}

-- | 'v1beta1EndpointSliceMetadata' Lens
v1beta1EndpointSliceMetadataL :: Lens_' V1beta1EndpointSlice (Maybe V1ObjectMeta)
v1beta1EndpointSliceMetadataL f V1beta1EndpointSlice{..} = (\v1beta1EndpointSliceMetadata -> V1beta1EndpointSlice { v1beta1EndpointSliceMetadata, ..} ) <$> f v1beta1EndpointSliceMetadata
{-# INLINE v1beta1EndpointSliceMetadataL #-}

-- | 'v1beta1EndpointSlicePorts' Lens
v1beta1EndpointSlicePortsL :: Lens_' V1beta1EndpointSlice (Maybe [V1beta1EndpointPort])
v1beta1EndpointSlicePortsL f V1beta1EndpointSlice{..} = (\v1beta1EndpointSlicePorts -> V1beta1EndpointSlice { v1beta1EndpointSlicePorts, ..} ) <$> f v1beta1EndpointSlicePorts
{-# INLINE v1beta1EndpointSlicePortsL #-}



-- * V1beta1EndpointSliceList

-- | 'v1beta1EndpointSliceListApiVersion' Lens
v1beta1EndpointSliceListApiVersionL :: Lens_' V1beta1EndpointSliceList (Maybe Text)
v1beta1EndpointSliceListApiVersionL f V1beta1EndpointSliceList{..} = (\v1beta1EndpointSliceListApiVersion -> V1beta1EndpointSliceList { v1beta1EndpointSliceListApiVersion, ..} ) <$> f v1beta1EndpointSliceListApiVersion
{-# INLINE v1beta1EndpointSliceListApiVersionL #-}

-- | 'v1beta1EndpointSliceListItems' Lens
v1beta1EndpointSliceListItemsL :: Lens_' V1beta1EndpointSliceList ([V1beta1EndpointSlice])
v1beta1EndpointSliceListItemsL f V1beta1EndpointSliceList{..} = (\v1beta1EndpointSliceListItems -> V1beta1EndpointSliceList { v1beta1EndpointSliceListItems, ..} ) <$> f v1beta1EndpointSliceListItems
{-# INLINE v1beta1EndpointSliceListItemsL #-}

-- | 'v1beta1EndpointSliceListKind' Lens
v1beta1EndpointSliceListKindL :: Lens_' V1beta1EndpointSliceList (Maybe Text)
v1beta1EndpointSliceListKindL f V1beta1EndpointSliceList{..} = (\v1beta1EndpointSliceListKind -> V1beta1EndpointSliceList { v1beta1EndpointSliceListKind, ..} ) <$> f v1beta1EndpointSliceListKind
{-# INLINE v1beta1EndpointSliceListKindL #-}

-- | 'v1beta1EndpointSliceListMetadata' Lens
v1beta1EndpointSliceListMetadataL :: Lens_' V1beta1EndpointSliceList (Maybe V1ListMeta)
v1beta1EndpointSliceListMetadataL f V1beta1EndpointSliceList{..} = (\v1beta1EndpointSliceListMetadata -> V1beta1EndpointSliceList { v1beta1EndpointSliceListMetadata, ..} ) <$> f v1beta1EndpointSliceListMetadata
{-# INLINE v1beta1EndpointSliceListMetadataL #-}



-- * V1beta1Event

-- | 'v1beta1EventAction' Lens
v1beta1EventActionL :: Lens_' V1beta1Event (Maybe Text)
v1beta1EventActionL f V1beta1Event{..} = (\v1beta1EventAction -> V1beta1Event { v1beta1EventAction, ..} ) <$> f v1beta1EventAction
{-# INLINE v1beta1EventActionL #-}

-- | 'v1beta1EventApiVersion' Lens
v1beta1EventApiVersionL :: Lens_' V1beta1Event (Maybe Text)
v1beta1EventApiVersionL f V1beta1Event{..} = (\v1beta1EventApiVersion -> V1beta1Event { v1beta1EventApiVersion, ..} ) <$> f v1beta1EventApiVersion
{-# INLINE v1beta1EventApiVersionL #-}

-- | 'v1beta1EventDeprecatedCount' Lens
v1beta1EventDeprecatedCountL :: Lens_' V1beta1Event (Maybe Int)
v1beta1EventDeprecatedCountL f V1beta1Event{..} = (\v1beta1EventDeprecatedCount -> V1beta1Event { v1beta1EventDeprecatedCount, ..} ) <$> f v1beta1EventDeprecatedCount
{-# INLINE v1beta1EventDeprecatedCountL #-}

-- | 'v1beta1EventDeprecatedFirstTimestamp' Lens
v1beta1EventDeprecatedFirstTimestampL :: Lens_' V1beta1Event (Maybe DateTime)
v1beta1EventDeprecatedFirstTimestampL f V1beta1Event{..} = (\v1beta1EventDeprecatedFirstTimestamp -> V1beta1Event { v1beta1EventDeprecatedFirstTimestamp, ..} ) <$> f v1beta1EventDeprecatedFirstTimestamp
{-# INLINE v1beta1EventDeprecatedFirstTimestampL #-}

-- | 'v1beta1EventDeprecatedLastTimestamp' Lens
v1beta1EventDeprecatedLastTimestampL :: Lens_' V1beta1Event (Maybe DateTime)
v1beta1EventDeprecatedLastTimestampL f V1beta1Event{..} = (\v1beta1EventDeprecatedLastTimestamp -> V1beta1Event { v1beta1EventDeprecatedLastTimestamp, ..} ) <$> f v1beta1EventDeprecatedLastTimestamp
{-# INLINE v1beta1EventDeprecatedLastTimestampL #-}

-- | 'v1beta1EventDeprecatedSource' Lens
v1beta1EventDeprecatedSourceL :: Lens_' V1beta1Event (Maybe V1EventSource)
v1beta1EventDeprecatedSourceL f V1beta1Event{..} = (\v1beta1EventDeprecatedSource -> V1beta1Event { v1beta1EventDeprecatedSource, ..} ) <$> f v1beta1EventDeprecatedSource
{-# INLINE v1beta1EventDeprecatedSourceL #-}

-- | 'v1beta1EventEventTime' Lens
v1beta1EventEventTimeL :: Lens_' V1beta1Event (DateTime)
v1beta1EventEventTimeL f V1beta1Event{..} = (\v1beta1EventEventTime -> V1beta1Event { v1beta1EventEventTime, ..} ) <$> f v1beta1EventEventTime
{-# INLINE v1beta1EventEventTimeL #-}

-- | 'v1beta1EventKind' Lens
v1beta1EventKindL :: Lens_' V1beta1Event (Maybe Text)
v1beta1EventKindL f V1beta1Event{..} = (\v1beta1EventKind -> V1beta1Event { v1beta1EventKind, ..} ) <$> f v1beta1EventKind
{-# INLINE v1beta1EventKindL #-}

-- | 'v1beta1EventMetadata' Lens
v1beta1EventMetadataL :: Lens_' V1beta1Event (Maybe V1ObjectMeta)
v1beta1EventMetadataL f V1beta1Event{..} = (\v1beta1EventMetadata -> V1beta1Event { v1beta1EventMetadata, ..} ) <$> f v1beta1EventMetadata
{-# INLINE v1beta1EventMetadataL #-}

-- | 'v1beta1EventNote' Lens
v1beta1EventNoteL :: Lens_' V1beta1Event (Maybe Text)
v1beta1EventNoteL f V1beta1Event{..} = (\v1beta1EventNote -> V1beta1Event { v1beta1EventNote, ..} ) <$> f v1beta1EventNote
{-# INLINE v1beta1EventNoteL #-}

-- | 'v1beta1EventReason' Lens
v1beta1EventReasonL :: Lens_' V1beta1Event (Maybe Text)
v1beta1EventReasonL f V1beta1Event{..} = (\v1beta1EventReason -> V1beta1Event { v1beta1EventReason, ..} ) <$> f v1beta1EventReason
{-# INLINE v1beta1EventReasonL #-}

-- | 'v1beta1EventRegarding' Lens
v1beta1EventRegardingL :: Lens_' V1beta1Event (Maybe V1ObjectReference)
v1beta1EventRegardingL f V1beta1Event{..} = (\v1beta1EventRegarding -> V1beta1Event { v1beta1EventRegarding, ..} ) <$> f v1beta1EventRegarding
{-# INLINE v1beta1EventRegardingL #-}

-- | 'v1beta1EventRelated' Lens
v1beta1EventRelatedL :: Lens_' V1beta1Event (Maybe V1ObjectReference)
v1beta1EventRelatedL f V1beta1Event{..} = (\v1beta1EventRelated -> V1beta1Event { v1beta1EventRelated, ..} ) <$> f v1beta1EventRelated
{-# INLINE v1beta1EventRelatedL #-}

-- | 'v1beta1EventReportingController' Lens
v1beta1EventReportingControllerL :: Lens_' V1beta1Event (Maybe Text)
v1beta1EventReportingControllerL f V1beta1Event{..} = (\v1beta1EventReportingController -> V1beta1Event { v1beta1EventReportingController, ..} ) <$> f v1beta1EventReportingController
{-# INLINE v1beta1EventReportingControllerL #-}

-- | 'v1beta1EventReportingInstance' Lens
v1beta1EventReportingInstanceL :: Lens_' V1beta1Event (Maybe Text)
v1beta1EventReportingInstanceL f V1beta1Event{..} = (\v1beta1EventReportingInstance -> V1beta1Event { v1beta1EventReportingInstance, ..} ) <$> f v1beta1EventReportingInstance
{-# INLINE v1beta1EventReportingInstanceL #-}

-- | 'v1beta1EventSeries' Lens
v1beta1EventSeriesL :: Lens_' V1beta1Event (Maybe V1beta1EventSeries)
v1beta1EventSeriesL f V1beta1Event{..} = (\v1beta1EventSeries -> V1beta1Event { v1beta1EventSeries, ..} ) <$> f v1beta1EventSeries
{-# INLINE v1beta1EventSeriesL #-}

-- | 'v1beta1EventType' Lens
v1beta1EventTypeL :: Lens_' V1beta1Event (Maybe Text)
v1beta1EventTypeL f V1beta1Event{..} = (\v1beta1EventType -> V1beta1Event { v1beta1EventType, ..} ) <$> f v1beta1EventType
{-# INLINE v1beta1EventTypeL #-}



-- * V1beta1EventList

-- | 'v1beta1EventListApiVersion' Lens
v1beta1EventListApiVersionL :: Lens_' V1beta1EventList (Maybe Text)
v1beta1EventListApiVersionL f V1beta1EventList{..} = (\v1beta1EventListApiVersion -> V1beta1EventList { v1beta1EventListApiVersion, ..} ) <$> f v1beta1EventListApiVersion
{-# INLINE v1beta1EventListApiVersionL #-}

-- | 'v1beta1EventListItems' Lens
v1beta1EventListItemsL :: Lens_' V1beta1EventList ([V1beta1Event])
v1beta1EventListItemsL f V1beta1EventList{..} = (\v1beta1EventListItems -> V1beta1EventList { v1beta1EventListItems, ..} ) <$> f v1beta1EventListItems
{-# INLINE v1beta1EventListItemsL #-}

-- | 'v1beta1EventListKind' Lens
v1beta1EventListKindL :: Lens_' V1beta1EventList (Maybe Text)
v1beta1EventListKindL f V1beta1EventList{..} = (\v1beta1EventListKind -> V1beta1EventList { v1beta1EventListKind, ..} ) <$> f v1beta1EventListKind
{-# INLINE v1beta1EventListKindL #-}

-- | 'v1beta1EventListMetadata' Lens
v1beta1EventListMetadataL :: Lens_' V1beta1EventList (Maybe V1ListMeta)
v1beta1EventListMetadataL f V1beta1EventList{..} = (\v1beta1EventListMetadata -> V1beta1EventList { v1beta1EventListMetadata, ..} ) <$> f v1beta1EventListMetadata
{-# INLINE v1beta1EventListMetadataL #-}



-- * V1beta1EventSeries

-- | 'v1beta1EventSeriesCount' Lens
v1beta1EventSeriesCountL :: Lens_' V1beta1EventSeries (Int)
v1beta1EventSeriesCountL f V1beta1EventSeries{..} = (\v1beta1EventSeriesCount -> V1beta1EventSeries { v1beta1EventSeriesCount, ..} ) <$> f v1beta1EventSeriesCount
{-# INLINE v1beta1EventSeriesCountL #-}

-- | 'v1beta1EventSeriesLastObservedTime' Lens
v1beta1EventSeriesLastObservedTimeL :: Lens_' V1beta1EventSeries (DateTime)
v1beta1EventSeriesLastObservedTimeL f V1beta1EventSeries{..} = (\v1beta1EventSeriesLastObservedTime -> V1beta1EventSeries { v1beta1EventSeriesLastObservedTime, ..} ) <$> f v1beta1EventSeriesLastObservedTime
{-# INLINE v1beta1EventSeriesLastObservedTimeL #-}



-- * V1beta1FSGroupStrategyOptions

-- | 'v1beta1FSGroupStrategyOptionsRanges' Lens
v1beta1FSGroupStrategyOptionsRangesL :: Lens_' V1beta1FSGroupStrategyOptions (Maybe [V1beta1IDRange])
v1beta1FSGroupStrategyOptionsRangesL f V1beta1FSGroupStrategyOptions{..} = (\v1beta1FSGroupStrategyOptionsRanges -> V1beta1FSGroupStrategyOptions { v1beta1FSGroupStrategyOptionsRanges, ..} ) <$> f v1beta1FSGroupStrategyOptionsRanges
{-# INLINE v1beta1FSGroupStrategyOptionsRangesL #-}

-- | 'v1beta1FSGroupStrategyOptionsRule' Lens
v1beta1FSGroupStrategyOptionsRuleL :: Lens_' V1beta1FSGroupStrategyOptions (Maybe Text)
v1beta1FSGroupStrategyOptionsRuleL f V1beta1FSGroupStrategyOptions{..} = (\v1beta1FSGroupStrategyOptionsRule -> V1beta1FSGroupStrategyOptions { v1beta1FSGroupStrategyOptionsRule, ..} ) <$> f v1beta1FSGroupStrategyOptionsRule
{-# INLINE v1beta1FSGroupStrategyOptionsRuleL #-}



-- * V1beta1FlowDistinguisherMethod

-- | 'v1beta1FlowDistinguisherMethodType' Lens
v1beta1FlowDistinguisherMethodTypeL :: Lens_' V1beta1FlowDistinguisherMethod (Text)
v1beta1FlowDistinguisherMethodTypeL f V1beta1FlowDistinguisherMethod{..} = (\v1beta1FlowDistinguisherMethodType -> V1beta1FlowDistinguisherMethod { v1beta1FlowDistinguisherMethodType, ..} ) <$> f v1beta1FlowDistinguisherMethodType
{-# INLINE v1beta1FlowDistinguisherMethodTypeL #-}



-- * V1beta1FlowSchema

-- | 'v1beta1FlowSchemaApiVersion' Lens
v1beta1FlowSchemaApiVersionL :: Lens_' V1beta1FlowSchema (Maybe Text)
v1beta1FlowSchemaApiVersionL f V1beta1FlowSchema{..} = (\v1beta1FlowSchemaApiVersion -> V1beta1FlowSchema { v1beta1FlowSchemaApiVersion, ..} ) <$> f v1beta1FlowSchemaApiVersion
{-# INLINE v1beta1FlowSchemaApiVersionL #-}

-- | 'v1beta1FlowSchemaKind' Lens
v1beta1FlowSchemaKindL :: Lens_' V1beta1FlowSchema (Maybe Text)
v1beta1FlowSchemaKindL f V1beta1FlowSchema{..} = (\v1beta1FlowSchemaKind -> V1beta1FlowSchema { v1beta1FlowSchemaKind, ..} ) <$> f v1beta1FlowSchemaKind
{-# INLINE v1beta1FlowSchemaKindL #-}

-- | 'v1beta1FlowSchemaMetadata' Lens
v1beta1FlowSchemaMetadataL :: Lens_' V1beta1FlowSchema (Maybe V1ObjectMeta)
v1beta1FlowSchemaMetadataL f V1beta1FlowSchema{..} = (\v1beta1FlowSchemaMetadata -> V1beta1FlowSchema { v1beta1FlowSchemaMetadata, ..} ) <$> f v1beta1FlowSchemaMetadata
{-# INLINE v1beta1FlowSchemaMetadataL #-}

-- | 'v1beta1FlowSchemaSpec' Lens
v1beta1FlowSchemaSpecL :: Lens_' V1beta1FlowSchema (Maybe V1beta1FlowSchemaSpec)
v1beta1FlowSchemaSpecL f V1beta1FlowSchema{..} = (\v1beta1FlowSchemaSpec -> V1beta1FlowSchema { v1beta1FlowSchemaSpec, ..} ) <$> f v1beta1FlowSchemaSpec
{-# INLINE v1beta1FlowSchemaSpecL #-}

-- | 'v1beta1FlowSchemaStatus' Lens
v1beta1FlowSchemaStatusL :: Lens_' V1beta1FlowSchema (Maybe V1beta1FlowSchemaStatus)
v1beta1FlowSchemaStatusL f V1beta1FlowSchema{..} = (\v1beta1FlowSchemaStatus -> V1beta1FlowSchema { v1beta1FlowSchemaStatus, ..} ) <$> f v1beta1FlowSchemaStatus
{-# INLINE v1beta1FlowSchemaStatusL #-}



-- * V1beta1FlowSchemaCondition

-- | 'v1beta1FlowSchemaConditionLastTransitionTime' Lens
v1beta1FlowSchemaConditionLastTransitionTimeL :: Lens_' V1beta1FlowSchemaCondition (Maybe DateTime)
v1beta1FlowSchemaConditionLastTransitionTimeL f V1beta1FlowSchemaCondition{..} = (\v1beta1FlowSchemaConditionLastTransitionTime -> V1beta1FlowSchemaCondition { v1beta1FlowSchemaConditionLastTransitionTime, ..} ) <$> f v1beta1FlowSchemaConditionLastTransitionTime
{-# INLINE v1beta1FlowSchemaConditionLastTransitionTimeL #-}

-- | 'v1beta1FlowSchemaConditionMessage' Lens
v1beta1FlowSchemaConditionMessageL :: Lens_' V1beta1FlowSchemaCondition (Maybe Text)
v1beta1FlowSchemaConditionMessageL f V1beta1FlowSchemaCondition{..} = (\v1beta1FlowSchemaConditionMessage -> V1beta1FlowSchemaCondition { v1beta1FlowSchemaConditionMessage, ..} ) <$> f v1beta1FlowSchemaConditionMessage
{-# INLINE v1beta1FlowSchemaConditionMessageL #-}

-- | 'v1beta1FlowSchemaConditionReason' Lens
v1beta1FlowSchemaConditionReasonL :: Lens_' V1beta1FlowSchemaCondition (Maybe Text)
v1beta1FlowSchemaConditionReasonL f V1beta1FlowSchemaCondition{..} = (\v1beta1FlowSchemaConditionReason -> V1beta1FlowSchemaCondition { v1beta1FlowSchemaConditionReason, ..} ) <$> f v1beta1FlowSchemaConditionReason
{-# INLINE v1beta1FlowSchemaConditionReasonL #-}

-- | 'v1beta1FlowSchemaConditionStatus' Lens
v1beta1FlowSchemaConditionStatusL :: Lens_' V1beta1FlowSchemaCondition (Maybe Text)
v1beta1FlowSchemaConditionStatusL f V1beta1FlowSchemaCondition{..} = (\v1beta1FlowSchemaConditionStatus -> V1beta1FlowSchemaCondition { v1beta1FlowSchemaConditionStatus, ..} ) <$> f v1beta1FlowSchemaConditionStatus
{-# INLINE v1beta1FlowSchemaConditionStatusL #-}

-- | 'v1beta1FlowSchemaConditionType' Lens
v1beta1FlowSchemaConditionTypeL :: Lens_' V1beta1FlowSchemaCondition (Maybe Text)
v1beta1FlowSchemaConditionTypeL f V1beta1FlowSchemaCondition{..} = (\v1beta1FlowSchemaConditionType -> V1beta1FlowSchemaCondition { v1beta1FlowSchemaConditionType, ..} ) <$> f v1beta1FlowSchemaConditionType
{-# INLINE v1beta1FlowSchemaConditionTypeL #-}



-- * V1beta1FlowSchemaList

-- | 'v1beta1FlowSchemaListApiVersion' Lens
v1beta1FlowSchemaListApiVersionL :: Lens_' V1beta1FlowSchemaList (Maybe Text)
v1beta1FlowSchemaListApiVersionL f V1beta1FlowSchemaList{..} = (\v1beta1FlowSchemaListApiVersion -> V1beta1FlowSchemaList { v1beta1FlowSchemaListApiVersion, ..} ) <$> f v1beta1FlowSchemaListApiVersion
{-# INLINE v1beta1FlowSchemaListApiVersionL #-}

-- | 'v1beta1FlowSchemaListItems' Lens
v1beta1FlowSchemaListItemsL :: Lens_' V1beta1FlowSchemaList ([V1beta1FlowSchema])
v1beta1FlowSchemaListItemsL f V1beta1FlowSchemaList{..} = (\v1beta1FlowSchemaListItems -> V1beta1FlowSchemaList { v1beta1FlowSchemaListItems, ..} ) <$> f v1beta1FlowSchemaListItems
{-# INLINE v1beta1FlowSchemaListItemsL #-}

-- | 'v1beta1FlowSchemaListKind' Lens
v1beta1FlowSchemaListKindL :: Lens_' V1beta1FlowSchemaList (Maybe Text)
v1beta1FlowSchemaListKindL f V1beta1FlowSchemaList{..} = (\v1beta1FlowSchemaListKind -> V1beta1FlowSchemaList { v1beta1FlowSchemaListKind, ..} ) <$> f v1beta1FlowSchemaListKind
{-# INLINE v1beta1FlowSchemaListKindL #-}

-- | 'v1beta1FlowSchemaListMetadata' Lens
v1beta1FlowSchemaListMetadataL :: Lens_' V1beta1FlowSchemaList (Maybe V1ListMeta)
v1beta1FlowSchemaListMetadataL f V1beta1FlowSchemaList{..} = (\v1beta1FlowSchemaListMetadata -> V1beta1FlowSchemaList { v1beta1FlowSchemaListMetadata, ..} ) <$> f v1beta1FlowSchemaListMetadata
{-# INLINE v1beta1FlowSchemaListMetadataL #-}



-- * V1beta1FlowSchemaSpec

-- | 'v1beta1FlowSchemaSpecDistinguisherMethod' Lens
v1beta1FlowSchemaSpecDistinguisherMethodL :: Lens_' V1beta1FlowSchemaSpec (Maybe V1beta1FlowDistinguisherMethod)
v1beta1FlowSchemaSpecDistinguisherMethodL f V1beta1FlowSchemaSpec{..} = (\v1beta1FlowSchemaSpecDistinguisherMethod -> V1beta1FlowSchemaSpec { v1beta1FlowSchemaSpecDistinguisherMethod, ..} ) <$> f v1beta1FlowSchemaSpecDistinguisherMethod
{-# INLINE v1beta1FlowSchemaSpecDistinguisherMethodL #-}

-- | 'v1beta1FlowSchemaSpecMatchingPrecedence' Lens
v1beta1FlowSchemaSpecMatchingPrecedenceL :: Lens_' V1beta1FlowSchemaSpec (Maybe Int)
v1beta1FlowSchemaSpecMatchingPrecedenceL f V1beta1FlowSchemaSpec{..} = (\v1beta1FlowSchemaSpecMatchingPrecedence -> V1beta1FlowSchemaSpec { v1beta1FlowSchemaSpecMatchingPrecedence, ..} ) <$> f v1beta1FlowSchemaSpecMatchingPrecedence
{-# INLINE v1beta1FlowSchemaSpecMatchingPrecedenceL #-}

-- | 'v1beta1FlowSchemaSpecPriorityLevelConfiguration' Lens
v1beta1FlowSchemaSpecPriorityLevelConfigurationL :: Lens_' V1beta1FlowSchemaSpec (V1beta1PriorityLevelConfigurationReference)
v1beta1FlowSchemaSpecPriorityLevelConfigurationL f V1beta1FlowSchemaSpec{..} = (\v1beta1FlowSchemaSpecPriorityLevelConfiguration -> V1beta1FlowSchemaSpec { v1beta1FlowSchemaSpecPriorityLevelConfiguration, ..} ) <$> f v1beta1FlowSchemaSpecPriorityLevelConfiguration
{-# INLINE v1beta1FlowSchemaSpecPriorityLevelConfigurationL #-}

-- | 'v1beta1FlowSchemaSpecRules' Lens
v1beta1FlowSchemaSpecRulesL :: Lens_' V1beta1FlowSchemaSpec (Maybe [V1beta1PolicyRulesWithSubjects])
v1beta1FlowSchemaSpecRulesL f V1beta1FlowSchemaSpec{..} = (\v1beta1FlowSchemaSpecRules -> V1beta1FlowSchemaSpec { v1beta1FlowSchemaSpecRules, ..} ) <$> f v1beta1FlowSchemaSpecRules
{-# INLINE v1beta1FlowSchemaSpecRulesL #-}



-- * V1beta1FlowSchemaStatus

-- | 'v1beta1FlowSchemaStatusConditions' Lens
v1beta1FlowSchemaStatusConditionsL :: Lens_' V1beta1FlowSchemaStatus (Maybe [V1beta1FlowSchemaCondition])
v1beta1FlowSchemaStatusConditionsL f V1beta1FlowSchemaStatus{..} = (\v1beta1FlowSchemaStatusConditions -> V1beta1FlowSchemaStatus { v1beta1FlowSchemaStatusConditions, ..} ) <$> f v1beta1FlowSchemaStatusConditions
{-# INLINE v1beta1FlowSchemaStatusConditionsL #-}



-- * V1beta1ForZone

-- | 'v1beta1ForZoneName' Lens
v1beta1ForZoneNameL :: Lens_' V1beta1ForZone (Text)
v1beta1ForZoneNameL f V1beta1ForZone{..} = (\v1beta1ForZoneName -> V1beta1ForZone { v1beta1ForZoneName, ..} ) <$> f v1beta1ForZoneName
{-# INLINE v1beta1ForZoneNameL #-}



-- * V1beta1GroupSubject

-- | 'v1beta1GroupSubjectName' Lens
v1beta1GroupSubjectNameL :: Lens_' V1beta1GroupSubject (Text)
v1beta1GroupSubjectNameL f V1beta1GroupSubject{..} = (\v1beta1GroupSubjectName -> V1beta1GroupSubject { v1beta1GroupSubjectName, ..} ) <$> f v1beta1GroupSubjectName
{-# INLINE v1beta1GroupSubjectNameL #-}



-- * V1beta1HostPortRange

-- | 'v1beta1HostPortRangeMax' Lens
v1beta1HostPortRangeMaxL :: Lens_' V1beta1HostPortRange (Int)
v1beta1HostPortRangeMaxL f V1beta1HostPortRange{..} = (\v1beta1HostPortRangeMax -> V1beta1HostPortRange { v1beta1HostPortRangeMax, ..} ) <$> f v1beta1HostPortRangeMax
{-# INLINE v1beta1HostPortRangeMaxL #-}

-- | 'v1beta1HostPortRangeMin' Lens
v1beta1HostPortRangeMinL :: Lens_' V1beta1HostPortRange (Int)
v1beta1HostPortRangeMinL f V1beta1HostPortRange{..} = (\v1beta1HostPortRangeMin -> V1beta1HostPortRange { v1beta1HostPortRangeMin, ..} ) <$> f v1beta1HostPortRangeMin
{-# INLINE v1beta1HostPortRangeMinL #-}



-- * V1beta1IDRange

-- | 'v1beta1IDRangeMax' Lens
v1beta1IDRangeMaxL :: Lens_' V1beta1IDRange (Integer)
v1beta1IDRangeMaxL f V1beta1IDRange{..} = (\v1beta1IDRangeMax -> V1beta1IDRange { v1beta1IDRangeMax, ..} ) <$> f v1beta1IDRangeMax
{-# INLINE v1beta1IDRangeMaxL #-}

-- | 'v1beta1IDRangeMin' Lens
v1beta1IDRangeMinL :: Lens_' V1beta1IDRange (Integer)
v1beta1IDRangeMinL f V1beta1IDRange{..} = (\v1beta1IDRangeMin -> V1beta1IDRange { v1beta1IDRangeMin, ..} ) <$> f v1beta1IDRangeMin
{-# INLINE v1beta1IDRangeMinL #-}



-- * V1beta1JobTemplateSpec

-- | 'v1beta1JobTemplateSpecMetadata' Lens
v1beta1JobTemplateSpecMetadataL :: Lens_' V1beta1JobTemplateSpec (Maybe V1ObjectMeta)
v1beta1JobTemplateSpecMetadataL f V1beta1JobTemplateSpec{..} = (\v1beta1JobTemplateSpecMetadata -> V1beta1JobTemplateSpec { v1beta1JobTemplateSpecMetadata, ..} ) <$> f v1beta1JobTemplateSpecMetadata
{-# INLINE v1beta1JobTemplateSpecMetadataL #-}

-- | 'v1beta1JobTemplateSpecSpec' Lens
v1beta1JobTemplateSpecSpecL :: Lens_' V1beta1JobTemplateSpec (Maybe V1JobSpec)
v1beta1JobTemplateSpecSpecL f V1beta1JobTemplateSpec{..} = (\v1beta1JobTemplateSpecSpec -> V1beta1JobTemplateSpec { v1beta1JobTemplateSpecSpec, ..} ) <$> f v1beta1JobTemplateSpecSpec
{-# INLINE v1beta1JobTemplateSpecSpecL #-}



-- * V1beta1LimitResponse

-- | 'v1beta1LimitResponseQueuing' Lens
v1beta1LimitResponseQueuingL :: Lens_' V1beta1LimitResponse (Maybe V1beta1QueuingConfiguration)
v1beta1LimitResponseQueuingL f V1beta1LimitResponse{..} = (\v1beta1LimitResponseQueuing -> V1beta1LimitResponse { v1beta1LimitResponseQueuing, ..} ) <$> f v1beta1LimitResponseQueuing
{-# INLINE v1beta1LimitResponseQueuingL #-}

-- | 'v1beta1LimitResponseType' Lens
v1beta1LimitResponseTypeL :: Lens_' V1beta1LimitResponse (Text)
v1beta1LimitResponseTypeL f V1beta1LimitResponse{..} = (\v1beta1LimitResponseType -> V1beta1LimitResponse { v1beta1LimitResponseType, ..} ) <$> f v1beta1LimitResponseType
{-# INLINE v1beta1LimitResponseTypeL #-}



-- * V1beta1LimitedPriorityLevelConfiguration

-- | 'v1beta1LimitedPriorityLevelConfigurationAssuredConcurrencyShares' Lens
v1beta1LimitedPriorityLevelConfigurationAssuredConcurrencySharesL :: Lens_' V1beta1LimitedPriorityLevelConfiguration (Maybe Int)
v1beta1LimitedPriorityLevelConfigurationAssuredConcurrencySharesL f V1beta1LimitedPriorityLevelConfiguration{..} = (\v1beta1LimitedPriorityLevelConfigurationAssuredConcurrencyShares -> V1beta1LimitedPriorityLevelConfiguration { v1beta1LimitedPriorityLevelConfigurationAssuredConcurrencyShares, ..} ) <$> f v1beta1LimitedPriorityLevelConfigurationAssuredConcurrencyShares
{-# INLINE v1beta1LimitedPriorityLevelConfigurationAssuredConcurrencySharesL #-}

-- | 'v1beta1LimitedPriorityLevelConfigurationLimitResponse' Lens
v1beta1LimitedPriorityLevelConfigurationLimitResponseL :: Lens_' V1beta1LimitedPriorityLevelConfiguration (Maybe V1beta1LimitResponse)
v1beta1LimitedPriorityLevelConfigurationLimitResponseL f V1beta1LimitedPriorityLevelConfiguration{..} = (\v1beta1LimitedPriorityLevelConfigurationLimitResponse -> V1beta1LimitedPriorityLevelConfiguration { v1beta1LimitedPriorityLevelConfigurationLimitResponse, ..} ) <$> f v1beta1LimitedPriorityLevelConfigurationLimitResponse
{-# INLINE v1beta1LimitedPriorityLevelConfigurationLimitResponseL #-}



-- * V1beta1NonResourcePolicyRule

-- | 'v1beta1NonResourcePolicyRuleNonResourceUrls' Lens
v1beta1NonResourcePolicyRuleNonResourceUrlsL :: Lens_' V1beta1NonResourcePolicyRule ([Text])
v1beta1NonResourcePolicyRuleNonResourceUrlsL f V1beta1NonResourcePolicyRule{..} = (\v1beta1NonResourcePolicyRuleNonResourceUrls -> V1beta1NonResourcePolicyRule { v1beta1NonResourcePolicyRuleNonResourceUrls, ..} ) <$> f v1beta1NonResourcePolicyRuleNonResourceUrls
{-# INLINE v1beta1NonResourcePolicyRuleNonResourceUrlsL #-}

-- | 'v1beta1NonResourcePolicyRuleVerbs' Lens
v1beta1NonResourcePolicyRuleVerbsL :: Lens_' V1beta1NonResourcePolicyRule ([Text])
v1beta1NonResourcePolicyRuleVerbsL f V1beta1NonResourcePolicyRule{..} = (\v1beta1NonResourcePolicyRuleVerbs -> V1beta1NonResourcePolicyRule { v1beta1NonResourcePolicyRuleVerbs, ..} ) <$> f v1beta1NonResourcePolicyRuleVerbs
{-# INLINE v1beta1NonResourcePolicyRuleVerbsL #-}



-- * V1beta1Overhead

-- | 'v1beta1OverheadPodFixed' Lens
v1beta1OverheadPodFixedL :: Lens_' V1beta1Overhead (Maybe (Map.Map String Quantity))
v1beta1OverheadPodFixedL f V1beta1Overhead{..} = (\v1beta1OverheadPodFixed -> V1beta1Overhead { v1beta1OverheadPodFixed, ..} ) <$> f v1beta1OverheadPodFixed
{-# INLINE v1beta1OverheadPodFixedL #-}



-- * V1beta1PodDisruptionBudget

-- | 'v1beta1PodDisruptionBudgetApiVersion' Lens
v1beta1PodDisruptionBudgetApiVersionL :: Lens_' V1beta1PodDisruptionBudget (Maybe Text)
v1beta1PodDisruptionBudgetApiVersionL f V1beta1PodDisruptionBudget{..} = (\v1beta1PodDisruptionBudgetApiVersion -> V1beta1PodDisruptionBudget { v1beta1PodDisruptionBudgetApiVersion, ..} ) <$> f v1beta1PodDisruptionBudgetApiVersion
{-# INLINE v1beta1PodDisruptionBudgetApiVersionL #-}

-- | 'v1beta1PodDisruptionBudgetKind' Lens
v1beta1PodDisruptionBudgetKindL :: Lens_' V1beta1PodDisruptionBudget (Maybe Text)
v1beta1PodDisruptionBudgetKindL f V1beta1PodDisruptionBudget{..} = (\v1beta1PodDisruptionBudgetKind -> V1beta1PodDisruptionBudget { v1beta1PodDisruptionBudgetKind, ..} ) <$> f v1beta1PodDisruptionBudgetKind
{-# INLINE v1beta1PodDisruptionBudgetKindL #-}

-- | 'v1beta1PodDisruptionBudgetMetadata' Lens
v1beta1PodDisruptionBudgetMetadataL :: Lens_' V1beta1PodDisruptionBudget (Maybe V1ObjectMeta)
v1beta1PodDisruptionBudgetMetadataL f V1beta1PodDisruptionBudget{..} = (\v1beta1PodDisruptionBudgetMetadata -> V1beta1PodDisruptionBudget { v1beta1PodDisruptionBudgetMetadata, ..} ) <$> f v1beta1PodDisruptionBudgetMetadata
{-# INLINE v1beta1PodDisruptionBudgetMetadataL #-}

-- | 'v1beta1PodDisruptionBudgetSpec' Lens
v1beta1PodDisruptionBudgetSpecL :: Lens_' V1beta1PodDisruptionBudget (Maybe V1beta1PodDisruptionBudgetSpec)
v1beta1PodDisruptionBudgetSpecL f V1beta1PodDisruptionBudget{..} = (\v1beta1PodDisruptionBudgetSpec -> V1beta1PodDisruptionBudget { v1beta1PodDisruptionBudgetSpec, ..} ) <$> f v1beta1PodDisruptionBudgetSpec
{-# INLINE v1beta1PodDisruptionBudgetSpecL #-}

-- | 'v1beta1PodDisruptionBudgetStatus' Lens
v1beta1PodDisruptionBudgetStatusL :: Lens_' V1beta1PodDisruptionBudget (Maybe V1beta1PodDisruptionBudgetStatus)
v1beta1PodDisruptionBudgetStatusL f V1beta1PodDisruptionBudget{..} = (\v1beta1PodDisruptionBudgetStatus -> V1beta1PodDisruptionBudget { v1beta1PodDisruptionBudgetStatus, ..} ) <$> f v1beta1PodDisruptionBudgetStatus
{-# INLINE v1beta1PodDisruptionBudgetStatusL #-}



-- * V1beta1PodDisruptionBudgetList

-- | 'v1beta1PodDisruptionBudgetListApiVersion' Lens
v1beta1PodDisruptionBudgetListApiVersionL :: Lens_' V1beta1PodDisruptionBudgetList (Maybe Text)
v1beta1PodDisruptionBudgetListApiVersionL f V1beta1PodDisruptionBudgetList{..} = (\v1beta1PodDisruptionBudgetListApiVersion -> V1beta1PodDisruptionBudgetList { v1beta1PodDisruptionBudgetListApiVersion, ..} ) <$> f v1beta1PodDisruptionBudgetListApiVersion
{-# INLINE v1beta1PodDisruptionBudgetListApiVersionL #-}

-- | 'v1beta1PodDisruptionBudgetListItems' Lens
v1beta1PodDisruptionBudgetListItemsL :: Lens_' V1beta1PodDisruptionBudgetList ([V1beta1PodDisruptionBudget])
v1beta1PodDisruptionBudgetListItemsL f V1beta1PodDisruptionBudgetList{..} = (\v1beta1PodDisruptionBudgetListItems -> V1beta1PodDisruptionBudgetList { v1beta1PodDisruptionBudgetListItems, ..} ) <$> f v1beta1PodDisruptionBudgetListItems
{-# INLINE v1beta1PodDisruptionBudgetListItemsL #-}

-- | 'v1beta1PodDisruptionBudgetListKind' Lens
v1beta1PodDisruptionBudgetListKindL :: Lens_' V1beta1PodDisruptionBudgetList (Maybe Text)
v1beta1PodDisruptionBudgetListKindL f V1beta1PodDisruptionBudgetList{..} = (\v1beta1PodDisruptionBudgetListKind -> V1beta1PodDisruptionBudgetList { v1beta1PodDisruptionBudgetListKind, ..} ) <$> f v1beta1PodDisruptionBudgetListKind
{-# INLINE v1beta1PodDisruptionBudgetListKindL #-}

-- | 'v1beta1PodDisruptionBudgetListMetadata' Lens
v1beta1PodDisruptionBudgetListMetadataL :: Lens_' V1beta1PodDisruptionBudgetList (Maybe V1ListMeta)
v1beta1PodDisruptionBudgetListMetadataL f V1beta1PodDisruptionBudgetList{..} = (\v1beta1PodDisruptionBudgetListMetadata -> V1beta1PodDisruptionBudgetList { v1beta1PodDisruptionBudgetListMetadata, ..} ) <$> f v1beta1PodDisruptionBudgetListMetadata
{-# INLINE v1beta1PodDisruptionBudgetListMetadataL #-}



-- * V1beta1PodDisruptionBudgetSpec

-- | 'v1beta1PodDisruptionBudgetSpecMaxUnavailable' Lens
v1beta1PodDisruptionBudgetSpecMaxUnavailableL :: Lens_' V1beta1PodDisruptionBudgetSpec (Maybe IntOrString)
v1beta1PodDisruptionBudgetSpecMaxUnavailableL f V1beta1PodDisruptionBudgetSpec{..} = (\v1beta1PodDisruptionBudgetSpecMaxUnavailable -> V1beta1PodDisruptionBudgetSpec { v1beta1PodDisruptionBudgetSpecMaxUnavailable, ..} ) <$> f v1beta1PodDisruptionBudgetSpecMaxUnavailable
{-# INLINE v1beta1PodDisruptionBudgetSpecMaxUnavailableL #-}

-- | 'v1beta1PodDisruptionBudgetSpecMinAvailable' Lens
v1beta1PodDisruptionBudgetSpecMinAvailableL :: Lens_' V1beta1PodDisruptionBudgetSpec (Maybe IntOrString)
v1beta1PodDisruptionBudgetSpecMinAvailableL f V1beta1PodDisruptionBudgetSpec{..} = (\v1beta1PodDisruptionBudgetSpecMinAvailable -> V1beta1PodDisruptionBudgetSpec { v1beta1PodDisruptionBudgetSpecMinAvailable, ..} ) <$> f v1beta1PodDisruptionBudgetSpecMinAvailable
{-# INLINE v1beta1PodDisruptionBudgetSpecMinAvailableL #-}

-- | 'v1beta1PodDisruptionBudgetSpecSelector' Lens
v1beta1PodDisruptionBudgetSpecSelectorL :: Lens_' V1beta1PodDisruptionBudgetSpec (Maybe V1LabelSelector)
v1beta1PodDisruptionBudgetSpecSelectorL f V1beta1PodDisruptionBudgetSpec{..} = (\v1beta1PodDisruptionBudgetSpecSelector -> V1beta1PodDisruptionBudgetSpec { v1beta1PodDisruptionBudgetSpecSelector, ..} ) <$> f v1beta1PodDisruptionBudgetSpecSelector
{-# INLINE v1beta1PodDisruptionBudgetSpecSelectorL #-}



-- * V1beta1PodDisruptionBudgetStatus

-- | 'v1beta1PodDisruptionBudgetStatusConditions' Lens
v1beta1PodDisruptionBudgetStatusConditionsL :: Lens_' V1beta1PodDisruptionBudgetStatus (Maybe [V1Condition])
v1beta1PodDisruptionBudgetStatusConditionsL f V1beta1PodDisruptionBudgetStatus{..} = (\v1beta1PodDisruptionBudgetStatusConditions -> V1beta1PodDisruptionBudgetStatus { v1beta1PodDisruptionBudgetStatusConditions, ..} ) <$> f v1beta1PodDisruptionBudgetStatusConditions
{-# INLINE v1beta1PodDisruptionBudgetStatusConditionsL #-}

-- | 'v1beta1PodDisruptionBudgetStatusCurrentHealthy' Lens
v1beta1PodDisruptionBudgetStatusCurrentHealthyL :: Lens_' V1beta1PodDisruptionBudgetStatus (Int)
v1beta1PodDisruptionBudgetStatusCurrentHealthyL f V1beta1PodDisruptionBudgetStatus{..} = (\v1beta1PodDisruptionBudgetStatusCurrentHealthy -> V1beta1PodDisruptionBudgetStatus { v1beta1PodDisruptionBudgetStatusCurrentHealthy, ..} ) <$> f v1beta1PodDisruptionBudgetStatusCurrentHealthy
{-# INLINE v1beta1PodDisruptionBudgetStatusCurrentHealthyL #-}

-- | 'v1beta1PodDisruptionBudgetStatusDesiredHealthy' Lens
v1beta1PodDisruptionBudgetStatusDesiredHealthyL :: Lens_' V1beta1PodDisruptionBudgetStatus (Int)
v1beta1PodDisruptionBudgetStatusDesiredHealthyL f V1beta1PodDisruptionBudgetStatus{..} = (\v1beta1PodDisruptionBudgetStatusDesiredHealthy -> V1beta1PodDisruptionBudgetStatus { v1beta1PodDisruptionBudgetStatusDesiredHealthy, ..} ) <$> f v1beta1PodDisruptionBudgetStatusDesiredHealthy
{-# INLINE v1beta1PodDisruptionBudgetStatusDesiredHealthyL #-}

-- | 'v1beta1PodDisruptionBudgetStatusDisruptedPods' Lens
v1beta1PodDisruptionBudgetStatusDisruptedPodsL :: Lens_' V1beta1PodDisruptionBudgetStatus (Maybe (Map.Map String DateTime))
v1beta1PodDisruptionBudgetStatusDisruptedPodsL f V1beta1PodDisruptionBudgetStatus{..} = (\v1beta1PodDisruptionBudgetStatusDisruptedPods -> V1beta1PodDisruptionBudgetStatus { v1beta1PodDisruptionBudgetStatusDisruptedPods, ..} ) <$> f v1beta1PodDisruptionBudgetStatusDisruptedPods
{-# INLINE v1beta1PodDisruptionBudgetStatusDisruptedPodsL #-}

-- | 'v1beta1PodDisruptionBudgetStatusDisruptionsAllowed' Lens
v1beta1PodDisruptionBudgetStatusDisruptionsAllowedL :: Lens_' V1beta1PodDisruptionBudgetStatus (Int)
v1beta1PodDisruptionBudgetStatusDisruptionsAllowedL f V1beta1PodDisruptionBudgetStatus{..} = (\v1beta1PodDisruptionBudgetStatusDisruptionsAllowed -> V1beta1PodDisruptionBudgetStatus { v1beta1PodDisruptionBudgetStatusDisruptionsAllowed, ..} ) <$> f v1beta1PodDisruptionBudgetStatusDisruptionsAllowed
{-# INLINE v1beta1PodDisruptionBudgetStatusDisruptionsAllowedL #-}

-- | 'v1beta1PodDisruptionBudgetStatusExpectedPods' Lens
v1beta1PodDisruptionBudgetStatusExpectedPodsL :: Lens_' V1beta1PodDisruptionBudgetStatus (Int)
v1beta1PodDisruptionBudgetStatusExpectedPodsL f V1beta1PodDisruptionBudgetStatus{..} = (\v1beta1PodDisruptionBudgetStatusExpectedPods -> V1beta1PodDisruptionBudgetStatus { v1beta1PodDisruptionBudgetStatusExpectedPods, ..} ) <$> f v1beta1PodDisruptionBudgetStatusExpectedPods
{-# INLINE v1beta1PodDisruptionBudgetStatusExpectedPodsL #-}

-- | 'v1beta1PodDisruptionBudgetStatusObservedGeneration' Lens
v1beta1PodDisruptionBudgetStatusObservedGenerationL :: Lens_' V1beta1PodDisruptionBudgetStatus (Maybe Integer)
v1beta1PodDisruptionBudgetStatusObservedGenerationL f V1beta1PodDisruptionBudgetStatus{..} = (\v1beta1PodDisruptionBudgetStatusObservedGeneration -> V1beta1PodDisruptionBudgetStatus { v1beta1PodDisruptionBudgetStatusObservedGeneration, ..} ) <$> f v1beta1PodDisruptionBudgetStatusObservedGeneration
{-# INLINE v1beta1PodDisruptionBudgetStatusObservedGenerationL #-}



-- * V1beta1PodSecurityPolicy

-- | 'v1beta1PodSecurityPolicyApiVersion' Lens
v1beta1PodSecurityPolicyApiVersionL :: Lens_' V1beta1PodSecurityPolicy (Maybe Text)
v1beta1PodSecurityPolicyApiVersionL f V1beta1PodSecurityPolicy{..} = (\v1beta1PodSecurityPolicyApiVersion -> V1beta1PodSecurityPolicy { v1beta1PodSecurityPolicyApiVersion, ..} ) <$> f v1beta1PodSecurityPolicyApiVersion
{-# INLINE v1beta1PodSecurityPolicyApiVersionL #-}

-- | 'v1beta1PodSecurityPolicyKind' Lens
v1beta1PodSecurityPolicyKindL :: Lens_' V1beta1PodSecurityPolicy (Maybe Text)
v1beta1PodSecurityPolicyKindL f V1beta1PodSecurityPolicy{..} = (\v1beta1PodSecurityPolicyKind -> V1beta1PodSecurityPolicy { v1beta1PodSecurityPolicyKind, ..} ) <$> f v1beta1PodSecurityPolicyKind
{-# INLINE v1beta1PodSecurityPolicyKindL #-}

-- | 'v1beta1PodSecurityPolicyMetadata' Lens
v1beta1PodSecurityPolicyMetadataL :: Lens_' V1beta1PodSecurityPolicy (Maybe V1ObjectMeta)
v1beta1PodSecurityPolicyMetadataL f V1beta1PodSecurityPolicy{..} = (\v1beta1PodSecurityPolicyMetadata -> V1beta1PodSecurityPolicy { v1beta1PodSecurityPolicyMetadata, ..} ) <$> f v1beta1PodSecurityPolicyMetadata
{-# INLINE v1beta1PodSecurityPolicyMetadataL #-}

-- | 'v1beta1PodSecurityPolicySpec' Lens
v1beta1PodSecurityPolicySpecL :: Lens_' V1beta1PodSecurityPolicy (Maybe V1beta1PodSecurityPolicySpec)
v1beta1PodSecurityPolicySpecL f V1beta1PodSecurityPolicy{..} = (\v1beta1PodSecurityPolicySpec -> V1beta1PodSecurityPolicy { v1beta1PodSecurityPolicySpec, ..} ) <$> f v1beta1PodSecurityPolicySpec
{-# INLINE v1beta1PodSecurityPolicySpecL #-}



-- * V1beta1PodSecurityPolicyList

-- | 'v1beta1PodSecurityPolicyListApiVersion' Lens
v1beta1PodSecurityPolicyListApiVersionL :: Lens_' V1beta1PodSecurityPolicyList (Maybe Text)
v1beta1PodSecurityPolicyListApiVersionL f V1beta1PodSecurityPolicyList{..} = (\v1beta1PodSecurityPolicyListApiVersion -> V1beta1PodSecurityPolicyList { v1beta1PodSecurityPolicyListApiVersion, ..} ) <$> f v1beta1PodSecurityPolicyListApiVersion
{-# INLINE v1beta1PodSecurityPolicyListApiVersionL #-}

-- | 'v1beta1PodSecurityPolicyListItems' Lens
v1beta1PodSecurityPolicyListItemsL :: Lens_' V1beta1PodSecurityPolicyList ([V1beta1PodSecurityPolicy])
v1beta1PodSecurityPolicyListItemsL f V1beta1PodSecurityPolicyList{..} = (\v1beta1PodSecurityPolicyListItems -> V1beta1PodSecurityPolicyList { v1beta1PodSecurityPolicyListItems, ..} ) <$> f v1beta1PodSecurityPolicyListItems
{-# INLINE v1beta1PodSecurityPolicyListItemsL #-}

-- | 'v1beta1PodSecurityPolicyListKind' Lens
v1beta1PodSecurityPolicyListKindL :: Lens_' V1beta1PodSecurityPolicyList (Maybe Text)
v1beta1PodSecurityPolicyListKindL f V1beta1PodSecurityPolicyList{..} = (\v1beta1PodSecurityPolicyListKind -> V1beta1PodSecurityPolicyList { v1beta1PodSecurityPolicyListKind, ..} ) <$> f v1beta1PodSecurityPolicyListKind
{-# INLINE v1beta1PodSecurityPolicyListKindL #-}

-- | 'v1beta1PodSecurityPolicyListMetadata' Lens
v1beta1PodSecurityPolicyListMetadataL :: Lens_' V1beta1PodSecurityPolicyList (Maybe V1ListMeta)
v1beta1PodSecurityPolicyListMetadataL f V1beta1PodSecurityPolicyList{..} = (\v1beta1PodSecurityPolicyListMetadata -> V1beta1PodSecurityPolicyList { v1beta1PodSecurityPolicyListMetadata, ..} ) <$> f v1beta1PodSecurityPolicyListMetadata
{-# INLINE v1beta1PodSecurityPolicyListMetadataL #-}



-- * V1beta1PodSecurityPolicySpec

-- | 'v1beta1PodSecurityPolicySpecAllowPrivilegeEscalation' Lens
v1beta1PodSecurityPolicySpecAllowPrivilegeEscalationL :: Lens_' V1beta1PodSecurityPolicySpec (Maybe Bool)
v1beta1PodSecurityPolicySpecAllowPrivilegeEscalationL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecAllowPrivilegeEscalation -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecAllowPrivilegeEscalation, ..} ) <$> f v1beta1PodSecurityPolicySpecAllowPrivilegeEscalation
{-# INLINE v1beta1PodSecurityPolicySpecAllowPrivilegeEscalationL #-}

-- | 'v1beta1PodSecurityPolicySpecAllowedCsiDrivers' Lens
v1beta1PodSecurityPolicySpecAllowedCsiDriversL :: Lens_' V1beta1PodSecurityPolicySpec (Maybe [V1beta1AllowedCSIDriver])
v1beta1PodSecurityPolicySpecAllowedCsiDriversL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecAllowedCsiDrivers -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecAllowedCsiDrivers, ..} ) <$> f v1beta1PodSecurityPolicySpecAllowedCsiDrivers
{-# INLINE v1beta1PodSecurityPolicySpecAllowedCsiDriversL #-}

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

-- | 'v1beta1PodSecurityPolicySpecAllowedFlexVolumes' Lens
v1beta1PodSecurityPolicySpecAllowedFlexVolumesL :: Lens_' V1beta1PodSecurityPolicySpec (Maybe [V1beta1AllowedFlexVolume])
v1beta1PodSecurityPolicySpecAllowedFlexVolumesL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecAllowedFlexVolumes -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecAllowedFlexVolumes, ..} ) <$> f v1beta1PodSecurityPolicySpecAllowedFlexVolumes
{-# INLINE v1beta1PodSecurityPolicySpecAllowedFlexVolumesL #-}

-- | 'v1beta1PodSecurityPolicySpecAllowedHostPaths' Lens
v1beta1PodSecurityPolicySpecAllowedHostPathsL :: Lens_' V1beta1PodSecurityPolicySpec (Maybe [V1beta1AllowedHostPath])
v1beta1PodSecurityPolicySpecAllowedHostPathsL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecAllowedHostPaths -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecAllowedHostPaths, ..} ) <$> f v1beta1PodSecurityPolicySpecAllowedHostPaths
{-# INLINE v1beta1PodSecurityPolicySpecAllowedHostPathsL #-}

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

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

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

-- | 'v1beta1PodSecurityPolicySpecDefaultAllowPrivilegeEscalation' Lens
v1beta1PodSecurityPolicySpecDefaultAllowPrivilegeEscalationL :: Lens_' V1beta1PodSecurityPolicySpec (Maybe Bool)
v1beta1PodSecurityPolicySpecDefaultAllowPrivilegeEscalationL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecDefaultAllowPrivilegeEscalation -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecDefaultAllowPrivilegeEscalation, ..} ) <$> f v1beta1PodSecurityPolicySpecDefaultAllowPrivilegeEscalation
{-# INLINE v1beta1PodSecurityPolicySpecDefaultAllowPrivilegeEscalationL #-}

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

-- | 'v1beta1PodSecurityPolicySpecFsGroup' Lens
v1beta1PodSecurityPolicySpecFsGroupL :: Lens_' V1beta1PodSecurityPolicySpec (V1beta1FSGroupStrategyOptions)
v1beta1PodSecurityPolicySpecFsGroupL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecFsGroup -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecFsGroup, ..} ) <$> f v1beta1PodSecurityPolicySpecFsGroup
{-# INLINE v1beta1PodSecurityPolicySpecFsGroupL #-}

-- | 'v1beta1PodSecurityPolicySpecHostIpc' Lens
v1beta1PodSecurityPolicySpecHostIpcL :: Lens_' V1beta1PodSecurityPolicySpec (Maybe Bool)
v1beta1PodSecurityPolicySpecHostIpcL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecHostIpc -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecHostIpc, ..} ) <$> f v1beta1PodSecurityPolicySpecHostIpc
{-# INLINE v1beta1PodSecurityPolicySpecHostIpcL #-}

-- | 'v1beta1PodSecurityPolicySpecHostNetwork' Lens
v1beta1PodSecurityPolicySpecHostNetworkL :: Lens_' V1beta1PodSecurityPolicySpec (Maybe Bool)
v1beta1PodSecurityPolicySpecHostNetworkL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecHostNetwork -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecHostNetwork, ..} ) <$> f v1beta1PodSecurityPolicySpecHostNetwork
{-# INLINE v1beta1PodSecurityPolicySpecHostNetworkL #-}

-- | 'v1beta1PodSecurityPolicySpecHostPid' Lens
v1beta1PodSecurityPolicySpecHostPidL :: Lens_' V1beta1PodSecurityPolicySpec (Maybe Bool)
v1beta1PodSecurityPolicySpecHostPidL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecHostPid -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecHostPid, ..} ) <$> f v1beta1PodSecurityPolicySpecHostPid
{-# INLINE v1beta1PodSecurityPolicySpecHostPidL #-}

-- | 'v1beta1PodSecurityPolicySpecHostPorts' Lens
v1beta1PodSecurityPolicySpecHostPortsL :: Lens_' V1beta1PodSecurityPolicySpec (Maybe [V1beta1HostPortRange])
v1beta1PodSecurityPolicySpecHostPortsL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecHostPorts -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecHostPorts, ..} ) <$> f v1beta1PodSecurityPolicySpecHostPorts
{-# INLINE v1beta1PodSecurityPolicySpecHostPortsL #-}

-- | 'v1beta1PodSecurityPolicySpecPrivileged' Lens
v1beta1PodSecurityPolicySpecPrivilegedL :: Lens_' V1beta1PodSecurityPolicySpec (Maybe Bool)
v1beta1PodSecurityPolicySpecPrivilegedL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecPrivileged -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecPrivileged, ..} ) <$> f v1beta1PodSecurityPolicySpecPrivileged
{-# INLINE v1beta1PodSecurityPolicySpecPrivilegedL #-}

-- | 'v1beta1PodSecurityPolicySpecReadOnlyRootFilesystem' Lens
v1beta1PodSecurityPolicySpecReadOnlyRootFilesystemL :: Lens_' V1beta1PodSecurityPolicySpec (Maybe Bool)
v1beta1PodSecurityPolicySpecReadOnlyRootFilesystemL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecReadOnlyRootFilesystem -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecReadOnlyRootFilesystem, ..} ) <$> f v1beta1PodSecurityPolicySpecReadOnlyRootFilesystem
{-# INLINE v1beta1PodSecurityPolicySpecReadOnlyRootFilesystemL #-}

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

-- | 'v1beta1PodSecurityPolicySpecRunAsGroup' Lens
v1beta1PodSecurityPolicySpecRunAsGroupL :: Lens_' V1beta1PodSecurityPolicySpec (Maybe V1beta1RunAsGroupStrategyOptions)
v1beta1PodSecurityPolicySpecRunAsGroupL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecRunAsGroup -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecRunAsGroup, ..} ) <$> f v1beta1PodSecurityPolicySpecRunAsGroup
{-# INLINE v1beta1PodSecurityPolicySpecRunAsGroupL #-}

-- | 'v1beta1PodSecurityPolicySpecRunAsUser' Lens
v1beta1PodSecurityPolicySpecRunAsUserL :: Lens_' V1beta1PodSecurityPolicySpec (V1beta1RunAsUserStrategyOptions)
v1beta1PodSecurityPolicySpecRunAsUserL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecRunAsUser -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecRunAsUser, ..} ) <$> f v1beta1PodSecurityPolicySpecRunAsUser
{-# INLINE v1beta1PodSecurityPolicySpecRunAsUserL #-}

-- | 'v1beta1PodSecurityPolicySpecRuntimeClass' Lens
v1beta1PodSecurityPolicySpecRuntimeClassL :: Lens_' V1beta1PodSecurityPolicySpec (Maybe V1beta1RuntimeClassStrategyOptions)
v1beta1PodSecurityPolicySpecRuntimeClassL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecRuntimeClass -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecRuntimeClass, ..} ) <$> f v1beta1PodSecurityPolicySpecRuntimeClass
{-# INLINE v1beta1PodSecurityPolicySpecRuntimeClassL #-}

-- | 'v1beta1PodSecurityPolicySpecSeLinux' Lens
v1beta1PodSecurityPolicySpecSeLinuxL :: Lens_' V1beta1PodSecurityPolicySpec (V1beta1SELinuxStrategyOptions)
v1beta1PodSecurityPolicySpecSeLinuxL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecSeLinux -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecSeLinux, ..} ) <$> f v1beta1PodSecurityPolicySpecSeLinux
{-# INLINE v1beta1PodSecurityPolicySpecSeLinuxL #-}

-- | 'v1beta1PodSecurityPolicySpecSupplementalGroups' Lens
v1beta1PodSecurityPolicySpecSupplementalGroupsL :: Lens_' V1beta1PodSecurityPolicySpec (V1beta1SupplementalGroupsStrategyOptions)
v1beta1PodSecurityPolicySpecSupplementalGroupsL f V1beta1PodSecurityPolicySpec{..} = (\v1beta1PodSecurityPolicySpecSupplementalGroups -> V1beta1PodSecurityPolicySpec { v1beta1PodSecurityPolicySpecSupplementalGroups, ..} ) <$> f v1beta1PodSecurityPolicySpecSupplementalGroups
{-# INLINE v1beta1PodSecurityPolicySpecSupplementalGroupsL #-}

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



-- * V1beta1PolicyRulesWithSubjects

-- | 'v1beta1PolicyRulesWithSubjectsNonResourceRules' Lens
v1beta1PolicyRulesWithSubjectsNonResourceRulesL :: Lens_' V1beta1PolicyRulesWithSubjects (Maybe [V1beta1NonResourcePolicyRule])
v1beta1PolicyRulesWithSubjectsNonResourceRulesL f V1beta1PolicyRulesWithSubjects{..} = (\v1beta1PolicyRulesWithSubjectsNonResourceRules -> V1beta1PolicyRulesWithSubjects { v1beta1PolicyRulesWithSubjectsNonResourceRules, ..} ) <$> f v1beta1PolicyRulesWithSubjectsNonResourceRules
{-# INLINE v1beta1PolicyRulesWithSubjectsNonResourceRulesL #-}

-- | 'v1beta1PolicyRulesWithSubjectsResourceRules' Lens
v1beta1PolicyRulesWithSubjectsResourceRulesL :: Lens_' V1beta1PolicyRulesWithSubjects (Maybe [V1beta1ResourcePolicyRule])
v1beta1PolicyRulesWithSubjectsResourceRulesL f V1beta1PolicyRulesWithSubjects{..} = (\v1beta1PolicyRulesWithSubjectsResourceRules -> V1beta1PolicyRulesWithSubjects { v1beta1PolicyRulesWithSubjectsResourceRules, ..} ) <$> f v1beta1PolicyRulesWithSubjectsResourceRules
{-# INLINE v1beta1PolicyRulesWithSubjectsResourceRulesL #-}

-- | 'v1beta1PolicyRulesWithSubjectsSubjects' Lens
v1beta1PolicyRulesWithSubjectsSubjectsL :: Lens_' V1beta1PolicyRulesWithSubjects ([V1beta1Subject])
v1beta1PolicyRulesWithSubjectsSubjectsL f V1beta1PolicyRulesWithSubjects{..} = (\v1beta1PolicyRulesWithSubjectsSubjects -> V1beta1PolicyRulesWithSubjects { v1beta1PolicyRulesWithSubjectsSubjects, ..} ) <$> f v1beta1PolicyRulesWithSubjectsSubjects
{-# INLINE v1beta1PolicyRulesWithSubjectsSubjectsL #-}



-- * V1beta1PriorityLevelConfiguration

-- | 'v1beta1PriorityLevelConfigurationApiVersion' Lens
v1beta1PriorityLevelConfigurationApiVersionL :: Lens_' V1beta1PriorityLevelConfiguration (Maybe Text)
v1beta1PriorityLevelConfigurationApiVersionL f V1beta1PriorityLevelConfiguration{..} = (\v1beta1PriorityLevelConfigurationApiVersion -> V1beta1PriorityLevelConfiguration { v1beta1PriorityLevelConfigurationApiVersion, ..} ) <$> f v1beta1PriorityLevelConfigurationApiVersion
{-# INLINE v1beta1PriorityLevelConfigurationApiVersionL #-}

-- | 'v1beta1PriorityLevelConfigurationKind' Lens
v1beta1PriorityLevelConfigurationKindL :: Lens_' V1beta1PriorityLevelConfiguration (Maybe Text)
v1beta1PriorityLevelConfigurationKindL f V1beta1PriorityLevelConfiguration{..} = (\v1beta1PriorityLevelConfigurationKind -> V1beta1PriorityLevelConfiguration { v1beta1PriorityLevelConfigurationKind, ..} ) <$> f v1beta1PriorityLevelConfigurationKind
{-# INLINE v1beta1PriorityLevelConfigurationKindL #-}

-- | 'v1beta1PriorityLevelConfigurationMetadata' Lens
v1beta1PriorityLevelConfigurationMetadataL :: Lens_' V1beta1PriorityLevelConfiguration (Maybe V1ObjectMeta)
v1beta1PriorityLevelConfigurationMetadataL f V1beta1PriorityLevelConfiguration{..} = (\v1beta1PriorityLevelConfigurationMetadata -> V1beta1PriorityLevelConfiguration { v1beta1PriorityLevelConfigurationMetadata, ..} ) <$> f v1beta1PriorityLevelConfigurationMetadata
{-# INLINE v1beta1PriorityLevelConfigurationMetadataL #-}

-- | 'v1beta1PriorityLevelConfigurationSpec' Lens
v1beta1PriorityLevelConfigurationSpecL :: Lens_' V1beta1PriorityLevelConfiguration (Maybe V1beta1PriorityLevelConfigurationSpec)
v1beta1PriorityLevelConfigurationSpecL f V1beta1PriorityLevelConfiguration{..} = (\v1beta1PriorityLevelConfigurationSpec -> V1beta1PriorityLevelConfiguration { v1beta1PriorityLevelConfigurationSpec, ..} ) <$> f v1beta1PriorityLevelConfigurationSpec
{-# INLINE v1beta1PriorityLevelConfigurationSpecL #-}

-- | 'v1beta1PriorityLevelConfigurationStatus' Lens
v1beta1PriorityLevelConfigurationStatusL :: Lens_' V1beta1PriorityLevelConfiguration (Maybe V1beta1PriorityLevelConfigurationStatus)
v1beta1PriorityLevelConfigurationStatusL f V1beta1PriorityLevelConfiguration{..} = (\v1beta1PriorityLevelConfigurationStatus -> V1beta1PriorityLevelConfiguration { v1beta1PriorityLevelConfigurationStatus, ..} ) <$> f v1beta1PriorityLevelConfigurationStatus
{-# INLINE v1beta1PriorityLevelConfigurationStatusL #-}



-- * V1beta1PriorityLevelConfigurationCondition

-- | 'v1beta1PriorityLevelConfigurationConditionLastTransitionTime' Lens
v1beta1PriorityLevelConfigurationConditionLastTransitionTimeL :: Lens_' V1beta1PriorityLevelConfigurationCondition (Maybe DateTime)
v1beta1PriorityLevelConfigurationConditionLastTransitionTimeL f V1beta1PriorityLevelConfigurationCondition{..} = (\v1beta1PriorityLevelConfigurationConditionLastTransitionTime -> V1beta1PriorityLevelConfigurationCondition { v1beta1PriorityLevelConfigurationConditionLastTransitionTime, ..} ) <$> f v1beta1PriorityLevelConfigurationConditionLastTransitionTime
{-# INLINE v1beta1PriorityLevelConfigurationConditionLastTransitionTimeL #-}

-- | 'v1beta1PriorityLevelConfigurationConditionMessage' Lens
v1beta1PriorityLevelConfigurationConditionMessageL :: Lens_' V1beta1PriorityLevelConfigurationCondition (Maybe Text)
v1beta1PriorityLevelConfigurationConditionMessageL f V1beta1PriorityLevelConfigurationCondition{..} = (\v1beta1PriorityLevelConfigurationConditionMessage -> V1beta1PriorityLevelConfigurationCondition { v1beta1PriorityLevelConfigurationConditionMessage, ..} ) <$> f v1beta1PriorityLevelConfigurationConditionMessage
{-# INLINE v1beta1PriorityLevelConfigurationConditionMessageL #-}

-- | 'v1beta1PriorityLevelConfigurationConditionReason' Lens
v1beta1PriorityLevelConfigurationConditionReasonL :: Lens_' V1beta1PriorityLevelConfigurationCondition (Maybe Text)
v1beta1PriorityLevelConfigurationConditionReasonL f V1beta1PriorityLevelConfigurationCondition{..} = (\v1beta1PriorityLevelConfigurationConditionReason -> V1beta1PriorityLevelConfigurationCondition { v1beta1PriorityLevelConfigurationConditionReason, ..} ) <$> f v1beta1PriorityLevelConfigurationConditionReason
{-# INLINE v1beta1PriorityLevelConfigurationConditionReasonL #-}

-- | 'v1beta1PriorityLevelConfigurationConditionStatus' Lens
v1beta1PriorityLevelConfigurationConditionStatusL :: Lens_' V1beta1PriorityLevelConfigurationCondition (Maybe Text)
v1beta1PriorityLevelConfigurationConditionStatusL f V1beta1PriorityLevelConfigurationCondition{..} = (\v1beta1PriorityLevelConfigurationConditionStatus -> V1beta1PriorityLevelConfigurationCondition { v1beta1PriorityLevelConfigurationConditionStatus, ..} ) <$> f v1beta1PriorityLevelConfigurationConditionStatus
{-# INLINE v1beta1PriorityLevelConfigurationConditionStatusL #-}

-- | 'v1beta1PriorityLevelConfigurationConditionType' Lens
v1beta1PriorityLevelConfigurationConditionTypeL :: Lens_' V1beta1PriorityLevelConfigurationCondition (Maybe Text)
v1beta1PriorityLevelConfigurationConditionTypeL f V1beta1PriorityLevelConfigurationCondition{..} = (\v1beta1PriorityLevelConfigurationConditionType -> V1beta1PriorityLevelConfigurationCondition { v1beta1PriorityLevelConfigurationConditionType, ..} ) <$> f v1beta1PriorityLevelConfigurationConditionType
{-# INLINE v1beta1PriorityLevelConfigurationConditionTypeL #-}



-- * V1beta1PriorityLevelConfigurationList

-- | 'v1beta1PriorityLevelConfigurationListApiVersion' Lens
v1beta1PriorityLevelConfigurationListApiVersionL :: Lens_' V1beta1PriorityLevelConfigurationList (Maybe Text)
v1beta1PriorityLevelConfigurationListApiVersionL f V1beta1PriorityLevelConfigurationList{..} = (\v1beta1PriorityLevelConfigurationListApiVersion -> V1beta1PriorityLevelConfigurationList { v1beta1PriorityLevelConfigurationListApiVersion, ..} ) <$> f v1beta1PriorityLevelConfigurationListApiVersion
{-# INLINE v1beta1PriorityLevelConfigurationListApiVersionL #-}

-- | 'v1beta1PriorityLevelConfigurationListItems' Lens
v1beta1PriorityLevelConfigurationListItemsL :: Lens_' V1beta1PriorityLevelConfigurationList ([V1beta1PriorityLevelConfiguration])
v1beta1PriorityLevelConfigurationListItemsL f V1beta1PriorityLevelConfigurationList{..} = (\v1beta1PriorityLevelConfigurationListItems -> V1beta1PriorityLevelConfigurationList { v1beta1PriorityLevelConfigurationListItems, ..} ) <$> f v1beta1PriorityLevelConfigurationListItems
{-# INLINE v1beta1PriorityLevelConfigurationListItemsL #-}

-- | 'v1beta1PriorityLevelConfigurationListKind' Lens
v1beta1PriorityLevelConfigurationListKindL :: Lens_' V1beta1PriorityLevelConfigurationList (Maybe Text)
v1beta1PriorityLevelConfigurationListKindL f V1beta1PriorityLevelConfigurationList{..} = (\v1beta1PriorityLevelConfigurationListKind -> V1beta1PriorityLevelConfigurationList { v1beta1PriorityLevelConfigurationListKind, ..} ) <$> f v1beta1PriorityLevelConfigurationListKind
{-# INLINE v1beta1PriorityLevelConfigurationListKindL #-}

-- | 'v1beta1PriorityLevelConfigurationListMetadata' Lens
v1beta1PriorityLevelConfigurationListMetadataL :: Lens_' V1beta1PriorityLevelConfigurationList (Maybe V1ListMeta)
v1beta1PriorityLevelConfigurationListMetadataL f V1beta1PriorityLevelConfigurationList{..} = (\v1beta1PriorityLevelConfigurationListMetadata -> V1beta1PriorityLevelConfigurationList { v1beta1PriorityLevelConfigurationListMetadata, ..} ) <$> f v1beta1PriorityLevelConfigurationListMetadata
{-# INLINE v1beta1PriorityLevelConfigurationListMetadataL #-}



-- * V1beta1PriorityLevelConfigurationReference

-- | 'v1beta1PriorityLevelConfigurationReferenceName' Lens
v1beta1PriorityLevelConfigurationReferenceNameL :: Lens_' V1beta1PriorityLevelConfigurationReference (Text)
v1beta1PriorityLevelConfigurationReferenceNameL f V1beta1PriorityLevelConfigurationReference{..} = (\v1beta1PriorityLevelConfigurationReferenceName -> V1beta1PriorityLevelConfigurationReference { v1beta1PriorityLevelConfigurationReferenceName, ..} ) <$> f v1beta1PriorityLevelConfigurationReferenceName
{-# INLINE v1beta1PriorityLevelConfigurationReferenceNameL #-}



-- * V1beta1PriorityLevelConfigurationSpec

-- | 'v1beta1PriorityLevelConfigurationSpecLimited' Lens
v1beta1PriorityLevelConfigurationSpecLimitedL :: Lens_' V1beta1PriorityLevelConfigurationSpec (Maybe V1beta1LimitedPriorityLevelConfiguration)
v1beta1PriorityLevelConfigurationSpecLimitedL f V1beta1PriorityLevelConfigurationSpec{..} = (\v1beta1PriorityLevelConfigurationSpecLimited -> V1beta1PriorityLevelConfigurationSpec { v1beta1PriorityLevelConfigurationSpecLimited, ..} ) <$> f v1beta1PriorityLevelConfigurationSpecLimited
{-# INLINE v1beta1PriorityLevelConfigurationSpecLimitedL #-}

-- | 'v1beta1PriorityLevelConfigurationSpecType' Lens
v1beta1PriorityLevelConfigurationSpecTypeL :: Lens_' V1beta1PriorityLevelConfigurationSpec (Text)
v1beta1PriorityLevelConfigurationSpecTypeL f V1beta1PriorityLevelConfigurationSpec{..} = (\v1beta1PriorityLevelConfigurationSpecType -> V1beta1PriorityLevelConfigurationSpec { v1beta1PriorityLevelConfigurationSpecType, ..} ) <$> f v1beta1PriorityLevelConfigurationSpecType
{-# INLINE v1beta1PriorityLevelConfigurationSpecTypeL #-}



-- * V1beta1PriorityLevelConfigurationStatus

-- | 'v1beta1PriorityLevelConfigurationStatusConditions' Lens
v1beta1PriorityLevelConfigurationStatusConditionsL :: Lens_' V1beta1PriorityLevelConfigurationStatus (Maybe [V1beta1PriorityLevelConfigurationCondition])
v1beta1PriorityLevelConfigurationStatusConditionsL f V1beta1PriorityLevelConfigurationStatus{..} = (\v1beta1PriorityLevelConfigurationStatusConditions -> V1beta1PriorityLevelConfigurationStatus { v1beta1PriorityLevelConfigurationStatusConditions, ..} ) <$> f v1beta1PriorityLevelConfigurationStatusConditions
{-# INLINE v1beta1PriorityLevelConfigurationStatusConditionsL #-}



-- * V1beta1QueuingConfiguration

-- | 'v1beta1QueuingConfigurationHandSize' Lens
v1beta1QueuingConfigurationHandSizeL :: Lens_' V1beta1QueuingConfiguration (Maybe Int)
v1beta1QueuingConfigurationHandSizeL f V1beta1QueuingConfiguration{..} = (\v1beta1QueuingConfigurationHandSize -> V1beta1QueuingConfiguration { v1beta1QueuingConfigurationHandSize, ..} ) <$> f v1beta1QueuingConfigurationHandSize
{-# INLINE v1beta1QueuingConfigurationHandSizeL #-}

-- | 'v1beta1QueuingConfigurationQueueLengthLimit' Lens
v1beta1QueuingConfigurationQueueLengthLimitL :: Lens_' V1beta1QueuingConfiguration (Maybe Int)
v1beta1QueuingConfigurationQueueLengthLimitL f V1beta1QueuingConfiguration{..} = (\v1beta1QueuingConfigurationQueueLengthLimit -> V1beta1QueuingConfiguration { v1beta1QueuingConfigurationQueueLengthLimit, ..} ) <$> f v1beta1QueuingConfigurationQueueLengthLimit
{-# INLINE v1beta1QueuingConfigurationQueueLengthLimitL #-}

-- | 'v1beta1QueuingConfigurationQueues' Lens
v1beta1QueuingConfigurationQueuesL :: Lens_' V1beta1QueuingConfiguration (Maybe Int)
v1beta1QueuingConfigurationQueuesL f V1beta1QueuingConfiguration{..} = (\v1beta1QueuingConfigurationQueues -> V1beta1QueuingConfiguration { v1beta1QueuingConfigurationQueues, ..} ) <$> f v1beta1QueuingConfigurationQueues
{-# INLINE v1beta1QueuingConfigurationQueuesL #-}



-- * V1beta1ResourcePolicyRule

-- | 'v1beta1ResourcePolicyRuleApiGroups' Lens
v1beta1ResourcePolicyRuleApiGroupsL :: Lens_' V1beta1ResourcePolicyRule ([Text])
v1beta1ResourcePolicyRuleApiGroupsL f V1beta1ResourcePolicyRule{..} = (\v1beta1ResourcePolicyRuleApiGroups -> V1beta1ResourcePolicyRule { v1beta1ResourcePolicyRuleApiGroups, ..} ) <$> f v1beta1ResourcePolicyRuleApiGroups
{-# INLINE v1beta1ResourcePolicyRuleApiGroupsL #-}

-- | 'v1beta1ResourcePolicyRuleClusterScope' Lens
v1beta1ResourcePolicyRuleClusterScopeL :: Lens_' V1beta1ResourcePolicyRule (Maybe Bool)
v1beta1ResourcePolicyRuleClusterScopeL f V1beta1ResourcePolicyRule{..} = (\v1beta1ResourcePolicyRuleClusterScope -> V1beta1ResourcePolicyRule { v1beta1ResourcePolicyRuleClusterScope, ..} ) <$> f v1beta1ResourcePolicyRuleClusterScope
{-# INLINE v1beta1ResourcePolicyRuleClusterScopeL #-}

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

-- | 'v1beta1ResourcePolicyRuleResources' Lens
v1beta1ResourcePolicyRuleResourcesL :: Lens_' V1beta1ResourcePolicyRule ([Text])
v1beta1ResourcePolicyRuleResourcesL f V1beta1ResourcePolicyRule{..} = (\v1beta1ResourcePolicyRuleResources -> V1beta1ResourcePolicyRule { v1beta1ResourcePolicyRuleResources, ..} ) <$> f v1beta1ResourcePolicyRuleResources
{-# INLINE v1beta1ResourcePolicyRuleResourcesL #-}

-- | 'v1beta1ResourcePolicyRuleVerbs' Lens
v1beta1ResourcePolicyRuleVerbsL :: Lens_' V1beta1ResourcePolicyRule ([Text])
v1beta1ResourcePolicyRuleVerbsL f V1beta1ResourcePolicyRule{..} = (\v1beta1ResourcePolicyRuleVerbs -> V1beta1ResourcePolicyRule { v1beta1ResourcePolicyRuleVerbs, ..} ) <$> f v1beta1ResourcePolicyRuleVerbs
{-# INLINE v1beta1ResourcePolicyRuleVerbsL #-}



-- * V1beta1RunAsGroupStrategyOptions

-- | 'v1beta1RunAsGroupStrategyOptionsRanges' Lens
v1beta1RunAsGroupStrategyOptionsRangesL :: Lens_' V1beta1RunAsGroupStrategyOptions (Maybe [V1beta1IDRange])
v1beta1RunAsGroupStrategyOptionsRangesL f V1beta1RunAsGroupStrategyOptions{..} = (\v1beta1RunAsGroupStrategyOptionsRanges -> V1beta1RunAsGroupStrategyOptions { v1beta1RunAsGroupStrategyOptionsRanges, ..} ) <$> f v1beta1RunAsGroupStrategyOptionsRanges
{-# INLINE v1beta1RunAsGroupStrategyOptionsRangesL #-}

-- | 'v1beta1RunAsGroupStrategyOptionsRule' Lens
v1beta1RunAsGroupStrategyOptionsRuleL :: Lens_' V1beta1RunAsGroupStrategyOptions (Text)
v1beta1RunAsGroupStrategyOptionsRuleL f V1beta1RunAsGroupStrategyOptions{..} = (\v1beta1RunAsGroupStrategyOptionsRule -> V1beta1RunAsGroupStrategyOptions { v1beta1RunAsGroupStrategyOptionsRule, ..} ) <$> f v1beta1RunAsGroupStrategyOptionsRule
{-# INLINE v1beta1RunAsGroupStrategyOptionsRuleL #-}



-- * V1beta1RunAsUserStrategyOptions

-- | 'v1beta1RunAsUserStrategyOptionsRanges' Lens
v1beta1RunAsUserStrategyOptionsRangesL :: Lens_' V1beta1RunAsUserStrategyOptions (Maybe [V1beta1IDRange])
v1beta1RunAsUserStrategyOptionsRangesL f V1beta1RunAsUserStrategyOptions{..} = (\v1beta1RunAsUserStrategyOptionsRanges -> V1beta1RunAsUserStrategyOptions { v1beta1RunAsUserStrategyOptionsRanges, ..} ) <$> f v1beta1RunAsUserStrategyOptionsRanges
{-# INLINE v1beta1RunAsUserStrategyOptionsRangesL #-}

-- | 'v1beta1RunAsUserStrategyOptionsRule' Lens
v1beta1RunAsUserStrategyOptionsRuleL :: Lens_' V1beta1RunAsUserStrategyOptions (Text)
v1beta1RunAsUserStrategyOptionsRuleL f V1beta1RunAsUserStrategyOptions{..} = (\v1beta1RunAsUserStrategyOptionsRule -> V1beta1RunAsUserStrategyOptions { v1beta1RunAsUserStrategyOptionsRule, ..} ) <$> f v1beta1RunAsUserStrategyOptionsRule
{-# INLINE v1beta1RunAsUserStrategyOptionsRuleL #-}



-- * V1beta1RuntimeClass

-- | 'v1beta1RuntimeClassApiVersion' Lens
v1beta1RuntimeClassApiVersionL :: Lens_' V1beta1RuntimeClass (Maybe Text)
v1beta1RuntimeClassApiVersionL f V1beta1RuntimeClass{..} = (\v1beta1RuntimeClassApiVersion -> V1beta1RuntimeClass { v1beta1RuntimeClassApiVersion, ..} ) <$> f v1beta1RuntimeClassApiVersion
{-# INLINE v1beta1RuntimeClassApiVersionL #-}

-- | 'v1beta1RuntimeClassHandler' Lens
v1beta1RuntimeClassHandlerL :: Lens_' V1beta1RuntimeClass (Text)
v1beta1RuntimeClassHandlerL f V1beta1RuntimeClass{..} = (\v1beta1RuntimeClassHandler -> V1beta1RuntimeClass { v1beta1RuntimeClassHandler, ..} ) <$> f v1beta1RuntimeClassHandler
{-# INLINE v1beta1RuntimeClassHandlerL #-}

-- | 'v1beta1RuntimeClassKind' Lens
v1beta1RuntimeClassKindL :: Lens_' V1beta1RuntimeClass (Maybe Text)
v1beta1RuntimeClassKindL f V1beta1RuntimeClass{..} = (\v1beta1RuntimeClassKind -> V1beta1RuntimeClass { v1beta1RuntimeClassKind, ..} ) <$> f v1beta1RuntimeClassKind
{-# INLINE v1beta1RuntimeClassKindL #-}

-- | 'v1beta1RuntimeClassMetadata' Lens
v1beta1RuntimeClassMetadataL :: Lens_' V1beta1RuntimeClass (Maybe V1ObjectMeta)
v1beta1RuntimeClassMetadataL f V1beta1RuntimeClass{..} = (\v1beta1RuntimeClassMetadata -> V1beta1RuntimeClass { v1beta1RuntimeClassMetadata, ..} ) <$> f v1beta1RuntimeClassMetadata
{-# INLINE v1beta1RuntimeClassMetadataL #-}

-- | 'v1beta1RuntimeClassOverhead' Lens
v1beta1RuntimeClassOverheadL :: Lens_' V1beta1RuntimeClass (Maybe V1beta1Overhead)
v1beta1RuntimeClassOverheadL f V1beta1RuntimeClass{..} = (\v1beta1RuntimeClassOverhead -> V1beta1RuntimeClass { v1beta1RuntimeClassOverhead, ..} ) <$> f v1beta1RuntimeClassOverhead
{-# INLINE v1beta1RuntimeClassOverheadL #-}

-- | 'v1beta1RuntimeClassScheduling' Lens
v1beta1RuntimeClassSchedulingL :: Lens_' V1beta1RuntimeClass (Maybe V1beta1Scheduling)
v1beta1RuntimeClassSchedulingL f V1beta1RuntimeClass{..} = (\v1beta1RuntimeClassScheduling -> V1beta1RuntimeClass { v1beta1RuntimeClassScheduling, ..} ) <$> f v1beta1RuntimeClassScheduling
{-# INLINE v1beta1RuntimeClassSchedulingL #-}



-- * V1beta1RuntimeClassList

-- | 'v1beta1RuntimeClassListApiVersion' Lens
v1beta1RuntimeClassListApiVersionL :: Lens_' V1beta1RuntimeClassList (Maybe Text)
v1beta1RuntimeClassListApiVersionL f V1beta1RuntimeClassList{..} = (\v1beta1RuntimeClassListApiVersion -> V1beta1RuntimeClassList { v1beta1RuntimeClassListApiVersion, ..} ) <$> f v1beta1RuntimeClassListApiVersion
{-# INLINE v1beta1RuntimeClassListApiVersionL #-}

-- | 'v1beta1RuntimeClassListItems' Lens
v1beta1RuntimeClassListItemsL :: Lens_' V1beta1RuntimeClassList ([V1beta1RuntimeClass])
v1beta1RuntimeClassListItemsL f V1beta1RuntimeClassList{..} = (\v1beta1RuntimeClassListItems -> V1beta1RuntimeClassList { v1beta1RuntimeClassListItems, ..} ) <$> f v1beta1RuntimeClassListItems
{-# INLINE v1beta1RuntimeClassListItemsL #-}

-- | 'v1beta1RuntimeClassListKind' Lens
v1beta1RuntimeClassListKindL :: Lens_' V1beta1RuntimeClassList (Maybe Text)
v1beta1RuntimeClassListKindL f V1beta1RuntimeClassList{..} = (\v1beta1RuntimeClassListKind -> V1beta1RuntimeClassList { v1beta1RuntimeClassListKind, ..} ) <$> f v1beta1RuntimeClassListKind
{-# INLINE v1beta1RuntimeClassListKindL #-}

-- | 'v1beta1RuntimeClassListMetadata' Lens
v1beta1RuntimeClassListMetadataL :: Lens_' V1beta1RuntimeClassList (Maybe V1ListMeta)
v1beta1RuntimeClassListMetadataL f V1beta1RuntimeClassList{..} = (\v1beta1RuntimeClassListMetadata -> V1beta1RuntimeClassList { v1beta1RuntimeClassListMetadata, ..} ) <$> f v1beta1RuntimeClassListMetadata
{-# INLINE v1beta1RuntimeClassListMetadataL #-}



-- * V1beta1RuntimeClassStrategyOptions

-- | 'v1beta1RuntimeClassStrategyOptionsAllowedRuntimeClassNames' Lens
v1beta1RuntimeClassStrategyOptionsAllowedRuntimeClassNamesL :: Lens_' V1beta1RuntimeClassStrategyOptions ([Text])
v1beta1RuntimeClassStrategyOptionsAllowedRuntimeClassNamesL f V1beta1RuntimeClassStrategyOptions{..} = (\v1beta1RuntimeClassStrategyOptionsAllowedRuntimeClassNames -> V1beta1RuntimeClassStrategyOptions { v1beta1RuntimeClassStrategyOptionsAllowedRuntimeClassNames, ..} ) <$> f v1beta1RuntimeClassStrategyOptionsAllowedRuntimeClassNames
{-# INLINE v1beta1RuntimeClassStrategyOptionsAllowedRuntimeClassNamesL #-}

-- | 'v1beta1RuntimeClassStrategyOptionsDefaultRuntimeClassName' Lens
v1beta1RuntimeClassStrategyOptionsDefaultRuntimeClassNameL :: Lens_' V1beta1RuntimeClassStrategyOptions (Maybe Text)
v1beta1RuntimeClassStrategyOptionsDefaultRuntimeClassNameL f V1beta1RuntimeClassStrategyOptions{..} = (\v1beta1RuntimeClassStrategyOptionsDefaultRuntimeClassName -> V1beta1RuntimeClassStrategyOptions { v1beta1RuntimeClassStrategyOptionsDefaultRuntimeClassName, ..} ) <$> f v1beta1RuntimeClassStrategyOptionsDefaultRuntimeClassName
{-# INLINE v1beta1RuntimeClassStrategyOptionsDefaultRuntimeClassNameL #-}



-- * V1beta1SELinuxStrategyOptions

-- | 'v1beta1SELinuxStrategyOptionsRule' Lens
v1beta1SELinuxStrategyOptionsRuleL :: Lens_' V1beta1SELinuxStrategyOptions (Text)
v1beta1SELinuxStrategyOptionsRuleL f V1beta1SELinuxStrategyOptions{..} = (\v1beta1SELinuxStrategyOptionsRule -> V1beta1SELinuxStrategyOptions { v1beta1SELinuxStrategyOptionsRule, ..} ) <$> f v1beta1SELinuxStrategyOptionsRule
{-# INLINE v1beta1SELinuxStrategyOptionsRuleL #-}

-- | 'v1beta1SELinuxStrategyOptionsSeLinuxOptions' Lens
v1beta1SELinuxStrategyOptionsSeLinuxOptionsL :: Lens_' V1beta1SELinuxStrategyOptions (Maybe V1SELinuxOptions)
v1beta1SELinuxStrategyOptionsSeLinuxOptionsL f V1beta1SELinuxStrategyOptions{..} = (\v1beta1SELinuxStrategyOptionsSeLinuxOptions -> V1beta1SELinuxStrategyOptions { v1beta1SELinuxStrategyOptionsSeLinuxOptions, ..} ) <$> f v1beta1SELinuxStrategyOptionsSeLinuxOptions
{-# INLINE v1beta1SELinuxStrategyOptionsSeLinuxOptionsL #-}



-- * V1beta1Scheduling

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

-- | 'v1beta1SchedulingTolerations' Lens
v1beta1SchedulingTolerationsL :: Lens_' V1beta1Scheduling (Maybe [V1Toleration])
v1beta1SchedulingTolerationsL f V1beta1Scheduling{..} = (\v1beta1SchedulingTolerations -> V1beta1Scheduling { v1beta1SchedulingTolerations, ..} ) <$> f v1beta1SchedulingTolerations
{-# INLINE v1beta1SchedulingTolerationsL #-}



-- * V1beta1ServiceAccountSubject

-- | 'v1beta1ServiceAccountSubjectName' Lens
v1beta1ServiceAccountSubjectNameL :: Lens_' V1beta1ServiceAccountSubject (Text)
v1beta1ServiceAccountSubjectNameL f V1beta1ServiceAccountSubject{..} = (\v1beta1ServiceAccountSubjectName -> V1beta1ServiceAccountSubject { v1beta1ServiceAccountSubjectName, ..} ) <$> f v1beta1ServiceAccountSubjectName
{-# INLINE v1beta1ServiceAccountSubjectNameL #-}

-- | 'v1beta1ServiceAccountSubjectNamespace' Lens
v1beta1ServiceAccountSubjectNamespaceL :: Lens_' V1beta1ServiceAccountSubject (Text)
v1beta1ServiceAccountSubjectNamespaceL f V1beta1ServiceAccountSubject{..} = (\v1beta1ServiceAccountSubjectNamespace -> V1beta1ServiceAccountSubject { v1beta1ServiceAccountSubjectNamespace, ..} ) <$> f v1beta1ServiceAccountSubjectNamespace
{-# INLINE v1beta1ServiceAccountSubjectNamespaceL #-}



-- * V1beta1Subject

-- | 'v1beta1SubjectGroup' Lens
v1beta1SubjectGroupL :: Lens_' V1beta1Subject (Maybe V1beta1GroupSubject)
v1beta1SubjectGroupL f V1beta1Subject{..} = (\v1beta1SubjectGroup -> V1beta1Subject { v1beta1SubjectGroup, ..} ) <$> f v1beta1SubjectGroup
{-# INLINE v1beta1SubjectGroupL #-}

-- | 'v1beta1SubjectKind' Lens
v1beta1SubjectKindL :: Lens_' V1beta1Subject (Text)
v1beta1SubjectKindL f V1beta1Subject{..} = (\v1beta1SubjectKind -> V1beta1Subject { v1beta1SubjectKind, ..} ) <$> f v1beta1SubjectKind
{-# INLINE v1beta1SubjectKindL #-}

-- | 'v1beta1SubjectServiceAccount' Lens
v1beta1SubjectServiceAccountL :: Lens_' V1beta1Subject (Maybe V1beta1ServiceAccountSubject)
v1beta1SubjectServiceAccountL f V1beta1Subject{..} = (\v1beta1SubjectServiceAccount -> V1beta1Subject { v1beta1SubjectServiceAccount, ..} ) <$> f v1beta1SubjectServiceAccount
{-# INLINE v1beta1SubjectServiceAccountL #-}

-- | 'v1beta1SubjectUser' Lens
v1beta1SubjectUserL :: Lens_' V1beta1Subject (Maybe V1beta1UserSubject)
v1beta1SubjectUserL f V1beta1Subject{..} = (\v1beta1SubjectUser -> V1beta1Subject { v1beta1SubjectUser, ..} ) <$> f v1beta1SubjectUser
{-# INLINE v1beta1SubjectUserL #-}



-- * V1beta1SupplementalGroupsStrategyOptions

-- | 'v1beta1SupplementalGroupsStrategyOptionsRanges' Lens
v1beta1SupplementalGroupsStrategyOptionsRangesL :: Lens_' V1beta1SupplementalGroupsStrategyOptions (Maybe [V1beta1IDRange])
v1beta1SupplementalGroupsStrategyOptionsRangesL f V1beta1SupplementalGroupsStrategyOptions{..} = (\v1beta1SupplementalGroupsStrategyOptionsRanges -> V1beta1SupplementalGroupsStrategyOptions { v1beta1SupplementalGroupsStrategyOptionsRanges, ..} ) <$> f v1beta1SupplementalGroupsStrategyOptionsRanges
{-# INLINE v1beta1SupplementalGroupsStrategyOptionsRangesL #-}

-- | 'v1beta1SupplementalGroupsStrategyOptionsRule' Lens
v1beta1SupplementalGroupsStrategyOptionsRuleL :: Lens_' V1beta1SupplementalGroupsStrategyOptions (Maybe Text)
v1beta1SupplementalGroupsStrategyOptionsRuleL f V1beta1SupplementalGroupsStrategyOptions{..} = (\v1beta1SupplementalGroupsStrategyOptionsRule -> V1beta1SupplementalGroupsStrategyOptions { v1beta1SupplementalGroupsStrategyOptionsRule, ..} ) <$> f v1beta1SupplementalGroupsStrategyOptionsRule
{-# INLINE v1beta1SupplementalGroupsStrategyOptionsRuleL #-}



-- * V1beta1UserSubject

-- | 'v1beta1UserSubjectName' Lens
v1beta1UserSubjectNameL :: Lens_' V1beta1UserSubject (Text)
v1beta1UserSubjectNameL f V1beta1UserSubject{..} = (\v1beta1UserSubjectName -> V1beta1UserSubject { v1beta1UserSubjectName, ..} ) <$> f v1beta1UserSubjectName
{-# INLINE v1beta1UserSubjectNameL #-}



-- * V1beta2FlowDistinguisherMethod

-- | 'v1beta2FlowDistinguisherMethodType' Lens
v1beta2FlowDistinguisherMethodTypeL :: Lens_' V1beta2FlowDistinguisherMethod (Text)
v1beta2FlowDistinguisherMethodTypeL f V1beta2FlowDistinguisherMethod{..} = (\v1beta2FlowDistinguisherMethodType -> V1beta2FlowDistinguisherMethod { v1beta2FlowDistinguisherMethodType, ..} ) <$> f v1beta2FlowDistinguisherMethodType
{-# INLINE v1beta2FlowDistinguisherMethodTypeL #-}



-- * V1beta2FlowSchema

-- | 'v1beta2FlowSchemaApiVersion' Lens
v1beta2FlowSchemaApiVersionL :: Lens_' V1beta2FlowSchema (Maybe Text)
v1beta2FlowSchemaApiVersionL f V1beta2FlowSchema{..} = (\v1beta2FlowSchemaApiVersion -> V1beta2FlowSchema { v1beta2FlowSchemaApiVersion, ..} ) <$> f v1beta2FlowSchemaApiVersion
{-# INLINE v1beta2FlowSchemaApiVersionL #-}

-- | 'v1beta2FlowSchemaKind' Lens
v1beta2FlowSchemaKindL :: Lens_' V1beta2FlowSchema (Maybe Text)
v1beta2FlowSchemaKindL f V1beta2FlowSchema{..} = (\v1beta2FlowSchemaKind -> V1beta2FlowSchema { v1beta2FlowSchemaKind, ..} ) <$> f v1beta2FlowSchemaKind
{-# INLINE v1beta2FlowSchemaKindL #-}

-- | 'v1beta2FlowSchemaMetadata' Lens
v1beta2FlowSchemaMetadataL :: Lens_' V1beta2FlowSchema (Maybe V1ObjectMeta)
v1beta2FlowSchemaMetadataL f V1beta2FlowSchema{..} = (\v1beta2FlowSchemaMetadata -> V1beta2FlowSchema { v1beta2FlowSchemaMetadata, ..} ) <$> f v1beta2FlowSchemaMetadata
{-# INLINE v1beta2FlowSchemaMetadataL #-}

-- | 'v1beta2FlowSchemaSpec' Lens
v1beta2FlowSchemaSpecL :: Lens_' V1beta2FlowSchema (Maybe V1beta2FlowSchemaSpec)
v1beta2FlowSchemaSpecL f V1beta2FlowSchema{..} = (\v1beta2FlowSchemaSpec -> V1beta2FlowSchema { v1beta2FlowSchemaSpec, ..} ) <$> f v1beta2FlowSchemaSpec
{-# INLINE v1beta2FlowSchemaSpecL #-}

-- | 'v1beta2FlowSchemaStatus' Lens
v1beta2FlowSchemaStatusL :: Lens_' V1beta2FlowSchema (Maybe V1beta2FlowSchemaStatus)
v1beta2FlowSchemaStatusL f V1beta2FlowSchema{..} = (\v1beta2FlowSchemaStatus -> V1beta2FlowSchema { v1beta2FlowSchemaStatus, ..} ) <$> f v1beta2FlowSchemaStatus
{-# INLINE v1beta2FlowSchemaStatusL #-}



-- * V1beta2FlowSchemaCondition

-- | 'v1beta2FlowSchemaConditionLastTransitionTime' Lens
v1beta2FlowSchemaConditionLastTransitionTimeL :: Lens_' V1beta2FlowSchemaCondition (Maybe DateTime)
v1beta2FlowSchemaConditionLastTransitionTimeL f V1beta2FlowSchemaCondition{..} = (\v1beta2FlowSchemaConditionLastTransitionTime -> V1beta2FlowSchemaCondition { v1beta2FlowSchemaConditionLastTransitionTime, ..} ) <$> f v1beta2FlowSchemaConditionLastTransitionTime
{-# INLINE v1beta2FlowSchemaConditionLastTransitionTimeL #-}

-- | 'v1beta2FlowSchemaConditionMessage' Lens
v1beta2FlowSchemaConditionMessageL :: Lens_' V1beta2FlowSchemaCondition (Maybe Text)
v1beta2FlowSchemaConditionMessageL f V1beta2FlowSchemaCondition{..} = (\v1beta2FlowSchemaConditionMessage -> V1beta2FlowSchemaCondition { v1beta2FlowSchemaConditionMessage, ..} ) <$> f v1beta2FlowSchemaConditionMessage
{-# INLINE v1beta2FlowSchemaConditionMessageL #-}

-- | 'v1beta2FlowSchemaConditionReason' Lens
v1beta2FlowSchemaConditionReasonL :: Lens_' V1beta2FlowSchemaCondition (Maybe Text)
v1beta2FlowSchemaConditionReasonL f V1beta2FlowSchemaCondition{..} = (\v1beta2FlowSchemaConditionReason -> V1beta2FlowSchemaCondition { v1beta2FlowSchemaConditionReason, ..} ) <$> f v1beta2FlowSchemaConditionReason
{-# INLINE v1beta2FlowSchemaConditionReasonL #-}

-- | 'v1beta2FlowSchemaConditionStatus' Lens
v1beta2FlowSchemaConditionStatusL :: Lens_' V1beta2FlowSchemaCondition (Maybe Text)
v1beta2FlowSchemaConditionStatusL f V1beta2FlowSchemaCondition{..} = (\v1beta2FlowSchemaConditionStatus -> V1beta2FlowSchemaCondition { v1beta2FlowSchemaConditionStatus, ..} ) <$> f v1beta2FlowSchemaConditionStatus
{-# INLINE v1beta2FlowSchemaConditionStatusL #-}

-- | 'v1beta2FlowSchemaConditionType' Lens
v1beta2FlowSchemaConditionTypeL :: Lens_' V1beta2FlowSchemaCondition (Maybe Text)
v1beta2FlowSchemaConditionTypeL f V1beta2FlowSchemaCondition{..} = (\v1beta2FlowSchemaConditionType -> V1beta2FlowSchemaCondition { v1beta2FlowSchemaConditionType, ..} ) <$> f v1beta2FlowSchemaConditionType
{-# INLINE v1beta2FlowSchemaConditionTypeL #-}



-- * V1beta2FlowSchemaList

-- | 'v1beta2FlowSchemaListApiVersion' Lens
v1beta2FlowSchemaListApiVersionL :: Lens_' V1beta2FlowSchemaList (Maybe Text)
v1beta2FlowSchemaListApiVersionL f V1beta2FlowSchemaList{..} = (\v1beta2FlowSchemaListApiVersion -> V1beta2FlowSchemaList { v1beta2FlowSchemaListApiVersion, ..} ) <$> f v1beta2FlowSchemaListApiVersion
{-# INLINE v1beta2FlowSchemaListApiVersionL #-}

-- | 'v1beta2FlowSchemaListItems' Lens
v1beta2FlowSchemaListItemsL :: Lens_' V1beta2FlowSchemaList ([V1beta2FlowSchema])
v1beta2FlowSchemaListItemsL f V1beta2FlowSchemaList{..} = (\v1beta2FlowSchemaListItems -> V1beta2FlowSchemaList { v1beta2FlowSchemaListItems, ..} ) <$> f v1beta2FlowSchemaListItems
{-# INLINE v1beta2FlowSchemaListItemsL #-}

-- | 'v1beta2FlowSchemaListKind' Lens
v1beta2FlowSchemaListKindL :: Lens_' V1beta2FlowSchemaList (Maybe Text)
v1beta2FlowSchemaListKindL f V1beta2FlowSchemaList{..} = (\v1beta2FlowSchemaListKind -> V1beta2FlowSchemaList { v1beta2FlowSchemaListKind, ..} ) <$> f v1beta2FlowSchemaListKind
{-# INLINE v1beta2FlowSchemaListKindL #-}

-- | 'v1beta2FlowSchemaListMetadata' Lens
v1beta2FlowSchemaListMetadataL :: Lens_' V1beta2FlowSchemaList (Maybe V1ListMeta)
v1beta2FlowSchemaListMetadataL f V1beta2FlowSchemaList{..} = (\v1beta2FlowSchemaListMetadata -> V1beta2FlowSchemaList { v1beta2FlowSchemaListMetadata, ..} ) <$> f v1beta2FlowSchemaListMetadata
{-# INLINE v1beta2FlowSchemaListMetadataL #-}



-- * V1beta2FlowSchemaSpec

-- | 'v1beta2FlowSchemaSpecDistinguisherMethod' Lens
v1beta2FlowSchemaSpecDistinguisherMethodL :: Lens_' V1beta2FlowSchemaSpec (Maybe V1beta2FlowDistinguisherMethod)
v1beta2FlowSchemaSpecDistinguisherMethodL f V1beta2FlowSchemaSpec{..} = (\v1beta2FlowSchemaSpecDistinguisherMethod -> V1beta2FlowSchemaSpec { v1beta2FlowSchemaSpecDistinguisherMethod, ..} ) <$> f v1beta2FlowSchemaSpecDistinguisherMethod
{-# INLINE v1beta2FlowSchemaSpecDistinguisherMethodL #-}

-- | 'v1beta2FlowSchemaSpecMatchingPrecedence' Lens
v1beta2FlowSchemaSpecMatchingPrecedenceL :: Lens_' V1beta2FlowSchemaSpec (Maybe Int)
v1beta2FlowSchemaSpecMatchingPrecedenceL f V1beta2FlowSchemaSpec{..} = (\v1beta2FlowSchemaSpecMatchingPrecedence -> V1beta2FlowSchemaSpec { v1beta2FlowSchemaSpecMatchingPrecedence, ..} ) <$> f v1beta2FlowSchemaSpecMatchingPrecedence
{-# INLINE v1beta2FlowSchemaSpecMatchingPrecedenceL #-}

-- | 'v1beta2FlowSchemaSpecPriorityLevelConfiguration' Lens
v1beta2FlowSchemaSpecPriorityLevelConfigurationL :: Lens_' V1beta2FlowSchemaSpec (V1beta2PriorityLevelConfigurationReference)
v1beta2FlowSchemaSpecPriorityLevelConfigurationL f V1beta2FlowSchemaSpec{..} = (\v1beta2FlowSchemaSpecPriorityLevelConfiguration -> V1beta2FlowSchemaSpec { v1beta2FlowSchemaSpecPriorityLevelConfiguration, ..} ) <$> f v1beta2FlowSchemaSpecPriorityLevelConfiguration
{-# INLINE v1beta2FlowSchemaSpecPriorityLevelConfigurationL #-}

-- | 'v1beta2FlowSchemaSpecRules' Lens
v1beta2FlowSchemaSpecRulesL :: Lens_' V1beta2FlowSchemaSpec (Maybe [V1beta2PolicyRulesWithSubjects])
v1beta2FlowSchemaSpecRulesL f V1beta2FlowSchemaSpec{..} = (\v1beta2FlowSchemaSpecRules -> V1beta2FlowSchemaSpec { v1beta2FlowSchemaSpecRules, ..} ) <$> f v1beta2FlowSchemaSpecRules
{-# INLINE v1beta2FlowSchemaSpecRulesL #-}



-- * V1beta2FlowSchemaStatus

-- | 'v1beta2FlowSchemaStatusConditions' Lens
v1beta2FlowSchemaStatusConditionsL :: Lens_' V1beta2FlowSchemaStatus (Maybe [V1beta2FlowSchemaCondition])
v1beta2FlowSchemaStatusConditionsL f V1beta2FlowSchemaStatus{..} = (\v1beta2FlowSchemaStatusConditions -> V1beta2FlowSchemaStatus { v1beta2FlowSchemaStatusConditions, ..} ) <$> f v1beta2FlowSchemaStatusConditions
{-# INLINE v1beta2FlowSchemaStatusConditionsL #-}



-- * V1beta2GroupSubject

-- | 'v1beta2GroupSubjectName' Lens
v1beta2GroupSubjectNameL :: Lens_' V1beta2GroupSubject (Text)
v1beta2GroupSubjectNameL f V1beta2GroupSubject{..} = (\v1beta2GroupSubjectName -> V1beta2GroupSubject { v1beta2GroupSubjectName, ..} ) <$> f v1beta2GroupSubjectName
{-# INLINE v1beta2GroupSubjectNameL #-}



-- * V1beta2LimitResponse

-- | 'v1beta2LimitResponseQueuing' Lens
v1beta2LimitResponseQueuingL :: Lens_' V1beta2LimitResponse (Maybe V1beta2QueuingConfiguration)
v1beta2LimitResponseQueuingL f V1beta2LimitResponse{..} = (\v1beta2LimitResponseQueuing -> V1beta2LimitResponse { v1beta2LimitResponseQueuing, ..} ) <$> f v1beta2LimitResponseQueuing
{-# INLINE v1beta2LimitResponseQueuingL #-}

-- | 'v1beta2LimitResponseType' Lens
v1beta2LimitResponseTypeL :: Lens_' V1beta2LimitResponse (Text)
v1beta2LimitResponseTypeL f V1beta2LimitResponse{..} = (\v1beta2LimitResponseType -> V1beta2LimitResponse { v1beta2LimitResponseType, ..} ) <$> f v1beta2LimitResponseType
{-# INLINE v1beta2LimitResponseTypeL #-}



-- * V1beta2LimitedPriorityLevelConfiguration

-- | 'v1beta2LimitedPriorityLevelConfigurationAssuredConcurrencyShares' Lens
v1beta2LimitedPriorityLevelConfigurationAssuredConcurrencySharesL :: Lens_' V1beta2LimitedPriorityLevelConfiguration (Maybe Int)
v1beta2LimitedPriorityLevelConfigurationAssuredConcurrencySharesL f V1beta2LimitedPriorityLevelConfiguration{..} = (\v1beta2LimitedPriorityLevelConfigurationAssuredConcurrencyShares -> V1beta2LimitedPriorityLevelConfiguration { v1beta2LimitedPriorityLevelConfigurationAssuredConcurrencyShares, ..} ) <$> f v1beta2LimitedPriorityLevelConfigurationAssuredConcurrencyShares
{-# INLINE v1beta2LimitedPriorityLevelConfigurationAssuredConcurrencySharesL #-}

-- | 'v1beta2LimitedPriorityLevelConfigurationLimitResponse' Lens
v1beta2LimitedPriorityLevelConfigurationLimitResponseL :: Lens_' V1beta2LimitedPriorityLevelConfiguration (Maybe V1beta2LimitResponse)
v1beta2LimitedPriorityLevelConfigurationLimitResponseL f V1beta2LimitedPriorityLevelConfiguration{..} = (\v1beta2LimitedPriorityLevelConfigurationLimitResponse -> V1beta2LimitedPriorityLevelConfiguration { v1beta2LimitedPriorityLevelConfigurationLimitResponse, ..} ) <$> f v1beta2LimitedPriorityLevelConfigurationLimitResponse
{-# INLINE v1beta2LimitedPriorityLevelConfigurationLimitResponseL #-}



-- * V1beta2NonResourcePolicyRule

-- | 'v1beta2NonResourcePolicyRuleNonResourceUrls' Lens
v1beta2NonResourcePolicyRuleNonResourceUrlsL :: Lens_' V1beta2NonResourcePolicyRule ([Text])
v1beta2NonResourcePolicyRuleNonResourceUrlsL f V1beta2NonResourcePolicyRule{..} = (\v1beta2NonResourcePolicyRuleNonResourceUrls -> V1beta2NonResourcePolicyRule { v1beta2NonResourcePolicyRuleNonResourceUrls, ..} ) <$> f v1beta2NonResourcePolicyRuleNonResourceUrls
{-# INLINE v1beta2NonResourcePolicyRuleNonResourceUrlsL #-}

-- | 'v1beta2NonResourcePolicyRuleVerbs' Lens
v1beta2NonResourcePolicyRuleVerbsL :: Lens_' V1beta2NonResourcePolicyRule ([Text])
v1beta2NonResourcePolicyRuleVerbsL f V1beta2NonResourcePolicyRule{..} = (\v1beta2NonResourcePolicyRuleVerbs -> V1beta2NonResourcePolicyRule { v1beta2NonResourcePolicyRuleVerbs, ..} ) <$> f v1beta2NonResourcePolicyRuleVerbs
{-# INLINE v1beta2NonResourcePolicyRuleVerbsL #-}



-- * V1beta2PolicyRulesWithSubjects

-- | 'v1beta2PolicyRulesWithSubjectsNonResourceRules' Lens
v1beta2PolicyRulesWithSubjectsNonResourceRulesL :: Lens_' V1beta2PolicyRulesWithSubjects (Maybe [V1beta2NonResourcePolicyRule])
v1beta2PolicyRulesWithSubjectsNonResourceRulesL f V1beta2PolicyRulesWithSubjects{..} = (\v1beta2PolicyRulesWithSubjectsNonResourceRules -> V1beta2PolicyRulesWithSubjects { v1beta2PolicyRulesWithSubjectsNonResourceRules, ..} ) <$> f v1beta2PolicyRulesWithSubjectsNonResourceRules
{-# INLINE v1beta2PolicyRulesWithSubjectsNonResourceRulesL #-}

-- | 'v1beta2PolicyRulesWithSubjectsResourceRules' Lens
v1beta2PolicyRulesWithSubjectsResourceRulesL :: Lens_' V1beta2PolicyRulesWithSubjects (Maybe [V1beta2ResourcePolicyRule])
v1beta2PolicyRulesWithSubjectsResourceRulesL f V1beta2PolicyRulesWithSubjects{..} = (\v1beta2PolicyRulesWithSubjectsResourceRules -> V1beta2PolicyRulesWithSubjects { v1beta2PolicyRulesWithSubjectsResourceRules, ..} ) <$> f v1beta2PolicyRulesWithSubjectsResourceRules
{-# INLINE v1beta2PolicyRulesWithSubjectsResourceRulesL #-}

-- | 'v1beta2PolicyRulesWithSubjectsSubjects' Lens
v1beta2PolicyRulesWithSubjectsSubjectsL :: Lens_' V1beta2PolicyRulesWithSubjects ([V1beta2Subject])
v1beta2PolicyRulesWithSubjectsSubjectsL f V1beta2PolicyRulesWithSubjects{..} = (\v1beta2PolicyRulesWithSubjectsSubjects -> V1beta2PolicyRulesWithSubjects { v1beta2PolicyRulesWithSubjectsSubjects, ..} ) <$> f v1beta2PolicyRulesWithSubjectsSubjects
{-# INLINE v1beta2PolicyRulesWithSubjectsSubjectsL #-}



-- * V1beta2PriorityLevelConfiguration

-- | 'v1beta2PriorityLevelConfigurationApiVersion' Lens
v1beta2PriorityLevelConfigurationApiVersionL :: Lens_' V1beta2PriorityLevelConfiguration (Maybe Text)
v1beta2PriorityLevelConfigurationApiVersionL f V1beta2PriorityLevelConfiguration{..} = (\v1beta2PriorityLevelConfigurationApiVersion -> V1beta2PriorityLevelConfiguration { v1beta2PriorityLevelConfigurationApiVersion, ..} ) <$> f v1beta2PriorityLevelConfigurationApiVersion
{-# INLINE v1beta2PriorityLevelConfigurationApiVersionL #-}

-- | 'v1beta2PriorityLevelConfigurationKind' Lens
v1beta2PriorityLevelConfigurationKindL :: Lens_' V1beta2PriorityLevelConfiguration (Maybe Text)
v1beta2PriorityLevelConfigurationKindL f V1beta2PriorityLevelConfiguration{..} = (\v1beta2PriorityLevelConfigurationKind -> V1beta2PriorityLevelConfiguration { v1beta2PriorityLevelConfigurationKind, ..} ) <$> f v1beta2PriorityLevelConfigurationKind
{-# INLINE v1beta2PriorityLevelConfigurationKindL #-}

-- | 'v1beta2PriorityLevelConfigurationMetadata' Lens
v1beta2PriorityLevelConfigurationMetadataL :: Lens_' V1beta2PriorityLevelConfiguration (Maybe V1ObjectMeta)
v1beta2PriorityLevelConfigurationMetadataL f V1beta2PriorityLevelConfiguration{..} = (\v1beta2PriorityLevelConfigurationMetadata -> V1beta2PriorityLevelConfiguration { v1beta2PriorityLevelConfigurationMetadata, ..} ) <$> f v1beta2PriorityLevelConfigurationMetadata
{-# INLINE v1beta2PriorityLevelConfigurationMetadataL #-}

-- | 'v1beta2PriorityLevelConfigurationSpec' Lens
v1beta2PriorityLevelConfigurationSpecL :: Lens_' V1beta2PriorityLevelConfiguration (Maybe V1beta2PriorityLevelConfigurationSpec)
v1beta2PriorityLevelConfigurationSpecL f V1beta2PriorityLevelConfiguration{..} = (\v1beta2PriorityLevelConfigurationSpec -> V1beta2PriorityLevelConfiguration { v1beta2PriorityLevelConfigurationSpec, ..} ) <$> f v1beta2PriorityLevelConfigurationSpec
{-# INLINE v1beta2PriorityLevelConfigurationSpecL #-}

-- | 'v1beta2PriorityLevelConfigurationStatus' Lens
v1beta2PriorityLevelConfigurationStatusL :: Lens_' V1beta2PriorityLevelConfiguration (Maybe V1beta2PriorityLevelConfigurationStatus)
v1beta2PriorityLevelConfigurationStatusL f V1beta2PriorityLevelConfiguration{..} = (\v1beta2PriorityLevelConfigurationStatus -> V1beta2PriorityLevelConfiguration { v1beta2PriorityLevelConfigurationStatus, ..} ) <$> f v1beta2PriorityLevelConfigurationStatus
{-# INLINE v1beta2PriorityLevelConfigurationStatusL #-}



-- * V1beta2PriorityLevelConfigurationCondition

-- | 'v1beta2PriorityLevelConfigurationConditionLastTransitionTime' Lens
v1beta2PriorityLevelConfigurationConditionLastTransitionTimeL :: Lens_' V1beta2PriorityLevelConfigurationCondition (Maybe DateTime)
v1beta2PriorityLevelConfigurationConditionLastTransitionTimeL f V1beta2PriorityLevelConfigurationCondition{..} = (\v1beta2PriorityLevelConfigurationConditionLastTransitionTime -> V1beta2PriorityLevelConfigurationCondition { v1beta2PriorityLevelConfigurationConditionLastTransitionTime, ..} ) <$> f v1beta2PriorityLevelConfigurationConditionLastTransitionTime
{-# INLINE v1beta2PriorityLevelConfigurationConditionLastTransitionTimeL #-}

-- | 'v1beta2PriorityLevelConfigurationConditionMessage' Lens
v1beta2PriorityLevelConfigurationConditionMessageL :: Lens_' V1beta2PriorityLevelConfigurationCondition (Maybe Text)
v1beta2PriorityLevelConfigurationConditionMessageL f V1beta2PriorityLevelConfigurationCondition{..} = (\v1beta2PriorityLevelConfigurationConditionMessage -> V1beta2PriorityLevelConfigurationCondition { v1beta2PriorityLevelConfigurationConditionMessage, ..} ) <$> f v1beta2PriorityLevelConfigurationConditionMessage
{-# INLINE v1beta2PriorityLevelConfigurationConditionMessageL #-}

-- | 'v1beta2PriorityLevelConfigurationConditionReason' Lens
v1beta2PriorityLevelConfigurationConditionReasonL :: Lens_' V1beta2PriorityLevelConfigurationCondition (Maybe Text)
v1beta2PriorityLevelConfigurationConditionReasonL f V1beta2PriorityLevelConfigurationCondition{..} = (\v1beta2PriorityLevelConfigurationConditionReason -> V1beta2PriorityLevelConfigurationCondition { v1beta2PriorityLevelConfigurationConditionReason, ..} ) <$> f v1beta2PriorityLevelConfigurationConditionReason
{-# INLINE v1beta2PriorityLevelConfigurationConditionReasonL #-}

-- | 'v1beta2PriorityLevelConfigurationConditionStatus' Lens
v1beta2PriorityLevelConfigurationConditionStatusL :: Lens_' V1beta2PriorityLevelConfigurationCondition (Maybe Text)
v1beta2PriorityLevelConfigurationConditionStatusL f V1beta2PriorityLevelConfigurationCondition{..} = (\v1beta2PriorityLevelConfigurationConditionStatus -> V1beta2PriorityLevelConfigurationCondition { v1beta2PriorityLevelConfigurationConditionStatus, ..} ) <$> f v1beta2PriorityLevelConfigurationConditionStatus
{-# INLINE v1beta2PriorityLevelConfigurationConditionStatusL #-}

-- | 'v1beta2PriorityLevelConfigurationConditionType' Lens
v1beta2PriorityLevelConfigurationConditionTypeL :: Lens_' V1beta2PriorityLevelConfigurationCondition (Maybe Text)
v1beta2PriorityLevelConfigurationConditionTypeL f V1beta2PriorityLevelConfigurationCondition{..} = (\v1beta2PriorityLevelConfigurationConditionType -> V1beta2PriorityLevelConfigurationCondition { v1beta2PriorityLevelConfigurationConditionType, ..} ) <$> f v1beta2PriorityLevelConfigurationConditionType
{-# INLINE v1beta2PriorityLevelConfigurationConditionTypeL #-}



-- * V1beta2PriorityLevelConfigurationList

-- | 'v1beta2PriorityLevelConfigurationListApiVersion' Lens
v1beta2PriorityLevelConfigurationListApiVersionL :: Lens_' V1beta2PriorityLevelConfigurationList (Maybe Text)
v1beta2PriorityLevelConfigurationListApiVersionL f V1beta2PriorityLevelConfigurationList{..} = (\v1beta2PriorityLevelConfigurationListApiVersion -> V1beta2PriorityLevelConfigurationList { v1beta2PriorityLevelConfigurationListApiVersion, ..} ) <$> f v1beta2PriorityLevelConfigurationListApiVersion
{-# INLINE v1beta2PriorityLevelConfigurationListApiVersionL #-}

-- | 'v1beta2PriorityLevelConfigurationListItems' Lens
v1beta2PriorityLevelConfigurationListItemsL :: Lens_' V1beta2PriorityLevelConfigurationList ([V1beta2PriorityLevelConfiguration])
v1beta2PriorityLevelConfigurationListItemsL f V1beta2PriorityLevelConfigurationList{..} = (\v1beta2PriorityLevelConfigurationListItems -> V1beta2PriorityLevelConfigurationList { v1beta2PriorityLevelConfigurationListItems, ..} ) <$> f v1beta2PriorityLevelConfigurationListItems
{-# INLINE v1beta2PriorityLevelConfigurationListItemsL #-}

-- | 'v1beta2PriorityLevelConfigurationListKind' Lens
v1beta2PriorityLevelConfigurationListKindL :: Lens_' V1beta2PriorityLevelConfigurationList (Maybe Text)
v1beta2PriorityLevelConfigurationListKindL f V1beta2PriorityLevelConfigurationList{..} = (\v1beta2PriorityLevelConfigurationListKind -> V1beta2PriorityLevelConfigurationList { v1beta2PriorityLevelConfigurationListKind, ..} ) <$> f v1beta2PriorityLevelConfigurationListKind
{-# INLINE v1beta2PriorityLevelConfigurationListKindL #-}

-- | 'v1beta2PriorityLevelConfigurationListMetadata' Lens
v1beta2PriorityLevelConfigurationListMetadataL :: Lens_' V1beta2PriorityLevelConfigurationList (Maybe V1ListMeta)
v1beta2PriorityLevelConfigurationListMetadataL f V1beta2PriorityLevelConfigurationList{..} = (\v1beta2PriorityLevelConfigurationListMetadata -> V1beta2PriorityLevelConfigurationList { v1beta2PriorityLevelConfigurationListMetadata, ..} ) <$> f v1beta2PriorityLevelConfigurationListMetadata
{-# INLINE v1beta2PriorityLevelConfigurationListMetadataL #-}



-- * V1beta2PriorityLevelConfigurationReference

-- | 'v1beta2PriorityLevelConfigurationReferenceName' Lens
v1beta2PriorityLevelConfigurationReferenceNameL :: Lens_' V1beta2PriorityLevelConfigurationReference (Text)
v1beta2PriorityLevelConfigurationReferenceNameL f V1beta2PriorityLevelConfigurationReference{..} = (\v1beta2PriorityLevelConfigurationReferenceName -> V1beta2PriorityLevelConfigurationReference { v1beta2PriorityLevelConfigurationReferenceName, ..} ) <$> f v1beta2PriorityLevelConfigurationReferenceName
{-# INLINE v1beta2PriorityLevelConfigurationReferenceNameL #-}



-- * V1beta2PriorityLevelConfigurationSpec

-- | 'v1beta2PriorityLevelConfigurationSpecLimited' Lens
v1beta2PriorityLevelConfigurationSpecLimitedL :: Lens_' V1beta2PriorityLevelConfigurationSpec (Maybe V1beta2LimitedPriorityLevelConfiguration)
v1beta2PriorityLevelConfigurationSpecLimitedL f V1beta2PriorityLevelConfigurationSpec{..} = (\v1beta2PriorityLevelConfigurationSpecLimited -> V1beta2PriorityLevelConfigurationSpec { v1beta2PriorityLevelConfigurationSpecLimited, ..} ) <$> f v1beta2PriorityLevelConfigurationSpecLimited
{-# INLINE v1beta2PriorityLevelConfigurationSpecLimitedL #-}

-- | 'v1beta2PriorityLevelConfigurationSpecType' Lens
v1beta2PriorityLevelConfigurationSpecTypeL :: Lens_' V1beta2PriorityLevelConfigurationSpec (Text)
v1beta2PriorityLevelConfigurationSpecTypeL f V1beta2PriorityLevelConfigurationSpec{..} = (\v1beta2PriorityLevelConfigurationSpecType -> V1beta2PriorityLevelConfigurationSpec { v1beta2PriorityLevelConfigurationSpecType, ..} ) <$> f v1beta2PriorityLevelConfigurationSpecType
{-# INLINE v1beta2PriorityLevelConfigurationSpecTypeL #-}



-- * V1beta2PriorityLevelConfigurationStatus

-- | 'v1beta2PriorityLevelConfigurationStatusConditions' Lens
v1beta2PriorityLevelConfigurationStatusConditionsL :: Lens_' V1beta2PriorityLevelConfigurationStatus (Maybe [V1beta2PriorityLevelConfigurationCondition])
v1beta2PriorityLevelConfigurationStatusConditionsL f V1beta2PriorityLevelConfigurationStatus{..} = (\v1beta2PriorityLevelConfigurationStatusConditions -> V1beta2PriorityLevelConfigurationStatus { v1beta2PriorityLevelConfigurationStatusConditions, ..} ) <$> f v1beta2PriorityLevelConfigurationStatusConditions
{-# INLINE v1beta2PriorityLevelConfigurationStatusConditionsL #-}



-- * V1beta2QueuingConfiguration

-- | 'v1beta2QueuingConfigurationHandSize' Lens
v1beta2QueuingConfigurationHandSizeL :: Lens_' V1beta2QueuingConfiguration (Maybe Int)
v1beta2QueuingConfigurationHandSizeL f V1beta2QueuingConfiguration{..} = (\v1beta2QueuingConfigurationHandSize -> V1beta2QueuingConfiguration { v1beta2QueuingConfigurationHandSize, ..} ) <$> f v1beta2QueuingConfigurationHandSize
{-# INLINE v1beta2QueuingConfigurationHandSizeL #-}

-- | 'v1beta2QueuingConfigurationQueueLengthLimit' Lens
v1beta2QueuingConfigurationQueueLengthLimitL :: Lens_' V1beta2QueuingConfiguration (Maybe Int)
v1beta2QueuingConfigurationQueueLengthLimitL f V1beta2QueuingConfiguration{..} = (\v1beta2QueuingConfigurationQueueLengthLimit -> V1beta2QueuingConfiguration { v1beta2QueuingConfigurationQueueLengthLimit, ..} ) <$> f v1beta2QueuingConfigurationQueueLengthLimit
{-# INLINE v1beta2QueuingConfigurationQueueLengthLimitL #-}

-- | 'v1beta2QueuingConfigurationQueues' Lens
v1beta2QueuingConfigurationQueuesL :: Lens_' V1beta2QueuingConfiguration (Maybe Int)
v1beta2QueuingConfigurationQueuesL f V1beta2QueuingConfiguration{..} = (\v1beta2QueuingConfigurationQueues -> V1beta2QueuingConfiguration { v1beta2QueuingConfigurationQueues, ..} ) <$> f v1beta2QueuingConfigurationQueues
{-# INLINE v1beta2QueuingConfigurationQueuesL #-}



-- * V1beta2ResourcePolicyRule

-- | 'v1beta2ResourcePolicyRuleApiGroups' Lens
v1beta2ResourcePolicyRuleApiGroupsL :: Lens_' V1beta2ResourcePolicyRule ([Text])
v1beta2ResourcePolicyRuleApiGroupsL f V1beta2ResourcePolicyRule{..} = (\v1beta2ResourcePolicyRuleApiGroups -> V1beta2ResourcePolicyRule { v1beta2ResourcePolicyRuleApiGroups, ..} ) <$> f v1beta2ResourcePolicyRuleApiGroups
{-# INLINE v1beta2ResourcePolicyRuleApiGroupsL #-}

-- | 'v1beta2ResourcePolicyRuleClusterScope' Lens
v1beta2ResourcePolicyRuleClusterScopeL :: Lens_' V1beta2ResourcePolicyRule (Maybe Bool)
v1beta2ResourcePolicyRuleClusterScopeL f V1beta2ResourcePolicyRule{..} = (\v1beta2ResourcePolicyRuleClusterScope -> V1beta2ResourcePolicyRule { v1beta2ResourcePolicyRuleClusterScope, ..} ) <$> f v1beta2ResourcePolicyRuleClusterScope
{-# INLINE v1beta2ResourcePolicyRuleClusterScopeL #-}

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

-- | 'v1beta2ResourcePolicyRuleResources' Lens
v1beta2ResourcePolicyRuleResourcesL :: Lens_' V1beta2ResourcePolicyRule ([Text])
v1beta2ResourcePolicyRuleResourcesL f V1beta2ResourcePolicyRule{..} = (\v1beta2ResourcePolicyRuleResources -> V1beta2ResourcePolicyRule { v1beta2ResourcePolicyRuleResources, ..} ) <$> f v1beta2ResourcePolicyRuleResources
{-# INLINE v1beta2ResourcePolicyRuleResourcesL #-}

-- | 'v1beta2ResourcePolicyRuleVerbs' Lens
v1beta2ResourcePolicyRuleVerbsL :: Lens_' V1beta2ResourcePolicyRule ([Text])
v1beta2ResourcePolicyRuleVerbsL f V1beta2ResourcePolicyRule{..} = (\v1beta2ResourcePolicyRuleVerbs -> V1beta2ResourcePolicyRule { v1beta2ResourcePolicyRuleVerbs, ..} ) <$> f v1beta2ResourcePolicyRuleVerbs
{-# INLINE v1beta2ResourcePolicyRuleVerbsL #-}



-- * V1beta2ServiceAccountSubject

-- | 'v1beta2ServiceAccountSubjectName' Lens
v1beta2ServiceAccountSubjectNameL :: Lens_' V1beta2ServiceAccountSubject (Text)
v1beta2ServiceAccountSubjectNameL f V1beta2ServiceAccountSubject{..} = (\v1beta2ServiceAccountSubjectName -> V1beta2ServiceAccountSubject { v1beta2ServiceAccountSubjectName, ..} ) <$> f v1beta2ServiceAccountSubjectName
{-# INLINE v1beta2ServiceAccountSubjectNameL #-}

-- | 'v1beta2ServiceAccountSubjectNamespace' Lens
v1beta2ServiceAccountSubjectNamespaceL :: Lens_' V1beta2ServiceAccountSubject (Text)
v1beta2ServiceAccountSubjectNamespaceL f V1beta2ServiceAccountSubject{..} = (\v1beta2ServiceAccountSubjectNamespace -> V1beta2ServiceAccountSubject { v1beta2ServiceAccountSubjectNamespace, ..} ) <$> f v1beta2ServiceAccountSubjectNamespace
{-# INLINE v1beta2ServiceAccountSubjectNamespaceL #-}



-- * V1beta2Subject

-- | 'v1beta2SubjectGroup' Lens
v1beta2SubjectGroupL :: Lens_' V1beta2Subject (Maybe V1beta2GroupSubject)
v1beta2SubjectGroupL f V1beta2Subject{..} = (\v1beta2SubjectGroup -> V1beta2Subject { v1beta2SubjectGroup, ..} ) <$> f v1beta2SubjectGroup
{-# INLINE v1beta2SubjectGroupL #-}

-- | 'v1beta2SubjectKind' Lens
v1beta2SubjectKindL :: Lens_' V1beta2Subject (Text)
v1beta2SubjectKindL f V1beta2Subject{..} = (\v1beta2SubjectKind -> V1beta2Subject { v1beta2SubjectKind, ..} ) <$> f v1beta2SubjectKind
{-# INLINE v1beta2SubjectKindL #-}

-- | 'v1beta2SubjectServiceAccount' Lens
v1beta2SubjectServiceAccountL :: Lens_' V1beta2Subject (Maybe V1beta2ServiceAccountSubject)
v1beta2SubjectServiceAccountL f V1beta2Subject{..} = (\v1beta2SubjectServiceAccount -> V1beta2Subject { v1beta2SubjectServiceAccount, ..} ) <$> f v1beta2SubjectServiceAccount
{-# INLINE v1beta2SubjectServiceAccountL #-}

-- | 'v1beta2SubjectUser' Lens
v1beta2SubjectUserL :: Lens_' V1beta2Subject (Maybe V1beta2UserSubject)
v1beta2SubjectUserL f V1beta2Subject{..} = (\v1beta2SubjectUser -> V1beta2Subject { v1beta2SubjectUser, ..} ) <$> f v1beta2SubjectUser
{-# INLINE v1beta2SubjectUserL #-}



-- * V1beta2UserSubject

-- | 'v1beta2UserSubjectName' Lens
v1beta2UserSubjectNameL :: Lens_' V1beta2UserSubject (Text)
v1beta2UserSubjectNameL f V1beta2UserSubject{..} = (\v1beta2UserSubjectName -> V1beta2UserSubject { v1beta2UserSubjectName, ..} ) <$> f v1beta2UserSubjectName
{-# INLINE v1beta2UserSubjectNameL #-}



-- * V2ContainerResourceMetricSource

-- | 'v2ContainerResourceMetricSourceContainer' Lens
v2ContainerResourceMetricSourceContainerL :: Lens_' V2ContainerResourceMetricSource (Text)
v2ContainerResourceMetricSourceContainerL f V2ContainerResourceMetricSource{..} = (\v2ContainerResourceMetricSourceContainer -> V2ContainerResourceMetricSource { v2ContainerResourceMetricSourceContainer, ..} ) <$> f v2ContainerResourceMetricSourceContainer
{-# INLINE v2ContainerResourceMetricSourceContainerL #-}

-- | 'v2ContainerResourceMetricSourceName' Lens
v2ContainerResourceMetricSourceNameL :: Lens_' V2ContainerResourceMetricSource (Text)
v2ContainerResourceMetricSourceNameL f V2ContainerResourceMetricSource{..} = (\v2ContainerResourceMetricSourceName -> V2ContainerResourceMetricSource { v2ContainerResourceMetricSourceName, ..} ) <$> f v2ContainerResourceMetricSourceName
{-# INLINE v2ContainerResourceMetricSourceNameL #-}

-- | 'v2ContainerResourceMetricSourceTarget' Lens
v2ContainerResourceMetricSourceTargetL :: Lens_' V2ContainerResourceMetricSource (V2MetricTarget)
v2ContainerResourceMetricSourceTargetL f V2ContainerResourceMetricSource{..} = (\v2ContainerResourceMetricSourceTarget -> V2ContainerResourceMetricSource { v2ContainerResourceMetricSourceTarget, ..} ) <$> f v2ContainerResourceMetricSourceTarget
{-# INLINE v2ContainerResourceMetricSourceTargetL #-}



-- * V2ContainerResourceMetricStatus

-- | 'v2ContainerResourceMetricStatusContainer' Lens
v2ContainerResourceMetricStatusContainerL :: Lens_' V2ContainerResourceMetricStatus (Text)
v2ContainerResourceMetricStatusContainerL f V2ContainerResourceMetricStatus{..} = (\v2ContainerResourceMetricStatusContainer -> V2ContainerResourceMetricStatus { v2ContainerResourceMetricStatusContainer, ..} ) <$> f v2ContainerResourceMetricStatusContainer
{-# INLINE v2ContainerResourceMetricStatusContainerL #-}

-- | 'v2ContainerResourceMetricStatusCurrent' Lens
v2ContainerResourceMetricStatusCurrentL :: Lens_' V2ContainerResourceMetricStatus (V2MetricValueStatus)
v2ContainerResourceMetricStatusCurrentL f V2ContainerResourceMetricStatus{..} = (\v2ContainerResourceMetricStatusCurrent -> V2ContainerResourceMetricStatus { v2ContainerResourceMetricStatusCurrent, ..} ) <$> f v2ContainerResourceMetricStatusCurrent
{-# INLINE v2ContainerResourceMetricStatusCurrentL #-}

-- | 'v2ContainerResourceMetricStatusName' Lens
v2ContainerResourceMetricStatusNameL :: Lens_' V2ContainerResourceMetricStatus (Text)
v2ContainerResourceMetricStatusNameL f V2ContainerResourceMetricStatus{..} = (\v2ContainerResourceMetricStatusName -> V2ContainerResourceMetricStatus { v2ContainerResourceMetricStatusName, ..} ) <$> f v2ContainerResourceMetricStatusName
{-# INLINE v2ContainerResourceMetricStatusNameL #-}



-- * V2CrossVersionObjectReference

-- | 'v2CrossVersionObjectReferenceApiVersion' Lens
v2CrossVersionObjectReferenceApiVersionL :: Lens_' V2CrossVersionObjectReference (Maybe Text)
v2CrossVersionObjectReferenceApiVersionL f V2CrossVersionObjectReference{..} = (\v2CrossVersionObjectReferenceApiVersion -> V2CrossVersionObjectReference { v2CrossVersionObjectReferenceApiVersion, ..} ) <$> f v2CrossVersionObjectReferenceApiVersion
{-# INLINE v2CrossVersionObjectReferenceApiVersionL #-}

-- | 'v2CrossVersionObjectReferenceKind' Lens
v2CrossVersionObjectReferenceKindL :: Lens_' V2CrossVersionObjectReference (Text)
v2CrossVersionObjectReferenceKindL f V2CrossVersionObjectReference{..} = (\v2CrossVersionObjectReferenceKind -> V2CrossVersionObjectReference { v2CrossVersionObjectReferenceKind, ..} ) <$> f v2CrossVersionObjectReferenceKind
{-# INLINE v2CrossVersionObjectReferenceKindL #-}

-- | 'v2CrossVersionObjectReferenceName' Lens
v2CrossVersionObjectReferenceNameL :: Lens_' V2CrossVersionObjectReference (Text)
v2CrossVersionObjectReferenceNameL f V2CrossVersionObjectReference{..} = (\v2CrossVersionObjectReferenceName -> V2CrossVersionObjectReference { v2CrossVersionObjectReferenceName, ..} ) <$> f v2CrossVersionObjectReferenceName
{-# INLINE v2CrossVersionObjectReferenceNameL #-}



-- * V2ExternalMetricSource

-- | 'v2ExternalMetricSourceMetric' Lens
v2ExternalMetricSourceMetricL :: Lens_' V2ExternalMetricSource (V2MetricIdentifier)
v2ExternalMetricSourceMetricL f V2ExternalMetricSource{..} = (\v2ExternalMetricSourceMetric -> V2ExternalMetricSource { v2ExternalMetricSourceMetric, ..} ) <$> f v2ExternalMetricSourceMetric
{-# INLINE v2ExternalMetricSourceMetricL #-}

-- | 'v2ExternalMetricSourceTarget' Lens
v2ExternalMetricSourceTargetL :: Lens_' V2ExternalMetricSource (V2MetricTarget)
v2ExternalMetricSourceTargetL f V2ExternalMetricSource{..} = (\v2ExternalMetricSourceTarget -> V2ExternalMetricSource { v2ExternalMetricSourceTarget, ..} ) <$> f v2ExternalMetricSourceTarget
{-# INLINE v2ExternalMetricSourceTargetL #-}



-- * V2ExternalMetricStatus

-- | 'v2ExternalMetricStatusCurrent' Lens
v2ExternalMetricStatusCurrentL :: Lens_' V2ExternalMetricStatus (V2MetricValueStatus)
v2ExternalMetricStatusCurrentL f V2ExternalMetricStatus{..} = (\v2ExternalMetricStatusCurrent -> V2ExternalMetricStatus { v2ExternalMetricStatusCurrent, ..} ) <$> f v2ExternalMetricStatusCurrent
{-# INLINE v2ExternalMetricStatusCurrentL #-}

-- | 'v2ExternalMetricStatusMetric' Lens
v2ExternalMetricStatusMetricL :: Lens_' V2ExternalMetricStatus (V2MetricIdentifier)
v2ExternalMetricStatusMetricL f V2ExternalMetricStatus{..} = (\v2ExternalMetricStatusMetric -> V2ExternalMetricStatus { v2ExternalMetricStatusMetric, ..} ) <$> f v2ExternalMetricStatusMetric
{-# INLINE v2ExternalMetricStatusMetricL #-}



-- * V2HPAScalingPolicy

-- | 'v2HPAScalingPolicyPeriodSeconds' Lens
v2HPAScalingPolicyPeriodSecondsL :: Lens_' V2HPAScalingPolicy (Int)
v2HPAScalingPolicyPeriodSecondsL f V2HPAScalingPolicy{..} = (\v2HPAScalingPolicyPeriodSeconds -> V2HPAScalingPolicy { v2HPAScalingPolicyPeriodSeconds, ..} ) <$> f v2HPAScalingPolicyPeriodSeconds
{-# INLINE v2HPAScalingPolicyPeriodSecondsL #-}

-- | 'v2HPAScalingPolicyType' Lens
v2HPAScalingPolicyTypeL :: Lens_' V2HPAScalingPolicy (Text)
v2HPAScalingPolicyTypeL f V2HPAScalingPolicy{..} = (\v2HPAScalingPolicyType -> V2HPAScalingPolicy { v2HPAScalingPolicyType, ..} ) <$> f v2HPAScalingPolicyType
{-# INLINE v2HPAScalingPolicyTypeL #-}

-- | 'v2HPAScalingPolicyValue' Lens
v2HPAScalingPolicyValueL :: Lens_' V2HPAScalingPolicy (Int)
v2HPAScalingPolicyValueL f V2HPAScalingPolicy{..} = (\v2HPAScalingPolicyValue -> V2HPAScalingPolicy { v2HPAScalingPolicyValue, ..} ) <$> f v2HPAScalingPolicyValue
{-# INLINE v2HPAScalingPolicyValueL #-}



-- * V2HPAScalingRules

-- | 'v2HPAScalingRulesPolicies' Lens
v2HPAScalingRulesPoliciesL :: Lens_' V2HPAScalingRules (Maybe [V2HPAScalingPolicy])
v2HPAScalingRulesPoliciesL f V2HPAScalingRules{..} = (\v2HPAScalingRulesPolicies -> V2HPAScalingRules { v2HPAScalingRulesPolicies, ..} ) <$> f v2HPAScalingRulesPolicies
{-# INLINE v2HPAScalingRulesPoliciesL #-}

-- | 'v2HPAScalingRulesSelectPolicy' Lens
v2HPAScalingRulesSelectPolicyL :: Lens_' V2HPAScalingRules (Maybe Text)
v2HPAScalingRulesSelectPolicyL f V2HPAScalingRules{..} = (\v2HPAScalingRulesSelectPolicy -> V2HPAScalingRules { v2HPAScalingRulesSelectPolicy, ..} ) <$> f v2HPAScalingRulesSelectPolicy
{-# INLINE v2HPAScalingRulesSelectPolicyL #-}

-- | 'v2HPAScalingRulesStabilizationWindowSeconds' Lens
v2HPAScalingRulesStabilizationWindowSecondsL :: Lens_' V2HPAScalingRules (Maybe Int)
v2HPAScalingRulesStabilizationWindowSecondsL f V2HPAScalingRules{..} = (\v2HPAScalingRulesStabilizationWindowSeconds -> V2HPAScalingRules { v2HPAScalingRulesStabilizationWindowSeconds, ..} ) <$> f v2HPAScalingRulesStabilizationWindowSeconds
{-# INLINE v2HPAScalingRulesStabilizationWindowSecondsL #-}



-- * V2HorizontalPodAutoscaler

-- | 'v2HorizontalPodAutoscalerApiVersion' Lens
v2HorizontalPodAutoscalerApiVersionL :: Lens_' V2HorizontalPodAutoscaler (Maybe Text)
v2HorizontalPodAutoscalerApiVersionL f V2HorizontalPodAutoscaler{..} = (\v2HorizontalPodAutoscalerApiVersion -> V2HorizontalPodAutoscaler { v2HorizontalPodAutoscalerApiVersion, ..} ) <$> f v2HorizontalPodAutoscalerApiVersion
{-# INLINE v2HorizontalPodAutoscalerApiVersionL #-}

-- | 'v2HorizontalPodAutoscalerKind' Lens
v2HorizontalPodAutoscalerKindL :: Lens_' V2HorizontalPodAutoscaler (Maybe Text)
v2HorizontalPodAutoscalerKindL f V2HorizontalPodAutoscaler{..} = (\v2HorizontalPodAutoscalerKind -> V2HorizontalPodAutoscaler { v2HorizontalPodAutoscalerKind, ..} ) <$> f v2HorizontalPodAutoscalerKind
{-# INLINE v2HorizontalPodAutoscalerKindL #-}

-- | 'v2HorizontalPodAutoscalerMetadata' Lens
v2HorizontalPodAutoscalerMetadataL :: Lens_' V2HorizontalPodAutoscaler (Maybe V1ObjectMeta)
v2HorizontalPodAutoscalerMetadataL f V2HorizontalPodAutoscaler{..} = (\v2HorizontalPodAutoscalerMetadata -> V2HorizontalPodAutoscaler { v2HorizontalPodAutoscalerMetadata, ..} ) <$> f v2HorizontalPodAutoscalerMetadata
{-# INLINE v2HorizontalPodAutoscalerMetadataL #-}

-- | 'v2HorizontalPodAutoscalerSpec' Lens
v2HorizontalPodAutoscalerSpecL :: Lens_' V2HorizontalPodAutoscaler (Maybe V2HorizontalPodAutoscalerSpec)
v2HorizontalPodAutoscalerSpecL f V2HorizontalPodAutoscaler{..} = (\v2HorizontalPodAutoscalerSpec -> V2HorizontalPodAutoscaler { v2HorizontalPodAutoscalerSpec, ..} ) <$> f v2HorizontalPodAutoscalerSpec
{-# INLINE v2HorizontalPodAutoscalerSpecL #-}

-- | 'v2HorizontalPodAutoscalerStatus' Lens
v2HorizontalPodAutoscalerStatusL :: Lens_' V2HorizontalPodAutoscaler (Maybe V2HorizontalPodAutoscalerStatus)
v2HorizontalPodAutoscalerStatusL f V2HorizontalPodAutoscaler{..} = (\v2HorizontalPodAutoscalerStatus -> V2HorizontalPodAutoscaler { v2HorizontalPodAutoscalerStatus, ..} ) <$> f v2HorizontalPodAutoscalerStatus
{-# INLINE v2HorizontalPodAutoscalerStatusL #-}



-- * V2HorizontalPodAutoscalerBehavior

-- | 'v2HorizontalPodAutoscalerBehaviorScaleDown' Lens
v2HorizontalPodAutoscalerBehaviorScaleDownL :: Lens_' V2HorizontalPodAutoscalerBehavior (Maybe V2HPAScalingRules)
v2HorizontalPodAutoscalerBehaviorScaleDownL f V2HorizontalPodAutoscalerBehavior{..} = (\v2HorizontalPodAutoscalerBehaviorScaleDown -> V2HorizontalPodAutoscalerBehavior { v2HorizontalPodAutoscalerBehaviorScaleDown, ..} ) <$> f v2HorizontalPodAutoscalerBehaviorScaleDown
{-# INLINE v2HorizontalPodAutoscalerBehaviorScaleDownL #-}

-- | 'v2HorizontalPodAutoscalerBehaviorScaleUp' Lens
v2HorizontalPodAutoscalerBehaviorScaleUpL :: Lens_' V2HorizontalPodAutoscalerBehavior (Maybe V2HPAScalingRules)
v2HorizontalPodAutoscalerBehaviorScaleUpL f V2HorizontalPodAutoscalerBehavior{..} = (\v2HorizontalPodAutoscalerBehaviorScaleUp -> V2HorizontalPodAutoscalerBehavior { v2HorizontalPodAutoscalerBehaviorScaleUp, ..} ) <$> f v2HorizontalPodAutoscalerBehaviorScaleUp
{-# INLINE v2HorizontalPodAutoscalerBehaviorScaleUpL #-}



-- * V2HorizontalPodAutoscalerCondition

-- | 'v2HorizontalPodAutoscalerConditionLastTransitionTime' Lens
v2HorizontalPodAutoscalerConditionLastTransitionTimeL :: Lens_' V2HorizontalPodAutoscalerCondition (Maybe DateTime)
v2HorizontalPodAutoscalerConditionLastTransitionTimeL f V2HorizontalPodAutoscalerCondition{..} = (\v2HorizontalPodAutoscalerConditionLastTransitionTime -> V2HorizontalPodAutoscalerCondition { v2HorizontalPodAutoscalerConditionLastTransitionTime, ..} ) <$> f v2HorizontalPodAutoscalerConditionLastTransitionTime
{-# INLINE v2HorizontalPodAutoscalerConditionLastTransitionTimeL #-}

-- | 'v2HorizontalPodAutoscalerConditionMessage' Lens
v2HorizontalPodAutoscalerConditionMessageL :: Lens_' V2HorizontalPodAutoscalerCondition (Maybe Text)
v2HorizontalPodAutoscalerConditionMessageL f V2HorizontalPodAutoscalerCondition{..} = (\v2HorizontalPodAutoscalerConditionMessage -> V2HorizontalPodAutoscalerCondition { v2HorizontalPodAutoscalerConditionMessage, ..} ) <$> f v2HorizontalPodAutoscalerConditionMessage
{-# INLINE v2HorizontalPodAutoscalerConditionMessageL #-}

-- | 'v2HorizontalPodAutoscalerConditionReason' Lens
v2HorizontalPodAutoscalerConditionReasonL :: Lens_' V2HorizontalPodAutoscalerCondition (Maybe Text)
v2HorizontalPodAutoscalerConditionReasonL f V2HorizontalPodAutoscalerCondition{..} = (\v2HorizontalPodAutoscalerConditionReason -> V2HorizontalPodAutoscalerCondition { v2HorizontalPodAutoscalerConditionReason, ..} ) <$> f v2HorizontalPodAutoscalerConditionReason
{-# INLINE v2HorizontalPodAutoscalerConditionReasonL #-}

-- | 'v2HorizontalPodAutoscalerConditionStatus' Lens
v2HorizontalPodAutoscalerConditionStatusL :: Lens_' V2HorizontalPodAutoscalerCondition (Text)
v2HorizontalPodAutoscalerConditionStatusL f V2HorizontalPodAutoscalerCondition{..} = (\v2HorizontalPodAutoscalerConditionStatus -> V2HorizontalPodAutoscalerCondition { v2HorizontalPodAutoscalerConditionStatus, ..} ) <$> f v2HorizontalPodAutoscalerConditionStatus
{-# INLINE v2HorizontalPodAutoscalerConditionStatusL #-}

-- | 'v2HorizontalPodAutoscalerConditionType' Lens
v2HorizontalPodAutoscalerConditionTypeL :: Lens_' V2HorizontalPodAutoscalerCondition (Text)
v2HorizontalPodAutoscalerConditionTypeL f V2HorizontalPodAutoscalerCondition{..} = (\v2HorizontalPodAutoscalerConditionType -> V2HorizontalPodAutoscalerCondition { v2HorizontalPodAutoscalerConditionType, ..} ) <$> f v2HorizontalPodAutoscalerConditionType
{-# INLINE v2HorizontalPodAutoscalerConditionTypeL #-}



-- * V2HorizontalPodAutoscalerList

-- | 'v2HorizontalPodAutoscalerListApiVersion' Lens
v2HorizontalPodAutoscalerListApiVersionL :: Lens_' V2HorizontalPodAutoscalerList (Maybe Text)
v2HorizontalPodAutoscalerListApiVersionL f V2HorizontalPodAutoscalerList{..} = (\v2HorizontalPodAutoscalerListApiVersion -> V2HorizontalPodAutoscalerList { v2HorizontalPodAutoscalerListApiVersion, ..} ) <$> f v2HorizontalPodAutoscalerListApiVersion
{-# INLINE v2HorizontalPodAutoscalerListApiVersionL #-}

-- | 'v2HorizontalPodAutoscalerListItems' Lens
v2HorizontalPodAutoscalerListItemsL :: Lens_' V2HorizontalPodAutoscalerList ([V2HorizontalPodAutoscaler])
v2HorizontalPodAutoscalerListItemsL f V2HorizontalPodAutoscalerList{..} = (\v2HorizontalPodAutoscalerListItems -> V2HorizontalPodAutoscalerList { v2HorizontalPodAutoscalerListItems, ..} ) <$> f v2HorizontalPodAutoscalerListItems
{-# INLINE v2HorizontalPodAutoscalerListItemsL #-}

-- | 'v2HorizontalPodAutoscalerListKind' Lens
v2HorizontalPodAutoscalerListKindL :: Lens_' V2HorizontalPodAutoscalerList (Maybe Text)
v2HorizontalPodAutoscalerListKindL f V2HorizontalPodAutoscalerList{..} = (\v2HorizontalPodAutoscalerListKind -> V2HorizontalPodAutoscalerList { v2HorizontalPodAutoscalerListKind, ..} ) <$> f v2HorizontalPodAutoscalerListKind
{-# INLINE v2HorizontalPodAutoscalerListKindL #-}

-- | 'v2HorizontalPodAutoscalerListMetadata' Lens
v2HorizontalPodAutoscalerListMetadataL :: Lens_' V2HorizontalPodAutoscalerList (Maybe V1ListMeta)
v2HorizontalPodAutoscalerListMetadataL f V2HorizontalPodAutoscalerList{..} = (\v2HorizontalPodAutoscalerListMetadata -> V2HorizontalPodAutoscalerList { v2HorizontalPodAutoscalerListMetadata, ..} ) <$> f v2HorizontalPodAutoscalerListMetadata
{-# INLINE v2HorizontalPodAutoscalerListMetadataL #-}



-- * V2HorizontalPodAutoscalerSpec

-- | 'v2HorizontalPodAutoscalerSpecBehavior' Lens
v2HorizontalPodAutoscalerSpecBehaviorL :: Lens_' V2HorizontalPodAutoscalerSpec (Maybe V2HorizontalPodAutoscalerBehavior)
v2HorizontalPodAutoscalerSpecBehaviorL f V2HorizontalPodAutoscalerSpec{..} = (\v2HorizontalPodAutoscalerSpecBehavior -> V2HorizontalPodAutoscalerSpec { v2HorizontalPodAutoscalerSpecBehavior, ..} ) <$> f v2HorizontalPodAutoscalerSpecBehavior
{-# INLINE v2HorizontalPodAutoscalerSpecBehaviorL #-}

-- | 'v2HorizontalPodAutoscalerSpecMaxReplicas' Lens
v2HorizontalPodAutoscalerSpecMaxReplicasL :: Lens_' V2HorizontalPodAutoscalerSpec (Int)
v2HorizontalPodAutoscalerSpecMaxReplicasL f V2HorizontalPodAutoscalerSpec{..} = (\v2HorizontalPodAutoscalerSpecMaxReplicas -> V2HorizontalPodAutoscalerSpec { v2HorizontalPodAutoscalerSpecMaxReplicas, ..} ) <$> f v2HorizontalPodAutoscalerSpecMaxReplicas
{-# INLINE v2HorizontalPodAutoscalerSpecMaxReplicasL #-}

-- | 'v2HorizontalPodAutoscalerSpecMetrics' Lens
v2HorizontalPodAutoscalerSpecMetricsL :: Lens_' V2HorizontalPodAutoscalerSpec (Maybe [V2MetricSpec])
v2HorizontalPodAutoscalerSpecMetricsL f V2HorizontalPodAutoscalerSpec{..} = (\v2HorizontalPodAutoscalerSpecMetrics -> V2HorizontalPodAutoscalerSpec { v2HorizontalPodAutoscalerSpecMetrics, ..} ) <$> f v2HorizontalPodAutoscalerSpecMetrics
{-# INLINE v2HorizontalPodAutoscalerSpecMetricsL #-}

-- | 'v2HorizontalPodAutoscalerSpecMinReplicas' Lens
v2HorizontalPodAutoscalerSpecMinReplicasL :: Lens_' V2HorizontalPodAutoscalerSpec (Maybe Int)
v2HorizontalPodAutoscalerSpecMinReplicasL f V2HorizontalPodAutoscalerSpec{..} = (\v2HorizontalPodAutoscalerSpecMinReplicas -> V2HorizontalPodAutoscalerSpec { v2HorizontalPodAutoscalerSpecMinReplicas, ..} ) <$> f v2HorizontalPodAutoscalerSpecMinReplicas
{-# INLINE v2HorizontalPodAutoscalerSpecMinReplicasL #-}

-- | 'v2HorizontalPodAutoscalerSpecScaleTargetRef' Lens
v2HorizontalPodAutoscalerSpecScaleTargetRefL :: Lens_' V2HorizontalPodAutoscalerSpec (V2CrossVersionObjectReference)
v2HorizontalPodAutoscalerSpecScaleTargetRefL f V2HorizontalPodAutoscalerSpec{..} = (\v2HorizontalPodAutoscalerSpecScaleTargetRef -> V2HorizontalPodAutoscalerSpec { v2HorizontalPodAutoscalerSpecScaleTargetRef, ..} ) <$> f v2HorizontalPodAutoscalerSpecScaleTargetRef
{-# INLINE v2HorizontalPodAutoscalerSpecScaleTargetRefL #-}



-- * V2HorizontalPodAutoscalerStatus

-- | 'v2HorizontalPodAutoscalerStatusConditions' Lens
v2HorizontalPodAutoscalerStatusConditionsL :: Lens_' V2HorizontalPodAutoscalerStatus (Maybe [V2HorizontalPodAutoscalerCondition])
v2HorizontalPodAutoscalerStatusConditionsL f V2HorizontalPodAutoscalerStatus{..} = (\v2HorizontalPodAutoscalerStatusConditions -> V2HorizontalPodAutoscalerStatus { v2HorizontalPodAutoscalerStatusConditions, ..} ) <$> f v2HorizontalPodAutoscalerStatusConditions
{-# INLINE v2HorizontalPodAutoscalerStatusConditionsL #-}

-- | 'v2HorizontalPodAutoscalerStatusCurrentMetrics' Lens
v2HorizontalPodAutoscalerStatusCurrentMetricsL :: Lens_' V2HorizontalPodAutoscalerStatus (Maybe [V2MetricStatus])
v2HorizontalPodAutoscalerStatusCurrentMetricsL f V2HorizontalPodAutoscalerStatus{..} = (\v2HorizontalPodAutoscalerStatusCurrentMetrics -> V2HorizontalPodAutoscalerStatus { v2HorizontalPodAutoscalerStatusCurrentMetrics, ..} ) <$> f v2HorizontalPodAutoscalerStatusCurrentMetrics
{-# INLINE v2HorizontalPodAutoscalerStatusCurrentMetricsL #-}

-- | 'v2HorizontalPodAutoscalerStatusCurrentReplicas' Lens
v2HorizontalPodAutoscalerStatusCurrentReplicasL :: Lens_' V2HorizontalPodAutoscalerStatus (Maybe Int)
v2HorizontalPodAutoscalerStatusCurrentReplicasL f V2HorizontalPodAutoscalerStatus{..} = (\v2HorizontalPodAutoscalerStatusCurrentReplicas -> V2HorizontalPodAutoscalerStatus { v2HorizontalPodAutoscalerStatusCurrentReplicas, ..} ) <$> f v2HorizontalPodAutoscalerStatusCurrentReplicas
{-# INLINE v2HorizontalPodAutoscalerStatusCurrentReplicasL #-}

-- | 'v2HorizontalPodAutoscalerStatusDesiredReplicas' Lens
v2HorizontalPodAutoscalerStatusDesiredReplicasL :: Lens_' V2HorizontalPodAutoscalerStatus (Int)
v2HorizontalPodAutoscalerStatusDesiredReplicasL f V2HorizontalPodAutoscalerStatus{..} = (\v2HorizontalPodAutoscalerStatusDesiredReplicas -> V2HorizontalPodAutoscalerStatus { v2HorizontalPodAutoscalerStatusDesiredReplicas, ..} ) <$> f v2HorizontalPodAutoscalerStatusDesiredReplicas
{-# INLINE v2HorizontalPodAutoscalerStatusDesiredReplicasL #-}

-- | 'v2HorizontalPodAutoscalerStatusLastScaleTime' Lens
v2HorizontalPodAutoscalerStatusLastScaleTimeL :: Lens_' V2HorizontalPodAutoscalerStatus (Maybe DateTime)
v2HorizontalPodAutoscalerStatusLastScaleTimeL f V2HorizontalPodAutoscalerStatus{..} = (\v2HorizontalPodAutoscalerStatusLastScaleTime -> V2HorizontalPodAutoscalerStatus { v2HorizontalPodAutoscalerStatusLastScaleTime, ..} ) <$> f v2HorizontalPodAutoscalerStatusLastScaleTime
{-# INLINE v2HorizontalPodAutoscalerStatusLastScaleTimeL #-}

-- | 'v2HorizontalPodAutoscalerStatusObservedGeneration' Lens
v2HorizontalPodAutoscalerStatusObservedGenerationL :: Lens_' V2HorizontalPodAutoscalerStatus (Maybe Integer)
v2HorizontalPodAutoscalerStatusObservedGenerationL f V2HorizontalPodAutoscalerStatus{..} = (\v2HorizontalPodAutoscalerStatusObservedGeneration -> V2HorizontalPodAutoscalerStatus { v2HorizontalPodAutoscalerStatusObservedGeneration, ..} ) <$> f v2HorizontalPodAutoscalerStatusObservedGeneration
{-# INLINE v2HorizontalPodAutoscalerStatusObservedGenerationL #-}



-- * V2MetricIdentifier

-- | 'v2MetricIdentifierName' Lens
v2MetricIdentifierNameL :: Lens_' V2MetricIdentifier (Text)
v2MetricIdentifierNameL f V2MetricIdentifier{..} = (\v2MetricIdentifierName -> V2MetricIdentifier { v2MetricIdentifierName, ..} ) <$> f v2MetricIdentifierName
{-# INLINE v2MetricIdentifierNameL #-}

-- | 'v2MetricIdentifierSelector' Lens
v2MetricIdentifierSelectorL :: Lens_' V2MetricIdentifier (Maybe V1LabelSelector)
v2MetricIdentifierSelectorL f V2MetricIdentifier{..} = (\v2MetricIdentifierSelector -> V2MetricIdentifier { v2MetricIdentifierSelector, ..} ) <$> f v2MetricIdentifierSelector
{-# INLINE v2MetricIdentifierSelectorL #-}



-- * V2MetricSpec

-- | 'v2MetricSpecContainerResource' Lens
v2MetricSpecContainerResourceL :: Lens_' V2MetricSpec (Maybe V2ContainerResourceMetricSource)
v2MetricSpecContainerResourceL f V2MetricSpec{..} = (\v2MetricSpecContainerResource -> V2MetricSpec { v2MetricSpecContainerResource, ..} ) <$> f v2MetricSpecContainerResource
{-# INLINE v2MetricSpecContainerResourceL #-}

-- | 'v2MetricSpecExternal' Lens
v2MetricSpecExternalL :: Lens_' V2MetricSpec (Maybe V2ExternalMetricSource)
v2MetricSpecExternalL f V2MetricSpec{..} = (\v2MetricSpecExternal -> V2MetricSpec { v2MetricSpecExternal, ..} ) <$> f v2MetricSpecExternal
{-# INLINE v2MetricSpecExternalL #-}

-- | 'v2MetricSpecObject' Lens
v2MetricSpecObjectL :: Lens_' V2MetricSpec (Maybe V2ObjectMetricSource)
v2MetricSpecObjectL f V2MetricSpec{..} = (\v2MetricSpecObject -> V2MetricSpec { v2MetricSpecObject, ..} ) <$> f v2MetricSpecObject
{-# INLINE v2MetricSpecObjectL #-}

-- | 'v2MetricSpecPods' Lens
v2MetricSpecPodsL :: Lens_' V2MetricSpec (Maybe V2PodsMetricSource)
v2MetricSpecPodsL f V2MetricSpec{..} = (\v2MetricSpecPods -> V2MetricSpec { v2MetricSpecPods, ..} ) <$> f v2MetricSpecPods
{-# INLINE v2MetricSpecPodsL #-}

-- | 'v2MetricSpecResource' Lens
v2MetricSpecResourceL :: Lens_' V2MetricSpec (Maybe V2ResourceMetricSource)
v2MetricSpecResourceL f V2MetricSpec{..} = (\v2MetricSpecResource -> V2MetricSpec { v2MetricSpecResource, ..} ) <$> f v2MetricSpecResource
{-# INLINE v2MetricSpecResourceL #-}

-- | 'v2MetricSpecType' Lens
v2MetricSpecTypeL :: Lens_' V2MetricSpec (Text)
v2MetricSpecTypeL f V2MetricSpec{..} = (\v2MetricSpecType -> V2MetricSpec { v2MetricSpecType, ..} ) <$> f v2MetricSpecType
{-# INLINE v2MetricSpecTypeL #-}



-- * V2MetricStatus

-- | 'v2MetricStatusContainerResource' Lens
v2MetricStatusContainerResourceL :: Lens_' V2MetricStatus (Maybe V2ContainerResourceMetricStatus)
v2MetricStatusContainerResourceL f V2MetricStatus{..} = (\v2MetricStatusContainerResource -> V2MetricStatus { v2MetricStatusContainerResource, ..} ) <$> f v2MetricStatusContainerResource
{-# INLINE v2MetricStatusContainerResourceL #-}

-- | 'v2MetricStatusExternal' Lens
v2MetricStatusExternalL :: Lens_' V2MetricStatus (Maybe V2ExternalMetricStatus)
v2MetricStatusExternalL f V2MetricStatus{..} = (\v2MetricStatusExternal -> V2MetricStatus { v2MetricStatusExternal, ..} ) <$> f v2MetricStatusExternal
{-# INLINE v2MetricStatusExternalL #-}

-- | 'v2MetricStatusObject' Lens
v2MetricStatusObjectL :: Lens_' V2MetricStatus (Maybe V2ObjectMetricStatus)
v2MetricStatusObjectL f V2MetricStatus{..} = (\v2MetricStatusObject -> V2MetricStatus { v2MetricStatusObject, ..} ) <$> f v2MetricStatusObject
{-# INLINE v2MetricStatusObjectL #-}

-- | 'v2MetricStatusPods' Lens
v2MetricStatusPodsL :: Lens_' V2MetricStatus (Maybe V2PodsMetricStatus)
v2MetricStatusPodsL f V2MetricStatus{..} = (\v2MetricStatusPods -> V2MetricStatus { v2MetricStatusPods, ..} ) <$> f v2MetricStatusPods
{-# INLINE v2MetricStatusPodsL #-}

-- | 'v2MetricStatusResource' Lens
v2MetricStatusResourceL :: Lens_' V2MetricStatus (Maybe V2ResourceMetricStatus)
v2MetricStatusResourceL f V2MetricStatus{..} = (\v2MetricStatusResource -> V2MetricStatus { v2MetricStatusResource, ..} ) <$> f v2MetricStatusResource
{-# INLINE v2MetricStatusResourceL #-}

-- | 'v2MetricStatusType' Lens
v2MetricStatusTypeL :: Lens_' V2MetricStatus (Text)
v2MetricStatusTypeL f V2MetricStatus{..} = (\v2MetricStatusType -> V2MetricStatus { v2MetricStatusType, ..} ) <$> f v2MetricStatusType
{-# INLINE v2MetricStatusTypeL #-}



-- * V2MetricTarget

-- | 'v2MetricTargetAverageUtilization' Lens
v2MetricTargetAverageUtilizationL :: Lens_' V2MetricTarget (Maybe Int)
v2MetricTargetAverageUtilizationL f V2MetricTarget{..} = (\v2MetricTargetAverageUtilization -> V2MetricTarget { v2MetricTargetAverageUtilization, ..} ) <$> f v2MetricTargetAverageUtilization
{-# INLINE v2MetricTargetAverageUtilizationL #-}

-- | 'v2MetricTargetAverageValue' Lens
v2MetricTargetAverageValueL :: Lens_' V2MetricTarget (Maybe Quantity)
v2MetricTargetAverageValueL f V2MetricTarget{..} = (\v2MetricTargetAverageValue -> V2MetricTarget { v2MetricTargetAverageValue, ..} ) <$> f v2MetricTargetAverageValue
{-# INLINE v2MetricTargetAverageValueL #-}

-- | 'v2MetricTargetType' Lens
v2MetricTargetTypeL :: Lens_' V2MetricTarget (Text)
v2MetricTargetTypeL f V2MetricTarget{..} = (\v2MetricTargetType -> V2MetricTarget { v2MetricTargetType, ..} ) <$> f v2MetricTargetType
{-# INLINE v2MetricTargetTypeL #-}

-- | 'v2MetricTargetValue' Lens
v2MetricTargetValueL :: Lens_' V2MetricTarget (Maybe Quantity)
v2MetricTargetValueL f V2MetricTarget{..} = (\v2MetricTargetValue -> V2MetricTarget { v2MetricTargetValue, ..} ) <$> f v2MetricTargetValue
{-# INLINE v2MetricTargetValueL #-}



-- * V2MetricValueStatus

-- | 'v2MetricValueStatusAverageUtilization' Lens
v2MetricValueStatusAverageUtilizationL :: Lens_' V2MetricValueStatus (Maybe Int)
v2MetricValueStatusAverageUtilizationL f V2MetricValueStatus{..} = (\v2MetricValueStatusAverageUtilization -> V2MetricValueStatus { v2MetricValueStatusAverageUtilization, ..} ) <$> f v2MetricValueStatusAverageUtilization
{-# INLINE v2MetricValueStatusAverageUtilizationL #-}

-- | 'v2MetricValueStatusAverageValue' Lens
v2MetricValueStatusAverageValueL :: Lens_' V2MetricValueStatus (Maybe Quantity)
v2MetricValueStatusAverageValueL f V2MetricValueStatus{..} = (\v2MetricValueStatusAverageValue -> V2MetricValueStatus { v2MetricValueStatusAverageValue, ..} ) <$> f v2MetricValueStatusAverageValue
{-# INLINE v2MetricValueStatusAverageValueL #-}

-- | 'v2MetricValueStatusValue' Lens
v2MetricValueStatusValueL :: Lens_' V2MetricValueStatus (Maybe Quantity)
v2MetricValueStatusValueL f V2MetricValueStatus{..} = (\v2MetricValueStatusValue -> V2MetricValueStatus { v2MetricValueStatusValue, ..} ) <$> f v2MetricValueStatusValue
{-# INLINE v2MetricValueStatusValueL #-}



-- * V2ObjectMetricSource

-- | 'v2ObjectMetricSourceDescribedObject' Lens
v2ObjectMetricSourceDescribedObjectL :: Lens_' V2ObjectMetricSource (V2CrossVersionObjectReference)
v2ObjectMetricSourceDescribedObjectL f V2ObjectMetricSource{..} = (\v2ObjectMetricSourceDescribedObject -> V2ObjectMetricSource { v2ObjectMetricSourceDescribedObject, ..} ) <$> f v2ObjectMetricSourceDescribedObject
{-# INLINE v2ObjectMetricSourceDescribedObjectL #-}

-- | 'v2ObjectMetricSourceMetric' Lens
v2ObjectMetricSourceMetricL :: Lens_' V2ObjectMetricSource (V2MetricIdentifier)
v2ObjectMetricSourceMetricL f V2ObjectMetricSource{..} = (\v2ObjectMetricSourceMetric -> V2ObjectMetricSource { v2ObjectMetricSourceMetric, ..} ) <$> f v2ObjectMetricSourceMetric
{-# INLINE v2ObjectMetricSourceMetricL #-}

-- | 'v2ObjectMetricSourceTarget' Lens
v2ObjectMetricSourceTargetL :: Lens_' V2ObjectMetricSource (V2MetricTarget)
v2ObjectMetricSourceTargetL f V2ObjectMetricSource{..} = (\v2ObjectMetricSourceTarget -> V2ObjectMetricSource { v2ObjectMetricSourceTarget, ..} ) <$> f v2ObjectMetricSourceTarget
{-# INLINE v2ObjectMetricSourceTargetL #-}



-- * V2ObjectMetricStatus

-- | 'v2ObjectMetricStatusCurrent' Lens
v2ObjectMetricStatusCurrentL :: Lens_' V2ObjectMetricStatus (V2MetricValueStatus)
v2ObjectMetricStatusCurrentL f V2ObjectMetricStatus{..} = (\v2ObjectMetricStatusCurrent -> V2ObjectMetricStatus { v2ObjectMetricStatusCurrent, ..} ) <$> f v2ObjectMetricStatusCurrent
{-# INLINE v2ObjectMetricStatusCurrentL #-}

-- | 'v2ObjectMetricStatusDescribedObject' Lens
v2ObjectMetricStatusDescribedObjectL :: Lens_' V2ObjectMetricStatus (V2CrossVersionObjectReference)
v2ObjectMetricStatusDescribedObjectL f V2ObjectMetricStatus{..} = (\v2ObjectMetricStatusDescribedObject -> V2ObjectMetricStatus { v2ObjectMetricStatusDescribedObject, ..} ) <$> f v2ObjectMetricStatusDescribedObject
{-# INLINE v2ObjectMetricStatusDescribedObjectL #-}

-- | 'v2ObjectMetricStatusMetric' Lens
v2ObjectMetricStatusMetricL :: Lens_' V2ObjectMetricStatus (V2MetricIdentifier)
v2ObjectMetricStatusMetricL f V2ObjectMetricStatus{..} = (\v2ObjectMetricStatusMetric -> V2ObjectMetricStatus { v2ObjectMetricStatusMetric, ..} ) <$> f v2ObjectMetricStatusMetric
{-# INLINE v2ObjectMetricStatusMetricL #-}



-- * V2PodsMetricSource

-- | 'v2PodsMetricSourceMetric' Lens
v2PodsMetricSourceMetricL :: Lens_' V2PodsMetricSource (V2MetricIdentifier)
v2PodsMetricSourceMetricL f V2PodsMetricSource{..} = (\v2PodsMetricSourceMetric -> V2PodsMetricSource { v2PodsMetricSourceMetric, ..} ) <$> f v2PodsMetricSourceMetric
{-# INLINE v2PodsMetricSourceMetricL #-}

-- | 'v2PodsMetricSourceTarget' Lens
v2PodsMetricSourceTargetL :: Lens_' V2PodsMetricSource (V2MetricTarget)
v2PodsMetricSourceTargetL f V2PodsMetricSource{..} = (\v2PodsMetricSourceTarget -> V2PodsMetricSource { v2PodsMetricSourceTarget, ..} ) <$> f v2PodsMetricSourceTarget
{-# INLINE v2PodsMetricSourceTargetL #-}



-- * V2PodsMetricStatus

-- | 'v2PodsMetricStatusCurrent' Lens
v2PodsMetricStatusCurrentL :: Lens_' V2PodsMetricStatus (V2MetricValueStatus)
v2PodsMetricStatusCurrentL f V2PodsMetricStatus{..} = (\v2PodsMetricStatusCurrent -> V2PodsMetricStatus { v2PodsMetricStatusCurrent, ..} ) <$> f v2PodsMetricStatusCurrent
{-# INLINE v2PodsMetricStatusCurrentL #-}

-- | 'v2PodsMetricStatusMetric' Lens
v2PodsMetricStatusMetricL :: Lens_' V2PodsMetricStatus (V2MetricIdentifier)
v2PodsMetricStatusMetricL f V2PodsMetricStatus{..} = (\v2PodsMetricStatusMetric -> V2PodsMetricStatus { v2PodsMetricStatusMetric, ..} ) <$> f v2PodsMetricStatusMetric
{-# INLINE v2PodsMetricStatusMetricL #-}



-- * V2ResourceMetricSource

-- | 'v2ResourceMetricSourceName' Lens
v2ResourceMetricSourceNameL :: Lens_' V2ResourceMetricSource (Text)
v2ResourceMetricSourceNameL f V2ResourceMetricSource{..} = (\v2ResourceMetricSourceName -> V2ResourceMetricSource { v2ResourceMetricSourceName, ..} ) <$> f v2ResourceMetricSourceName
{-# INLINE v2ResourceMetricSourceNameL #-}

-- | 'v2ResourceMetricSourceTarget' Lens
v2ResourceMetricSourceTargetL :: Lens_' V2ResourceMetricSource (V2MetricTarget)
v2ResourceMetricSourceTargetL f V2ResourceMetricSource{..} = (\v2ResourceMetricSourceTarget -> V2ResourceMetricSource { v2ResourceMetricSourceTarget, ..} ) <$> f v2ResourceMetricSourceTarget
{-# INLINE v2ResourceMetricSourceTargetL #-}



-- * V2ResourceMetricStatus

-- | 'v2ResourceMetricStatusCurrent' Lens
v2ResourceMetricStatusCurrentL :: Lens_' V2ResourceMetricStatus (V2MetricValueStatus)
v2ResourceMetricStatusCurrentL f V2ResourceMetricStatus{..} = (\v2ResourceMetricStatusCurrent -> V2ResourceMetricStatus { v2ResourceMetricStatusCurrent, ..} ) <$> f v2ResourceMetricStatusCurrent
{-# INLINE v2ResourceMetricStatusCurrentL #-}

-- | 'v2ResourceMetricStatusName' Lens
v2ResourceMetricStatusNameL :: Lens_' V2ResourceMetricStatus (Text)
v2ResourceMetricStatusNameL f V2ResourceMetricStatus{..} = (\v2ResourceMetricStatusName -> V2ResourceMetricStatus { v2ResourceMetricStatusName, ..} ) <$> f v2ResourceMetricStatusName
{-# INLINE v2ResourceMetricStatusNameL #-}



-- * V2beta1ContainerResourceMetricSource

-- | 'v2beta1ContainerResourceMetricSourceContainer' Lens
v2beta1ContainerResourceMetricSourceContainerL :: Lens_' V2beta1ContainerResourceMetricSource (Text)
v2beta1ContainerResourceMetricSourceContainerL f V2beta1ContainerResourceMetricSource{..} = (\v2beta1ContainerResourceMetricSourceContainer -> V2beta1ContainerResourceMetricSource { v2beta1ContainerResourceMetricSourceContainer, ..} ) <$> f v2beta1ContainerResourceMetricSourceContainer
{-# INLINE v2beta1ContainerResourceMetricSourceContainerL #-}

-- | 'v2beta1ContainerResourceMetricSourceName' Lens
v2beta1ContainerResourceMetricSourceNameL :: Lens_' V2beta1ContainerResourceMetricSource (Text)
v2beta1ContainerResourceMetricSourceNameL f V2beta1ContainerResourceMetricSource{..} = (\v2beta1ContainerResourceMetricSourceName -> V2beta1ContainerResourceMetricSource { v2beta1ContainerResourceMetricSourceName, ..} ) <$> f v2beta1ContainerResourceMetricSourceName
{-# INLINE v2beta1ContainerResourceMetricSourceNameL #-}

-- | 'v2beta1ContainerResourceMetricSourceTargetAverageUtilization' Lens
v2beta1ContainerResourceMetricSourceTargetAverageUtilizationL :: Lens_' V2beta1ContainerResourceMetricSource (Maybe Int)
v2beta1ContainerResourceMetricSourceTargetAverageUtilizationL f V2beta1ContainerResourceMetricSource{..} = (\v2beta1ContainerResourceMetricSourceTargetAverageUtilization -> V2beta1ContainerResourceMetricSource { v2beta1ContainerResourceMetricSourceTargetAverageUtilization, ..} ) <$> f v2beta1ContainerResourceMetricSourceTargetAverageUtilization
{-# INLINE v2beta1ContainerResourceMetricSourceTargetAverageUtilizationL #-}

-- | 'v2beta1ContainerResourceMetricSourceTargetAverageValue' Lens
v2beta1ContainerResourceMetricSourceTargetAverageValueL :: Lens_' V2beta1ContainerResourceMetricSource (Maybe Quantity)
v2beta1ContainerResourceMetricSourceTargetAverageValueL f V2beta1ContainerResourceMetricSource{..} = (\v2beta1ContainerResourceMetricSourceTargetAverageValue -> V2beta1ContainerResourceMetricSource { v2beta1ContainerResourceMetricSourceTargetAverageValue, ..} ) <$> f v2beta1ContainerResourceMetricSourceTargetAverageValue
{-# INLINE v2beta1ContainerResourceMetricSourceTargetAverageValueL #-}



-- * V2beta1ContainerResourceMetricStatus

-- | 'v2beta1ContainerResourceMetricStatusContainer' Lens
v2beta1ContainerResourceMetricStatusContainerL :: Lens_' V2beta1ContainerResourceMetricStatus (Text)
v2beta1ContainerResourceMetricStatusContainerL f V2beta1ContainerResourceMetricStatus{..} = (\v2beta1ContainerResourceMetricStatusContainer -> V2beta1ContainerResourceMetricStatus { v2beta1ContainerResourceMetricStatusContainer, ..} ) <$> f v2beta1ContainerResourceMetricStatusContainer
{-# INLINE v2beta1ContainerResourceMetricStatusContainerL #-}

-- | 'v2beta1ContainerResourceMetricStatusCurrentAverageUtilization' Lens
v2beta1ContainerResourceMetricStatusCurrentAverageUtilizationL :: Lens_' V2beta1ContainerResourceMetricStatus (Maybe Int)
v2beta1ContainerResourceMetricStatusCurrentAverageUtilizationL f V2beta1ContainerResourceMetricStatus{..} = (\v2beta1ContainerResourceMetricStatusCurrentAverageUtilization -> V2beta1ContainerResourceMetricStatus { v2beta1ContainerResourceMetricStatusCurrentAverageUtilization, ..} ) <$> f v2beta1ContainerResourceMetricStatusCurrentAverageUtilization
{-# INLINE v2beta1ContainerResourceMetricStatusCurrentAverageUtilizationL #-}

-- | 'v2beta1ContainerResourceMetricStatusCurrentAverageValue' Lens
v2beta1ContainerResourceMetricStatusCurrentAverageValueL :: Lens_' V2beta1ContainerResourceMetricStatus (Quantity)
v2beta1ContainerResourceMetricStatusCurrentAverageValueL f V2beta1ContainerResourceMetricStatus{..} = (\v2beta1ContainerResourceMetricStatusCurrentAverageValue -> V2beta1ContainerResourceMetricStatus { v2beta1ContainerResourceMetricStatusCurrentAverageValue, ..} ) <$> f v2beta1ContainerResourceMetricStatusCurrentAverageValue
{-# INLINE v2beta1ContainerResourceMetricStatusCurrentAverageValueL #-}

-- | 'v2beta1ContainerResourceMetricStatusName' Lens
v2beta1ContainerResourceMetricStatusNameL :: Lens_' V2beta1ContainerResourceMetricStatus (Text)
v2beta1ContainerResourceMetricStatusNameL f V2beta1ContainerResourceMetricStatus{..} = (\v2beta1ContainerResourceMetricStatusName -> V2beta1ContainerResourceMetricStatus { v2beta1ContainerResourceMetricStatusName, ..} ) <$> f v2beta1ContainerResourceMetricStatusName
{-# INLINE v2beta1ContainerResourceMetricStatusNameL #-}



-- * V2beta1CrossVersionObjectReference

-- | 'v2beta1CrossVersionObjectReferenceApiVersion' Lens
v2beta1CrossVersionObjectReferenceApiVersionL :: Lens_' V2beta1CrossVersionObjectReference (Maybe Text)
v2beta1CrossVersionObjectReferenceApiVersionL f V2beta1CrossVersionObjectReference{..} = (\v2beta1CrossVersionObjectReferenceApiVersion -> V2beta1CrossVersionObjectReference { v2beta1CrossVersionObjectReferenceApiVersion, ..} ) <$> f v2beta1CrossVersionObjectReferenceApiVersion
{-# INLINE v2beta1CrossVersionObjectReferenceApiVersionL #-}

-- | 'v2beta1CrossVersionObjectReferenceKind' Lens
v2beta1CrossVersionObjectReferenceKindL :: Lens_' V2beta1CrossVersionObjectReference (Text)
v2beta1CrossVersionObjectReferenceKindL f V2beta1CrossVersionObjectReference{..} = (\v2beta1CrossVersionObjectReferenceKind -> V2beta1CrossVersionObjectReference { v2beta1CrossVersionObjectReferenceKind, ..} ) <$> f v2beta1CrossVersionObjectReferenceKind
{-# INLINE v2beta1CrossVersionObjectReferenceKindL #-}

-- | 'v2beta1CrossVersionObjectReferenceName' Lens
v2beta1CrossVersionObjectReferenceNameL :: Lens_' V2beta1CrossVersionObjectReference (Text)
v2beta1CrossVersionObjectReferenceNameL f V2beta1CrossVersionObjectReference{..} = (\v2beta1CrossVersionObjectReferenceName -> V2beta1CrossVersionObjectReference { v2beta1CrossVersionObjectReferenceName, ..} ) <$> f v2beta1CrossVersionObjectReferenceName
{-# INLINE v2beta1CrossVersionObjectReferenceNameL #-}



-- * V2beta1ExternalMetricSource

-- | 'v2beta1ExternalMetricSourceMetricName' Lens
v2beta1ExternalMetricSourceMetricNameL :: Lens_' V2beta1ExternalMetricSource (Text)
v2beta1ExternalMetricSourceMetricNameL f V2beta1ExternalMetricSource{..} = (\v2beta1ExternalMetricSourceMetricName -> V2beta1ExternalMetricSource { v2beta1ExternalMetricSourceMetricName, ..} ) <$> f v2beta1ExternalMetricSourceMetricName
{-# INLINE v2beta1ExternalMetricSourceMetricNameL #-}

-- | 'v2beta1ExternalMetricSourceMetricSelector' Lens
v2beta1ExternalMetricSourceMetricSelectorL :: Lens_' V2beta1ExternalMetricSource (Maybe V1LabelSelector)
v2beta1ExternalMetricSourceMetricSelectorL f V2beta1ExternalMetricSource{..} = (\v2beta1ExternalMetricSourceMetricSelector -> V2beta1ExternalMetricSource { v2beta1ExternalMetricSourceMetricSelector, ..} ) <$> f v2beta1ExternalMetricSourceMetricSelector
{-# INLINE v2beta1ExternalMetricSourceMetricSelectorL #-}

-- | 'v2beta1ExternalMetricSourceTargetAverageValue' Lens
v2beta1ExternalMetricSourceTargetAverageValueL :: Lens_' V2beta1ExternalMetricSource (Maybe Quantity)
v2beta1ExternalMetricSourceTargetAverageValueL f V2beta1ExternalMetricSource{..} = (\v2beta1ExternalMetricSourceTargetAverageValue -> V2beta1ExternalMetricSource { v2beta1ExternalMetricSourceTargetAverageValue, ..} ) <$> f v2beta1ExternalMetricSourceTargetAverageValue
{-# INLINE v2beta1ExternalMetricSourceTargetAverageValueL #-}

-- | 'v2beta1ExternalMetricSourceTargetValue' Lens
v2beta1ExternalMetricSourceTargetValueL :: Lens_' V2beta1ExternalMetricSource (Maybe Quantity)
v2beta1ExternalMetricSourceTargetValueL f V2beta1ExternalMetricSource{..} = (\v2beta1ExternalMetricSourceTargetValue -> V2beta1ExternalMetricSource { v2beta1ExternalMetricSourceTargetValue, ..} ) <$> f v2beta1ExternalMetricSourceTargetValue
{-# INLINE v2beta1ExternalMetricSourceTargetValueL #-}



-- * V2beta1ExternalMetricStatus

-- | 'v2beta1ExternalMetricStatusCurrentAverageValue' Lens
v2beta1ExternalMetricStatusCurrentAverageValueL :: Lens_' V2beta1ExternalMetricStatus (Maybe Quantity)
v2beta1ExternalMetricStatusCurrentAverageValueL f V2beta1ExternalMetricStatus{..} = (\v2beta1ExternalMetricStatusCurrentAverageValue -> V2beta1ExternalMetricStatus { v2beta1ExternalMetricStatusCurrentAverageValue, ..} ) <$> f v2beta1ExternalMetricStatusCurrentAverageValue
{-# INLINE v2beta1ExternalMetricStatusCurrentAverageValueL #-}

-- | 'v2beta1ExternalMetricStatusCurrentValue' Lens
v2beta1ExternalMetricStatusCurrentValueL :: Lens_' V2beta1ExternalMetricStatus (Quantity)
v2beta1ExternalMetricStatusCurrentValueL f V2beta1ExternalMetricStatus{..} = (\v2beta1ExternalMetricStatusCurrentValue -> V2beta1ExternalMetricStatus { v2beta1ExternalMetricStatusCurrentValue, ..} ) <$> f v2beta1ExternalMetricStatusCurrentValue
{-# INLINE v2beta1ExternalMetricStatusCurrentValueL #-}

-- | 'v2beta1ExternalMetricStatusMetricName' Lens
v2beta1ExternalMetricStatusMetricNameL :: Lens_' V2beta1ExternalMetricStatus (Text)
v2beta1ExternalMetricStatusMetricNameL f V2beta1ExternalMetricStatus{..} = (\v2beta1ExternalMetricStatusMetricName -> V2beta1ExternalMetricStatus { v2beta1ExternalMetricStatusMetricName, ..} ) <$> f v2beta1ExternalMetricStatusMetricName
{-# INLINE v2beta1ExternalMetricStatusMetricNameL #-}

-- | 'v2beta1ExternalMetricStatusMetricSelector' Lens
v2beta1ExternalMetricStatusMetricSelectorL :: Lens_' V2beta1ExternalMetricStatus (Maybe V1LabelSelector)
v2beta1ExternalMetricStatusMetricSelectorL f V2beta1ExternalMetricStatus{..} = (\v2beta1ExternalMetricStatusMetricSelector -> V2beta1ExternalMetricStatus { v2beta1ExternalMetricStatusMetricSelector, ..} ) <$> f v2beta1ExternalMetricStatusMetricSelector
{-# INLINE v2beta1ExternalMetricStatusMetricSelectorL #-}



-- * V2beta1HorizontalPodAutoscaler

-- | 'v2beta1HorizontalPodAutoscalerApiVersion' Lens
v2beta1HorizontalPodAutoscalerApiVersionL :: Lens_' V2beta1HorizontalPodAutoscaler (Maybe Text)
v2beta1HorizontalPodAutoscalerApiVersionL f V2beta1HorizontalPodAutoscaler{..} = (\v2beta1HorizontalPodAutoscalerApiVersion -> V2beta1HorizontalPodAutoscaler { v2beta1HorizontalPodAutoscalerApiVersion, ..} ) <$> f v2beta1HorizontalPodAutoscalerApiVersion
{-# INLINE v2beta1HorizontalPodAutoscalerApiVersionL #-}

-- | 'v2beta1HorizontalPodAutoscalerKind' Lens
v2beta1HorizontalPodAutoscalerKindL :: Lens_' V2beta1HorizontalPodAutoscaler (Maybe Text)
v2beta1HorizontalPodAutoscalerKindL f V2beta1HorizontalPodAutoscaler{..} = (\v2beta1HorizontalPodAutoscalerKind -> V2beta1HorizontalPodAutoscaler { v2beta1HorizontalPodAutoscalerKind, ..} ) <$> f v2beta1HorizontalPodAutoscalerKind
{-# INLINE v2beta1HorizontalPodAutoscalerKindL #-}

-- | 'v2beta1HorizontalPodAutoscalerMetadata' Lens
v2beta1HorizontalPodAutoscalerMetadataL :: Lens_' V2beta1HorizontalPodAutoscaler (Maybe V1ObjectMeta)
v2beta1HorizontalPodAutoscalerMetadataL f V2beta1HorizontalPodAutoscaler{..} = (\v2beta1HorizontalPodAutoscalerMetadata -> V2beta1HorizontalPodAutoscaler { v2beta1HorizontalPodAutoscalerMetadata, ..} ) <$> f v2beta1HorizontalPodAutoscalerMetadata
{-# INLINE v2beta1HorizontalPodAutoscalerMetadataL #-}

-- | 'v2beta1HorizontalPodAutoscalerSpec' Lens
v2beta1HorizontalPodAutoscalerSpecL :: Lens_' V2beta1HorizontalPodAutoscaler (Maybe V2beta1HorizontalPodAutoscalerSpec)
v2beta1HorizontalPodAutoscalerSpecL f V2beta1HorizontalPodAutoscaler{..} = (\v2beta1HorizontalPodAutoscalerSpec -> V2beta1HorizontalPodAutoscaler { v2beta1HorizontalPodAutoscalerSpec, ..} ) <$> f v2beta1HorizontalPodAutoscalerSpec
{-# INLINE v2beta1HorizontalPodAutoscalerSpecL #-}

-- | 'v2beta1HorizontalPodAutoscalerStatus' Lens
v2beta1HorizontalPodAutoscalerStatusL :: Lens_' V2beta1HorizontalPodAutoscaler (Maybe V2beta1HorizontalPodAutoscalerStatus)
v2beta1HorizontalPodAutoscalerStatusL f V2beta1HorizontalPodAutoscaler{..} = (\v2beta1HorizontalPodAutoscalerStatus -> V2beta1HorizontalPodAutoscaler { v2beta1HorizontalPodAutoscalerStatus, ..} ) <$> f v2beta1HorizontalPodAutoscalerStatus
{-# INLINE v2beta1HorizontalPodAutoscalerStatusL #-}



-- * V2beta1HorizontalPodAutoscalerCondition

-- | 'v2beta1HorizontalPodAutoscalerConditionLastTransitionTime' Lens
v2beta1HorizontalPodAutoscalerConditionLastTransitionTimeL :: Lens_' V2beta1HorizontalPodAutoscalerCondition (Maybe DateTime)
v2beta1HorizontalPodAutoscalerConditionLastTransitionTimeL f V2beta1HorizontalPodAutoscalerCondition{..} = (\v2beta1HorizontalPodAutoscalerConditionLastTransitionTime -> V2beta1HorizontalPodAutoscalerCondition { v2beta1HorizontalPodAutoscalerConditionLastTransitionTime, ..} ) <$> f v2beta1HorizontalPodAutoscalerConditionLastTransitionTime
{-# INLINE v2beta1HorizontalPodAutoscalerConditionLastTransitionTimeL #-}

-- | 'v2beta1HorizontalPodAutoscalerConditionMessage' Lens
v2beta1HorizontalPodAutoscalerConditionMessageL :: Lens_' V2beta1HorizontalPodAutoscalerCondition (Maybe Text)
v2beta1HorizontalPodAutoscalerConditionMessageL f V2beta1HorizontalPodAutoscalerCondition{..} = (\v2beta1HorizontalPodAutoscalerConditionMessage -> V2beta1HorizontalPodAutoscalerCondition { v2beta1HorizontalPodAutoscalerConditionMessage, ..} ) <$> f v2beta1HorizontalPodAutoscalerConditionMessage
{-# INLINE v2beta1HorizontalPodAutoscalerConditionMessageL #-}

-- | 'v2beta1HorizontalPodAutoscalerConditionReason' Lens
v2beta1HorizontalPodAutoscalerConditionReasonL :: Lens_' V2beta1HorizontalPodAutoscalerCondition (Maybe Text)
v2beta1HorizontalPodAutoscalerConditionReasonL f V2beta1HorizontalPodAutoscalerCondition{..} = (\v2beta1HorizontalPodAutoscalerConditionReason -> V2beta1HorizontalPodAutoscalerCondition { v2beta1HorizontalPodAutoscalerConditionReason, ..} ) <$> f v2beta1HorizontalPodAutoscalerConditionReason
{-# INLINE v2beta1HorizontalPodAutoscalerConditionReasonL #-}

-- | 'v2beta1HorizontalPodAutoscalerConditionStatus' Lens
v2beta1HorizontalPodAutoscalerConditionStatusL :: Lens_' V2beta1HorizontalPodAutoscalerCondition (Text)
v2beta1HorizontalPodAutoscalerConditionStatusL f V2beta1HorizontalPodAutoscalerCondition{..} = (\v2beta1HorizontalPodAutoscalerConditionStatus -> V2beta1HorizontalPodAutoscalerCondition { v2beta1HorizontalPodAutoscalerConditionStatus, ..} ) <$> f v2beta1HorizontalPodAutoscalerConditionStatus
{-# INLINE v2beta1HorizontalPodAutoscalerConditionStatusL #-}

-- | 'v2beta1HorizontalPodAutoscalerConditionType' Lens
v2beta1HorizontalPodAutoscalerConditionTypeL :: Lens_' V2beta1HorizontalPodAutoscalerCondition (Text)
v2beta1HorizontalPodAutoscalerConditionTypeL f V2beta1HorizontalPodAutoscalerCondition{..} = (\v2beta1HorizontalPodAutoscalerConditionType -> V2beta1HorizontalPodAutoscalerCondition { v2beta1HorizontalPodAutoscalerConditionType, ..} ) <$> f v2beta1HorizontalPodAutoscalerConditionType
{-# INLINE v2beta1HorizontalPodAutoscalerConditionTypeL #-}



-- * V2beta1HorizontalPodAutoscalerList

-- | 'v2beta1HorizontalPodAutoscalerListApiVersion' Lens
v2beta1HorizontalPodAutoscalerListApiVersionL :: Lens_' V2beta1HorizontalPodAutoscalerList (Maybe Text)
v2beta1HorizontalPodAutoscalerListApiVersionL f V2beta1HorizontalPodAutoscalerList{..} = (\v2beta1HorizontalPodAutoscalerListApiVersion -> V2beta1HorizontalPodAutoscalerList { v2beta1HorizontalPodAutoscalerListApiVersion, ..} ) <$> f v2beta1HorizontalPodAutoscalerListApiVersion
{-# INLINE v2beta1HorizontalPodAutoscalerListApiVersionL #-}

-- | 'v2beta1HorizontalPodAutoscalerListItems' Lens
v2beta1HorizontalPodAutoscalerListItemsL :: Lens_' V2beta1HorizontalPodAutoscalerList ([V2beta1HorizontalPodAutoscaler])
v2beta1HorizontalPodAutoscalerListItemsL f V2beta1HorizontalPodAutoscalerList{..} = (\v2beta1HorizontalPodAutoscalerListItems -> V2beta1HorizontalPodAutoscalerList { v2beta1HorizontalPodAutoscalerListItems, ..} ) <$> f v2beta1HorizontalPodAutoscalerListItems
{-# INLINE v2beta1HorizontalPodAutoscalerListItemsL #-}

-- | 'v2beta1HorizontalPodAutoscalerListKind' Lens
v2beta1HorizontalPodAutoscalerListKindL :: Lens_' V2beta1HorizontalPodAutoscalerList (Maybe Text)
v2beta1HorizontalPodAutoscalerListKindL f V2beta1HorizontalPodAutoscalerList{..} = (\v2beta1HorizontalPodAutoscalerListKind -> V2beta1HorizontalPodAutoscalerList { v2beta1HorizontalPodAutoscalerListKind, ..} ) <$> f v2beta1HorizontalPodAutoscalerListKind
{-# INLINE v2beta1HorizontalPodAutoscalerListKindL #-}

-- | 'v2beta1HorizontalPodAutoscalerListMetadata' Lens
v2beta1HorizontalPodAutoscalerListMetadataL :: Lens_' V2beta1HorizontalPodAutoscalerList (Maybe V1ListMeta)
v2beta1HorizontalPodAutoscalerListMetadataL f V2beta1HorizontalPodAutoscalerList{..} = (\v2beta1HorizontalPodAutoscalerListMetadata -> V2beta1HorizontalPodAutoscalerList { v2beta1HorizontalPodAutoscalerListMetadata, ..} ) <$> f v2beta1HorizontalPodAutoscalerListMetadata
{-# INLINE v2beta1HorizontalPodAutoscalerListMetadataL #-}



-- * V2beta1HorizontalPodAutoscalerSpec

-- | 'v2beta1HorizontalPodAutoscalerSpecMaxReplicas' Lens
v2beta1HorizontalPodAutoscalerSpecMaxReplicasL :: Lens_' V2beta1HorizontalPodAutoscalerSpec (Int)
v2beta1HorizontalPodAutoscalerSpecMaxReplicasL f V2beta1HorizontalPodAutoscalerSpec{..} = (\v2beta1HorizontalPodAutoscalerSpecMaxReplicas -> V2beta1HorizontalPodAutoscalerSpec { v2beta1HorizontalPodAutoscalerSpecMaxReplicas, ..} ) <$> f v2beta1HorizontalPodAutoscalerSpecMaxReplicas
{-# INLINE v2beta1HorizontalPodAutoscalerSpecMaxReplicasL #-}

-- | 'v2beta1HorizontalPodAutoscalerSpecMetrics' Lens
v2beta1HorizontalPodAutoscalerSpecMetricsL :: Lens_' V2beta1HorizontalPodAutoscalerSpec (Maybe [V2beta1MetricSpec])
v2beta1HorizontalPodAutoscalerSpecMetricsL f V2beta1HorizontalPodAutoscalerSpec{..} = (\v2beta1HorizontalPodAutoscalerSpecMetrics -> V2beta1HorizontalPodAutoscalerSpec { v2beta1HorizontalPodAutoscalerSpecMetrics, ..} ) <$> f v2beta1HorizontalPodAutoscalerSpecMetrics
{-# INLINE v2beta1HorizontalPodAutoscalerSpecMetricsL #-}

-- | 'v2beta1HorizontalPodAutoscalerSpecMinReplicas' Lens
v2beta1HorizontalPodAutoscalerSpecMinReplicasL :: Lens_' V2beta1HorizontalPodAutoscalerSpec (Maybe Int)
v2beta1HorizontalPodAutoscalerSpecMinReplicasL f V2beta1HorizontalPodAutoscalerSpec{..} = (\v2beta1HorizontalPodAutoscalerSpecMinReplicas -> V2beta1HorizontalPodAutoscalerSpec { v2beta1HorizontalPodAutoscalerSpecMinReplicas, ..} ) <$> f v2beta1HorizontalPodAutoscalerSpecMinReplicas
{-# INLINE v2beta1HorizontalPodAutoscalerSpecMinReplicasL #-}

-- | 'v2beta1HorizontalPodAutoscalerSpecScaleTargetRef' Lens
v2beta1HorizontalPodAutoscalerSpecScaleTargetRefL :: Lens_' V2beta1HorizontalPodAutoscalerSpec (V2beta1CrossVersionObjectReference)
v2beta1HorizontalPodAutoscalerSpecScaleTargetRefL f V2beta1HorizontalPodAutoscalerSpec{..} = (\v2beta1HorizontalPodAutoscalerSpecScaleTargetRef -> V2beta1HorizontalPodAutoscalerSpec { v2beta1HorizontalPodAutoscalerSpecScaleTargetRef, ..} ) <$> f v2beta1HorizontalPodAutoscalerSpecScaleTargetRef
{-# INLINE v2beta1HorizontalPodAutoscalerSpecScaleTargetRefL #-}



-- * V2beta1HorizontalPodAutoscalerStatus

-- | 'v2beta1HorizontalPodAutoscalerStatusConditions' Lens
v2beta1HorizontalPodAutoscalerStatusConditionsL :: Lens_' V2beta1HorizontalPodAutoscalerStatus (Maybe [V2beta1HorizontalPodAutoscalerCondition])
v2beta1HorizontalPodAutoscalerStatusConditionsL f V2beta1HorizontalPodAutoscalerStatus{..} = (\v2beta1HorizontalPodAutoscalerStatusConditions -> V2beta1HorizontalPodAutoscalerStatus { v2beta1HorizontalPodAutoscalerStatusConditions, ..} ) <$> f v2beta1HorizontalPodAutoscalerStatusConditions
{-# INLINE v2beta1HorizontalPodAutoscalerStatusConditionsL #-}

-- | 'v2beta1HorizontalPodAutoscalerStatusCurrentMetrics' Lens
v2beta1HorizontalPodAutoscalerStatusCurrentMetricsL :: Lens_' V2beta1HorizontalPodAutoscalerStatus (Maybe [V2beta1MetricStatus])
v2beta1HorizontalPodAutoscalerStatusCurrentMetricsL f V2beta1HorizontalPodAutoscalerStatus{..} = (\v2beta1HorizontalPodAutoscalerStatusCurrentMetrics -> V2beta1HorizontalPodAutoscalerStatus { v2beta1HorizontalPodAutoscalerStatusCurrentMetrics, ..} ) <$> f v2beta1HorizontalPodAutoscalerStatusCurrentMetrics
{-# INLINE v2beta1HorizontalPodAutoscalerStatusCurrentMetricsL #-}

-- | 'v2beta1HorizontalPodAutoscalerStatusCurrentReplicas' Lens
v2beta1HorizontalPodAutoscalerStatusCurrentReplicasL :: Lens_' V2beta1HorizontalPodAutoscalerStatus (Int)
v2beta1HorizontalPodAutoscalerStatusCurrentReplicasL f V2beta1HorizontalPodAutoscalerStatus{..} = (\v2beta1HorizontalPodAutoscalerStatusCurrentReplicas -> V2beta1HorizontalPodAutoscalerStatus { v2beta1HorizontalPodAutoscalerStatusCurrentReplicas, ..} ) <$> f v2beta1HorizontalPodAutoscalerStatusCurrentReplicas
{-# INLINE v2beta1HorizontalPodAutoscalerStatusCurrentReplicasL #-}

-- | 'v2beta1HorizontalPodAutoscalerStatusDesiredReplicas' Lens
v2beta1HorizontalPodAutoscalerStatusDesiredReplicasL :: Lens_' V2beta1HorizontalPodAutoscalerStatus (Int)
v2beta1HorizontalPodAutoscalerStatusDesiredReplicasL f V2beta1HorizontalPodAutoscalerStatus{..} = (\v2beta1HorizontalPodAutoscalerStatusDesiredReplicas -> V2beta1HorizontalPodAutoscalerStatus { v2beta1HorizontalPodAutoscalerStatusDesiredReplicas, ..} ) <$> f v2beta1HorizontalPodAutoscalerStatusDesiredReplicas
{-# INLINE v2beta1HorizontalPodAutoscalerStatusDesiredReplicasL #-}

-- | 'v2beta1HorizontalPodAutoscalerStatusLastScaleTime' Lens
v2beta1HorizontalPodAutoscalerStatusLastScaleTimeL :: Lens_' V2beta1HorizontalPodAutoscalerStatus (Maybe DateTime)
v2beta1HorizontalPodAutoscalerStatusLastScaleTimeL f V2beta1HorizontalPodAutoscalerStatus{..} = (\v2beta1HorizontalPodAutoscalerStatusLastScaleTime -> V2beta1HorizontalPodAutoscalerStatus { v2beta1HorizontalPodAutoscalerStatusLastScaleTime, ..} ) <$> f v2beta1HorizontalPodAutoscalerStatusLastScaleTime
{-# INLINE v2beta1HorizontalPodAutoscalerStatusLastScaleTimeL #-}

-- | 'v2beta1HorizontalPodAutoscalerStatusObservedGeneration' Lens
v2beta1HorizontalPodAutoscalerStatusObservedGenerationL :: Lens_' V2beta1HorizontalPodAutoscalerStatus (Maybe Integer)
v2beta1HorizontalPodAutoscalerStatusObservedGenerationL f V2beta1HorizontalPodAutoscalerStatus{..} = (\v2beta1HorizontalPodAutoscalerStatusObservedGeneration -> V2beta1HorizontalPodAutoscalerStatus { v2beta1HorizontalPodAutoscalerStatusObservedGeneration, ..} ) <$> f v2beta1HorizontalPodAutoscalerStatusObservedGeneration
{-# INLINE v2beta1HorizontalPodAutoscalerStatusObservedGenerationL #-}



-- * V2beta1MetricSpec

-- | 'v2beta1MetricSpecContainerResource' Lens
v2beta1MetricSpecContainerResourceL :: Lens_' V2beta1MetricSpec (Maybe V2beta1ContainerResourceMetricSource)
v2beta1MetricSpecContainerResourceL f V2beta1MetricSpec{..} = (\v2beta1MetricSpecContainerResource -> V2beta1MetricSpec { v2beta1MetricSpecContainerResource, ..} ) <$> f v2beta1MetricSpecContainerResource
{-# INLINE v2beta1MetricSpecContainerResourceL #-}

-- | 'v2beta1MetricSpecExternal' Lens
v2beta1MetricSpecExternalL :: Lens_' V2beta1MetricSpec (Maybe V2beta1ExternalMetricSource)
v2beta1MetricSpecExternalL f V2beta1MetricSpec{..} = (\v2beta1MetricSpecExternal -> V2beta1MetricSpec { v2beta1MetricSpecExternal, ..} ) <$> f v2beta1MetricSpecExternal
{-# INLINE v2beta1MetricSpecExternalL #-}

-- | 'v2beta1MetricSpecObject' Lens
v2beta1MetricSpecObjectL :: Lens_' V2beta1MetricSpec (Maybe V2beta1ObjectMetricSource)
v2beta1MetricSpecObjectL f V2beta1MetricSpec{..} = (\v2beta1MetricSpecObject -> V2beta1MetricSpec { v2beta1MetricSpecObject, ..} ) <$> f v2beta1MetricSpecObject
{-# INLINE v2beta1MetricSpecObjectL #-}

-- | 'v2beta1MetricSpecPods' Lens
v2beta1MetricSpecPodsL :: Lens_' V2beta1MetricSpec (Maybe V2beta1PodsMetricSource)
v2beta1MetricSpecPodsL f V2beta1MetricSpec{..} = (\v2beta1MetricSpecPods -> V2beta1MetricSpec { v2beta1MetricSpecPods, ..} ) <$> f v2beta1MetricSpecPods
{-# INLINE v2beta1MetricSpecPodsL #-}

-- | 'v2beta1MetricSpecResource' Lens
v2beta1MetricSpecResourceL :: Lens_' V2beta1MetricSpec (Maybe V2beta1ResourceMetricSource)
v2beta1MetricSpecResourceL f V2beta1MetricSpec{..} = (\v2beta1MetricSpecResource -> V2beta1MetricSpec { v2beta1MetricSpecResource, ..} ) <$> f v2beta1MetricSpecResource
{-# INLINE v2beta1MetricSpecResourceL #-}

-- | 'v2beta1MetricSpecType' Lens
v2beta1MetricSpecTypeL :: Lens_' V2beta1MetricSpec (Text)
v2beta1MetricSpecTypeL f V2beta1MetricSpec{..} = (\v2beta1MetricSpecType -> V2beta1MetricSpec { v2beta1MetricSpecType, ..} ) <$> f v2beta1MetricSpecType
{-# INLINE v2beta1MetricSpecTypeL #-}



-- * V2beta1MetricStatus

-- | 'v2beta1MetricStatusContainerResource' Lens
v2beta1MetricStatusContainerResourceL :: Lens_' V2beta1MetricStatus (Maybe V2beta1ContainerResourceMetricStatus)
v2beta1MetricStatusContainerResourceL f V2beta1MetricStatus{..} = (\v2beta1MetricStatusContainerResource -> V2beta1MetricStatus { v2beta1MetricStatusContainerResource, ..} ) <$> f v2beta1MetricStatusContainerResource
{-# INLINE v2beta1MetricStatusContainerResourceL #-}

-- | 'v2beta1MetricStatusExternal' Lens
v2beta1MetricStatusExternalL :: Lens_' V2beta1MetricStatus (Maybe V2beta1ExternalMetricStatus)
v2beta1MetricStatusExternalL f V2beta1MetricStatus{..} = (\v2beta1MetricStatusExternal -> V2beta1MetricStatus { v2beta1MetricStatusExternal, ..} ) <$> f v2beta1MetricStatusExternal
{-# INLINE v2beta1MetricStatusExternalL #-}

-- | 'v2beta1MetricStatusObject' Lens
v2beta1MetricStatusObjectL :: Lens_' V2beta1MetricStatus (Maybe V2beta1ObjectMetricStatus)
v2beta1MetricStatusObjectL f V2beta1MetricStatus{..} = (\v2beta1MetricStatusObject -> V2beta1MetricStatus { v2beta1MetricStatusObject, ..} ) <$> f v2beta1MetricStatusObject
{-# INLINE v2beta1MetricStatusObjectL #-}

-- | 'v2beta1MetricStatusPods' Lens
v2beta1MetricStatusPodsL :: Lens_' V2beta1MetricStatus (Maybe V2beta1PodsMetricStatus)
v2beta1MetricStatusPodsL f V2beta1MetricStatus{..} = (\v2beta1MetricStatusPods -> V2beta1MetricStatus { v2beta1MetricStatusPods, ..} ) <$> f v2beta1MetricStatusPods
{-# INLINE v2beta1MetricStatusPodsL #-}

-- | 'v2beta1MetricStatusResource' Lens
v2beta1MetricStatusResourceL :: Lens_' V2beta1MetricStatus (Maybe V2beta1ResourceMetricStatus)
v2beta1MetricStatusResourceL f V2beta1MetricStatus{..} = (\v2beta1MetricStatusResource -> V2beta1MetricStatus { v2beta1MetricStatusResource, ..} ) <$> f v2beta1MetricStatusResource
{-# INLINE v2beta1MetricStatusResourceL #-}

-- | 'v2beta1MetricStatusType' Lens
v2beta1MetricStatusTypeL :: Lens_' V2beta1MetricStatus (Text)
v2beta1MetricStatusTypeL f V2beta1MetricStatus{..} = (\v2beta1MetricStatusType -> V2beta1MetricStatus { v2beta1MetricStatusType, ..} ) <$> f v2beta1MetricStatusType
{-# INLINE v2beta1MetricStatusTypeL #-}



-- * V2beta1ObjectMetricSource

-- | 'v2beta1ObjectMetricSourceAverageValue' Lens
v2beta1ObjectMetricSourceAverageValueL :: Lens_' V2beta1ObjectMetricSource (Maybe Quantity)
v2beta1ObjectMetricSourceAverageValueL f V2beta1ObjectMetricSource{..} = (\v2beta1ObjectMetricSourceAverageValue -> V2beta1ObjectMetricSource { v2beta1ObjectMetricSourceAverageValue, ..} ) <$> f v2beta1ObjectMetricSourceAverageValue
{-# INLINE v2beta1ObjectMetricSourceAverageValueL #-}

-- | 'v2beta1ObjectMetricSourceMetricName' Lens
v2beta1ObjectMetricSourceMetricNameL :: Lens_' V2beta1ObjectMetricSource (Text)
v2beta1ObjectMetricSourceMetricNameL f V2beta1ObjectMetricSource{..} = (\v2beta1ObjectMetricSourceMetricName -> V2beta1ObjectMetricSource { v2beta1ObjectMetricSourceMetricName, ..} ) <$> f v2beta1ObjectMetricSourceMetricName
{-# INLINE v2beta1ObjectMetricSourceMetricNameL #-}

-- | 'v2beta1ObjectMetricSourceSelector' Lens
v2beta1ObjectMetricSourceSelectorL :: Lens_' V2beta1ObjectMetricSource (Maybe V1LabelSelector)
v2beta1ObjectMetricSourceSelectorL f V2beta1ObjectMetricSource{..} = (\v2beta1ObjectMetricSourceSelector -> V2beta1ObjectMetricSource { v2beta1ObjectMetricSourceSelector, ..} ) <$> f v2beta1ObjectMetricSourceSelector
{-# INLINE v2beta1ObjectMetricSourceSelectorL #-}

-- | 'v2beta1ObjectMetricSourceTarget' Lens
v2beta1ObjectMetricSourceTargetL :: Lens_' V2beta1ObjectMetricSource (V2beta1CrossVersionObjectReference)
v2beta1ObjectMetricSourceTargetL f V2beta1ObjectMetricSource{..} = (\v2beta1ObjectMetricSourceTarget -> V2beta1ObjectMetricSource { v2beta1ObjectMetricSourceTarget, ..} ) <$> f v2beta1ObjectMetricSourceTarget
{-# INLINE v2beta1ObjectMetricSourceTargetL #-}

-- | 'v2beta1ObjectMetricSourceTargetValue' Lens
v2beta1ObjectMetricSourceTargetValueL :: Lens_' V2beta1ObjectMetricSource (Quantity)
v2beta1ObjectMetricSourceTargetValueL f V2beta1ObjectMetricSource{..} = (\v2beta1ObjectMetricSourceTargetValue -> V2beta1ObjectMetricSource { v2beta1ObjectMetricSourceTargetValue, ..} ) <$> f v2beta1ObjectMetricSourceTargetValue
{-# INLINE v2beta1ObjectMetricSourceTargetValueL #-}



-- * V2beta1ObjectMetricStatus

-- | 'v2beta1ObjectMetricStatusAverageValue' Lens
v2beta1ObjectMetricStatusAverageValueL :: Lens_' V2beta1ObjectMetricStatus (Maybe Quantity)
v2beta1ObjectMetricStatusAverageValueL f V2beta1ObjectMetricStatus{..} = (\v2beta1ObjectMetricStatusAverageValue -> V2beta1ObjectMetricStatus { v2beta1ObjectMetricStatusAverageValue, ..} ) <$> f v2beta1ObjectMetricStatusAverageValue
{-# INLINE v2beta1ObjectMetricStatusAverageValueL #-}

-- | 'v2beta1ObjectMetricStatusCurrentValue' Lens
v2beta1ObjectMetricStatusCurrentValueL :: Lens_' V2beta1ObjectMetricStatus (Quantity)
v2beta1ObjectMetricStatusCurrentValueL f V2beta1ObjectMetricStatus{..} = (\v2beta1ObjectMetricStatusCurrentValue -> V2beta1ObjectMetricStatus { v2beta1ObjectMetricStatusCurrentValue, ..} ) <$> f v2beta1ObjectMetricStatusCurrentValue
{-# INLINE v2beta1ObjectMetricStatusCurrentValueL #-}

-- | 'v2beta1ObjectMetricStatusMetricName' Lens
v2beta1ObjectMetricStatusMetricNameL :: Lens_' V2beta1ObjectMetricStatus (Text)
v2beta1ObjectMetricStatusMetricNameL f V2beta1ObjectMetricStatus{..} = (\v2beta1ObjectMetricStatusMetricName -> V2beta1ObjectMetricStatus { v2beta1ObjectMetricStatusMetricName, ..} ) <$> f v2beta1ObjectMetricStatusMetricName
{-# INLINE v2beta1ObjectMetricStatusMetricNameL #-}

-- | 'v2beta1ObjectMetricStatusSelector' Lens
v2beta1ObjectMetricStatusSelectorL :: Lens_' V2beta1ObjectMetricStatus (Maybe V1LabelSelector)
v2beta1ObjectMetricStatusSelectorL f V2beta1ObjectMetricStatus{..} = (\v2beta1ObjectMetricStatusSelector -> V2beta1ObjectMetricStatus { v2beta1ObjectMetricStatusSelector, ..} ) <$> f v2beta1ObjectMetricStatusSelector
{-# INLINE v2beta1ObjectMetricStatusSelectorL #-}

-- | 'v2beta1ObjectMetricStatusTarget' Lens
v2beta1ObjectMetricStatusTargetL :: Lens_' V2beta1ObjectMetricStatus (V2beta1CrossVersionObjectReference)
v2beta1ObjectMetricStatusTargetL f V2beta1ObjectMetricStatus{..} = (\v2beta1ObjectMetricStatusTarget -> V2beta1ObjectMetricStatus { v2beta1ObjectMetricStatusTarget, ..} ) <$> f v2beta1ObjectMetricStatusTarget
{-# INLINE v2beta1ObjectMetricStatusTargetL #-}



-- * V2beta1PodsMetricSource

-- | 'v2beta1PodsMetricSourceMetricName' Lens
v2beta1PodsMetricSourceMetricNameL :: Lens_' V2beta1PodsMetricSource (Text)
v2beta1PodsMetricSourceMetricNameL f V2beta1PodsMetricSource{..} = (\v2beta1PodsMetricSourceMetricName -> V2beta1PodsMetricSource { v2beta1PodsMetricSourceMetricName, ..} ) <$> f v2beta1PodsMetricSourceMetricName
{-# INLINE v2beta1PodsMetricSourceMetricNameL #-}

-- | 'v2beta1PodsMetricSourceSelector' Lens
v2beta1PodsMetricSourceSelectorL :: Lens_' V2beta1PodsMetricSource (Maybe V1LabelSelector)
v2beta1PodsMetricSourceSelectorL f V2beta1PodsMetricSource{..} = (\v2beta1PodsMetricSourceSelector -> V2beta1PodsMetricSource { v2beta1PodsMetricSourceSelector, ..} ) <$> f v2beta1PodsMetricSourceSelector
{-# INLINE v2beta1PodsMetricSourceSelectorL #-}

-- | 'v2beta1PodsMetricSourceTargetAverageValue' Lens
v2beta1PodsMetricSourceTargetAverageValueL :: Lens_' V2beta1PodsMetricSource (Quantity)
v2beta1PodsMetricSourceTargetAverageValueL f V2beta1PodsMetricSource{..} = (\v2beta1PodsMetricSourceTargetAverageValue -> V2beta1PodsMetricSource { v2beta1PodsMetricSourceTargetAverageValue, ..} ) <$> f v2beta1PodsMetricSourceTargetAverageValue
{-# INLINE v2beta1PodsMetricSourceTargetAverageValueL #-}



-- * V2beta1PodsMetricStatus

-- | 'v2beta1PodsMetricStatusCurrentAverageValue' Lens
v2beta1PodsMetricStatusCurrentAverageValueL :: Lens_' V2beta1PodsMetricStatus (Quantity)
v2beta1PodsMetricStatusCurrentAverageValueL f V2beta1PodsMetricStatus{..} = (\v2beta1PodsMetricStatusCurrentAverageValue -> V2beta1PodsMetricStatus { v2beta1PodsMetricStatusCurrentAverageValue, ..} ) <$> f v2beta1PodsMetricStatusCurrentAverageValue
{-# INLINE v2beta1PodsMetricStatusCurrentAverageValueL #-}

-- | 'v2beta1PodsMetricStatusMetricName' Lens
v2beta1PodsMetricStatusMetricNameL :: Lens_' V2beta1PodsMetricStatus (Text)
v2beta1PodsMetricStatusMetricNameL f V2beta1PodsMetricStatus{..} = (\v2beta1PodsMetricStatusMetricName -> V2beta1PodsMetricStatus { v2beta1PodsMetricStatusMetricName, ..} ) <$> f v2beta1PodsMetricStatusMetricName
{-# INLINE v2beta1PodsMetricStatusMetricNameL #-}

-- | 'v2beta1PodsMetricStatusSelector' Lens
v2beta1PodsMetricStatusSelectorL :: Lens_' V2beta1PodsMetricStatus (Maybe V1LabelSelector)
v2beta1PodsMetricStatusSelectorL f V2beta1PodsMetricStatus{..} = (\v2beta1PodsMetricStatusSelector -> V2beta1PodsMetricStatus { v2beta1PodsMetricStatusSelector, ..} ) <$> f v2beta1PodsMetricStatusSelector
{-# INLINE v2beta1PodsMetricStatusSelectorL #-}



-- * V2beta1ResourceMetricSource

-- | 'v2beta1ResourceMetricSourceName' Lens
v2beta1ResourceMetricSourceNameL :: Lens_' V2beta1ResourceMetricSource (Text)
v2beta1ResourceMetricSourceNameL f V2beta1ResourceMetricSource{..} = (\v2beta1ResourceMetricSourceName -> V2beta1ResourceMetricSource { v2beta1ResourceMetricSourceName, ..} ) <$> f v2beta1ResourceMetricSourceName
{-# INLINE v2beta1ResourceMetricSourceNameL #-}

-- | 'v2beta1ResourceMetricSourceTargetAverageUtilization' Lens
v2beta1ResourceMetricSourceTargetAverageUtilizationL :: Lens_' V2beta1ResourceMetricSource (Maybe Int)
v2beta1ResourceMetricSourceTargetAverageUtilizationL f V2beta1ResourceMetricSource{..} = (\v2beta1ResourceMetricSourceTargetAverageUtilization -> V2beta1ResourceMetricSource { v2beta1ResourceMetricSourceTargetAverageUtilization, ..} ) <$> f v2beta1ResourceMetricSourceTargetAverageUtilization
{-# INLINE v2beta1ResourceMetricSourceTargetAverageUtilizationL #-}

-- | 'v2beta1ResourceMetricSourceTargetAverageValue' Lens
v2beta1ResourceMetricSourceTargetAverageValueL :: Lens_' V2beta1ResourceMetricSource (Maybe Quantity)
v2beta1ResourceMetricSourceTargetAverageValueL f V2beta1ResourceMetricSource{..} = (\v2beta1ResourceMetricSourceTargetAverageValue -> V2beta1ResourceMetricSource { v2beta1ResourceMetricSourceTargetAverageValue, ..} ) <$> f v2beta1ResourceMetricSourceTargetAverageValue
{-# INLINE v2beta1ResourceMetricSourceTargetAverageValueL #-}



-- * V2beta1ResourceMetricStatus

-- | 'v2beta1ResourceMetricStatusCurrentAverageUtilization' Lens
v2beta1ResourceMetricStatusCurrentAverageUtilizationL :: Lens_' V2beta1ResourceMetricStatus (Maybe Int)
v2beta1ResourceMetricStatusCurrentAverageUtilizationL f V2beta1ResourceMetricStatus{..} = (\v2beta1ResourceMetricStatusCurrentAverageUtilization -> V2beta1ResourceMetricStatus { v2beta1ResourceMetricStatusCurrentAverageUtilization, ..} ) <$> f v2beta1ResourceMetricStatusCurrentAverageUtilization
{-# INLINE v2beta1ResourceMetricStatusCurrentAverageUtilizationL #-}

-- | 'v2beta1ResourceMetricStatusCurrentAverageValue' Lens
v2beta1ResourceMetricStatusCurrentAverageValueL :: Lens_' V2beta1ResourceMetricStatus (Quantity)
v2beta1ResourceMetricStatusCurrentAverageValueL f V2beta1ResourceMetricStatus{..} = (\v2beta1ResourceMetricStatusCurrentAverageValue -> V2beta1ResourceMetricStatus { v2beta1ResourceMetricStatusCurrentAverageValue, ..} ) <$> f v2beta1ResourceMetricStatusCurrentAverageValue
{-# INLINE v2beta1ResourceMetricStatusCurrentAverageValueL #-}

-- | 'v2beta1ResourceMetricStatusName' Lens
v2beta1ResourceMetricStatusNameL :: Lens_' V2beta1ResourceMetricStatus (Text)
v2beta1ResourceMetricStatusNameL f V2beta1ResourceMetricStatus{..} = (\v2beta1ResourceMetricStatusName -> V2beta1ResourceMetricStatus { v2beta1ResourceMetricStatusName, ..} ) <$> f v2beta1ResourceMetricStatusName
{-# INLINE v2beta1ResourceMetricStatusNameL #-}



-- * V2beta2ContainerResourceMetricSource

-- | 'v2beta2ContainerResourceMetricSourceContainer' Lens
v2beta2ContainerResourceMetricSourceContainerL :: Lens_' V2beta2ContainerResourceMetricSource (Text)
v2beta2ContainerResourceMetricSourceContainerL f V2beta2ContainerResourceMetricSource{..} = (\v2beta2ContainerResourceMetricSourceContainer -> V2beta2ContainerResourceMetricSource { v2beta2ContainerResourceMetricSourceContainer, ..} ) <$> f v2beta2ContainerResourceMetricSourceContainer
{-# INLINE v2beta2ContainerResourceMetricSourceContainerL #-}

-- | 'v2beta2ContainerResourceMetricSourceName' Lens
v2beta2ContainerResourceMetricSourceNameL :: Lens_' V2beta2ContainerResourceMetricSource (Text)
v2beta2ContainerResourceMetricSourceNameL f V2beta2ContainerResourceMetricSource{..} = (\v2beta2ContainerResourceMetricSourceName -> V2beta2ContainerResourceMetricSource { v2beta2ContainerResourceMetricSourceName, ..} ) <$> f v2beta2ContainerResourceMetricSourceName
{-# INLINE v2beta2ContainerResourceMetricSourceNameL #-}

-- | 'v2beta2ContainerResourceMetricSourceTarget' Lens
v2beta2ContainerResourceMetricSourceTargetL :: Lens_' V2beta2ContainerResourceMetricSource (V2beta2MetricTarget)
v2beta2ContainerResourceMetricSourceTargetL f V2beta2ContainerResourceMetricSource{..} = (\v2beta2ContainerResourceMetricSourceTarget -> V2beta2ContainerResourceMetricSource { v2beta2ContainerResourceMetricSourceTarget, ..} ) <$> f v2beta2ContainerResourceMetricSourceTarget
{-# INLINE v2beta2ContainerResourceMetricSourceTargetL #-}



-- * V2beta2ContainerResourceMetricStatus

-- | 'v2beta2ContainerResourceMetricStatusContainer' Lens
v2beta2ContainerResourceMetricStatusContainerL :: Lens_' V2beta2ContainerResourceMetricStatus (Text)
v2beta2ContainerResourceMetricStatusContainerL f V2beta2ContainerResourceMetricStatus{..} = (\v2beta2ContainerResourceMetricStatusContainer -> V2beta2ContainerResourceMetricStatus { v2beta2ContainerResourceMetricStatusContainer, ..} ) <$> f v2beta2ContainerResourceMetricStatusContainer
{-# INLINE v2beta2ContainerResourceMetricStatusContainerL #-}

-- | 'v2beta2ContainerResourceMetricStatusCurrent' Lens
v2beta2ContainerResourceMetricStatusCurrentL :: Lens_' V2beta2ContainerResourceMetricStatus (V2beta2MetricValueStatus)
v2beta2ContainerResourceMetricStatusCurrentL f V2beta2ContainerResourceMetricStatus{..} = (\v2beta2ContainerResourceMetricStatusCurrent -> V2beta2ContainerResourceMetricStatus { v2beta2ContainerResourceMetricStatusCurrent, ..} ) <$> f v2beta2ContainerResourceMetricStatusCurrent
{-# INLINE v2beta2ContainerResourceMetricStatusCurrentL #-}

-- | 'v2beta2ContainerResourceMetricStatusName' Lens
v2beta2ContainerResourceMetricStatusNameL :: Lens_' V2beta2ContainerResourceMetricStatus (Text)
v2beta2ContainerResourceMetricStatusNameL f V2beta2ContainerResourceMetricStatus{..} = (\v2beta2ContainerResourceMetricStatusName -> V2beta2ContainerResourceMetricStatus { v2beta2ContainerResourceMetricStatusName, ..} ) <$> f v2beta2ContainerResourceMetricStatusName
{-# INLINE v2beta2ContainerResourceMetricStatusNameL #-}



-- * V2beta2CrossVersionObjectReference

-- | 'v2beta2CrossVersionObjectReferenceApiVersion' Lens
v2beta2CrossVersionObjectReferenceApiVersionL :: Lens_' V2beta2CrossVersionObjectReference (Maybe Text)
v2beta2CrossVersionObjectReferenceApiVersionL f V2beta2CrossVersionObjectReference{..} = (\v2beta2CrossVersionObjectReferenceApiVersion -> V2beta2CrossVersionObjectReference { v2beta2CrossVersionObjectReferenceApiVersion, ..} ) <$> f v2beta2CrossVersionObjectReferenceApiVersion
{-# INLINE v2beta2CrossVersionObjectReferenceApiVersionL #-}

-- | 'v2beta2CrossVersionObjectReferenceKind' Lens
v2beta2CrossVersionObjectReferenceKindL :: Lens_' V2beta2CrossVersionObjectReference (Text)
v2beta2CrossVersionObjectReferenceKindL f V2beta2CrossVersionObjectReference{..} = (\v2beta2CrossVersionObjectReferenceKind -> V2beta2CrossVersionObjectReference { v2beta2CrossVersionObjectReferenceKind, ..} ) <$> f v2beta2CrossVersionObjectReferenceKind
{-# INLINE v2beta2CrossVersionObjectReferenceKindL #-}

-- | 'v2beta2CrossVersionObjectReferenceName' Lens
v2beta2CrossVersionObjectReferenceNameL :: Lens_' V2beta2CrossVersionObjectReference (Text)
v2beta2CrossVersionObjectReferenceNameL f V2beta2CrossVersionObjectReference{..} = (\v2beta2CrossVersionObjectReferenceName -> V2beta2CrossVersionObjectReference { v2beta2CrossVersionObjectReferenceName, ..} ) <$> f v2beta2CrossVersionObjectReferenceName
{-# INLINE v2beta2CrossVersionObjectReferenceNameL #-}



-- * V2beta2ExternalMetricSource

-- | 'v2beta2ExternalMetricSourceMetric' Lens
v2beta2ExternalMetricSourceMetricL :: Lens_' V2beta2ExternalMetricSource (V2beta2MetricIdentifier)
v2beta2ExternalMetricSourceMetricL f V2beta2ExternalMetricSource{..} = (\v2beta2ExternalMetricSourceMetric -> V2beta2ExternalMetricSource { v2beta2ExternalMetricSourceMetric, ..} ) <$> f v2beta2ExternalMetricSourceMetric
{-# INLINE v2beta2ExternalMetricSourceMetricL #-}

-- | 'v2beta2ExternalMetricSourceTarget' Lens
v2beta2ExternalMetricSourceTargetL :: Lens_' V2beta2ExternalMetricSource (V2beta2MetricTarget)
v2beta2ExternalMetricSourceTargetL f V2beta2ExternalMetricSource{..} = (\v2beta2ExternalMetricSourceTarget -> V2beta2ExternalMetricSource { v2beta2ExternalMetricSourceTarget, ..} ) <$> f v2beta2ExternalMetricSourceTarget
{-# INLINE v2beta2ExternalMetricSourceTargetL #-}



-- * V2beta2ExternalMetricStatus

-- | 'v2beta2ExternalMetricStatusCurrent' Lens
v2beta2ExternalMetricStatusCurrentL :: Lens_' V2beta2ExternalMetricStatus (V2beta2MetricValueStatus)
v2beta2ExternalMetricStatusCurrentL f V2beta2ExternalMetricStatus{..} = (\v2beta2ExternalMetricStatusCurrent -> V2beta2ExternalMetricStatus { v2beta2ExternalMetricStatusCurrent, ..} ) <$> f v2beta2ExternalMetricStatusCurrent
{-# INLINE v2beta2ExternalMetricStatusCurrentL #-}

-- | 'v2beta2ExternalMetricStatusMetric' Lens
v2beta2ExternalMetricStatusMetricL :: Lens_' V2beta2ExternalMetricStatus (V2beta2MetricIdentifier)
v2beta2ExternalMetricStatusMetricL f V2beta2ExternalMetricStatus{..} = (\v2beta2ExternalMetricStatusMetric -> V2beta2ExternalMetricStatus { v2beta2ExternalMetricStatusMetric, ..} ) <$> f v2beta2ExternalMetricStatusMetric
{-# INLINE v2beta2ExternalMetricStatusMetricL #-}



-- * V2beta2HPAScalingPolicy

-- | 'v2beta2HPAScalingPolicyPeriodSeconds' Lens
v2beta2HPAScalingPolicyPeriodSecondsL :: Lens_' V2beta2HPAScalingPolicy (Int)
v2beta2HPAScalingPolicyPeriodSecondsL f V2beta2HPAScalingPolicy{..} = (\v2beta2HPAScalingPolicyPeriodSeconds -> V2beta2HPAScalingPolicy { v2beta2HPAScalingPolicyPeriodSeconds, ..} ) <$> f v2beta2HPAScalingPolicyPeriodSeconds
{-# INLINE v2beta2HPAScalingPolicyPeriodSecondsL #-}

-- | 'v2beta2HPAScalingPolicyType' Lens
v2beta2HPAScalingPolicyTypeL :: Lens_' V2beta2HPAScalingPolicy (Text)
v2beta2HPAScalingPolicyTypeL f V2beta2HPAScalingPolicy{..} = (\v2beta2HPAScalingPolicyType -> V2beta2HPAScalingPolicy { v2beta2HPAScalingPolicyType, ..} ) <$> f v2beta2HPAScalingPolicyType
{-# INLINE v2beta2HPAScalingPolicyTypeL #-}

-- | 'v2beta2HPAScalingPolicyValue' Lens
v2beta2HPAScalingPolicyValueL :: Lens_' V2beta2HPAScalingPolicy (Int)
v2beta2HPAScalingPolicyValueL f V2beta2HPAScalingPolicy{..} = (\v2beta2HPAScalingPolicyValue -> V2beta2HPAScalingPolicy { v2beta2HPAScalingPolicyValue, ..} ) <$> f v2beta2HPAScalingPolicyValue
{-# INLINE v2beta2HPAScalingPolicyValueL #-}



-- * V2beta2HPAScalingRules

-- | 'v2beta2HPAScalingRulesPolicies' Lens
v2beta2HPAScalingRulesPoliciesL :: Lens_' V2beta2HPAScalingRules (Maybe [V2beta2HPAScalingPolicy])
v2beta2HPAScalingRulesPoliciesL f V2beta2HPAScalingRules{..} = (\v2beta2HPAScalingRulesPolicies -> V2beta2HPAScalingRules { v2beta2HPAScalingRulesPolicies, ..} ) <$> f v2beta2HPAScalingRulesPolicies
{-# INLINE v2beta2HPAScalingRulesPoliciesL #-}

-- | 'v2beta2HPAScalingRulesSelectPolicy' Lens
v2beta2HPAScalingRulesSelectPolicyL :: Lens_' V2beta2HPAScalingRules (Maybe Text)
v2beta2HPAScalingRulesSelectPolicyL f V2beta2HPAScalingRules{..} = (\v2beta2HPAScalingRulesSelectPolicy -> V2beta2HPAScalingRules { v2beta2HPAScalingRulesSelectPolicy, ..} ) <$> f v2beta2HPAScalingRulesSelectPolicy
{-# INLINE v2beta2HPAScalingRulesSelectPolicyL #-}

-- | 'v2beta2HPAScalingRulesStabilizationWindowSeconds' Lens
v2beta2HPAScalingRulesStabilizationWindowSecondsL :: Lens_' V2beta2HPAScalingRules (Maybe Int)
v2beta2HPAScalingRulesStabilizationWindowSecondsL f V2beta2HPAScalingRules{..} = (\v2beta2HPAScalingRulesStabilizationWindowSeconds -> V2beta2HPAScalingRules { v2beta2HPAScalingRulesStabilizationWindowSeconds, ..} ) <$> f v2beta2HPAScalingRulesStabilizationWindowSeconds
{-# INLINE v2beta2HPAScalingRulesStabilizationWindowSecondsL #-}



-- * V2beta2HorizontalPodAutoscaler

-- | 'v2beta2HorizontalPodAutoscalerApiVersion' Lens
v2beta2HorizontalPodAutoscalerApiVersionL :: Lens_' V2beta2HorizontalPodAutoscaler (Maybe Text)
v2beta2HorizontalPodAutoscalerApiVersionL f V2beta2HorizontalPodAutoscaler{..} = (\v2beta2HorizontalPodAutoscalerApiVersion -> V2beta2HorizontalPodAutoscaler { v2beta2HorizontalPodAutoscalerApiVersion, ..} ) <$> f v2beta2HorizontalPodAutoscalerApiVersion
{-# INLINE v2beta2HorizontalPodAutoscalerApiVersionL #-}

-- | 'v2beta2HorizontalPodAutoscalerKind' Lens
v2beta2HorizontalPodAutoscalerKindL :: Lens_' V2beta2HorizontalPodAutoscaler (Maybe Text)
v2beta2HorizontalPodAutoscalerKindL f V2beta2HorizontalPodAutoscaler{..} = (\v2beta2HorizontalPodAutoscalerKind -> V2beta2HorizontalPodAutoscaler { v2beta2HorizontalPodAutoscalerKind, ..} ) <$> f v2beta2HorizontalPodAutoscalerKind
{-# INLINE v2beta2HorizontalPodAutoscalerKindL #-}

-- | 'v2beta2HorizontalPodAutoscalerMetadata' Lens
v2beta2HorizontalPodAutoscalerMetadataL :: Lens_' V2beta2HorizontalPodAutoscaler (Maybe V1ObjectMeta)
v2beta2HorizontalPodAutoscalerMetadataL f V2beta2HorizontalPodAutoscaler{..} = (\v2beta2HorizontalPodAutoscalerMetadata -> V2beta2HorizontalPodAutoscaler { v2beta2HorizontalPodAutoscalerMetadata, ..} ) <$> f v2beta2HorizontalPodAutoscalerMetadata
{-# INLINE v2beta2HorizontalPodAutoscalerMetadataL #-}

-- | 'v2beta2HorizontalPodAutoscalerSpec' Lens
v2beta2HorizontalPodAutoscalerSpecL :: Lens_' V2beta2HorizontalPodAutoscaler (Maybe V2beta2HorizontalPodAutoscalerSpec)
v2beta2HorizontalPodAutoscalerSpecL f V2beta2HorizontalPodAutoscaler{..} = (\v2beta2HorizontalPodAutoscalerSpec -> V2beta2HorizontalPodAutoscaler { v2beta2HorizontalPodAutoscalerSpec, ..} ) <$> f v2beta2HorizontalPodAutoscalerSpec
{-# INLINE v2beta2HorizontalPodAutoscalerSpecL #-}

-- | 'v2beta2HorizontalPodAutoscalerStatus' Lens
v2beta2HorizontalPodAutoscalerStatusL :: Lens_' V2beta2HorizontalPodAutoscaler (Maybe V2beta2HorizontalPodAutoscalerStatus)
v2beta2HorizontalPodAutoscalerStatusL f V2beta2HorizontalPodAutoscaler{..} = (\v2beta2HorizontalPodAutoscalerStatus -> V2beta2HorizontalPodAutoscaler { v2beta2HorizontalPodAutoscalerStatus, ..} ) <$> f v2beta2HorizontalPodAutoscalerStatus
{-# INLINE v2beta2HorizontalPodAutoscalerStatusL #-}



-- * V2beta2HorizontalPodAutoscalerBehavior

-- | 'v2beta2HorizontalPodAutoscalerBehaviorScaleDown' Lens
v2beta2HorizontalPodAutoscalerBehaviorScaleDownL :: Lens_' V2beta2HorizontalPodAutoscalerBehavior (Maybe V2beta2HPAScalingRules)
v2beta2HorizontalPodAutoscalerBehaviorScaleDownL f V2beta2HorizontalPodAutoscalerBehavior{..} = (\v2beta2HorizontalPodAutoscalerBehaviorScaleDown -> V2beta2HorizontalPodAutoscalerBehavior { v2beta2HorizontalPodAutoscalerBehaviorScaleDown, ..} ) <$> f v2beta2HorizontalPodAutoscalerBehaviorScaleDown
{-# INLINE v2beta2HorizontalPodAutoscalerBehaviorScaleDownL #-}

-- | 'v2beta2HorizontalPodAutoscalerBehaviorScaleUp' Lens
v2beta2HorizontalPodAutoscalerBehaviorScaleUpL :: Lens_' V2beta2HorizontalPodAutoscalerBehavior (Maybe V2beta2HPAScalingRules)
v2beta2HorizontalPodAutoscalerBehaviorScaleUpL f V2beta2HorizontalPodAutoscalerBehavior{..} = (\v2beta2HorizontalPodAutoscalerBehaviorScaleUp -> V2beta2HorizontalPodAutoscalerBehavior { v2beta2HorizontalPodAutoscalerBehaviorScaleUp, ..} ) <$> f v2beta2HorizontalPodAutoscalerBehaviorScaleUp
{-# INLINE v2beta2HorizontalPodAutoscalerBehaviorScaleUpL #-}



-- * V2beta2HorizontalPodAutoscalerCondition

-- | 'v2beta2HorizontalPodAutoscalerConditionLastTransitionTime' Lens
v2beta2HorizontalPodAutoscalerConditionLastTransitionTimeL :: Lens_' V2beta2HorizontalPodAutoscalerCondition (Maybe DateTime)
v2beta2HorizontalPodAutoscalerConditionLastTransitionTimeL f V2beta2HorizontalPodAutoscalerCondition{..} = (\v2beta2HorizontalPodAutoscalerConditionLastTransitionTime -> V2beta2HorizontalPodAutoscalerCondition { v2beta2HorizontalPodAutoscalerConditionLastTransitionTime, ..} ) <$> f v2beta2HorizontalPodAutoscalerConditionLastTransitionTime
{-# INLINE v2beta2HorizontalPodAutoscalerConditionLastTransitionTimeL #-}

-- | 'v2beta2HorizontalPodAutoscalerConditionMessage' Lens
v2beta2HorizontalPodAutoscalerConditionMessageL :: Lens_' V2beta2HorizontalPodAutoscalerCondition (Maybe Text)
v2beta2HorizontalPodAutoscalerConditionMessageL f V2beta2HorizontalPodAutoscalerCondition{..} = (\v2beta2HorizontalPodAutoscalerConditionMessage -> V2beta2HorizontalPodAutoscalerCondition { v2beta2HorizontalPodAutoscalerConditionMessage, ..} ) <$> f v2beta2HorizontalPodAutoscalerConditionMessage
{-# INLINE v2beta2HorizontalPodAutoscalerConditionMessageL #-}

-- | 'v2beta2HorizontalPodAutoscalerConditionReason' Lens
v2beta2HorizontalPodAutoscalerConditionReasonL :: Lens_' V2beta2HorizontalPodAutoscalerCondition (Maybe Text)
v2beta2HorizontalPodAutoscalerConditionReasonL f V2beta2HorizontalPodAutoscalerCondition{..} = (\v2beta2HorizontalPodAutoscalerConditionReason -> V2beta2HorizontalPodAutoscalerCondition { v2beta2HorizontalPodAutoscalerConditionReason, ..} ) <$> f v2beta2HorizontalPodAutoscalerConditionReason
{-# INLINE v2beta2HorizontalPodAutoscalerConditionReasonL #-}

-- | 'v2beta2HorizontalPodAutoscalerConditionStatus' Lens
v2beta2HorizontalPodAutoscalerConditionStatusL :: Lens_' V2beta2HorizontalPodAutoscalerCondition (Text)
v2beta2HorizontalPodAutoscalerConditionStatusL f V2beta2HorizontalPodAutoscalerCondition{..} = (\v2beta2HorizontalPodAutoscalerConditionStatus -> V2beta2HorizontalPodAutoscalerCondition { v2beta2HorizontalPodAutoscalerConditionStatus, ..} ) <$> f v2beta2HorizontalPodAutoscalerConditionStatus
{-# INLINE v2beta2HorizontalPodAutoscalerConditionStatusL #-}

-- | 'v2beta2HorizontalPodAutoscalerConditionType' Lens
v2beta2HorizontalPodAutoscalerConditionTypeL :: Lens_' V2beta2HorizontalPodAutoscalerCondition (Text)
v2beta2HorizontalPodAutoscalerConditionTypeL f V2beta2HorizontalPodAutoscalerCondition{..} = (\v2beta2HorizontalPodAutoscalerConditionType -> V2beta2HorizontalPodAutoscalerCondition { v2beta2HorizontalPodAutoscalerConditionType, ..} ) <$> f v2beta2HorizontalPodAutoscalerConditionType
{-# INLINE v2beta2HorizontalPodAutoscalerConditionTypeL #-}



-- * V2beta2HorizontalPodAutoscalerList

-- | 'v2beta2HorizontalPodAutoscalerListApiVersion' Lens
v2beta2HorizontalPodAutoscalerListApiVersionL :: Lens_' V2beta2HorizontalPodAutoscalerList (Maybe Text)
v2beta2HorizontalPodAutoscalerListApiVersionL f V2beta2HorizontalPodAutoscalerList{..} = (\v2beta2HorizontalPodAutoscalerListApiVersion -> V2beta2HorizontalPodAutoscalerList { v2beta2HorizontalPodAutoscalerListApiVersion, ..} ) <$> f v2beta2HorizontalPodAutoscalerListApiVersion
{-# INLINE v2beta2HorizontalPodAutoscalerListApiVersionL #-}

-- | 'v2beta2HorizontalPodAutoscalerListItems' Lens
v2beta2HorizontalPodAutoscalerListItemsL :: Lens_' V2beta2HorizontalPodAutoscalerList ([V2beta2HorizontalPodAutoscaler])
v2beta2HorizontalPodAutoscalerListItemsL f V2beta2HorizontalPodAutoscalerList{..} = (\v2beta2HorizontalPodAutoscalerListItems -> V2beta2HorizontalPodAutoscalerList { v2beta2HorizontalPodAutoscalerListItems, ..} ) <$> f v2beta2HorizontalPodAutoscalerListItems
{-# INLINE v2beta2HorizontalPodAutoscalerListItemsL #-}

-- | 'v2beta2HorizontalPodAutoscalerListKind' Lens
v2beta2HorizontalPodAutoscalerListKindL :: Lens_' V2beta2HorizontalPodAutoscalerList (Maybe Text)
v2beta2HorizontalPodAutoscalerListKindL f V2beta2HorizontalPodAutoscalerList{..} = (\v2beta2HorizontalPodAutoscalerListKind -> V2beta2HorizontalPodAutoscalerList { v2beta2HorizontalPodAutoscalerListKind, ..} ) <$> f v2beta2HorizontalPodAutoscalerListKind
{-# INLINE v2beta2HorizontalPodAutoscalerListKindL #-}

-- | 'v2beta2HorizontalPodAutoscalerListMetadata' Lens
v2beta2HorizontalPodAutoscalerListMetadataL :: Lens_' V2beta2HorizontalPodAutoscalerList (Maybe V1ListMeta)
v2beta2HorizontalPodAutoscalerListMetadataL f V2beta2HorizontalPodAutoscalerList{..} = (\v2beta2HorizontalPodAutoscalerListMetadata -> V2beta2HorizontalPodAutoscalerList { v2beta2HorizontalPodAutoscalerListMetadata, ..} ) <$> f v2beta2HorizontalPodAutoscalerListMetadata
{-# INLINE v2beta2HorizontalPodAutoscalerListMetadataL #-}



-- * V2beta2HorizontalPodAutoscalerSpec

-- | 'v2beta2HorizontalPodAutoscalerSpecBehavior' Lens
v2beta2HorizontalPodAutoscalerSpecBehaviorL :: Lens_' V2beta2HorizontalPodAutoscalerSpec (Maybe V2beta2HorizontalPodAutoscalerBehavior)
v2beta2HorizontalPodAutoscalerSpecBehaviorL f V2beta2HorizontalPodAutoscalerSpec{..} = (\v2beta2HorizontalPodAutoscalerSpecBehavior -> V2beta2HorizontalPodAutoscalerSpec { v2beta2HorizontalPodAutoscalerSpecBehavior, ..} ) <$> f v2beta2HorizontalPodAutoscalerSpecBehavior
{-# INLINE v2beta2HorizontalPodAutoscalerSpecBehaviorL #-}

-- | 'v2beta2HorizontalPodAutoscalerSpecMaxReplicas' Lens
v2beta2HorizontalPodAutoscalerSpecMaxReplicasL :: Lens_' V2beta2HorizontalPodAutoscalerSpec (Int)
v2beta2HorizontalPodAutoscalerSpecMaxReplicasL f V2beta2HorizontalPodAutoscalerSpec{..} = (\v2beta2HorizontalPodAutoscalerSpecMaxReplicas -> V2beta2HorizontalPodAutoscalerSpec { v2beta2HorizontalPodAutoscalerSpecMaxReplicas, ..} ) <$> f v2beta2HorizontalPodAutoscalerSpecMaxReplicas
{-# INLINE v2beta2HorizontalPodAutoscalerSpecMaxReplicasL #-}

-- | 'v2beta2HorizontalPodAutoscalerSpecMetrics' Lens
v2beta2HorizontalPodAutoscalerSpecMetricsL :: Lens_' V2beta2HorizontalPodAutoscalerSpec (Maybe [V2beta2MetricSpec])
v2beta2HorizontalPodAutoscalerSpecMetricsL f V2beta2HorizontalPodAutoscalerSpec{..} = (\v2beta2HorizontalPodAutoscalerSpecMetrics -> V2beta2HorizontalPodAutoscalerSpec { v2beta2HorizontalPodAutoscalerSpecMetrics, ..} ) <$> f v2beta2HorizontalPodAutoscalerSpecMetrics
{-# INLINE v2beta2HorizontalPodAutoscalerSpecMetricsL #-}

-- | 'v2beta2HorizontalPodAutoscalerSpecMinReplicas' Lens
v2beta2HorizontalPodAutoscalerSpecMinReplicasL :: Lens_' V2beta2HorizontalPodAutoscalerSpec (Maybe Int)
v2beta2HorizontalPodAutoscalerSpecMinReplicasL f V2beta2HorizontalPodAutoscalerSpec{..} = (\v2beta2HorizontalPodAutoscalerSpecMinReplicas -> V2beta2HorizontalPodAutoscalerSpec { v2beta2HorizontalPodAutoscalerSpecMinReplicas, ..} ) <$> f v2beta2HorizontalPodAutoscalerSpecMinReplicas
{-# INLINE v2beta2HorizontalPodAutoscalerSpecMinReplicasL #-}

-- | 'v2beta2HorizontalPodAutoscalerSpecScaleTargetRef' Lens
v2beta2HorizontalPodAutoscalerSpecScaleTargetRefL :: Lens_' V2beta2HorizontalPodAutoscalerSpec (V2beta2CrossVersionObjectReference)
v2beta2HorizontalPodAutoscalerSpecScaleTargetRefL f V2beta2HorizontalPodAutoscalerSpec{..} = (\v2beta2HorizontalPodAutoscalerSpecScaleTargetRef -> V2beta2HorizontalPodAutoscalerSpec { v2beta2HorizontalPodAutoscalerSpecScaleTargetRef, ..} ) <$> f v2beta2HorizontalPodAutoscalerSpecScaleTargetRef
{-# INLINE v2beta2HorizontalPodAutoscalerSpecScaleTargetRefL #-}



-- * V2beta2HorizontalPodAutoscalerStatus

-- | 'v2beta2HorizontalPodAutoscalerStatusConditions' Lens
v2beta2HorizontalPodAutoscalerStatusConditionsL :: Lens_' V2beta2HorizontalPodAutoscalerStatus (Maybe [V2beta2HorizontalPodAutoscalerCondition])
v2beta2HorizontalPodAutoscalerStatusConditionsL f V2beta2HorizontalPodAutoscalerStatus{..} = (\v2beta2HorizontalPodAutoscalerStatusConditions -> V2beta2HorizontalPodAutoscalerStatus { v2beta2HorizontalPodAutoscalerStatusConditions, ..} ) <$> f v2beta2HorizontalPodAutoscalerStatusConditions
{-# INLINE v2beta2HorizontalPodAutoscalerStatusConditionsL #-}

-- | 'v2beta2HorizontalPodAutoscalerStatusCurrentMetrics' Lens
v2beta2HorizontalPodAutoscalerStatusCurrentMetricsL :: Lens_' V2beta2HorizontalPodAutoscalerStatus (Maybe [V2beta2MetricStatus])
v2beta2HorizontalPodAutoscalerStatusCurrentMetricsL f V2beta2HorizontalPodAutoscalerStatus{..} = (\v2beta2HorizontalPodAutoscalerStatusCurrentMetrics -> V2beta2HorizontalPodAutoscalerStatus { v2beta2HorizontalPodAutoscalerStatusCurrentMetrics, ..} ) <$> f v2beta2HorizontalPodAutoscalerStatusCurrentMetrics
{-# INLINE v2beta2HorizontalPodAutoscalerStatusCurrentMetricsL #-}

-- | 'v2beta2HorizontalPodAutoscalerStatusCurrentReplicas' Lens
v2beta2HorizontalPodAutoscalerStatusCurrentReplicasL :: Lens_' V2beta2HorizontalPodAutoscalerStatus (Int)
v2beta2HorizontalPodAutoscalerStatusCurrentReplicasL f V2beta2HorizontalPodAutoscalerStatus{..} = (\v2beta2HorizontalPodAutoscalerStatusCurrentReplicas -> V2beta2HorizontalPodAutoscalerStatus { v2beta2HorizontalPodAutoscalerStatusCurrentReplicas, ..} ) <$> f v2beta2HorizontalPodAutoscalerStatusCurrentReplicas
{-# INLINE v2beta2HorizontalPodAutoscalerStatusCurrentReplicasL #-}

-- | 'v2beta2HorizontalPodAutoscalerStatusDesiredReplicas' Lens
v2beta2HorizontalPodAutoscalerStatusDesiredReplicasL :: Lens_' V2beta2HorizontalPodAutoscalerStatus (Int)
v2beta2HorizontalPodAutoscalerStatusDesiredReplicasL f V2beta2HorizontalPodAutoscalerStatus{..} = (\v2beta2HorizontalPodAutoscalerStatusDesiredReplicas -> V2beta2HorizontalPodAutoscalerStatus { v2beta2HorizontalPodAutoscalerStatusDesiredReplicas, ..} ) <$> f v2beta2HorizontalPodAutoscalerStatusDesiredReplicas
{-# INLINE v2beta2HorizontalPodAutoscalerStatusDesiredReplicasL #-}

-- | 'v2beta2HorizontalPodAutoscalerStatusLastScaleTime' Lens
v2beta2HorizontalPodAutoscalerStatusLastScaleTimeL :: Lens_' V2beta2HorizontalPodAutoscalerStatus (Maybe DateTime)
v2beta2HorizontalPodAutoscalerStatusLastScaleTimeL f V2beta2HorizontalPodAutoscalerStatus{..} = (\v2beta2HorizontalPodAutoscalerStatusLastScaleTime -> V2beta2HorizontalPodAutoscalerStatus { v2beta2HorizontalPodAutoscalerStatusLastScaleTime, ..} ) <$> f v2beta2HorizontalPodAutoscalerStatusLastScaleTime
{-# INLINE v2beta2HorizontalPodAutoscalerStatusLastScaleTimeL #-}

-- | 'v2beta2HorizontalPodAutoscalerStatusObservedGeneration' Lens
v2beta2HorizontalPodAutoscalerStatusObservedGenerationL :: Lens_' V2beta2HorizontalPodAutoscalerStatus (Maybe Integer)
v2beta2HorizontalPodAutoscalerStatusObservedGenerationL f V2beta2HorizontalPodAutoscalerStatus{..} = (\v2beta2HorizontalPodAutoscalerStatusObservedGeneration -> V2beta2HorizontalPodAutoscalerStatus { v2beta2HorizontalPodAutoscalerStatusObservedGeneration, ..} ) <$> f v2beta2HorizontalPodAutoscalerStatusObservedGeneration
{-# INLINE v2beta2HorizontalPodAutoscalerStatusObservedGenerationL #-}



-- * V2beta2MetricIdentifier

-- | 'v2beta2MetricIdentifierName' Lens
v2beta2MetricIdentifierNameL :: Lens_' V2beta2MetricIdentifier (Text)
v2beta2MetricIdentifierNameL f V2beta2MetricIdentifier{..} = (\v2beta2MetricIdentifierName -> V2beta2MetricIdentifier { v2beta2MetricIdentifierName, ..} ) <$> f v2beta2MetricIdentifierName
{-# INLINE v2beta2MetricIdentifierNameL #-}

-- | 'v2beta2MetricIdentifierSelector' Lens
v2beta2MetricIdentifierSelectorL :: Lens_' V2beta2MetricIdentifier (Maybe V1LabelSelector)
v2beta2MetricIdentifierSelectorL f V2beta2MetricIdentifier{..} = (\v2beta2MetricIdentifierSelector -> V2beta2MetricIdentifier { v2beta2MetricIdentifierSelector, ..} ) <$> f v2beta2MetricIdentifierSelector
{-# INLINE v2beta2MetricIdentifierSelectorL #-}



-- * V2beta2MetricSpec

-- | 'v2beta2MetricSpecContainerResource' Lens
v2beta2MetricSpecContainerResourceL :: Lens_' V2beta2MetricSpec (Maybe V2beta2ContainerResourceMetricSource)
v2beta2MetricSpecContainerResourceL f V2beta2MetricSpec{..} = (\v2beta2MetricSpecContainerResource -> V2beta2MetricSpec { v2beta2MetricSpecContainerResource, ..} ) <$> f v2beta2MetricSpecContainerResource
{-# INLINE v2beta2MetricSpecContainerResourceL #-}

-- | 'v2beta2MetricSpecExternal' Lens
v2beta2MetricSpecExternalL :: Lens_' V2beta2MetricSpec (Maybe V2beta2ExternalMetricSource)
v2beta2MetricSpecExternalL f V2beta2MetricSpec{..} = (\v2beta2MetricSpecExternal -> V2beta2MetricSpec { v2beta2MetricSpecExternal, ..} ) <$> f v2beta2MetricSpecExternal
{-# INLINE v2beta2MetricSpecExternalL #-}

-- | 'v2beta2MetricSpecObject' Lens
v2beta2MetricSpecObjectL :: Lens_' V2beta2MetricSpec (Maybe V2beta2ObjectMetricSource)
v2beta2MetricSpecObjectL f V2beta2MetricSpec{..} = (\v2beta2MetricSpecObject -> V2beta2MetricSpec { v2beta2MetricSpecObject, ..} ) <$> f v2beta2MetricSpecObject
{-# INLINE v2beta2MetricSpecObjectL #-}

-- | 'v2beta2MetricSpecPods' Lens
v2beta2MetricSpecPodsL :: Lens_' V2beta2MetricSpec (Maybe V2beta2PodsMetricSource)
v2beta2MetricSpecPodsL f V2beta2MetricSpec{..} = (\v2beta2MetricSpecPods -> V2beta2MetricSpec { v2beta2MetricSpecPods, ..} ) <$> f v2beta2MetricSpecPods
{-# INLINE v2beta2MetricSpecPodsL #-}

-- | 'v2beta2MetricSpecResource' Lens
v2beta2MetricSpecResourceL :: Lens_' V2beta2MetricSpec (Maybe V2beta2ResourceMetricSource)
v2beta2MetricSpecResourceL f V2beta2MetricSpec{..} = (\v2beta2MetricSpecResource -> V2beta2MetricSpec { v2beta2MetricSpecResource, ..} ) <$> f v2beta2MetricSpecResource
{-# INLINE v2beta2MetricSpecResourceL #-}

-- | 'v2beta2MetricSpecType' Lens
v2beta2MetricSpecTypeL :: Lens_' V2beta2MetricSpec (Text)
v2beta2MetricSpecTypeL f V2beta2MetricSpec{..} = (\v2beta2MetricSpecType -> V2beta2MetricSpec { v2beta2MetricSpecType, ..} ) <$> f v2beta2MetricSpecType
{-# INLINE v2beta2MetricSpecTypeL #-}



-- * V2beta2MetricStatus

-- | 'v2beta2MetricStatusContainerResource' Lens
v2beta2MetricStatusContainerResourceL :: Lens_' V2beta2MetricStatus (Maybe V2beta2ContainerResourceMetricStatus)
v2beta2MetricStatusContainerResourceL f V2beta2MetricStatus{..} = (\v2beta2MetricStatusContainerResource -> V2beta2MetricStatus { v2beta2MetricStatusContainerResource, ..} ) <$> f v2beta2MetricStatusContainerResource
{-# INLINE v2beta2MetricStatusContainerResourceL #-}

-- | 'v2beta2MetricStatusExternal' Lens
v2beta2MetricStatusExternalL :: Lens_' V2beta2MetricStatus (Maybe V2beta2ExternalMetricStatus)
v2beta2MetricStatusExternalL f V2beta2MetricStatus{..} = (\v2beta2MetricStatusExternal -> V2beta2MetricStatus { v2beta2MetricStatusExternal, ..} ) <$> f v2beta2MetricStatusExternal
{-# INLINE v2beta2MetricStatusExternalL #-}

-- | 'v2beta2MetricStatusObject' Lens
v2beta2MetricStatusObjectL :: Lens_' V2beta2MetricStatus (Maybe V2beta2ObjectMetricStatus)
v2beta2MetricStatusObjectL f V2beta2MetricStatus{..} = (\v2beta2MetricStatusObject -> V2beta2MetricStatus { v2beta2MetricStatusObject, ..} ) <$> f v2beta2MetricStatusObject
{-# INLINE v2beta2MetricStatusObjectL #-}

-- | 'v2beta2MetricStatusPods' Lens
v2beta2MetricStatusPodsL :: Lens_' V2beta2MetricStatus (Maybe V2beta2PodsMetricStatus)
v2beta2MetricStatusPodsL f V2beta2MetricStatus{..} = (\v2beta2MetricStatusPods -> V2beta2MetricStatus { v2beta2MetricStatusPods, ..} ) <$> f v2beta2MetricStatusPods
{-# INLINE v2beta2MetricStatusPodsL #-}

-- | 'v2beta2MetricStatusResource' Lens
v2beta2MetricStatusResourceL :: Lens_' V2beta2MetricStatus (Maybe V2beta2ResourceMetricStatus)
v2beta2MetricStatusResourceL f V2beta2MetricStatus{..} = (\v2beta2MetricStatusResource -> V2beta2MetricStatus { v2beta2MetricStatusResource, ..} ) <$> f v2beta2MetricStatusResource
{-# INLINE v2beta2MetricStatusResourceL #-}

-- | 'v2beta2MetricStatusType' Lens
v2beta2MetricStatusTypeL :: Lens_' V2beta2MetricStatus (Text)
v2beta2MetricStatusTypeL f V2beta2MetricStatus{..} = (\v2beta2MetricStatusType -> V2beta2MetricStatus { v2beta2MetricStatusType, ..} ) <$> f v2beta2MetricStatusType
{-# INLINE v2beta2MetricStatusTypeL #-}



-- * V2beta2MetricTarget

-- | 'v2beta2MetricTargetAverageUtilization' Lens
v2beta2MetricTargetAverageUtilizationL :: Lens_' V2beta2MetricTarget (Maybe Int)
v2beta2MetricTargetAverageUtilizationL f V2beta2MetricTarget{..} = (\v2beta2MetricTargetAverageUtilization -> V2beta2MetricTarget { v2beta2MetricTargetAverageUtilization, ..} ) <$> f v2beta2MetricTargetAverageUtilization
{-# INLINE v2beta2MetricTargetAverageUtilizationL #-}

-- | 'v2beta2MetricTargetAverageValue' Lens
v2beta2MetricTargetAverageValueL :: Lens_' V2beta2MetricTarget (Maybe Quantity)
v2beta2MetricTargetAverageValueL f V2beta2MetricTarget{..} = (\v2beta2MetricTargetAverageValue -> V2beta2MetricTarget { v2beta2MetricTargetAverageValue, ..} ) <$> f v2beta2MetricTargetAverageValue
{-# INLINE v2beta2MetricTargetAverageValueL #-}

-- | 'v2beta2MetricTargetType' Lens
v2beta2MetricTargetTypeL :: Lens_' V2beta2MetricTarget (Text)
v2beta2MetricTargetTypeL f V2beta2MetricTarget{..} = (\v2beta2MetricTargetType -> V2beta2MetricTarget { v2beta2MetricTargetType, ..} ) <$> f v2beta2MetricTargetType
{-# INLINE v2beta2MetricTargetTypeL #-}

-- | 'v2beta2MetricTargetValue' Lens
v2beta2MetricTargetValueL :: Lens_' V2beta2MetricTarget (Maybe Quantity)
v2beta2MetricTargetValueL f V2beta2MetricTarget{..} = (\v2beta2MetricTargetValue -> V2beta2MetricTarget { v2beta2MetricTargetValue, ..} ) <$> f v2beta2MetricTargetValue
{-# INLINE v2beta2MetricTargetValueL #-}



-- * V2beta2MetricValueStatus

-- | 'v2beta2MetricValueStatusAverageUtilization' Lens
v2beta2MetricValueStatusAverageUtilizationL :: Lens_' V2beta2MetricValueStatus (Maybe Int)
v2beta2MetricValueStatusAverageUtilizationL f V2beta2MetricValueStatus{..} = (\v2beta2MetricValueStatusAverageUtilization -> V2beta2MetricValueStatus { v2beta2MetricValueStatusAverageUtilization, ..} ) <$> f v2beta2MetricValueStatusAverageUtilization
{-# INLINE v2beta2MetricValueStatusAverageUtilizationL #-}

-- | 'v2beta2MetricValueStatusAverageValue' Lens
v2beta2MetricValueStatusAverageValueL :: Lens_' V2beta2MetricValueStatus (Maybe Quantity)
v2beta2MetricValueStatusAverageValueL f V2beta2MetricValueStatus{..} = (\v2beta2MetricValueStatusAverageValue -> V2beta2MetricValueStatus { v2beta2MetricValueStatusAverageValue, ..} ) <$> f v2beta2MetricValueStatusAverageValue
{-# INLINE v2beta2MetricValueStatusAverageValueL #-}

-- | 'v2beta2MetricValueStatusValue' Lens
v2beta2MetricValueStatusValueL :: Lens_' V2beta2MetricValueStatus (Maybe Quantity)
v2beta2MetricValueStatusValueL f V2beta2MetricValueStatus{..} = (\v2beta2MetricValueStatusValue -> V2beta2MetricValueStatus { v2beta2MetricValueStatusValue, ..} ) <$> f v2beta2MetricValueStatusValue
{-# INLINE v2beta2MetricValueStatusValueL #-}



-- * V2beta2ObjectMetricSource

-- | 'v2beta2ObjectMetricSourceDescribedObject' Lens
v2beta2ObjectMetricSourceDescribedObjectL :: Lens_' V2beta2ObjectMetricSource (V2beta2CrossVersionObjectReference)
v2beta2ObjectMetricSourceDescribedObjectL f V2beta2ObjectMetricSource{..} = (\v2beta2ObjectMetricSourceDescribedObject -> V2beta2ObjectMetricSource { v2beta2ObjectMetricSourceDescribedObject, ..} ) <$> f v2beta2ObjectMetricSourceDescribedObject
{-# INLINE v2beta2ObjectMetricSourceDescribedObjectL #-}

-- | 'v2beta2ObjectMetricSourceMetric' Lens
v2beta2ObjectMetricSourceMetricL :: Lens_' V2beta2ObjectMetricSource (V2beta2MetricIdentifier)
v2beta2ObjectMetricSourceMetricL f V2beta2ObjectMetricSource{..} = (\v2beta2ObjectMetricSourceMetric -> V2beta2ObjectMetricSource { v2beta2ObjectMetricSourceMetric, ..} ) <$> f v2beta2ObjectMetricSourceMetric
{-# INLINE v2beta2ObjectMetricSourceMetricL #-}

-- | 'v2beta2ObjectMetricSourceTarget' Lens
v2beta2ObjectMetricSourceTargetL :: Lens_' V2beta2ObjectMetricSource (V2beta2MetricTarget)
v2beta2ObjectMetricSourceTargetL f V2beta2ObjectMetricSource{..} = (\v2beta2ObjectMetricSourceTarget -> V2beta2ObjectMetricSource { v2beta2ObjectMetricSourceTarget, ..} ) <$> f v2beta2ObjectMetricSourceTarget
{-# INLINE v2beta2ObjectMetricSourceTargetL #-}



-- * V2beta2ObjectMetricStatus

-- | 'v2beta2ObjectMetricStatusCurrent' Lens
v2beta2ObjectMetricStatusCurrentL :: Lens_' V2beta2ObjectMetricStatus (V2beta2MetricValueStatus)
v2beta2ObjectMetricStatusCurrentL f V2beta2ObjectMetricStatus{..} = (\v2beta2ObjectMetricStatusCurrent -> V2beta2ObjectMetricStatus { v2beta2ObjectMetricStatusCurrent, ..} ) <$> f v2beta2ObjectMetricStatusCurrent
{-# INLINE v2beta2ObjectMetricStatusCurrentL #-}

-- | 'v2beta2ObjectMetricStatusDescribedObject' Lens
v2beta2ObjectMetricStatusDescribedObjectL :: Lens_' V2beta2ObjectMetricStatus (V2beta2CrossVersionObjectReference)
v2beta2ObjectMetricStatusDescribedObjectL f V2beta2ObjectMetricStatus{..} = (\v2beta2ObjectMetricStatusDescribedObject -> V2beta2ObjectMetricStatus { v2beta2ObjectMetricStatusDescribedObject, ..} ) <$> f v2beta2ObjectMetricStatusDescribedObject
{-# INLINE v2beta2ObjectMetricStatusDescribedObjectL #-}

-- | 'v2beta2ObjectMetricStatusMetric' Lens
v2beta2ObjectMetricStatusMetricL :: Lens_' V2beta2ObjectMetricStatus (V2beta2MetricIdentifier)
v2beta2ObjectMetricStatusMetricL f V2beta2ObjectMetricStatus{..} = (\v2beta2ObjectMetricStatusMetric -> V2beta2ObjectMetricStatus { v2beta2ObjectMetricStatusMetric, ..} ) <$> f v2beta2ObjectMetricStatusMetric
{-# INLINE v2beta2ObjectMetricStatusMetricL #-}



-- * V2beta2PodsMetricSource

-- | 'v2beta2PodsMetricSourceMetric' Lens
v2beta2PodsMetricSourceMetricL :: Lens_' V2beta2PodsMetricSource (V2beta2MetricIdentifier)
v2beta2PodsMetricSourceMetricL f V2beta2PodsMetricSource{..} = (\v2beta2PodsMetricSourceMetric -> V2beta2PodsMetricSource { v2beta2PodsMetricSourceMetric, ..} ) <$> f v2beta2PodsMetricSourceMetric
{-# INLINE v2beta2PodsMetricSourceMetricL #-}

-- | 'v2beta2PodsMetricSourceTarget' Lens
v2beta2PodsMetricSourceTargetL :: Lens_' V2beta2PodsMetricSource (V2beta2MetricTarget)
v2beta2PodsMetricSourceTargetL f V2beta2PodsMetricSource{..} = (\v2beta2PodsMetricSourceTarget -> V2beta2PodsMetricSource { v2beta2PodsMetricSourceTarget, ..} ) <$> f v2beta2PodsMetricSourceTarget
{-# INLINE v2beta2PodsMetricSourceTargetL #-}



-- * V2beta2PodsMetricStatus

-- | 'v2beta2PodsMetricStatusCurrent' Lens
v2beta2PodsMetricStatusCurrentL :: Lens_' V2beta2PodsMetricStatus (V2beta2MetricValueStatus)
v2beta2PodsMetricStatusCurrentL f V2beta2PodsMetricStatus{..} = (\v2beta2PodsMetricStatusCurrent -> V2beta2PodsMetricStatus { v2beta2PodsMetricStatusCurrent, ..} ) <$> f v2beta2PodsMetricStatusCurrent
{-# INLINE v2beta2PodsMetricStatusCurrentL #-}

-- | 'v2beta2PodsMetricStatusMetric' Lens
v2beta2PodsMetricStatusMetricL :: Lens_' V2beta2PodsMetricStatus (V2beta2MetricIdentifier)
v2beta2PodsMetricStatusMetricL f V2beta2PodsMetricStatus{..} = (\v2beta2PodsMetricStatusMetric -> V2beta2PodsMetricStatus { v2beta2PodsMetricStatusMetric, ..} ) <$> f v2beta2PodsMetricStatusMetric
{-# INLINE v2beta2PodsMetricStatusMetricL #-}



-- * V2beta2ResourceMetricSource

-- | 'v2beta2ResourceMetricSourceName' Lens
v2beta2ResourceMetricSourceNameL :: Lens_' V2beta2ResourceMetricSource (Text)
v2beta2ResourceMetricSourceNameL f V2beta2ResourceMetricSource{..} = (\v2beta2ResourceMetricSourceName -> V2beta2ResourceMetricSource { v2beta2ResourceMetricSourceName, ..} ) <$> f v2beta2ResourceMetricSourceName
{-# INLINE v2beta2ResourceMetricSourceNameL #-}

-- | 'v2beta2ResourceMetricSourceTarget' Lens
v2beta2ResourceMetricSourceTargetL :: Lens_' V2beta2ResourceMetricSource (V2beta2MetricTarget)
v2beta2ResourceMetricSourceTargetL f V2beta2ResourceMetricSource{..} = (\v2beta2ResourceMetricSourceTarget -> V2beta2ResourceMetricSource { v2beta2ResourceMetricSourceTarget, ..} ) <$> f v2beta2ResourceMetricSourceTarget
{-# INLINE v2beta2ResourceMetricSourceTargetL #-}



-- * V2beta2ResourceMetricStatus

-- | 'v2beta2ResourceMetricStatusCurrent' Lens
v2beta2ResourceMetricStatusCurrentL :: Lens_' V2beta2ResourceMetricStatus (V2beta2MetricValueStatus)
v2beta2ResourceMetricStatusCurrentL f V2beta2ResourceMetricStatus{..} = (\v2beta2ResourceMetricStatusCurrent -> V2beta2ResourceMetricStatus { v2beta2ResourceMetricStatusCurrent, ..} ) <$> f v2beta2ResourceMetricStatusCurrent
{-# INLINE v2beta2ResourceMetricStatusCurrentL #-}

-- | 'v2beta2ResourceMetricStatusName' Lens
v2beta2ResourceMetricStatusNameL :: Lens_' V2beta2ResourceMetricStatus (Text)
v2beta2ResourceMetricStatusNameL f V2beta2ResourceMetricStatus{..} = (\v2beta2ResourceMetricStatusName -> V2beta2ResourceMetricStatus { v2beta2ResourceMetricStatusName, ..} ) <$> f v2beta2ResourceMetricStatusName
{-# INLINE v2beta2ResourceMetricStatusNameL #-}



-- * VersionInfo

-- | 'versionInfoBuildDate' Lens
versionInfoBuildDateL :: Lens_' VersionInfo (Text)
versionInfoBuildDateL f VersionInfo{..} = (\versionInfoBuildDate -> VersionInfo { versionInfoBuildDate, ..} ) <$> f versionInfoBuildDate
{-# INLINE versionInfoBuildDateL #-}

-- | 'versionInfoCompiler' Lens
versionInfoCompilerL :: Lens_' VersionInfo (Text)
versionInfoCompilerL f VersionInfo{..} = (\versionInfoCompiler -> VersionInfo { versionInfoCompiler, ..} ) <$> f versionInfoCompiler
{-# INLINE versionInfoCompilerL #-}

-- | 'versionInfoGitCommit' Lens
versionInfoGitCommitL :: Lens_' VersionInfo (Text)
versionInfoGitCommitL f VersionInfo{..} = (\versionInfoGitCommit -> VersionInfo { versionInfoGitCommit, ..} ) <$> f versionInfoGitCommit
{-# INLINE versionInfoGitCommitL #-}

-- | 'versionInfoGitTreeState' Lens
versionInfoGitTreeStateL :: Lens_' VersionInfo (Text)
versionInfoGitTreeStateL f VersionInfo{..} = (\versionInfoGitTreeState -> VersionInfo { versionInfoGitTreeState, ..} ) <$> f versionInfoGitTreeState
{-# INLINE versionInfoGitTreeStateL #-}

-- | 'versionInfoGitVersion' Lens
versionInfoGitVersionL :: Lens_' VersionInfo (Text)
versionInfoGitVersionL f VersionInfo{..} = (\versionInfoGitVersion -> VersionInfo { versionInfoGitVersion, ..} ) <$> f versionInfoGitVersion
{-# INLINE versionInfoGitVersionL #-}

-- | 'versionInfoGoVersion' Lens
versionInfoGoVersionL :: Lens_' VersionInfo (Text)
versionInfoGoVersionL f VersionInfo{..} = (\versionInfoGoVersion -> VersionInfo { versionInfoGoVersion, ..} ) <$> f versionInfoGoVersion
{-# INLINE versionInfoGoVersionL #-}

-- | 'versionInfoMajor' Lens
versionInfoMajorL :: Lens_' VersionInfo (Text)
versionInfoMajorL f VersionInfo{..} = (\versionInfoMajor -> VersionInfo { versionInfoMajor, ..} ) <$> f versionInfoMajor
{-# INLINE versionInfoMajorL #-}

-- | 'versionInfoMinor' Lens
versionInfoMinorL :: Lens_' VersionInfo (Text)
versionInfoMinorL f VersionInfo{..} = (\versionInfoMinor -> VersionInfo { versionInfoMinor, ..} ) <$> f versionInfoMinor
{-# INLINE versionInfoMinorL #-}

-- | 'versionInfoPlatform' Lens
versionInfoPlatformL :: Lens_' VersionInfo (Text)
versionInfoPlatformL f VersionInfo{..} = (\versionInfoPlatform -> VersionInfo { versionInfoPlatform, ..} ) <$> f versionInfoPlatform
{-# INLINE versionInfoPlatformL #-}