content: {-
     OpenAPI Petstore
  
     This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
  
     OpenAPI Version: 3.0.1
     OpenAPI Petstore API version: 1.0.0
     Generated by OpenAPI Generator (https://openapi-generator.tech)
  -}
  
  {-|
  Module : OpenAPIPetstore.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 OpenAPIPetstore.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 OpenAPIPetstore.Model
  import OpenAPIPetstore.Core
  
  
  -- * AdditionalPropertiesAnyType
  
  -- | 'additionalPropertiesAnyTypeName' Lens
  additionalPropertiesAnyTypeNameL :: Lens_' AdditionalPropertiesAnyType (Maybe Text)
  additionalPropertiesAnyTypeNameL f AdditionalPropertiesAnyType{..} = (\additionalPropertiesAnyTypeName -> AdditionalPropertiesAnyType { additionalPropertiesAnyTypeName, ..} ) <$> f additionalPropertiesAnyTypeName
  {-# INLINE additionalPropertiesAnyTypeNameL #-}
  
  
  
  -- * AdditionalPropertiesArray
  
  -- | 'additionalPropertiesArrayName' Lens
  additionalPropertiesArrayNameL :: Lens_' AdditionalPropertiesArray (Maybe Text)
  additionalPropertiesArrayNameL f AdditionalPropertiesArray{..} = (\additionalPropertiesArrayName -> AdditionalPropertiesArray { additionalPropertiesArrayName, ..} ) <$> f additionalPropertiesArrayName
  {-# INLINE additionalPropertiesArrayNameL #-}
  
  
  
  -- * AdditionalPropertiesBoolean
  
  -- | 'additionalPropertiesBooleanName' Lens
  additionalPropertiesBooleanNameL :: Lens_' AdditionalPropertiesBoolean (Maybe Text)
  additionalPropertiesBooleanNameL f AdditionalPropertiesBoolean{..} = (\additionalPropertiesBooleanName -> AdditionalPropertiesBoolean { additionalPropertiesBooleanName, ..} ) <$> f additionalPropertiesBooleanName
  {-# INLINE additionalPropertiesBooleanNameL #-}
  
  
  
  -- * AdditionalPropertiesClass
  
  -- | 'additionalPropertiesClassMapString' Lens
  additionalPropertiesClassMapStringL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String Text))
  additionalPropertiesClassMapStringL f AdditionalPropertiesClass{..} = (\additionalPropertiesClassMapString -> AdditionalPropertiesClass { additionalPropertiesClassMapString, ..} ) <$> f additionalPropertiesClassMapString
  {-# INLINE additionalPropertiesClassMapStringL #-}
  
  -- | 'additionalPropertiesClassMapNumber' Lens
  additionalPropertiesClassMapNumberL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String Double))
  additionalPropertiesClassMapNumberL f AdditionalPropertiesClass{..} = (\additionalPropertiesClassMapNumber -> AdditionalPropertiesClass { additionalPropertiesClassMapNumber, ..} ) <$> f additionalPropertiesClassMapNumber
  {-# INLINE additionalPropertiesClassMapNumberL #-}
  
  -- | 'additionalPropertiesClassMapInteger' Lens
  additionalPropertiesClassMapIntegerL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String Int))
  additionalPropertiesClassMapIntegerL f AdditionalPropertiesClass{..} = (\additionalPropertiesClassMapInteger -> AdditionalPropertiesClass { additionalPropertiesClassMapInteger, ..} ) <$> f additionalPropertiesClassMapInteger
  {-# INLINE additionalPropertiesClassMapIntegerL #-}
  
  -- | 'additionalPropertiesClassMapBoolean' Lens
  additionalPropertiesClassMapBooleanL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String Bool))
  additionalPropertiesClassMapBooleanL f AdditionalPropertiesClass{..} = (\additionalPropertiesClassMapBoolean -> AdditionalPropertiesClass { additionalPropertiesClassMapBoolean, ..} ) <$> f additionalPropertiesClassMapBoolean
  {-# INLINE additionalPropertiesClassMapBooleanL #-}
  
  -- | 'additionalPropertiesClassMapArrayInteger' Lens
  additionalPropertiesClassMapArrayIntegerL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String [Int]))
  additionalPropertiesClassMapArrayIntegerL f AdditionalPropertiesClass{..} = (\additionalPropertiesClassMapArrayInteger -> AdditionalPropertiesClass { additionalPropertiesClassMapArrayInteger, ..} ) <$> f additionalPropertiesClassMapArrayInteger
  {-# INLINE additionalPropertiesClassMapArrayIntegerL #-}
  
  -- | 'additionalPropertiesClassMapArrayAnytype' Lens
  additionalPropertiesClassMapArrayAnytypeL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String [A.Value]))
  additionalPropertiesClassMapArrayAnytypeL f AdditionalPropertiesClass{..} = (\additionalPropertiesClassMapArrayAnytype -> AdditionalPropertiesClass { additionalPropertiesClassMapArrayAnytype, ..} ) <$> f additionalPropertiesClassMapArrayAnytype
  {-# INLINE additionalPropertiesClassMapArrayAnytypeL #-}
  
  -- | 'additionalPropertiesClassMapMapString' Lens
  additionalPropertiesClassMapMapStringL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String (Map.Map String Text)))
  additionalPropertiesClassMapMapStringL f AdditionalPropertiesClass{..} = (\additionalPropertiesClassMapMapString -> AdditionalPropertiesClass { additionalPropertiesClassMapMapString, ..} ) <$> f additionalPropertiesClassMapMapString
  {-# INLINE additionalPropertiesClassMapMapStringL #-}
  
  -- | 'additionalPropertiesClassMapMapAnytype' Lens
  additionalPropertiesClassMapMapAnytypeL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String (Map.Map String A.Value)))
  additionalPropertiesClassMapMapAnytypeL f AdditionalPropertiesClass{..} = (\additionalPropertiesClassMapMapAnytype -> AdditionalPropertiesClass { additionalPropertiesClassMapMapAnytype, ..} ) <$> f additionalPropertiesClassMapMapAnytype
  {-# INLINE additionalPropertiesClassMapMapAnytypeL #-}
  
  -- | 'additionalPropertiesClassAnytype1' Lens
  additionalPropertiesClassAnytype1L :: Lens_' AdditionalPropertiesClass (Maybe A.Value)
  additionalPropertiesClassAnytype1L f AdditionalPropertiesClass{..} = (\additionalPropertiesClassAnytype1 -> AdditionalPropertiesClass { additionalPropertiesClassAnytype1, ..} ) <$> f additionalPropertiesClassAnytype1
  {-# INLINE additionalPropertiesClassAnytype1L #-}
  
  -- | 'additionalPropertiesClassAnytype2' Lens
  additionalPropertiesClassAnytype2L :: Lens_' AdditionalPropertiesClass (Maybe A.Value)
  additionalPropertiesClassAnytype2L f AdditionalPropertiesClass{..} = (\additionalPropertiesClassAnytype2 -> AdditionalPropertiesClass { additionalPropertiesClassAnytype2, ..} ) <$> f additionalPropertiesClassAnytype2
  {-# INLINE additionalPropertiesClassAnytype2L #-}
  
  -- | 'additionalPropertiesClassAnytype3' Lens
  additionalPropertiesClassAnytype3L :: Lens_' AdditionalPropertiesClass (Maybe A.Value)
  additionalPropertiesClassAnytype3L f AdditionalPropertiesClass{..} = (\additionalPropertiesClassAnytype3 -> AdditionalPropertiesClass { additionalPropertiesClassAnytype3, ..} ) <$> f additionalPropertiesClassAnytype3
  {-# INLINE additionalPropertiesClassAnytype3L #-}
  
  
  
  -- * AdditionalPropertiesInteger
  
  -- | 'additionalPropertiesIntegerName' Lens
  additionalPropertiesIntegerNameL :: Lens_' AdditionalPropertiesInteger (Maybe Text)
  additionalPropertiesIntegerNameL f AdditionalPropertiesInteger{..} = (\additionalPropertiesIntegerName -> AdditionalPropertiesInteger { additionalPropertiesIntegerName, ..} ) <$> f additionalPropertiesIntegerName
  {-# INLINE additionalPropertiesIntegerNameL #-}
  
  
  
  -- * AdditionalPropertiesNumber
  
  -- | 'additionalPropertiesNumberName' Lens
  additionalPropertiesNumberNameL :: Lens_' AdditionalPropertiesNumber (Maybe Text)
  additionalPropertiesNumberNameL f AdditionalPropertiesNumber{..} = (\additionalPropertiesNumberName -> AdditionalPropertiesNumber { additionalPropertiesNumberName, ..} ) <$> f additionalPropertiesNumberName
  {-# INLINE additionalPropertiesNumberNameL #-}
  
  
  
  -- * AdditionalPropertiesObject
  
  -- | 'additionalPropertiesObjectName' Lens
  additionalPropertiesObjectNameL :: Lens_' AdditionalPropertiesObject (Maybe Text)
  additionalPropertiesObjectNameL f AdditionalPropertiesObject{..} = (\additionalPropertiesObjectName -> AdditionalPropertiesObject { additionalPropertiesObjectName, ..} ) <$> f additionalPropertiesObjectName
  {-# INLINE additionalPropertiesObjectNameL #-}
  
  
  
  -- * AdditionalPropertiesString
  
  -- | 'additionalPropertiesStringName' Lens
  additionalPropertiesStringNameL :: Lens_' AdditionalPropertiesString (Maybe Text)
  additionalPropertiesStringNameL f AdditionalPropertiesString{..} = (\additionalPropertiesStringName -> AdditionalPropertiesString { additionalPropertiesStringName, ..} ) <$> f additionalPropertiesStringName
  {-# INLINE additionalPropertiesStringNameL #-}
  
  
  
  -- * Animal
  
  -- | 'animalClassName' Lens
  animalClassNameL :: Lens_' Animal (Text)
  animalClassNameL f Animal{..} = (\animalClassName -> Animal { animalClassName, ..} ) <$> f animalClassName
  {-# INLINE animalClassNameL #-}
  
  -- | 'animalColor' Lens
  animalColorL :: Lens_' Animal (Maybe Text)
  animalColorL f Animal{..} = (\animalColor -> Animal { animalColor, ..} ) <$> f animalColor
  {-# INLINE animalColorL #-}
  
  
  
  -- * ApiResponse
  
  -- | 'apiResponseCode' Lens
  apiResponseCodeL :: Lens_' ApiResponse (Maybe Int)
  apiResponseCodeL f ApiResponse{..} = (\apiResponseCode -> ApiResponse { apiResponseCode, ..} ) <$> f apiResponseCode
  {-# INLINE apiResponseCodeL #-}
  
  -- | 'apiResponseType' Lens
  apiResponseTypeL :: Lens_' ApiResponse (Maybe Text)
  apiResponseTypeL f ApiResponse{..} = (\apiResponseType -> ApiResponse { apiResponseType, ..} ) <$> f apiResponseType
  {-# INLINE apiResponseTypeL #-}
  
  -- | 'apiResponseMessage' Lens
  apiResponseMessageL :: Lens_' ApiResponse (Maybe Text)
  apiResponseMessageL f ApiResponse{..} = (\apiResponseMessage -> ApiResponse { apiResponseMessage, ..} ) <$> f apiResponseMessage
  {-# INLINE apiResponseMessageL #-}
  
  
  
  -- * ArrayOfArrayOfNumberOnly
  
  -- | 'arrayOfArrayOfNumberOnlyArrayArrayNumber' Lens
  arrayOfArrayOfNumberOnlyArrayArrayNumberL :: Lens_' ArrayOfArrayOfNumberOnly (Maybe [[Double]])
  arrayOfArrayOfNumberOnlyArrayArrayNumberL f ArrayOfArrayOfNumberOnly{..} = (\arrayOfArrayOfNumberOnlyArrayArrayNumber -> ArrayOfArrayOfNumberOnly { arrayOfArrayOfNumberOnlyArrayArrayNumber, ..} ) <$> f arrayOfArrayOfNumberOnlyArrayArrayNumber
  {-# INLINE arrayOfArrayOfNumberOnlyArrayArrayNumberL #-}
  
  
  
  -- * ArrayOfNumberOnly
  
  -- | 'arrayOfNumberOnlyArrayNumber' Lens
  arrayOfNumberOnlyArrayNumberL :: Lens_' ArrayOfNumberOnly (Maybe [Double])
  arrayOfNumberOnlyArrayNumberL f ArrayOfNumberOnly{..} = (\arrayOfNumberOnlyArrayNumber -> ArrayOfNumberOnly { arrayOfNumberOnlyArrayNumber, ..} ) <$> f arrayOfNumberOnlyArrayNumber
  {-# INLINE arrayOfNumberOnlyArrayNumberL #-}
  
  
  
  -- * ArrayTest
  
  -- | 'arrayTestArrayOfString' Lens
  arrayTestArrayOfStringL :: Lens_' ArrayTest (Maybe [Text])
  arrayTestArrayOfStringL f ArrayTest{..} = (\arrayTestArrayOfString -> ArrayTest { arrayTestArrayOfString, ..} ) <$> f arrayTestArrayOfString
  {-# INLINE arrayTestArrayOfStringL #-}
  
  -- | 'arrayTestArrayArrayOfInteger' Lens
  arrayTestArrayArrayOfIntegerL :: Lens_' ArrayTest (Maybe [[Integer]])
  arrayTestArrayArrayOfIntegerL f ArrayTest{..} = (\arrayTestArrayArrayOfInteger -> ArrayTest { arrayTestArrayArrayOfInteger, ..} ) <$> f arrayTestArrayArrayOfInteger
  {-# INLINE arrayTestArrayArrayOfIntegerL #-}
  
  -- | 'arrayTestArrayArrayOfModel' Lens
  arrayTestArrayArrayOfModelL :: Lens_' ArrayTest (Maybe [[ReadOnlyFirst]])
  arrayTestArrayArrayOfModelL f ArrayTest{..} = (\arrayTestArrayArrayOfModel -> ArrayTest { arrayTestArrayArrayOfModel, ..} ) <$> f arrayTestArrayArrayOfModel
  {-# INLINE arrayTestArrayArrayOfModelL #-}
  
  
  
  -- * BigCat
  
  -- | 'bigCatClassName' Lens
  bigCatClassNameL :: Lens_' BigCat (Text)
  bigCatClassNameL f BigCat{..} = (\bigCatClassName -> BigCat { bigCatClassName, ..} ) <$> f bigCatClassName
  {-# INLINE bigCatClassNameL #-}
  
  -- | 'bigCatColor' Lens
  bigCatColorL :: Lens_' BigCat (Maybe Text)
  bigCatColorL f BigCat{..} = (\bigCatColor -> BigCat { bigCatColor, ..} ) <$> f bigCatColor
  {-# INLINE bigCatColorL #-}
  
  -- | 'bigCatDeclawed' Lens
  bigCatDeclawedL :: Lens_' BigCat (Maybe Bool)
  bigCatDeclawedL f BigCat{..} = (\bigCatDeclawed -> BigCat { bigCatDeclawed, ..} ) <$> f bigCatDeclawed
  {-# INLINE bigCatDeclawedL #-}
  
  -- | 'bigCatKind' Lens
  bigCatKindL :: Lens_' BigCat (Maybe E'Kind)
  bigCatKindL f BigCat{..} = (\bigCatKind -> BigCat { bigCatKind, ..} ) <$> f bigCatKind
  {-# INLINE bigCatKindL #-}
  
  
  
  -- * Capitalization
  
  -- | 'capitalizationSmallCamel' Lens
  capitalizationSmallCamelL :: Lens_' Capitalization (Maybe Text)
  capitalizationSmallCamelL f Capitalization{..} = (\capitalizationSmallCamel -> Capitalization { capitalizationSmallCamel, ..} ) <$> f capitalizationSmallCamel
  {-# INLINE capitalizationSmallCamelL #-}
  
  -- | 'capitalizationCapitalCamel' Lens
  capitalizationCapitalCamelL :: Lens_' Capitalization (Maybe Text)
  capitalizationCapitalCamelL f Capitalization{..} = (\capitalizationCapitalCamel -> Capitalization { capitalizationCapitalCamel, ..} ) <$> f capitalizationCapitalCamel
  {-# INLINE capitalizationCapitalCamelL #-}
  
  -- | 'capitalizationSmallSnake' Lens
  capitalizationSmallSnakeL :: Lens_' Capitalization (Maybe Text)
  capitalizationSmallSnakeL f Capitalization{..} = (\capitalizationSmallSnake -> Capitalization { capitalizationSmallSnake, ..} ) <$> f capitalizationSmallSnake
  {-# INLINE capitalizationSmallSnakeL #-}
  
  -- | 'capitalizationCapitalSnake' Lens
  capitalizationCapitalSnakeL :: Lens_' Capitalization (Maybe Text)
  capitalizationCapitalSnakeL f Capitalization{..} = (\capitalizationCapitalSnake -> Capitalization { capitalizationCapitalSnake, ..} ) <$> f capitalizationCapitalSnake
  {-# INLINE capitalizationCapitalSnakeL #-}
  
  -- | 'capitalizationScaEthFlowPoints' Lens
  capitalizationScaEthFlowPointsL :: Lens_' Capitalization (Maybe Text)
  capitalizationScaEthFlowPointsL f Capitalization{..} = (\capitalizationScaEthFlowPoints -> Capitalization { capitalizationScaEthFlowPoints, ..} ) <$> f capitalizationScaEthFlowPoints
  {-# INLINE capitalizationScaEthFlowPointsL #-}
  
  -- | 'capitalizationAttName' Lens
  capitalizationAttNameL :: Lens_' Capitalization (Maybe Text)
  capitalizationAttNameL f Capitalization{..} = (\capitalizationAttName -> Capitalization { capitalizationAttName, ..} ) <$> f capitalizationAttName
  {-# INLINE capitalizationAttNameL #-}
  
  
  
  -- * Cat
  
  -- | 'catClassName' Lens
  catClassNameL :: Lens_' Cat (Text)
  catClassNameL f Cat{..} = (\catClassName -> Cat { catClassName, ..} ) <$> f catClassName
  {-# INLINE catClassNameL #-}
  
  -- | 'catColor' Lens
  catColorL :: Lens_' Cat (Maybe Text)
  catColorL f Cat{..} = (\catColor -> Cat { catColor, ..} ) <$> f catColor
  {-# INLINE catColorL #-}
  
  -- | 'catDeclawed' Lens
  catDeclawedL :: Lens_' Cat (Maybe Bool)
  catDeclawedL f Cat{..} = (\catDeclawed -> Cat { catDeclawed, ..} ) <$> f catDeclawed
  {-# INLINE catDeclawedL #-}
  
  
  
  -- * Category
  
  -- | 'categoryId' Lens
  categoryIdL :: Lens_' Category (Maybe Integer)
  categoryIdL f Category{..} = (\categoryId -> Category { categoryId, ..} ) <$> f categoryId
  {-# INLINE categoryIdL #-}
  
  -- | 'categoryName' Lens
  categoryNameL :: Lens_' Category (Text)
  categoryNameL f Category{..} = (\categoryName -> Category { categoryName, ..} ) <$> f categoryName
  {-# INLINE categoryNameL #-}
  
  
  
  -- * ClassModel
  
  -- | 'classModelClass' Lens
  classModelClassL :: Lens_' ClassModel (Maybe Text)
  classModelClassL f ClassModel{..} = (\classModelClass -> ClassModel { classModelClass, ..} ) <$> f classModelClass
  {-# INLINE classModelClassL #-}
  
  
  
  -- * Client
  
  -- | 'clientClient' Lens
  clientClientL :: Lens_' Client (Maybe Text)
  clientClientL f Client{..} = (\clientClient -> Client { clientClient, ..} ) <$> f clientClient
  {-# INLINE clientClientL #-}
  
  
  
  -- * Dog
  
  -- | 'dogClassName' Lens
  dogClassNameL :: Lens_' Dog (Text)
  dogClassNameL f Dog{..} = (\dogClassName -> Dog { dogClassName, ..} ) <$> f dogClassName
  {-# INLINE dogClassNameL #-}
  
  -- | 'dogColor' Lens
  dogColorL :: Lens_' Dog (Maybe Text)
  dogColorL f Dog{..} = (\dogColor -> Dog { dogColor, ..} ) <$> f dogColor
  {-# INLINE dogColorL #-}
  
  -- | 'dogBreed' Lens
  dogBreedL :: Lens_' Dog (Maybe Text)
  dogBreedL f Dog{..} = (\dogBreed -> Dog { dogBreed, ..} ) <$> f dogBreed
  {-# INLINE dogBreedL #-}
  
  
  
  -- * EnumArrays
  
  -- | 'enumArraysJustSymbol' Lens
  enumArraysJustSymbolL :: Lens_' EnumArrays (Maybe E'JustSymbol)
  enumArraysJustSymbolL f EnumArrays{..} = (\enumArraysJustSymbol -> EnumArrays { enumArraysJustSymbol, ..} ) <$> f enumArraysJustSymbol
  {-# INLINE enumArraysJustSymbolL #-}
  
  -- | 'enumArraysArrayEnum' Lens
  enumArraysArrayEnumL :: Lens_' EnumArrays (Maybe [E'ArrayEnum])
  enumArraysArrayEnumL f EnumArrays{..} = (\enumArraysArrayEnum -> EnumArrays { enumArraysArrayEnum, ..} ) <$> f enumArraysArrayEnum
  {-# INLINE enumArraysArrayEnumL #-}
  
  
  
  -- * EnumClass
  
  
  
  -- * EnumTest
  
  -- | 'enumTestEnumString' Lens
  enumTestEnumStringL :: Lens_' EnumTest (Maybe E'EnumString)
  enumTestEnumStringL f EnumTest{..} = (\enumTestEnumString -> EnumTest { enumTestEnumString, ..} ) <$> f enumTestEnumString
  {-# INLINE enumTestEnumStringL #-}
  
  -- | 'enumTestEnumStringRequired' Lens
  enumTestEnumStringRequiredL :: Lens_' EnumTest (E'EnumString)
  enumTestEnumStringRequiredL f EnumTest{..} = (\enumTestEnumStringRequired -> EnumTest { enumTestEnumStringRequired, ..} ) <$> f enumTestEnumStringRequired
  {-# INLINE enumTestEnumStringRequiredL #-}
  
  -- | 'enumTestEnumInteger' Lens
  enumTestEnumIntegerL :: Lens_' EnumTest (Maybe E'EnumInteger)
  enumTestEnumIntegerL f EnumTest{..} = (\enumTestEnumInteger -> EnumTest { enumTestEnumInteger, ..} ) <$> f enumTestEnumInteger
  {-# INLINE enumTestEnumIntegerL #-}
  
  -- | 'enumTestEnumNumber' Lens
  enumTestEnumNumberL :: Lens_' EnumTest (Maybe E'EnumNumber)
  enumTestEnumNumberL f EnumTest{..} = (\enumTestEnumNumber -> EnumTest { enumTestEnumNumber, ..} ) <$> f enumTestEnumNumber
  {-# INLINE enumTestEnumNumberL #-}
  
  -- | 'enumTestOuterEnum' Lens
  enumTestOuterEnumL :: Lens_' EnumTest (Maybe OuterEnum)
  enumTestOuterEnumL f EnumTest{..} = (\enumTestOuterEnum -> EnumTest { enumTestOuterEnum, ..} ) <$> f enumTestOuterEnum
  {-# INLINE enumTestOuterEnumL #-}
  
  
  
  -- * File
  
  -- | 'fileSourceUri' Lens
  fileSourceUriL :: Lens_' File (Maybe Text)
  fileSourceUriL f File{..} = (\fileSourceUri -> File { fileSourceUri, ..} ) <$> f fileSourceUri
  {-# INLINE fileSourceUriL #-}
  
  
  
  -- * FileSchemaTestClass
  
  -- | 'fileSchemaTestClassFile' Lens
  fileSchemaTestClassFileL :: Lens_' FileSchemaTestClass (Maybe File)
  fileSchemaTestClassFileL f FileSchemaTestClass{..} = (\fileSchemaTestClassFile -> FileSchemaTestClass { fileSchemaTestClassFile, ..} ) <$> f fileSchemaTestClassFile
  {-# INLINE fileSchemaTestClassFileL #-}
  
  -- | 'fileSchemaTestClassFiles' Lens
  fileSchemaTestClassFilesL :: Lens_' FileSchemaTestClass (Maybe [File])
  fileSchemaTestClassFilesL f FileSchemaTestClass{..} = (\fileSchemaTestClassFiles -> FileSchemaTestClass { fileSchemaTestClassFiles, ..} ) <$> f fileSchemaTestClassFiles
  {-# INLINE fileSchemaTestClassFilesL #-}
  
  
  
  -- * FormatTest
  
  -- | 'formatTestInteger' Lens
  formatTestIntegerL :: Lens_' FormatTest (Maybe Int)
  formatTestIntegerL f FormatTest{..} = (\formatTestInteger -> FormatTest { formatTestInteger, ..} ) <$> f formatTestInteger
  {-# INLINE formatTestIntegerL #-}
  
  -- | 'formatTestInt32' Lens
  formatTestInt32L :: Lens_' FormatTest (Maybe Int)
  formatTestInt32L f FormatTest{..} = (\formatTestInt32 -> FormatTest { formatTestInt32, ..} ) <$> f formatTestInt32
  {-# INLINE formatTestInt32L #-}
  
  -- | 'formatTestInt64' Lens
  formatTestInt64L :: Lens_' FormatTest (Maybe Integer)
  formatTestInt64L f FormatTest{..} = (\formatTestInt64 -> FormatTest { formatTestInt64, ..} ) <$> f formatTestInt64
  {-# INLINE formatTestInt64L #-}
  
  -- | 'formatTestNumber' Lens
  formatTestNumberL :: Lens_' FormatTest (Double)
  formatTestNumberL f FormatTest{..} = (\formatTestNumber -> FormatTest { formatTestNumber, ..} ) <$> f formatTestNumber
  {-# INLINE formatTestNumberL #-}
  
  -- | 'formatTestFloat' Lens
  formatTestFloatL :: Lens_' FormatTest (Maybe Float)
  formatTestFloatL f FormatTest{..} = (\formatTestFloat -> FormatTest { formatTestFloat, ..} ) <$> f formatTestFloat
  {-# INLINE formatTestFloatL #-}
  
  -- | 'formatTestDouble' Lens
  formatTestDoubleL :: Lens_' FormatTest (Maybe Double)
  formatTestDoubleL f FormatTest{..} = (\formatTestDouble -> FormatTest { formatTestDouble, ..} ) <$> f formatTestDouble
  {-# INLINE formatTestDoubleL #-}
  
  -- | 'formatTestString' Lens
  formatTestStringL :: Lens_' FormatTest (Maybe Text)
  formatTestStringL f FormatTest{..} = (\formatTestString -> FormatTest { formatTestString, ..} ) <$> f formatTestString
  {-# INLINE formatTestStringL #-}
  
  -- | 'formatTestByte' Lens
  formatTestByteL :: Lens_' FormatTest (ByteArray)
  formatTestByteL f FormatTest{..} = (\formatTestByte -> FormatTest { formatTestByte, ..} ) <$> f formatTestByte
  {-# INLINE formatTestByteL #-}
  
  -- | 'formatTestBinary' Lens
  formatTestBinaryL :: Lens_' FormatTest (Maybe FilePath)
  formatTestBinaryL f FormatTest{..} = (\formatTestBinary -> FormatTest { formatTestBinary, ..} ) <$> f formatTestBinary
  {-# INLINE formatTestBinaryL #-}
  
  -- | 'formatTestDate' Lens
  formatTestDateL :: Lens_' FormatTest (Date)
  formatTestDateL f FormatTest{..} = (\formatTestDate -> FormatTest { formatTestDate, ..} ) <$> f formatTestDate
  {-# INLINE formatTestDateL #-}
  
  -- | 'formatTestDateTime' Lens
  formatTestDateTimeL :: Lens_' FormatTest (Maybe DateTime)
  formatTestDateTimeL f FormatTest{..} = (\formatTestDateTime -> FormatTest { formatTestDateTime, ..} ) <$> f formatTestDateTime
  {-# INLINE formatTestDateTimeL #-}
  
  -- | 'formatTestUuid' Lens
  formatTestUuidL :: Lens_' FormatTest (Maybe Text)
  formatTestUuidL f FormatTest{..} = (\formatTestUuid -> FormatTest { formatTestUuid, ..} ) <$> f formatTestUuid
  {-# INLINE formatTestUuidL #-}
  
  -- | 'formatTestPassword' Lens
  formatTestPasswordL :: Lens_' FormatTest (Text)
  formatTestPasswordL f FormatTest{..} = (\formatTestPassword -> FormatTest { formatTestPassword, ..} ) <$> f formatTestPassword
  {-# INLINE formatTestPasswordL #-}
  
  -- | 'formatTestBigDecimal' Lens
  formatTestBigDecimalL :: Lens_' FormatTest (Maybe Double)
  formatTestBigDecimalL f FormatTest{..} = (\formatTestBigDecimal -> FormatTest { formatTestBigDecimal, ..} ) <$> f formatTestBigDecimal
  {-# INLINE formatTestBigDecimalL #-}
  
  
  
  -- * HasOnlyReadOnly
  
  -- | 'hasOnlyReadOnlyBar' Lens
  hasOnlyReadOnlyBarL :: Lens_' HasOnlyReadOnly (Maybe Text)
  hasOnlyReadOnlyBarL f HasOnlyReadOnly{..} = (\hasOnlyReadOnlyBar -> HasOnlyReadOnly { hasOnlyReadOnlyBar, ..} ) <$> f hasOnlyReadOnlyBar
  {-# INLINE hasOnlyReadOnlyBarL #-}
  
  -- | 'hasOnlyReadOnlyFoo' Lens
  hasOnlyReadOnlyFooL :: Lens_' HasOnlyReadOnly (Maybe Text)
  hasOnlyReadOnlyFooL f HasOnlyReadOnly{..} = (\hasOnlyReadOnlyFoo -> HasOnlyReadOnly { hasOnlyReadOnlyFoo, ..} ) <$> f hasOnlyReadOnlyFoo
  {-# INLINE hasOnlyReadOnlyFooL #-}
  
  
  
  -- * MapTest
  
  -- | 'mapTestMapMapOfString' Lens
  mapTestMapMapOfStringL :: Lens_' MapTest (Maybe (Map.Map String (Map.Map String Text)))
  mapTestMapMapOfStringL f MapTest{..} = (\mapTestMapMapOfString -> MapTest { mapTestMapMapOfString, ..} ) <$> f mapTestMapMapOfString
  {-# INLINE mapTestMapMapOfStringL #-}
  
  -- | 'mapTestMapOfEnumString' Lens
  mapTestMapOfEnumStringL :: Lens_' MapTest (Maybe (Map.Map String E'Inner))
  mapTestMapOfEnumStringL f MapTest{..} = (\mapTestMapOfEnumString -> MapTest { mapTestMapOfEnumString, ..} ) <$> f mapTestMapOfEnumString
  {-# INLINE mapTestMapOfEnumStringL #-}
  
  -- | 'mapTestDirectMap' Lens
  mapTestDirectMapL :: Lens_' MapTest (Maybe (Map.Map String Bool))
  mapTestDirectMapL f MapTest{..} = (\mapTestDirectMap -> MapTest { mapTestDirectMap, ..} ) <$> f mapTestDirectMap
  {-# INLINE mapTestDirectMapL #-}
  
  -- | 'mapTestIndirectMap' Lens
  mapTestIndirectMapL :: Lens_' MapTest (Maybe (Map.Map String Bool))
  mapTestIndirectMapL f MapTest{..} = (\mapTestIndirectMap -> MapTest { mapTestIndirectMap, ..} ) <$> f mapTestIndirectMap
  {-# INLINE mapTestIndirectMapL #-}
  
  
  
  -- * MixedPropertiesAndAdditionalPropertiesClass
  
  -- | 'mixedPropertiesAndAdditionalPropertiesClassUuid' Lens
  mixedPropertiesAndAdditionalPropertiesClassUuidL :: Lens_' MixedPropertiesAndAdditionalPropertiesClass (Maybe Text)
  mixedPropertiesAndAdditionalPropertiesClassUuidL f MixedPropertiesAndAdditionalPropertiesClass{..} = (\mixedPropertiesAndAdditionalPropertiesClassUuid -> MixedPropertiesAndAdditionalPropertiesClass { mixedPropertiesAndAdditionalPropertiesClassUuid, ..} ) <$> f mixedPropertiesAndAdditionalPropertiesClassUuid
  {-# INLINE mixedPropertiesAndAdditionalPropertiesClassUuidL #-}
  
  -- | 'mixedPropertiesAndAdditionalPropertiesClassDateTime' Lens
  mixedPropertiesAndAdditionalPropertiesClassDateTimeL :: Lens_' MixedPropertiesAndAdditionalPropertiesClass (Maybe DateTime)
  mixedPropertiesAndAdditionalPropertiesClassDateTimeL f MixedPropertiesAndAdditionalPropertiesClass{..} = (\mixedPropertiesAndAdditionalPropertiesClassDateTime -> MixedPropertiesAndAdditionalPropertiesClass { mixedPropertiesAndAdditionalPropertiesClassDateTime, ..} ) <$> f mixedPropertiesAndAdditionalPropertiesClassDateTime
  {-# INLINE mixedPropertiesAndAdditionalPropertiesClassDateTimeL #-}
  
  -- | 'mixedPropertiesAndAdditionalPropertiesClassMap' Lens
  mixedPropertiesAndAdditionalPropertiesClassMapL :: Lens_' MixedPropertiesAndAdditionalPropertiesClass (Maybe (Map.Map String Animal))
  mixedPropertiesAndAdditionalPropertiesClassMapL f MixedPropertiesAndAdditionalPropertiesClass{..} = (\mixedPropertiesAndAdditionalPropertiesClassMap -> MixedPropertiesAndAdditionalPropertiesClass { mixedPropertiesAndAdditionalPropertiesClassMap, ..} ) <$> f mixedPropertiesAndAdditionalPropertiesClassMap
  {-# INLINE mixedPropertiesAndAdditionalPropertiesClassMapL #-}
  
  
  
  -- * Model200Response
  
  -- | 'model200ResponseName' Lens
  model200ResponseNameL :: Lens_' Model200Response (Maybe Int)
  model200ResponseNameL f Model200Response{..} = (\model200ResponseName -> Model200Response { model200ResponseName, ..} ) <$> f model200ResponseName
  {-# INLINE model200ResponseNameL #-}
  
  -- | 'model200ResponseClass' Lens
  model200ResponseClassL :: Lens_' Model200Response (Maybe Text)
  model200ResponseClassL f Model200Response{..} = (\model200ResponseClass -> Model200Response { model200ResponseClass, ..} ) <$> f model200ResponseClass
  {-# INLINE model200ResponseClassL #-}
  
  
  
  -- * ModelList
  
  -- | 'modelList123list' Lens
  modelList123listL :: Lens_' ModelList (Maybe Text)
  modelList123listL f ModelList{..} = (\modelList123list -> ModelList { modelList123list, ..} ) <$> f modelList123list
  {-# INLINE modelList123listL #-}
  
  
  
  -- * ModelReturn
  
  -- | 'modelReturnReturn' Lens
  modelReturnReturnL :: Lens_' ModelReturn (Maybe Int)
  modelReturnReturnL f ModelReturn{..} = (\modelReturnReturn -> ModelReturn { modelReturnReturn, ..} ) <$> f modelReturnReturn
  {-# INLINE modelReturnReturnL #-}
  
  
  
  -- * Name
  
  -- | 'nameName' Lens
  nameNameL :: Lens_' Name (Int)
  nameNameL f Name{..} = (\nameName -> Name { nameName, ..} ) <$> f nameName
  {-# INLINE nameNameL #-}
  
  -- | 'nameSnakeCase' Lens
  nameSnakeCaseL :: Lens_' Name (Maybe Int)
  nameSnakeCaseL f Name{..} = (\nameSnakeCase -> Name { nameSnakeCase, ..} ) <$> f nameSnakeCase
  {-# INLINE nameSnakeCaseL #-}
  
  -- | 'nameProperty' Lens
  namePropertyL :: Lens_' Name (Maybe Text)
  namePropertyL f Name{..} = (\nameProperty -> Name { nameProperty, ..} ) <$> f nameProperty
  {-# INLINE namePropertyL #-}
  
  -- | 'name123number' Lens
  name123numberL :: Lens_' Name (Maybe Int)
  name123numberL f Name{..} = (\name123number -> Name { name123number, ..} ) <$> f name123number
  {-# INLINE name123numberL #-}
  
  
  
  -- * NumberOnly
  
  -- | 'numberOnlyJustNumber' Lens
  numberOnlyJustNumberL :: Lens_' NumberOnly (Maybe Double)
  numberOnlyJustNumberL f NumberOnly{..} = (\numberOnlyJustNumber -> NumberOnly { numberOnlyJustNumber, ..} ) <$> f numberOnlyJustNumber
  {-# INLINE numberOnlyJustNumberL #-}
  
  
  
  -- * Order
  
  -- | 'orderId' Lens
  orderIdL :: Lens_' Order (Maybe Integer)
  orderIdL f Order{..} = (\orderId -> Order { orderId, ..} ) <$> f orderId
  {-# INLINE orderIdL #-}
  
  -- | 'orderPetId' Lens
  orderPetIdL :: Lens_' Order (Maybe Integer)
  orderPetIdL f Order{..} = (\orderPetId -> Order { orderPetId, ..} ) <$> f orderPetId
  {-# INLINE orderPetIdL #-}
  
  -- | 'orderQuantity' Lens
  orderQuantityL :: Lens_' Order (Maybe Int)
  orderQuantityL f Order{..} = (\orderQuantity -> Order { orderQuantity, ..} ) <$> f orderQuantity
  {-# INLINE orderQuantityL #-}
  
  -- | 'orderShipDate' Lens
  orderShipDateL :: Lens_' Order (Maybe DateTime)
  orderShipDateL f Order{..} = (\orderShipDate -> Order { orderShipDate, ..} ) <$> f orderShipDate
  {-# INLINE orderShipDateL #-}
  
  -- | 'orderStatus' Lens
  orderStatusL :: Lens_' Order (Maybe E'Status)
  orderStatusL f Order{..} = (\orderStatus -> Order { orderStatus, ..} ) <$> f orderStatus
  {-# INLINE orderStatusL #-}
  
  -- | 'orderComplete' Lens
  orderCompleteL :: Lens_' Order (Maybe Bool)
  orderCompleteL f Order{..} = (\orderComplete -> Order { orderComplete, ..} ) <$> f orderComplete
  {-# INLINE orderCompleteL #-}
  
  
  
  -- * OuterComposite
  
  -- | 'outerCompositeMyNumber' Lens
  outerCompositeMyNumberL :: Lens_' OuterComposite (Maybe Double)
  outerCompositeMyNumberL f OuterComposite{..} = (\outerCompositeMyNumber -> OuterComposite { outerCompositeMyNumber, ..} ) <$> f outerCompositeMyNumber
  {-# INLINE outerCompositeMyNumberL #-}
  
  -- | 'outerCompositeMyString' Lens
  outerCompositeMyStringL :: Lens_' OuterComposite (Maybe Text)
  outerCompositeMyStringL f OuterComposite{..} = (\outerCompositeMyString -> OuterComposite { outerCompositeMyString, ..} ) <$> f outerCompositeMyString
  {-# INLINE outerCompositeMyStringL #-}
  
  -- | 'outerCompositeMyBoolean' Lens
  outerCompositeMyBooleanL :: Lens_' OuterComposite (Maybe Bool)
  outerCompositeMyBooleanL f OuterComposite{..} = (\outerCompositeMyBoolean -> OuterComposite { outerCompositeMyBoolean, ..} ) <$> f outerCompositeMyBoolean
  {-# INLINE outerCompositeMyBooleanL #-}
  
  
  
  -- * OuterEnum
  
  
  
  -- * Pet
  
  -- | 'petId' Lens
  petIdL :: Lens_' Pet (Maybe Integer)
  petIdL f Pet{..} = (\petId -> Pet { petId, ..} ) <$> f petId
  {-# INLINE petIdL #-}
  
  -- | 'petCategory' Lens
  petCategoryL :: Lens_' Pet (Maybe Category)
  petCategoryL f Pet{..} = (\petCategory -> Pet { petCategory, ..} ) <$> f petCategory
  {-# INLINE petCategoryL #-}
  
  -- | 'petName' Lens
  petNameL :: Lens_' Pet (Text)
  petNameL f Pet{..} = (\petName -> Pet { petName, ..} ) <$> f petName
  {-# INLINE petNameL #-}
  
  -- | 'petPhotoUrls' Lens
  petPhotoUrlsL :: Lens_' Pet ([Text])
  petPhotoUrlsL f Pet{..} = (\petPhotoUrls -> Pet { petPhotoUrls, ..} ) <$> f petPhotoUrls
  {-# INLINE petPhotoUrlsL #-}
  
  -- | 'petTags' Lens
  petTagsL :: Lens_' Pet (Maybe [Tag])
  petTagsL f Pet{..} = (\petTags -> Pet { petTags, ..} ) <$> f petTags
  {-# INLINE petTagsL #-}
  
  -- | 'petStatus' Lens
  petStatusL :: Lens_' Pet (Maybe E'Status2)
  petStatusL f Pet{..} = (\petStatus -> Pet { petStatus, ..} ) <$> f petStatus
  {-# INLINE petStatusL #-}
  
  
  
  -- * PetFilter
  
  -- | 'petFilterTags' Lens
  petFilterTagsL :: Lens_' PetFilter (Maybe [Text])
  petFilterTagsL f PetFilter{..} = (\petFilterTags -> PetFilter { petFilterTags, ..} ) <$> f petFilterTags
  {-# INLINE petFilterTagsL #-}
  
  -- | 'petFilterStatus' Lens
  petFilterStatusL :: Lens_' PetFilter (Maybe [Text])
  petFilterStatusL f PetFilter{..} = (\petFilterStatus -> PetFilter { petFilterStatus, ..} ) <$> f petFilterStatus
  {-# INLINE petFilterStatusL #-}
  
  
  
  -- * PetOrder
  
  -- | 'petOrderName' Lens
  petOrderNameL :: Lens_' PetOrder (Maybe E'Name)
  petOrderNameL f PetOrder{..} = (\petOrderName -> PetOrder { petOrderName, ..} ) <$> f petOrderName
  {-# INLINE petOrderNameL #-}
  
  
  
  -- * ReadOnlyFirst
  
  -- | 'readOnlyFirstBar' Lens
  readOnlyFirstBarL :: Lens_' ReadOnlyFirst (Maybe Text)
  readOnlyFirstBarL f ReadOnlyFirst{..} = (\readOnlyFirstBar -> ReadOnlyFirst { readOnlyFirstBar, ..} ) <$> f readOnlyFirstBar
  {-# INLINE readOnlyFirstBarL #-}
  
  -- | 'readOnlyFirstBaz' Lens
  readOnlyFirstBazL :: Lens_' ReadOnlyFirst (Maybe Text)
  readOnlyFirstBazL f ReadOnlyFirst{..} = (\readOnlyFirstBaz -> ReadOnlyFirst { readOnlyFirstBaz, ..} ) <$> f readOnlyFirstBaz
  {-# INLINE readOnlyFirstBazL #-}
  
  
  
  -- * Tag
  
  -- | 'tagId' Lens
  tagIdL :: Lens_' Tag (Maybe Integer)
  tagIdL f Tag{..} = (\tagId -> Tag { tagId, ..} ) <$> f tagId
  {-# INLINE tagIdL #-}
  
  -- | 'tagName' Lens
  tagNameL :: Lens_' Tag (Maybe Text)
  tagNameL f Tag{..} = (\tagName -> Tag { tagName, ..} ) <$> f tagName
  {-# INLINE tagNameL #-}
  
  
  
  -- * TypeHolderDefault
  
  -- | 'typeHolderDefaultStringItem' Lens
  typeHolderDefaultStringItemL :: Lens_' TypeHolderDefault (Text)
  typeHolderDefaultStringItemL f TypeHolderDefault{..} = (\typeHolderDefaultStringItem -> TypeHolderDefault { typeHolderDefaultStringItem, ..} ) <$> f typeHolderDefaultStringItem
  {-# INLINE typeHolderDefaultStringItemL #-}
  
  -- | 'typeHolderDefaultNumberItem' Lens
  typeHolderDefaultNumberItemL :: Lens_' TypeHolderDefault (Double)
  typeHolderDefaultNumberItemL f TypeHolderDefault{..} = (\typeHolderDefaultNumberItem -> TypeHolderDefault { typeHolderDefaultNumberItem, ..} ) <$> f typeHolderDefaultNumberItem
  {-# INLINE typeHolderDefaultNumberItemL #-}
  
  -- | 'typeHolderDefaultIntegerItem' Lens
  typeHolderDefaultIntegerItemL :: Lens_' TypeHolderDefault (Int)
  typeHolderDefaultIntegerItemL f TypeHolderDefault{..} = (\typeHolderDefaultIntegerItem -> TypeHolderDefault { typeHolderDefaultIntegerItem, ..} ) <$> f typeHolderDefaultIntegerItem
  {-# INLINE typeHolderDefaultIntegerItemL #-}
  
  -- | 'typeHolderDefaultBoolItem' Lens
  typeHolderDefaultBoolItemL :: Lens_' TypeHolderDefault (Bool)
  typeHolderDefaultBoolItemL f TypeHolderDefault{..} = (\typeHolderDefaultBoolItem -> TypeHolderDefault { typeHolderDefaultBoolItem, ..} ) <$> f typeHolderDefaultBoolItem
  {-# INLINE typeHolderDefaultBoolItemL #-}
  
  -- | 'typeHolderDefaultArrayItem' Lens
  typeHolderDefaultArrayItemL :: Lens_' TypeHolderDefault ([Int])
  typeHolderDefaultArrayItemL f TypeHolderDefault{..} = (\typeHolderDefaultArrayItem -> TypeHolderDefault { typeHolderDefaultArrayItem, ..} ) <$> f typeHolderDefaultArrayItem
  {-# INLINE typeHolderDefaultArrayItemL #-}
  
  
  
  -- * TypeHolderExample
  
  -- | 'typeHolderExampleStringItem' Lens
  typeHolderExampleStringItemL :: Lens_' TypeHolderExample (Text)
  typeHolderExampleStringItemL f TypeHolderExample{..} = (\typeHolderExampleStringItem -> TypeHolderExample { typeHolderExampleStringItem, ..} ) <$> f typeHolderExampleStringItem
  {-# INLINE typeHolderExampleStringItemL #-}
  
  -- | 'typeHolderExampleNumberItem' Lens
  typeHolderExampleNumberItemL :: Lens_' TypeHolderExample (Double)
  typeHolderExampleNumberItemL f TypeHolderExample{..} = (\typeHolderExampleNumberItem -> TypeHolderExample { typeHolderExampleNumberItem, ..} ) <$> f typeHolderExampleNumberItem
  {-# INLINE typeHolderExampleNumberItemL #-}
  
  -- | 'typeHolderExampleFloatItem' Lens
  typeHolderExampleFloatItemL :: Lens_' TypeHolderExample (Float)
  typeHolderExampleFloatItemL f TypeHolderExample{..} = (\typeHolderExampleFloatItem -> TypeHolderExample { typeHolderExampleFloatItem, ..} ) <$> f typeHolderExampleFloatItem
  {-# INLINE typeHolderExampleFloatItemL #-}
  
  -- | 'typeHolderExampleIntegerItem' Lens
  typeHolderExampleIntegerItemL :: Lens_' TypeHolderExample (Int)
  typeHolderExampleIntegerItemL f TypeHolderExample{..} = (\typeHolderExampleIntegerItem -> TypeHolderExample { typeHolderExampleIntegerItem, ..} ) <$> f typeHolderExampleIntegerItem
  {-# INLINE typeHolderExampleIntegerItemL #-}
  
  -- | 'typeHolderExampleBoolItem' Lens
  typeHolderExampleBoolItemL :: Lens_' TypeHolderExample (Bool)
  typeHolderExampleBoolItemL f TypeHolderExample{..} = (\typeHolderExampleBoolItem -> TypeHolderExample { typeHolderExampleBoolItem, ..} ) <$> f typeHolderExampleBoolItem
  {-# INLINE typeHolderExampleBoolItemL #-}
  
  -- | 'typeHolderExampleArrayItem' Lens
  typeHolderExampleArrayItemL :: Lens_' TypeHolderExample ([Int])
  typeHolderExampleArrayItemL f TypeHolderExample{..} = (\typeHolderExampleArrayItem -> TypeHolderExample { typeHolderExampleArrayItem, ..} ) <$> f typeHolderExampleArrayItem
  {-# INLINE typeHolderExampleArrayItemL #-}
  
  
  
  -- * User
  
  -- | 'userId' Lens
  userIdL :: Lens_' User (Maybe Integer)
  userIdL f User{..} = (\userId -> User { userId, ..} ) <$> f userId
  {-# INLINE userIdL #-}
  
  -- | 'userUsername' Lens
  userUsernameL :: Lens_' User (Maybe Text)
  userUsernameL f User{..} = (\userUsername -> User { userUsername, ..} ) <$> f userUsername
  {-# INLINE userUsernameL #-}
  
  -- | 'userFirstName' Lens
  userFirstNameL :: Lens_' User (Maybe Text)
  userFirstNameL f User{..} = (\userFirstName -> User { userFirstName, ..} ) <$> f userFirstName
  {-# INLINE userFirstNameL #-}
  
  -- | 'userLastName' Lens
  userLastNameL :: Lens_' User (Maybe Text)
  userLastNameL f User{..} = (\userLastName -> User { userLastName, ..} ) <$> f userLastName
  {-# INLINE userLastNameL #-}
  
  -- | 'userEmail' Lens
  userEmailL :: Lens_' User (Maybe Text)
  userEmailL f User{..} = (\userEmail -> User { userEmail, ..} ) <$> f userEmail
  {-# INLINE userEmailL #-}
  
  -- | 'userPassword' Lens
  userPasswordL :: Lens_' User (Maybe Text)
  userPasswordL f User{..} = (\userPassword -> User { userPassword, ..} ) <$> f userPassword
  {-# INLINE userPasswordL #-}
  
  -- | 'userPhone' Lens
  userPhoneL :: Lens_' User (Maybe Text)
  userPhoneL f User{..} = (\userPhone -> User { userPhone, ..} ) <$> f userPhone
  {-# INLINE userPhoneL #-}
  
  -- | 'userUserStatus' Lens
  userUserStatusL :: Lens_' User (Maybe Int)
  userUserStatusL f User{..} = (\userUserStatus -> User { userUserStatus, ..} ) <$> f userUserStatus
  {-# INLINE userUserStatusL #-}
  
  
  
  -- * XmlItem
  
  -- | 'xmlItemAttributeString' Lens
  xmlItemAttributeStringL :: Lens_' XmlItem (Maybe Text)
  xmlItemAttributeStringL f XmlItem{..} = (\xmlItemAttributeString -> XmlItem { xmlItemAttributeString, ..} ) <$> f xmlItemAttributeString
  {-# INLINE xmlItemAttributeStringL #-}
  
  -- | 'xmlItemAttributeNumber' Lens
  xmlItemAttributeNumberL :: Lens_' XmlItem (Maybe Double)
  xmlItemAttributeNumberL f XmlItem{..} = (\xmlItemAttributeNumber -> XmlItem { xmlItemAttributeNumber, ..} ) <$> f xmlItemAttributeNumber
  {-# INLINE xmlItemAttributeNumberL #-}
  
  -- | 'xmlItemAttributeInteger' Lens
  xmlItemAttributeIntegerL :: Lens_' XmlItem (Maybe Int)
  xmlItemAttributeIntegerL f XmlItem{..} = (\xmlItemAttributeInteger -> XmlItem { xmlItemAttributeInteger, ..} ) <$> f xmlItemAttributeInteger
  {-# INLINE xmlItemAttributeIntegerL #-}
  
  -- | 'xmlItemAttributeBoolean' Lens
  xmlItemAttributeBooleanL :: Lens_' XmlItem (Maybe Bool)
  xmlItemAttributeBooleanL f XmlItem{..} = (\xmlItemAttributeBoolean -> XmlItem { xmlItemAttributeBoolean, ..} ) <$> f xmlItemAttributeBoolean
  {-# INLINE xmlItemAttributeBooleanL #-}
  
  -- | 'xmlItemWrappedArray' Lens
  xmlItemWrappedArrayL :: Lens_' XmlItem (Maybe [Int])
  xmlItemWrappedArrayL f XmlItem{..} = (\xmlItemWrappedArray -> XmlItem { xmlItemWrappedArray, ..} ) <$> f xmlItemWrappedArray
  {-# INLINE xmlItemWrappedArrayL #-}
  
  -- | 'xmlItemNameString' Lens
  xmlItemNameStringL :: Lens_' XmlItem (Maybe Text)
  xmlItemNameStringL f XmlItem{..} = (\xmlItemNameString -> XmlItem { xmlItemNameString, ..} ) <$> f xmlItemNameString
  {-# INLINE xmlItemNameStringL #-}
  
  -- | 'xmlItemNameNumber' Lens
  xmlItemNameNumberL :: Lens_' XmlItem (Maybe Double)
  xmlItemNameNumberL f XmlItem{..} = (\xmlItemNameNumber -> XmlItem { xmlItemNameNumber, ..} ) <$> f xmlItemNameNumber
  {-# INLINE xmlItemNameNumberL #-}
  
  -- | 'xmlItemNameInteger' Lens
  xmlItemNameIntegerL :: Lens_' XmlItem (Maybe Int)
  xmlItemNameIntegerL f XmlItem{..} = (\xmlItemNameInteger -> XmlItem { xmlItemNameInteger, ..} ) <$> f xmlItemNameInteger
  {-# INLINE xmlItemNameIntegerL #-}
  
  -- | 'xmlItemNameBoolean' Lens
  xmlItemNameBooleanL :: Lens_' XmlItem (Maybe Bool)
  xmlItemNameBooleanL f XmlItem{..} = (\xmlItemNameBoolean -> XmlItem { xmlItemNameBoolean, ..} ) <$> f xmlItemNameBoolean
  {-# INLINE xmlItemNameBooleanL #-}
  
  -- | 'xmlItemNameArray' Lens
  xmlItemNameArrayL :: Lens_' XmlItem (Maybe [Int])
  xmlItemNameArrayL f XmlItem{..} = (\xmlItemNameArray -> XmlItem { xmlItemNameArray, ..} ) <$> f xmlItemNameArray
  {-# INLINE xmlItemNameArrayL #-}
  
  -- | 'xmlItemNameWrappedArray' Lens
  xmlItemNameWrappedArrayL :: Lens_' XmlItem (Maybe [Int])
  xmlItemNameWrappedArrayL f XmlItem{..} = (\xmlItemNameWrappedArray -> XmlItem { xmlItemNameWrappedArray, ..} ) <$> f xmlItemNameWrappedArray
  {-# INLINE xmlItemNameWrappedArrayL #-}
  
  -- | 'xmlItemPrefixString' Lens
  xmlItemPrefixStringL :: Lens_' XmlItem (Maybe Text)
  xmlItemPrefixStringL f XmlItem{..} = (\xmlItemPrefixString -> XmlItem { xmlItemPrefixString, ..} ) <$> f xmlItemPrefixString
  {-# INLINE xmlItemPrefixStringL #-}
  
  -- | 'xmlItemPrefixNumber' Lens
  xmlItemPrefixNumberL :: Lens_' XmlItem (Maybe Double)
  xmlItemPrefixNumberL f XmlItem{..} = (\xmlItemPrefixNumber -> XmlItem { xmlItemPrefixNumber, ..} ) <$> f xmlItemPrefixNumber
  {-# INLINE xmlItemPrefixNumberL #-}
  
  -- | 'xmlItemPrefixInteger' Lens
  xmlItemPrefixIntegerL :: Lens_' XmlItem (Maybe Int)
  xmlItemPrefixIntegerL f XmlItem{..} = (\xmlItemPrefixInteger -> XmlItem { xmlItemPrefixInteger, ..} ) <$> f xmlItemPrefixInteger
  {-# INLINE xmlItemPrefixIntegerL #-}
  
  -- | 'xmlItemPrefixBoolean' Lens
  xmlItemPrefixBooleanL :: Lens_' XmlItem (Maybe Bool)
  xmlItemPrefixBooleanL f XmlItem{..} = (\xmlItemPrefixBoolean -> XmlItem { xmlItemPrefixBoolean, ..} ) <$> f xmlItemPrefixBoolean
  {-# INLINE xmlItemPrefixBooleanL #-}
  
  -- | 'xmlItemPrefixArray' Lens
  xmlItemPrefixArrayL :: Lens_' XmlItem (Maybe [Int])
  xmlItemPrefixArrayL f XmlItem{..} = (\xmlItemPrefixArray -> XmlItem { xmlItemPrefixArray, ..} ) <$> f xmlItemPrefixArray
  {-# INLINE xmlItemPrefixArrayL #-}
  
  -- | 'xmlItemPrefixWrappedArray' Lens
  xmlItemPrefixWrappedArrayL :: Lens_' XmlItem (Maybe [Int])
  xmlItemPrefixWrappedArrayL f XmlItem{..} = (\xmlItemPrefixWrappedArray -> XmlItem { xmlItemPrefixWrappedArray, ..} ) <$> f xmlItemPrefixWrappedArray
  {-# INLINE xmlItemPrefixWrappedArrayL #-}
  
  -- | 'xmlItemNamespaceString' Lens
  xmlItemNamespaceStringL :: Lens_' XmlItem (Maybe Text)
  xmlItemNamespaceStringL f XmlItem{..} = (\xmlItemNamespaceString -> XmlItem { xmlItemNamespaceString, ..} ) <$> f xmlItemNamespaceString
  {-# INLINE xmlItemNamespaceStringL #-}
  
  -- | 'xmlItemNamespaceNumber' Lens
  xmlItemNamespaceNumberL :: Lens_' XmlItem (Maybe Double)
  xmlItemNamespaceNumberL f XmlItem{..} = (\xmlItemNamespaceNumber -> XmlItem { xmlItemNamespaceNumber, ..} ) <$> f xmlItemNamespaceNumber
  {-# INLINE xmlItemNamespaceNumberL #-}
  
  -- | 'xmlItemNamespaceInteger' Lens
  xmlItemNamespaceIntegerL :: Lens_' XmlItem (Maybe Int)
  xmlItemNamespaceIntegerL f XmlItem{..} = (\xmlItemNamespaceInteger -> XmlItem { xmlItemNamespaceInteger, ..} ) <$> f xmlItemNamespaceInteger
  {-# INLINE xmlItemNamespaceIntegerL #-}
  
  -- | 'xmlItemNamespaceBoolean' Lens
  xmlItemNamespaceBooleanL :: Lens_' XmlItem (Maybe Bool)
  xmlItemNamespaceBooleanL f XmlItem{..} = (\xmlItemNamespaceBoolean -> XmlItem { xmlItemNamespaceBoolean, ..} ) <$> f xmlItemNamespaceBoolean
  {-# INLINE xmlItemNamespaceBooleanL #-}
  
  -- | 'xmlItemNamespaceArray' Lens
  xmlItemNamespaceArrayL :: Lens_' XmlItem (Maybe [Int])
  xmlItemNamespaceArrayL f XmlItem{..} = (\xmlItemNamespaceArray -> XmlItem { xmlItemNamespaceArray, ..} ) <$> f xmlItemNamespaceArray
  {-# INLINE xmlItemNamespaceArrayL #-}
  
  -- | 'xmlItemNamespaceWrappedArray' Lens
  xmlItemNamespaceWrappedArrayL :: Lens_' XmlItem (Maybe [Int])
  xmlItemNamespaceWrappedArrayL f XmlItem{..} = (\xmlItemNamespaceWrappedArray -> XmlItem { xmlItemNamespaceWrappedArray, ..} ) <$> f xmlItemNamespaceWrappedArray
  {-# INLINE xmlItemNamespaceWrappedArrayL #-}
  
  -- | 'xmlItemPrefixNsString' Lens
  xmlItemPrefixNsStringL :: Lens_' XmlItem (Maybe Text)
  xmlItemPrefixNsStringL f XmlItem{..} = (\xmlItemPrefixNsString -> XmlItem { xmlItemPrefixNsString, ..} ) <$> f xmlItemPrefixNsString
  {-# INLINE xmlItemPrefixNsStringL #-}
  
  -- | 'xmlItemPrefixNsNumber' Lens
  xmlItemPrefixNsNumberL :: Lens_' XmlItem (Maybe Double)
  xmlItemPrefixNsNumberL f XmlItem{..} = (\xmlItemPrefixNsNumber -> XmlItem { xmlItemPrefixNsNumber, ..} ) <$> f xmlItemPrefixNsNumber
  {-# INLINE xmlItemPrefixNsNumberL #-}
  
  -- | 'xmlItemPrefixNsInteger' Lens
  xmlItemPrefixNsIntegerL :: Lens_' XmlItem (Maybe Int)
  xmlItemPrefixNsIntegerL f XmlItem{..} = (\xmlItemPrefixNsInteger -> XmlItem { xmlItemPrefixNsInteger, ..} ) <$> f xmlItemPrefixNsInteger
  {-# INLINE xmlItemPrefixNsIntegerL #-}
  
  -- | 'xmlItemPrefixNsBoolean' Lens
  xmlItemPrefixNsBooleanL :: Lens_' XmlItem (Maybe Bool)
  xmlItemPrefixNsBooleanL f XmlItem{..} = (\xmlItemPrefixNsBoolean -> XmlItem { xmlItemPrefixNsBoolean, ..} ) <$> f xmlItemPrefixNsBoolean
  {-# INLINE xmlItemPrefixNsBooleanL #-}
  
  -- | 'xmlItemPrefixNsArray' Lens
  xmlItemPrefixNsArrayL :: Lens_' XmlItem (Maybe [Int])
  xmlItemPrefixNsArrayL f XmlItem{..} = (\xmlItemPrefixNsArray -> XmlItem { xmlItemPrefixNsArray, ..} ) <$> f xmlItemPrefixNsArray
  {-# INLINE xmlItemPrefixNsArrayL #-}
  
  -- | 'xmlItemPrefixNsWrappedArray' Lens
  xmlItemPrefixNsWrappedArrayL :: Lens_' XmlItem (Maybe [Int])
  xmlItemPrefixNsWrappedArrayL f XmlItem{..} = (\xmlItemPrefixNsWrappedArray -> XmlItem { xmlItemPrefixNsWrappedArray, ..} ) <$> f xmlItemPrefixNsWrappedArray
  {-# INLINE xmlItemPrefixNsWrappedArrayL #-}
  
  
  