    {-
       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

    -- * AdditionalPropertiesClass

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

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

    -- * 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 #-}

    -- * 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 #-}

    -- * 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 #-}

    -- * 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 #-}

    -- * SpecialModelName

    -- | 'specialModelNameSpecialPropertyName' Lens
    specialModelNameSpecialPropertyNameL :: Lens_' SpecialModelName (Maybe Integer)
    specialModelNameSpecialPropertyNameL f SpecialModelName{..} = (\specialModelNameSpecialPropertyName -> SpecialModelName { specialModelNameSpecialPropertyName, ..} ) <$> f specialModelNameSpecialPropertyName
    {-# INLINE specialModelNameSpecialPropertyNameL #-}

    -- * 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 #-}

    -- | '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 #-}