    {-
       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 :: Lens_' AdditionalPropertiesAnyType (Maybe Text)
    additionalPropertiesAnyTypeNameL Maybe Text -> f (Maybe Text)
    f AdditionalPropertiesAnyType{Maybe Text
    additionalPropertiesAnyTypeName :: AdditionalPropertiesAnyType -> Maybe Text
    additionalPropertiesAnyTypeName :: Maybe Text
    ..} = (\Maybe Text
    additionalPropertiesAnyTypeName -> AdditionalPropertiesAnyType { Maybe Text
    additionalPropertiesAnyTypeName :: Maybe Text
    additionalPropertiesAnyTypeName :: Maybe Text
    additionalPropertiesAnyTypeName, ..} ) (Maybe Text -> AdditionalPropertiesAnyType)
    -> f (Maybe Text) -> f AdditionalPropertiesAnyType
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    additionalPropertiesAnyTypeName
    {-# INLINE additionalPropertiesAnyTypeNameL #-}

    -- * AdditionalPropertiesArray

    -- | 'additionalPropertiesArrayName' Lens
    additionalPropertiesArrayNameL :: Lens_' AdditionalPropertiesArray (Maybe Text)
    additionalPropertiesArrayNameL :: Lens_' AdditionalPropertiesArray (Maybe Text)
    additionalPropertiesArrayNameL Maybe Text -> f (Maybe Text)
    f AdditionalPropertiesArray{Maybe Text
    additionalPropertiesArrayName :: AdditionalPropertiesArray -> Maybe Text
    additionalPropertiesArrayName :: Maybe Text
    ..} = (\Maybe Text
    additionalPropertiesArrayName -> AdditionalPropertiesArray { Maybe Text
    additionalPropertiesArrayName :: Maybe Text
    additionalPropertiesArrayName :: Maybe Text
    additionalPropertiesArrayName, ..} ) (Maybe Text -> AdditionalPropertiesArray)
    -> f (Maybe Text) -> f AdditionalPropertiesArray
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    additionalPropertiesArrayName
    {-# INLINE additionalPropertiesArrayNameL #-}

    -- * AdditionalPropertiesBoolean

    -- | 'additionalPropertiesBooleanName' Lens
    additionalPropertiesBooleanNameL :: Lens_' AdditionalPropertiesBoolean (Maybe Text)
    additionalPropertiesBooleanNameL :: Lens_' AdditionalPropertiesBoolean (Maybe Text)
    additionalPropertiesBooleanNameL Maybe Text -> f (Maybe Text)
    f AdditionalPropertiesBoolean{Maybe Text
    additionalPropertiesBooleanName :: AdditionalPropertiesBoolean -> Maybe Text
    additionalPropertiesBooleanName :: Maybe Text
    ..} = (\Maybe Text
    additionalPropertiesBooleanName -> AdditionalPropertiesBoolean { Maybe Text
    additionalPropertiesBooleanName :: Maybe Text
    additionalPropertiesBooleanName :: Maybe Text
    additionalPropertiesBooleanName, ..} ) (Maybe Text -> AdditionalPropertiesBoolean)
    -> f (Maybe Text) -> f AdditionalPropertiesBoolean
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    additionalPropertiesBooleanName
    {-# INLINE additionalPropertiesBooleanNameL #-}

    -- * AdditionalPropertiesClass

    -- | 'additionalPropertiesClassMapString' Lens
    additionalPropertiesClassMapStringL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String Text))
    additionalPropertiesClassMapStringL :: Lens_' AdditionalPropertiesClass (Maybe (Map String Text))
    additionalPropertiesClassMapStringL Maybe (Map String Text) -> f (Maybe (Map String Text))
    f AdditionalPropertiesClass{Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: AdditionalPropertiesClass -> Maybe (Map String Text)
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    additionalPropertiesClassMapNumber :: AdditionalPropertiesClass -> Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: AdditionalPropertiesClass -> Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: AdditionalPropertiesClass -> Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: AdditionalPropertiesClass -> Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: AdditionalPropertiesClass -> Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: AdditionalPropertiesClass -> Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: AdditionalPropertiesClass -> Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype2 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype3 :: AdditionalPropertiesClass -> Maybe Value
    ..} = (\Maybe (Map String Text)
    additionalPropertiesClassMapString -> AdditionalPropertiesClass { Maybe (Map String Text)
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapString, Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe Value
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} ) (Maybe (Map String Text) -> AdditionalPropertiesClass)
    -> f (Maybe (Map String Text)) -> f AdditionalPropertiesClass
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (Map String Text) -> f (Maybe (Map String Text))
    f Maybe (Map String Text)
    additionalPropertiesClassMapString
    {-# INLINE additionalPropertiesClassMapStringL #-}

    -- | 'additionalPropertiesClassMapNumber' Lens
    additionalPropertiesClassMapNumberL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String Double))
    additionalPropertiesClassMapNumberL :: Lens_' AdditionalPropertiesClass (Maybe (Map String Double))
    additionalPropertiesClassMapNumberL Maybe (Map String Double) -> f (Maybe (Map String Double))
    f AdditionalPropertiesClass{Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: AdditionalPropertiesClass -> Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: AdditionalPropertiesClass -> Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: AdditionalPropertiesClass -> Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: AdditionalPropertiesClass -> Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: AdditionalPropertiesClass -> Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: AdditionalPropertiesClass -> Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: AdditionalPropertiesClass -> Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: AdditionalPropertiesClass -> Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype2 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype3 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} = (\Maybe (Map String Double)
    additionalPropertiesClassMapNumber -> AdditionalPropertiesClass { Maybe (Map String Double)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapNumber, Maybe (Map String Bool)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} ) (Maybe (Map String Double) -> AdditionalPropertiesClass)
    -> f (Maybe (Map String Double)) -> f AdditionalPropertiesClass
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (Map String Double) -> f (Maybe (Map String Double))
    f Maybe (Map String Double)
    additionalPropertiesClassMapNumber
    {-# INLINE additionalPropertiesClassMapNumberL #-}

    -- | 'additionalPropertiesClassMapInteger' Lens
    additionalPropertiesClassMapIntegerL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String Int))
    additionalPropertiesClassMapIntegerL :: Lens_' AdditionalPropertiesClass (Maybe (Map String Int))
    additionalPropertiesClassMapIntegerL Maybe (Map String Int) -> f (Maybe (Map String Int))
    f AdditionalPropertiesClass{Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: AdditionalPropertiesClass -> Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: AdditionalPropertiesClass -> Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: AdditionalPropertiesClass -> Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: AdditionalPropertiesClass -> Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: AdditionalPropertiesClass -> Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: AdditionalPropertiesClass -> Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: AdditionalPropertiesClass -> Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: AdditionalPropertiesClass -> Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype2 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype3 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} = (\Maybe (Map String Int)
    additionalPropertiesClassMapInteger -> AdditionalPropertiesClass { Maybe (Map String Int)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapInteger, Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} ) (Maybe (Map String Int) -> AdditionalPropertiesClass)
    -> f (Maybe (Map String Int)) -> f AdditionalPropertiesClass
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (Map String Int) -> f (Maybe (Map String Int))
    f Maybe (Map String Int)
    additionalPropertiesClassMapInteger
    {-# INLINE additionalPropertiesClassMapIntegerL #-}

    -- | 'additionalPropertiesClassMapBoolean' Lens
    additionalPropertiesClassMapBooleanL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String Bool))
    additionalPropertiesClassMapBooleanL :: Lens_' AdditionalPropertiesClass (Maybe (Map String Bool))
    additionalPropertiesClassMapBooleanL Maybe (Map String Bool) -> f (Maybe (Map String Bool))
    f AdditionalPropertiesClass{Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: AdditionalPropertiesClass -> Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: AdditionalPropertiesClass -> Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: AdditionalPropertiesClass -> Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: AdditionalPropertiesClass -> Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: AdditionalPropertiesClass -> Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: AdditionalPropertiesClass -> Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: AdditionalPropertiesClass -> Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: AdditionalPropertiesClass -> Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype2 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype3 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} = (\Maybe (Map String Bool)
    additionalPropertiesClassMapBoolean -> AdditionalPropertiesClass { Maybe (Map String Bool)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapBoolean, Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} ) (Maybe (Map String Bool) -> AdditionalPropertiesClass)
    -> f (Maybe (Map String Bool)) -> f AdditionalPropertiesClass
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (Map String Bool) -> f (Maybe (Map String Bool))
    f Maybe (Map String Bool)
    additionalPropertiesClassMapBoolean
    {-# INLINE additionalPropertiesClassMapBooleanL #-}

    -- | 'additionalPropertiesClassMapArrayInteger' Lens
    additionalPropertiesClassMapArrayIntegerL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String [Int]))
    additionalPropertiesClassMapArrayIntegerL :: Lens_' AdditionalPropertiesClass (Maybe (Map String [Int]))
    additionalPropertiesClassMapArrayIntegerL Maybe (Map String [Int]) -> f (Maybe (Map String [Int]))
    f AdditionalPropertiesClass{Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: AdditionalPropertiesClass -> Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: AdditionalPropertiesClass -> Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: AdditionalPropertiesClass -> Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: AdditionalPropertiesClass -> Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: AdditionalPropertiesClass -> Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: AdditionalPropertiesClass -> Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: AdditionalPropertiesClass -> Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: AdditionalPropertiesClass -> Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype2 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype3 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} = (\Maybe (Map String [Int])
    additionalPropertiesClassMapArrayInteger -> AdditionalPropertiesClass { Maybe (Map String [Int])
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayInteger, Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} ) (Maybe (Map String [Int]) -> AdditionalPropertiesClass)
    -> f (Maybe (Map String [Int])) -> f AdditionalPropertiesClass
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (Map String [Int]) -> f (Maybe (Map String [Int]))
    f Maybe (Map String [Int])
    additionalPropertiesClassMapArrayInteger
    {-# INLINE additionalPropertiesClassMapArrayIntegerL #-}

    -- | 'additionalPropertiesClassMapArrayAnytype' Lens
    additionalPropertiesClassMapArrayAnytypeL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String [A.Value]))
    additionalPropertiesClassMapArrayAnytypeL :: Lens_' AdditionalPropertiesClass (Maybe (Map String [Value]))
    additionalPropertiesClassMapArrayAnytypeL Maybe (Map String [Value]) -> f (Maybe (Map String [Value]))
    f AdditionalPropertiesClass{Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: AdditionalPropertiesClass -> Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: AdditionalPropertiesClass -> Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: AdditionalPropertiesClass -> Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: AdditionalPropertiesClass -> Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: AdditionalPropertiesClass -> Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: AdditionalPropertiesClass -> Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: AdditionalPropertiesClass -> Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: AdditionalPropertiesClass -> Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype2 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype3 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} = (\Maybe (Map String [Value])
    additionalPropertiesClassMapArrayAnytype -> AdditionalPropertiesClass { Maybe (Map String [Value])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapArrayAnytype, Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} ) (Maybe (Map String [Value]) -> AdditionalPropertiesClass)
    -> f (Maybe (Map String [Value])) -> f AdditionalPropertiesClass
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (Map String [Value]) -> f (Maybe (Map String [Value]))
    f Maybe (Map String [Value])
    additionalPropertiesClassMapArrayAnytype
    {-# INLINE additionalPropertiesClassMapArrayAnytypeL #-}

    -- | 'additionalPropertiesClassMapMapString' Lens
    additionalPropertiesClassMapMapStringL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String (Map.Map String Text)))
    additionalPropertiesClassMapMapStringL :: Lens_'
      AdditionalPropertiesClass (Maybe (Map String (Map String Text)))
    additionalPropertiesClassMapMapStringL Maybe (Map String (Map String Text))
    -> f (Maybe (Map String (Map String Text)))
    f AdditionalPropertiesClass{Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: AdditionalPropertiesClass -> Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: AdditionalPropertiesClass -> Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: AdditionalPropertiesClass -> Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: AdditionalPropertiesClass -> Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: AdditionalPropertiesClass -> Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: AdditionalPropertiesClass -> Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: AdditionalPropertiesClass -> Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: AdditionalPropertiesClass -> Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype2 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype3 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} = (\Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapString -> AdditionalPropertiesClass { Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapString, Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} ) (Maybe (Map String (Map String Text)) -> AdditionalPropertiesClass)
    -> f (Maybe (Map String (Map String Text)))
    -> f AdditionalPropertiesClass
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (Map String (Map String Text))
    -> f (Maybe (Map String (Map String Text)))
    f Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapString
    {-# INLINE additionalPropertiesClassMapMapStringL #-}

    -- | 'additionalPropertiesClassMapMapAnytype' Lens
    additionalPropertiesClassMapMapAnytypeL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String (Map.Map String A.Value)))
    additionalPropertiesClassMapMapAnytypeL :: Lens_'
      AdditionalPropertiesClass (Maybe (Map String (Map String Value)))
    additionalPropertiesClassMapMapAnytypeL Maybe (Map String (Map String Value))
    -> f (Maybe (Map String (Map String Value)))
    f AdditionalPropertiesClass{Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: AdditionalPropertiesClass -> Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: AdditionalPropertiesClass -> Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: AdditionalPropertiesClass -> Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: AdditionalPropertiesClass -> Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: AdditionalPropertiesClass -> Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: AdditionalPropertiesClass -> Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: AdditionalPropertiesClass -> Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: AdditionalPropertiesClass -> Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype2 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype3 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} = (\Maybe (Map String (Map String Value))
    additionalPropertiesClassMapMapAnytype -> AdditionalPropertiesClass { Maybe (Map String (Map String Value))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassMapMapAnytype, Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} ) (Maybe (Map String (Map String Value))
     -> AdditionalPropertiesClass)
    -> f (Maybe (Map String (Map String Value)))
    -> f AdditionalPropertiesClass
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (Map String (Map String Value))
    -> f (Maybe (Map String (Map String Value)))
    f Maybe (Map String (Map String Value))
    additionalPropertiesClassMapMapAnytype
    {-# INLINE additionalPropertiesClassMapMapAnytypeL #-}

    -- | 'additionalPropertiesClassAnytype1' Lens
    additionalPropertiesClassAnytype1L :: Lens_' AdditionalPropertiesClass (Maybe A.Value)
    additionalPropertiesClassAnytype1L :: Lens_' AdditionalPropertiesClass (Maybe Value)
    additionalPropertiesClassAnytype1L Maybe Value -> f (Maybe Value)
    f AdditionalPropertiesClass{Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: AdditionalPropertiesClass -> Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: AdditionalPropertiesClass -> Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: AdditionalPropertiesClass -> Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: AdditionalPropertiesClass -> Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: AdditionalPropertiesClass -> Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: AdditionalPropertiesClass -> Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: AdditionalPropertiesClass -> Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: AdditionalPropertiesClass -> Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype2 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype3 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} = (\Maybe Value
    additionalPropertiesClassAnytype1 -> AdditionalPropertiesClass { Maybe Value
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype1, Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} ) (Maybe Value -> AdditionalPropertiesClass)
    -> f (Maybe Value) -> f AdditionalPropertiesClass
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Value -> f (Maybe Value)
    f Maybe Value
    additionalPropertiesClassAnytype1
    {-# INLINE additionalPropertiesClassAnytype1L #-}

    -- | 'additionalPropertiesClassAnytype2' Lens
    additionalPropertiesClassAnytype2L :: Lens_' AdditionalPropertiesClass (Maybe A.Value)
    additionalPropertiesClassAnytype2L :: Lens_' AdditionalPropertiesClass (Maybe Value)
    additionalPropertiesClassAnytype2L Maybe Value -> f (Maybe Value)
    f AdditionalPropertiesClass{Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: AdditionalPropertiesClass -> Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: AdditionalPropertiesClass -> Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: AdditionalPropertiesClass -> Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: AdditionalPropertiesClass -> Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: AdditionalPropertiesClass -> Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: AdditionalPropertiesClass -> Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: AdditionalPropertiesClass -> Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: AdditionalPropertiesClass -> Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype2 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype3 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} = (\Maybe Value
    additionalPropertiesClassAnytype2 -> AdditionalPropertiesClass { Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype2, Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} ) (Maybe Value -> AdditionalPropertiesClass)
    -> f (Maybe Value) -> f AdditionalPropertiesClass
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Value -> f (Maybe Value)
    f Maybe Value
    additionalPropertiesClassAnytype2
    {-# INLINE additionalPropertiesClassAnytype2L #-}

    -- | 'additionalPropertiesClassAnytype3' Lens
    additionalPropertiesClassAnytype3L :: Lens_' AdditionalPropertiesClass (Maybe A.Value)
    additionalPropertiesClassAnytype3L :: Lens_' AdditionalPropertiesClass (Maybe Value)
    additionalPropertiesClassAnytype3L Maybe Value -> f (Maybe Value)
    f AdditionalPropertiesClass{Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: AdditionalPropertiesClass -> Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: AdditionalPropertiesClass -> Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: AdditionalPropertiesClass -> Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: AdditionalPropertiesClass -> Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: AdditionalPropertiesClass -> Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: AdditionalPropertiesClass -> Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: AdditionalPropertiesClass -> Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: AdditionalPropertiesClass -> Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype2 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype3 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} = (\Maybe Value
    additionalPropertiesClassAnytype3 -> AdditionalPropertiesClass { Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    additionalPropertiesClassAnytype3, Maybe (Map String Bool)
    Maybe (Map String Double)
    Maybe (Map String Int)
    Maybe (Map String [Int])
    Maybe (Map String [Value])
    Maybe (Map String (Map String Text))
    Maybe (Map String (Map String Value))
    Maybe (Map String Text)
    Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map String Text)
    additionalPropertiesClassMapNumber :: Maybe (Map String Double)
    additionalPropertiesClassMapInteger :: Maybe (Map String Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map String Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map String [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map String [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map String (Map String Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map String (Map String Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    ..} ) (Maybe Value -> AdditionalPropertiesClass)
    -> f (Maybe Value) -> f AdditionalPropertiesClass
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Value -> f (Maybe Value)
    f Maybe Value
    additionalPropertiesClassAnytype3
    {-# INLINE additionalPropertiesClassAnytype3L #-}

    -- * AdditionalPropertiesInteger

    -- | 'additionalPropertiesIntegerName' Lens
    additionalPropertiesIntegerNameL :: Lens_' AdditionalPropertiesInteger (Maybe Text)
    additionalPropertiesIntegerNameL :: Lens_' AdditionalPropertiesInteger (Maybe Text)
    additionalPropertiesIntegerNameL Maybe Text -> f (Maybe Text)
    f AdditionalPropertiesInteger{Maybe Text
    additionalPropertiesIntegerName :: AdditionalPropertiesInteger -> Maybe Text
    additionalPropertiesIntegerName :: Maybe Text
    ..} = (\Maybe Text
    additionalPropertiesIntegerName -> AdditionalPropertiesInteger { Maybe Text
    additionalPropertiesIntegerName :: Maybe Text
    additionalPropertiesIntegerName :: Maybe Text
    additionalPropertiesIntegerName, ..} ) (Maybe Text -> AdditionalPropertiesInteger)
    -> f (Maybe Text) -> f AdditionalPropertiesInteger
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    additionalPropertiesIntegerName
    {-# INLINE additionalPropertiesIntegerNameL #-}

    -- * AdditionalPropertiesNumber

    -- | 'additionalPropertiesNumberName' Lens
    additionalPropertiesNumberNameL :: Lens_' AdditionalPropertiesNumber (Maybe Text)
    additionalPropertiesNumberNameL :: Lens_' AdditionalPropertiesNumber (Maybe Text)
    additionalPropertiesNumberNameL Maybe Text -> f (Maybe Text)
    f AdditionalPropertiesNumber{Maybe Text
    additionalPropertiesNumberName :: AdditionalPropertiesNumber -> Maybe Text
    additionalPropertiesNumberName :: Maybe Text
    ..} = (\Maybe Text
    additionalPropertiesNumberName -> AdditionalPropertiesNumber { Maybe Text
    additionalPropertiesNumberName :: Maybe Text
    additionalPropertiesNumberName :: Maybe Text
    additionalPropertiesNumberName, ..} ) (Maybe Text -> AdditionalPropertiesNumber)
    -> f (Maybe Text) -> f AdditionalPropertiesNumber
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    additionalPropertiesNumberName
    {-# INLINE additionalPropertiesNumberNameL #-}

    -- * AdditionalPropertiesObject

    -- | 'additionalPropertiesObjectName' Lens
    additionalPropertiesObjectNameL :: Lens_' AdditionalPropertiesObject (Maybe Text)
    additionalPropertiesObjectNameL :: Lens_' AdditionalPropertiesObject (Maybe Text)
    additionalPropertiesObjectNameL Maybe Text -> f (Maybe Text)
    f AdditionalPropertiesObject{Maybe Text
    additionalPropertiesObjectName :: AdditionalPropertiesObject -> Maybe Text
    additionalPropertiesObjectName :: Maybe Text
    ..} = (\Maybe Text
    additionalPropertiesObjectName -> AdditionalPropertiesObject { Maybe Text
    additionalPropertiesObjectName :: Maybe Text
    additionalPropertiesObjectName :: Maybe Text
    additionalPropertiesObjectName, ..} ) (Maybe Text -> AdditionalPropertiesObject)
    -> f (Maybe Text) -> f AdditionalPropertiesObject
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    additionalPropertiesObjectName
    {-# INLINE additionalPropertiesObjectNameL #-}

    -- * AdditionalPropertiesString

    -- | 'additionalPropertiesStringName' Lens
    additionalPropertiesStringNameL :: Lens_' AdditionalPropertiesString (Maybe Text)
    additionalPropertiesStringNameL :: Lens_' AdditionalPropertiesString (Maybe Text)
    additionalPropertiesStringNameL Maybe Text -> f (Maybe Text)
    f AdditionalPropertiesString{Maybe Text
    additionalPropertiesStringName :: AdditionalPropertiesString -> Maybe Text
    additionalPropertiesStringName :: Maybe Text
    ..} = (\Maybe Text
    additionalPropertiesStringName -> AdditionalPropertiesString { Maybe Text
    additionalPropertiesStringName :: Maybe Text
    additionalPropertiesStringName :: Maybe Text
    additionalPropertiesStringName, ..} ) (Maybe Text -> AdditionalPropertiesString)
    -> f (Maybe Text) -> f AdditionalPropertiesString
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    additionalPropertiesStringName
    {-# INLINE additionalPropertiesStringNameL #-}

    -- * Animal

    -- | 'animalClassName' Lens
    animalClassNameL :: Lens_' Animal (Text)
    animalClassNameL :: Lens_' Animal Text
    animalClassNameL Text -> f Text
    f Animal{Maybe Text
    Text
    animalClassName :: Animal -> Text
    animalClassName :: Text
    animalColor :: Maybe Text
    animalColor :: Animal -> Maybe Text
    ..} = (\Text
    animalClassName -> Animal { Text
    animalClassName :: Text
    animalClassName :: Text
    animalClassName, Maybe Text
    animalColor :: Maybe Text
    animalColor :: Maybe Text
    ..} ) (Text -> Animal) -> f Text -> f Animal
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text -> f Text
    f Text
    animalClassName
    {-# INLINE animalClassNameL #-}

    -- | 'animalColor' Lens
    animalColorL :: Lens_' Animal (Maybe Text)
    animalColorL :: Lens_' Animal (Maybe Text)
    animalColorL Maybe Text -> f (Maybe Text)
    f Animal{Maybe Text
    Text
    animalClassName :: Animal -> Text
    animalColor :: Animal -> Maybe Text
    animalClassName :: Text
    animalColor :: Maybe Text
    ..} = (\Maybe Text
    animalColor -> Animal { Maybe Text
    animalColor :: Maybe Text
    animalColor :: Maybe Text
    animalColor, Text
    animalClassName :: Text
    animalClassName :: Text
    ..} ) (Maybe Text -> Animal) -> f (Maybe Text) -> f Animal
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    animalColor
    {-# INLINE animalColorL #-}

    -- * ApiResponse

    -- | 'apiResponseCode' Lens
    apiResponseCodeL :: Lens_' ApiResponse (Maybe Int)
    apiResponseCodeL :: Lens_' ApiResponse (Maybe Int)
    apiResponseCodeL Maybe Int -> f (Maybe Int)
    f ApiResponse{Maybe Int
    Maybe Text
    apiResponseCode :: ApiResponse -> Maybe Int
    apiResponseCode :: Maybe Int
    apiResponseType :: Maybe Text
    apiResponseMessage :: Maybe Text
    apiResponseType :: ApiResponse -> Maybe Text
    apiResponseMessage :: ApiResponse -> Maybe Text
    ..} = (\Maybe Int
    apiResponseCode -> ApiResponse { Maybe Int
    apiResponseCode :: Maybe Int
    apiResponseCode :: Maybe Int
    apiResponseCode, Maybe Text
    apiResponseType :: Maybe Text
    apiResponseMessage :: Maybe Text
    apiResponseType :: Maybe Text
    apiResponseMessage :: Maybe Text
    ..} ) (Maybe Int -> ApiResponse) -> f (Maybe Int) -> f ApiResponse
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Int -> f (Maybe Int)
    f Maybe Int
    apiResponseCode
    {-# INLINE apiResponseCodeL #-}

    -- | 'apiResponseType' Lens
    apiResponseTypeL :: Lens_' ApiResponse (Maybe Text)
    apiResponseTypeL :: Lens_' ApiResponse (Maybe Text)
    apiResponseTypeL Maybe Text -> f (Maybe Text)
    f ApiResponse{Maybe Int
    Maybe Text
    apiResponseCode :: ApiResponse -> Maybe Int
    apiResponseType :: ApiResponse -> Maybe Text
    apiResponseMessage :: ApiResponse -> Maybe Text
    apiResponseCode :: Maybe Int
    apiResponseType :: Maybe Text
    apiResponseMessage :: Maybe Text
    ..} = (\Maybe Text
    apiResponseType -> ApiResponse { Maybe Text
    apiResponseType :: Maybe Text
    apiResponseType :: Maybe Text
    apiResponseType, Maybe Int
    Maybe Text
    apiResponseCode :: Maybe Int
    apiResponseMessage :: Maybe Text
    apiResponseCode :: Maybe Int
    apiResponseMessage :: Maybe Text
    ..} ) (Maybe Text -> ApiResponse) -> f (Maybe Text) -> f ApiResponse
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    apiResponseType
    {-# INLINE apiResponseTypeL #-}

    -- | 'apiResponseMessage' Lens
    apiResponseMessageL :: Lens_' ApiResponse (Maybe Text)
    apiResponseMessageL :: Lens_' ApiResponse (Maybe Text)
    apiResponseMessageL Maybe Text -> f (Maybe Text)
    f ApiResponse{Maybe Int
    Maybe Text
    apiResponseCode :: ApiResponse -> Maybe Int
    apiResponseType :: ApiResponse -> Maybe Text
    apiResponseMessage :: ApiResponse -> Maybe Text
    apiResponseCode :: Maybe Int
    apiResponseType :: Maybe Text
    apiResponseMessage :: Maybe Text
    ..} = (\Maybe Text
    apiResponseMessage -> ApiResponse { Maybe Text
    apiResponseMessage :: Maybe Text
    apiResponseMessage :: Maybe Text
    apiResponseMessage, Maybe Int
    Maybe Text
    apiResponseCode :: Maybe Int
    apiResponseType :: Maybe Text
    apiResponseCode :: Maybe Int
    apiResponseType :: Maybe Text
    ..} ) (Maybe Text -> ApiResponse) -> f (Maybe Text) -> f ApiResponse
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    apiResponseMessage
    {-# INLINE apiResponseMessageL #-}

    -- * ArrayOfArrayOfNumberOnly

    -- | 'arrayOfArrayOfNumberOnlyArrayArrayNumber' Lens
    arrayOfArrayOfNumberOnlyArrayArrayNumberL :: Lens_' ArrayOfArrayOfNumberOnly (Maybe [[Double]])
    arrayOfArrayOfNumberOnlyArrayArrayNumberL :: Lens_' ArrayOfArrayOfNumberOnly (Maybe [[Double]])
    arrayOfArrayOfNumberOnlyArrayArrayNumberL Maybe [[Double]] -> f (Maybe [[Double]])
    f ArrayOfArrayOfNumberOnly{Maybe [[Double]]
    arrayOfArrayOfNumberOnlyArrayArrayNumber :: ArrayOfArrayOfNumberOnly -> Maybe [[Double]]
    arrayOfArrayOfNumberOnlyArrayArrayNumber :: Maybe [[Double]]
    ..} = (\Maybe [[Double]]
    arrayOfArrayOfNumberOnlyArrayArrayNumber -> ArrayOfArrayOfNumberOnly { Maybe [[Double]]
    arrayOfArrayOfNumberOnlyArrayArrayNumber :: Maybe [[Double]]
    arrayOfArrayOfNumberOnlyArrayArrayNumber :: Maybe [[Double]]
    arrayOfArrayOfNumberOnlyArrayArrayNumber, ..} ) (Maybe [[Double]] -> ArrayOfArrayOfNumberOnly)
    -> f (Maybe [[Double]]) -> f ArrayOfArrayOfNumberOnly
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [[Double]] -> f (Maybe [[Double]])
    f Maybe [[Double]]
    arrayOfArrayOfNumberOnlyArrayArrayNumber
    {-# INLINE arrayOfArrayOfNumberOnlyArrayArrayNumberL #-}

    -- * ArrayOfNumberOnly

    -- | 'arrayOfNumberOnlyArrayNumber' Lens
    arrayOfNumberOnlyArrayNumberL :: Lens_' ArrayOfNumberOnly (Maybe [Double])
    arrayOfNumberOnlyArrayNumberL :: Lens_' ArrayOfNumberOnly (Maybe [Double])
    arrayOfNumberOnlyArrayNumberL Maybe [Double] -> f (Maybe [Double])
    f ArrayOfNumberOnly{Maybe [Double]
    arrayOfNumberOnlyArrayNumber :: ArrayOfNumberOnly -> Maybe [Double]
    arrayOfNumberOnlyArrayNumber :: Maybe [Double]
    ..} = (\Maybe [Double]
    arrayOfNumberOnlyArrayNumber -> ArrayOfNumberOnly { Maybe [Double]
    arrayOfNumberOnlyArrayNumber :: Maybe [Double]
    arrayOfNumberOnlyArrayNumber :: Maybe [Double]
    arrayOfNumberOnlyArrayNumber, ..} ) (Maybe [Double] -> ArrayOfNumberOnly)
    -> f (Maybe [Double]) -> f ArrayOfNumberOnly
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [Double] -> f (Maybe [Double])
    f Maybe [Double]
    arrayOfNumberOnlyArrayNumber
    {-# INLINE arrayOfNumberOnlyArrayNumberL #-}

    -- * ArrayTest

    -- | 'arrayTestArrayOfString' Lens
    arrayTestArrayOfStringL :: Lens_' ArrayTest (Maybe [Text])
    arrayTestArrayOfStringL :: Lens_' ArrayTest (Maybe [Text])
    arrayTestArrayOfStringL Maybe [Text] -> f (Maybe [Text])
    f ArrayTest{Maybe [[Integer]]
    Maybe [[ReadOnlyFirst]]
    Maybe [Text]
    arrayTestArrayOfString :: ArrayTest -> Maybe [Text]
    arrayTestArrayOfString :: Maybe [Text]
    arrayTestArrayArrayOfInteger :: Maybe [[Integer]]
    arrayTestArrayArrayOfModel :: Maybe [[ReadOnlyFirst]]
    arrayTestArrayArrayOfInteger :: ArrayTest -> Maybe [[Integer]]
    arrayTestArrayArrayOfModel :: ArrayTest -> Maybe [[ReadOnlyFirst]]
    ..} = (\Maybe [Text]
    arrayTestArrayOfString -> ArrayTest { Maybe [Text]
    arrayTestArrayOfString :: Maybe [Text]
    arrayTestArrayOfString :: Maybe [Text]
    arrayTestArrayOfString, Maybe [[Integer]]
    Maybe [[ReadOnlyFirst]]
    arrayTestArrayArrayOfInteger :: Maybe [[Integer]]
    arrayTestArrayArrayOfModel :: Maybe [[ReadOnlyFirst]]
    arrayTestArrayArrayOfInteger :: Maybe [[Integer]]
    arrayTestArrayArrayOfModel :: Maybe [[ReadOnlyFirst]]
    ..} ) (Maybe [Text] -> ArrayTest) -> f (Maybe [Text]) -> f ArrayTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [Text] -> f (Maybe [Text])
    f Maybe [Text]
    arrayTestArrayOfString
    {-# INLINE arrayTestArrayOfStringL #-}

    -- | 'arrayTestArrayArrayOfInteger' Lens
    arrayTestArrayArrayOfIntegerL :: Lens_' ArrayTest (Maybe [[Integer]])
    arrayTestArrayArrayOfIntegerL :: Lens_' ArrayTest (Maybe [[Integer]])
    arrayTestArrayArrayOfIntegerL Maybe [[Integer]] -> f (Maybe [[Integer]])
    f ArrayTest{Maybe [[Integer]]
    Maybe [[ReadOnlyFirst]]
    Maybe [Text]
    arrayTestArrayOfString :: ArrayTest -> Maybe [Text]
    arrayTestArrayArrayOfInteger :: ArrayTest -> Maybe [[Integer]]
    arrayTestArrayArrayOfModel :: ArrayTest -> Maybe [[ReadOnlyFirst]]
    arrayTestArrayOfString :: Maybe [Text]
    arrayTestArrayArrayOfInteger :: Maybe [[Integer]]
    arrayTestArrayArrayOfModel :: Maybe [[ReadOnlyFirst]]
    ..} = (\Maybe [[Integer]]
    arrayTestArrayArrayOfInteger -> ArrayTest { Maybe [[Integer]]
    arrayTestArrayArrayOfInteger :: Maybe [[Integer]]
    arrayTestArrayArrayOfInteger :: Maybe [[Integer]]
    arrayTestArrayArrayOfInteger, Maybe [[ReadOnlyFirst]]
    Maybe [Text]
    arrayTestArrayOfString :: Maybe [Text]
    arrayTestArrayArrayOfModel :: Maybe [[ReadOnlyFirst]]
    arrayTestArrayOfString :: Maybe [Text]
    arrayTestArrayArrayOfModel :: Maybe [[ReadOnlyFirst]]
    ..} ) (Maybe [[Integer]] -> ArrayTest)
    -> f (Maybe [[Integer]]) -> f ArrayTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [[Integer]] -> f (Maybe [[Integer]])
    f Maybe [[Integer]]
    arrayTestArrayArrayOfInteger
    {-# INLINE arrayTestArrayArrayOfIntegerL #-}

    -- | 'arrayTestArrayArrayOfModel' Lens
    arrayTestArrayArrayOfModelL :: Lens_' ArrayTest (Maybe [[ReadOnlyFirst]])
    arrayTestArrayArrayOfModelL :: Lens_' ArrayTest (Maybe [[ReadOnlyFirst]])
    arrayTestArrayArrayOfModelL Maybe [[ReadOnlyFirst]] -> f (Maybe [[ReadOnlyFirst]])
    f ArrayTest{Maybe [[Integer]]
    Maybe [[ReadOnlyFirst]]
    Maybe [Text]
    arrayTestArrayOfString :: ArrayTest -> Maybe [Text]
    arrayTestArrayArrayOfInteger :: ArrayTest -> Maybe [[Integer]]
    arrayTestArrayArrayOfModel :: ArrayTest -> Maybe [[ReadOnlyFirst]]
    arrayTestArrayOfString :: Maybe [Text]
    arrayTestArrayArrayOfInteger :: Maybe [[Integer]]
    arrayTestArrayArrayOfModel :: Maybe [[ReadOnlyFirst]]
    ..} = (\Maybe [[ReadOnlyFirst]]
    arrayTestArrayArrayOfModel -> ArrayTest { Maybe [[ReadOnlyFirst]]
    arrayTestArrayArrayOfModel :: Maybe [[ReadOnlyFirst]]
    arrayTestArrayArrayOfModel :: Maybe [[ReadOnlyFirst]]
    arrayTestArrayArrayOfModel, Maybe [[Integer]]
    Maybe [Text]
    arrayTestArrayOfString :: Maybe [Text]
    arrayTestArrayArrayOfInteger :: Maybe [[Integer]]
    arrayTestArrayOfString :: Maybe [Text]
    arrayTestArrayArrayOfInteger :: Maybe [[Integer]]
    ..} ) (Maybe [[ReadOnlyFirst]] -> ArrayTest)
    -> f (Maybe [[ReadOnlyFirst]]) -> f ArrayTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [[ReadOnlyFirst]] -> f (Maybe [[ReadOnlyFirst]])
    f Maybe [[ReadOnlyFirst]]
    arrayTestArrayArrayOfModel
    {-# INLINE arrayTestArrayArrayOfModelL #-}

    -- * BigCat

    -- | 'bigCatClassName' Lens
    bigCatClassNameL :: Lens_' BigCat (Text)
    bigCatClassNameL :: Lens_' BigCat Text
    bigCatClassNameL Text -> f Text
    f BigCat{Maybe Bool
    Maybe Text
    Maybe E'Kind
    Text
    bigCatClassName :: BigCat -> Text
    bigCatClassName :: Text
    bigCatColor :: Maybe Text
    bigCatDeclawed :: Maybe Bool
    bigCatKind :: Maybe E'Kind
    bigCatColor :: BigCat -> Maybe Text
    bigCatDeclawed :: BigCat -> Maybe Bool
    bigCatKind :: BigCat -> Maybe E'Kind
    ..} = (\Text
    bigCatClassName -> BigCat { Text
    bigCatClassName :: Text
    bigCatClassName :: Text
    bigCatClassName, Maybe Bool
    Maybe Text
    Maybe E'Kind
    bigCatColor :: Maybe Text
    bigCatDeclawed :: Maybe Bool
    bigCatKind :: Maybe E'Kind
    bigCatColor :: Maybe Text
    bigCatDeclawed :: Maybe Bool
    bigCatKind :: Maybe E'Kind
    ..} ) (Text -> BigCat) -> f Text -> f BigCat
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text -> f Text
    f Text
    bigCatClassName
    {-# INLINE bigCatClassNameL #-}

    -- | 'bigCatColor' Lens
    bigCatColorL :: Lens_' BigCat (Maybe Text)
    bigCatColorL :: Lens_' BigCat (Maybe Text)
    bigCatColorL Maybe Text -> f (Maybe Text)
    f BigCat{Maybe Bool
    Maybe Text
    Maybe E'Kind
    Text
    bigCatClassName :: BigCat -> Text
    bigCatColor :: BigCat -> Maybe Text
    bigCatDeclawed :: BigCat -> Maybe Bool
    bigCatKind :: BigCat -> Maybe E'Kind
    bigCatClassName :: Text
    bigCatColor :: Maybe Text
    bigCatDeclawed :: Maybe Bool
    bigCatKind :: Maybe E'Kind
    ..} = (\Maybe Text
    bigCatColor -> BigCat { Maybe Text
    bigCatColor :: Maybe Text
    bigCatColor :: Maybe Text
    bigCatColor, Maybe Bool
    Maybe E'Kind
    Text
    bigCatClassName :: Text
    bigCatDeclawed :: Maybe Bool
    bigCatKind :: Maybe E'Kind
    bigCatClassName :: Text
    bigCatDeclawed :: Maybe Bool
    bigCatKind :: Maybe E'Kind
    ..} ) (Maybe Text -> BigCat) -> f (Maybe Text) -> f BigCat
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    bigCatColor
    {-# INLINE bigCatColorL #-}

    -- | 'bigCatDeclawed' Lens
    bigCatDeclawedL :: Lens_' BigCat (Maybe Bool)
    bigCatDeclawedL :: Lens_' BigCat (Maybe Bool)
    bigCatDeclawedL Maybe Bool -> f (Maybe Bool)
    f BigCat{Maybe Bool
    Maybe Text
    Maybe E'Kind
    Text
    bigCatClassName :: BigCat -> Text
    bigCatColor :: BigCat -> Maybe Text
    bigCatDeclawed :: BigCat -> Maybe Bool
    bigCatKind :: BigCat -> Maybe E'Kind
    bigCatClassName :: Text
    bigCatColor :: Maybe Text
    bigCatDeclawed :: Maybe Bool
    bigCatKind :: Maybe E'Kind
    ..} = (\Maybe Bool
    bigCatDeclawed -> BigCat { Maybe Bool
    bigCatDeclawed :: Maybe Bool
    bigCatDeclawed :: Maybe Bool
    bigCatDeclawed, Maybe Text
    Maybe E'Kind
    Text
    bigCatClassName :: Text
    bigCatColor :: Maybe Text
    bigCatKind :: Maybe E'Kind
    bigCatClassName :: Text
    bigCatColor :: Maybe Text
    bigCatKind :: Maybe E'Kind
    ..} ) (Maybe Bool -> BigCat) -> f (Maybe Bool) -> f BigCat
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Bool -> f (Maybe Bool)
    f Maybe Bool
    bigCatDeclawed
    {-# INLINE bigCatDeclawedL #-}

    -- | 'bigCatKind' Lens
    bigCatKindL :: Lens_' BigCat (Maybe E'Kind)
    bigCatKindL :: Lens_' BigCat (Maybe E'Kind)
    bigCatKindL Maybe E'Kind -> f (Maybe E'Kind)
    f BigCat{Maybe Bool
    Maybe Text
    Maybe E'Kind
    Text
    bigCatClassName :: BigCat -> Text
    bigCatColor :: BigCat -> Maybe Text
    bigCatDeclawed :: BigCat -> Maybe Bool
    bigCatKind :: BigCat -> Maybe E'Kind
    bigCatClassName :: Text
    bigCatColor :: Maybe Text
    bigCatDeclawed :: Maybe Bool
    bigCatKind :: Maybe E'Kind
    ..} = (\Maybe E'Kind
    bigCatKind -> BigCat { Maybe E'Kind
    bigCatKind :: Maybe E'Kind
    bigCatKind :: Maybe E'Kind
    bigCatKind, Maybe Bool
    Maybe Text
    Text
    bigCatClassName :: Text
    bigCatColor :: Maybe Text
    bigCatDeclawed :: Maybe Bool
    bigCatClassName :: Text
    bigCatColor :: Maybe Text
    bigCatDeclawed :: Maybe Bool
    ..} ) (Maybe E'Kind -> BigCat) -> f (Maybe E'Kind) -> f BigCat
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe E'Kind -> f (Maybe E'Kind)
    f Maybe E'Kind
    bigCatKind
    {-# INLINE bigCatKindL #-}

    -- * Capitalization

    -- | 'capitalizationSmallCamel' Lens
    capitalizationSmallCamelL :: Lens_' Capitalization (Maybe Text)
    capitalizationSmallCamelL :: Lens_' Capitalization (Maybe Text)
    capitalizationSmallCamelL Maybe Text -> f (Maybe Text)
    f Capitalization{Maybe Text
    capitalizationSmallCamel :: Capitalization -> Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationAttName :: Maybe Text
    capitalizationCapitalCamel :: Capitalization -> Maybe Text
    capitalizationSmallSnake :: Capitalization -> Maybe Text
    capitalizationCapitalSnake :: Capitalization -> Maybe Text
    capitalizationScaEthFlowPoints :: Capitalization -> Maybe Text
    capitalizationAttName :: Capitalization -> Maybe Text
    ..} = (\Maybe Text
    capitalizationSmallCamel -> Capitalization { Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationSmallCamel, Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationAttName :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationAttName :: Maybe Text
    ..} ) (Maybe Text -> Capitalization)
    -> f (Maybe Text) -> f Capitalization
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    capitalizationSmallCamel
    {-# INLINE capitalizationSmallCamelL #-}

    -- | 'capitalizationCapitalCamel' Lens
    capitalizationCapitalCamelL :: Lens_' Capitalization (Maybe Text)
    capitalizationCapitalCamelL :: Lens_' Capitalization (Maybe Text)
    capitalizationCapitalCamelL Maybe Text -> f (Maybe Text)
    f Capitalization{Maybe Text
    capitalizationSmallCamel :: Capitalization -> Maybe Text
    capitalizationCapitalCamel :: Capitalization -> Maybe Text
    capitalizationSmallSnake :: Capitalization -> Maybe Text
    capitalizationCapitalSnake :: Capitalization -> Maybe Text
    capitalizationScaEthFlowPoints :: Capitalization -> Maybe Text
    capitalizationAttName :: Capitalization -> Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationAttName :: Maybe Text
    ..} = (\Maybe Text
    capitalizationCapitalCamel -> Capitalization { Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationCapitalCamel, Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationAttName :: Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationAttName :: Maybe Text
    ..} ) (Maybe Text -> Capitalization)
    -> f (Maybe Text) -> f Capitalization
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    capitalizationCapitalCamel
    {-# INLINE capitalizationCapitalCamelL #-}

    -- | 'capitalizationSmallSnake' Lens
    capitalizationSmallSnakeL :: Lens_' Capitalization (Maybe Text)
    capitalizationSmallSnakeL :: Lens_' Capitalization (Maybe Text)
    capitalizationSmallSnakeL Maybe Text -> f (Maybe Text)
    f Capitalization{Maybe Text
    capitalizationSmallCamel :: Capitalization -> Maybe Text
    capitalizationCapitalCamel :: Capitalization -> Maybe Text
    capitalizationSmallSnake :: Capitalization -> Maybe Text
    capitalizationCapitalSnake :: Capitalization -> Maybe Text
    capitalizationScaEthFlowPoints :: Capitalization -> Maybe Text
    capitalizationAttName :: Capitalization -> Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationAttName :: Maybe Text
    ..} = (\Maybe Text
    capitalizationSmallSnake -> Capitalization { Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationSmallSnake, Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationAttName :: Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationAttName :: Maybe Text
    ..} ) (Maybe Text -> Capitalization)
    -> f (Maybe Text) -> f Capitalization
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    capitalizationSmallSnake
    {-# INLINE capitalizationSmallSnakeL #-}

    -- | 'capitalizationCapitalSnake' Lens
    capitalizationCapitalSnakeL :: Lens_' Capitalization (Maybe Text)
    capitalizationCapitalSnakeL :: Lens_' Capitalization (Maybe Text)
    capitalizationCapitalSnakeL Maybe Text -> f (Maybe Text)
    f Capitalization{Maybe Text
    capitalizationSmallCamel :: Capitalization -> Maybe Text
    capitalizationCapitalCamel :: Capitalization -> Maybe Text
    capitalizationSmallSnake :: Capitalization -> Maybe Text
    capitalizationCapitalSnake :: Capitalization -> Maybe Text
    capitalizationScaEthFlowPoints :: Capitalization -> Maybe Text
    capitalizationAttName :: Capitalization -> Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationAttName :: Maybe Text
    ..} = (\Maybe Text
    capitalizationCapitalSnake -> Capitalization { Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationCapitalSnake, Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationAttName :: Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationAttName :: Maybe Text
    ..} ) (Maybe Text -> Capitalization)
    -> f (Maybe Text) -> f Capitalization
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    capitalizationCapitalSnake
    {-# INLINE capitalizationCapitalSnakeL #-}

    -- | 'capitalizationScaEthFlowPoints' Lens
    capitalizationScaEthFlowPointsL :: Lens_' Capitalization (Maybe Text)
    capitalizationScaEthFlowPointsL :: Lens_' Capitalization (Maybe Text)
    capitalizationScaEthFlowPointsL Maybe Text -> f (Maybe Text)
    f Capitalization{Maybe Text
    capitalizationSmallCamel :: Capitalization -> Maybe Text
    capitalizationCapitalCamel :: Capitalization -> Maybe Text
    capitalizationSmallSnake :: Capitalization -> Maybe Text
    capitalizationCapitalSnake :: Capitalization -> Maybe Text
    capitalizationScaEthFlowPoints :: Capitalization -> Maybe Text
    capitalizationAttName :: Capitalization -> Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationAttName :: Maybe Text
    ..} = (\Maybe Text
    capitalizationScaEthFlowPoints -> Capitalization { Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationScaEthFlowPoints, Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationAttName :: Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationAttName :: Maybe Text
    ..} ) (Maybe Text -> Capitalization)
    -> f (Maybe Text) -> f Capitalization
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    capitalizationScaEthFlowPoints
    {-# INLINE capitalizationScaEthFlowPointsL #-}

    -- | 'capitalizationAttName' Lens
    capitalizationAttNameL :: Lens_' Capitalization (Maybe Text)
    capitalizationAttNameL :: Lens_' Capitalization (Maybe Text)
    capitalizationAttNameL Maybe Text -> f (Maybe Text)
    f Capitalization{Maybe Text
    capitalizationSmallCamel :: Capitalization -> Maybe Text
    capitalizationCapitalCamel :: Capitalization -> Maybe Text
    capitalizationSmallSnake :: Capitalization -> Maybe Text
    capitalizationCapitalSnake :: Capitalization -> Maybe Text
    capitalizationScaEthFlowPoints :: Capitalization -> Maybe Text
    capitalizationAttName :: Capitalization -> Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationAttName :: Maybe Text
    ..} = (\Maybe Text
    capitalizationAttName -> Capitalization { Maybe Text
    capitalizationAttName :: Maybe Text
    capitalizationAttName :: Maybe Text
    capitalizationAttName, Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    ..} ) (Maybe Text -> Capitalization)
    -> f (Maybe Text) -> f Capitalization
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    capitalizationAttName
    {-# INLINE capitalizationAttNameL #-}

    -- * Cat

    -- | 'catClassName' Lens
    catClassNameL :: Lens_' Cat (Text)
    catClassNameL :: Lens_' Cat Text
    catClassNameL Text -> f Text
    f Cat{Maybe Bool
    Maybe Text
    Text
    catClassName :: Cat -> Text
    catClassName :: Text
    catColor :: Maybe Text
    catDeclawed :: Maybe Bool
    catColor :: Cat -> Maybe Text
    catDeclawed :: Cat -> Maybe Bool
    ..} = (\Text
    catClassName -> Cat { Text
    catClassName :: Text
    catClassName :: Text
    catClassName, Maybe Bool
    Maybe Text
    catColor :: Maybe Text
    catDeclawed :: Maybe Bool
    catColor :: Maybe Text
    catDeclawed :: Maybe Bool
    ..} ) (Text -> Cat) -> f Text -> f Cat
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text -> f Text
    f Text
    catClassName
    {-# INLINE catClassNameL #-}

    -- | 'catColor' Lens
    catColorL :: Lens_' Cat (Maybe Text)
    catColorL :: Lens_' Cat (Maybe Text)
    catColorL Maybe Text -> f (Maybe Text)
    f Cat{Maybe Bool
    Maybe Text
    Text
    catClassName :: Cat -> Text
    catColor :: Cat -> Maybe Text
    catDeclawed :: Cat -> Maybe Bool
    catClassName :: Text
    catColor :: Maybe Text
    catDeclawed :: Maybe Bool
    ..} = (\Maybe Text
    catColor -> Cat { Maybe Text
    catColor :: Maybe Text
    catColor :: Maybe Text
    catColor, Maybe Bool
    Text
    catClassName :: Text
    catDeclawed :: Maybe Bool
    catClassName :: Text
    catDeclawed :: Maybe Bool
    ..} ) (Maybe Text -> Cat) -> f (Maybe Text) -> f Cat
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    catColor
    {-# INLINE catColorL #-}

    -- | 'catDeclawed' Lens
    catDeclawedL :: Lens_' Cat (Maybe Bool)
    catDeclawedL :: Lens_' Cat (Maybe Bool)
    catDeclawedL Maybe Bool -> f (Maybe Bool)
    f Cat{Maybe Bool
    Maybe Text
    Text
    catClassName :: Cat -> Text
    catColor :: Cat -> Maybe Text
    catDeclawed :: Cat -> Maybe Bool
    catClassName :: Text
    catColor :: Maybe Text
    catDeclawed :: Maybe Bool
    ..} = (\Maybe Bool
    catDeclawed -> Cat { Maybe Bool
    catDeclawed :: Maybe Bool
    catDeclawed :: Maybe Bool
    catDeclawed, Maybe Text
    Text
    catClassName :: Text
    catColor :: Maybe Text
    catClassName :: Text
    catColor :: Maybe Text
    ..} ) (Maybe Bool -> Cat) -> f (Maybe Bool) -> f Cat
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Bool -> f (Maybe Bool)
    f Maybe Bool
    catDeclawed
    {-# INLINE catDeclawedL #-}

    -- * Category

    -- | 'categoryId' Lens
    categoryIdL :: Lens_' Category (Maybe Integer)
    categoryIdL :: Lens_' Category (Maybe Integer)
    categoryIdL Maybe Integer -> f (Maybe Integer)
    f Category{Maybe Integer
    Text
    categoryId :: Category -> Maybe Integer
    categoryId :: Maybe Integer
    categoryName :: Text
    categoryName :: Category -> Text
    ..} = (\Maybe Integer
    categoryId -> Category { Maybe Integer
    categoryId :: Maybe Integer
    categoryId :: Maybe Integer
    categoryId, Text
    categoryName :: Text
    categoryName :: Text
    ..} ) (Maybe Integer -> Category) -> f (Maybe Integer) -> f Category
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Integer -> f (Maybe Integer)
    f Maybe Integer
    categoryId
    {-# INLINE categoryIdL #-}

    -- | 'categoryName' Lens
    categoryNameL :: Lens_' Category (Text)
    categoryNameL :: Lens_' Category Text
    categoryNameL Text -> f Text
    f Category{Maybe Integer
    Text
    categoryId :: Category -> Maybe Integer
    categoryName :: Category -> Text
    categoryId :: Maybe Integer
    categoryName :: Text
    ..} = (\Text
    categoryName -> Category { Text
    categoryName :: Text
    categoryName :: Text
    categoryName, Maybe Integer
    categoryId :: Maybe Integer
    categoryId :: Maybe Integer
    ..} ) (Text -> Category) -> f Text -> f Category
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text -> f Text
    f Text
    categoryName
    {-# INLINE categoryNameL #-}

    -- * ClassModel

    -- | 'classModelClass' Lens
    classModelClassL :: Lens_' ClassModel (Maybe Text)
    classModelClassL :: Lens_' ClassModel (Maybe Text)
    classModelClassL Maybe Text -> f (Maybe Text)
    f ClassModel{Maybe Text
    classModelClass :: ClassModel -> Maybe Text
    classModelClass :: Maybe Text
    ..} = (\Maybe Text
    classModelClass -> ClassModel { Maybe Text
    classModelClass :: Maybe Text
    classModelClass :: Maybe Text
    classModelClass, ..} ) (Maybe Text -> ClassModel) -> f (Maybe Text) -> f ClassModel
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    classModelClass
    {-# INLINE classModelClassL #-}

    -- * Client

    -- | 'clientClient' Lens
    clientClientL :: Lens_' Client (Maybe Text)
    clientClientL :: Lens_' Client (Maybe Text)
    clientClientL Maybe Text -> f (Maybe Text)
    f Client{Maybe Text
    clientClient :: Client -> Maybe Text
    clientClient :: Maybe Text
    ..} = (\Maybe Text
    clientClient -> Client { Maybe Text
    clientClient :: Maybe Text
    clientClient :: Maybe Text
    clientClient, ..} ) (Maybe Text -> Client) -> f (Maybe Text) -> f Client
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    clientClient
    {-# INLINE clientClientL #-}

    -- * Dog

    -- | 'dogClassName' Lens
    dogClassNameL :: Lens_' Dog (Text)
    dogClassNameL :: Lens_' Dog Text
    dogClassNameL Text -> f Text
    f Dog{Maybe Text
    Text
    dogClassName :: Dog -> Text
    dogClassName :: Text
    dogColor :: Maybe Text
    dogBreed :: Maybe Text
    dogColor :: Dog -> Maybe Text
    dogBreed :: Dog -> Maybe Text
    ..} = (\Text
    dogClassName -> Dog { Text
    dogClassName :: Text
    dogClassName :: Text
    dogClassName, Maybe Text
    dogColor :: Maybe Text
    dogBreed :: Maybe Text
    dogColor :: Maybe Text
    dogBreed :: Maybe Text
    ..} ) (Text -> Dog) -> f Text -> f Dog
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text -> f Text
    f Text
    dogClassName
    {-# INLINE dogClassNameL #-}

    -- | 'dogColor' Lens
    dogColorL :: Lens_' Dog (Maybe Text)
    dogColorL :: Lens_' Dog (Maybe Text)
    dogColorL Maybe Text -> f (Maybe Text)
    f Dog{Maybe Text
    Text
    dogClassName :: Dog -> Text
    dogColor :: Dog -> Maybe Text
    dogBreed :: Dog -> Maybe Text
    dogClassName :: Text
    dogColor :: Maybe Text
    dogBreed :: Maybe Text
    ..} = (\Maybe Text
    dogColor -> Dog { Maybe Text
    dogColor :: Maybe Text
    dogColor :: Maybe Text
    dogColor, Maybe Text
    Text
    dogClassName :: Text
    dogBreed :: Maybe Text
    dogClassName :: Text
    dogBreed :: Maybe Text
    ..} ) (Maybe Text -> Dog) -> f (Maybe Text) -> f Dog
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    dogColor
    {-# INLINE dogColorL #-}

    -- | 'dogBreed' Lens
    dogBreedL :: Lens_' Dog (Maybe Text)
    dogBreedL :: Lens_' Dog (Maybe Text)
    dogBreedL Maybe Text -> f (Maybe Text)
    f Dog{Maybe Text
    Text
    dogClassName :: Dog -> Text
    dogColor :: Dog -> Maybe Text
    dogBreed :: Dog -> Maybe Text
    dogClassName :: Text
    dogColor :: Maybe Text
    dogBreed :: Maybe Text
    ..} = (\Maybe Text
    dogBreed -> Dog { Maybe Text
    dogBreed :: Maybe Text
    dogBreed :: Maybe Text
    dogBreed, Maybe Text
    Text
    dogClassName :: Text
    dogColor :: Maybe Text
    dogClassName :: Text
    dogColor :: Maybe Text
    ..} ) (Maybe Text -> Dog) -> f (Maybe Text) -> f Dog
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    dogBreed
    {-# INLINE dogBreedL #-}

    -- * EnumArrays

    -- | 'enumArraysJustSymbol' Lens
    enumArraysJustSymbolL :: Lens_' EnumArrays (Maybe E'JustSymbol)
    enumArraysJustSymbolL :: Lens_' EnumArrays (Maybe E'JustSymbol)
    enumArraysJustSymbolL Maybe E'JustSymbol -> f (Maybe E'JustSymbol)
    f EnumArrays{Maybe [E'ArrayEnum]
    Maybe E'JustSymbol
    enumArraysJustSymbol :: EnumArrays -> Maybe E'JustSymbol
    enumArraysJustSymbol :: Maybe E'JustSymbol
    enumArraysArrayEnum :: Maybe [E'ArrayEnum]
    enumArraysArrayEnum :: EnumArrays -> Maybe [E'ArrayEnum]
    ..} = (\Maybe E'JustSymbol
    enumArraysJustSymbol -> EnumArrays { Maybe E'JustSymbol
    enumArraysJustSymbol :: Maybe E'JustSymbol
    enumArraysJustSymbol :: Maybe E'JustSymbol
    enumArraysJustSymbol, Maybe [E'ArrayEnum]
    enumArraysArrayEnum :: Maybe [E'ArrayEnum]
    enumArraysArrayEnum :: Maybe [E'ArrayEnum]
    ..} ) (Maybe E'JustSymbol -> EnumArrays)
    -> f (Maybe E'JustSymbol) -> f EnumArrays
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe E'JustSymbol -> f (Maybe E'JustSymbol)
    f Maybe E'JustSymbol
    enumArraysJustSymbol
    {-# INLINE enumArraysJustSymbolL #-}

    -- | 'enumArraysArrayEnum' Lens
    enumArraysArrayEnumL :: Lens_' EnumArrays (Maybe [E'ArrayEnum])
    enumArraysArrayEnumL :: Lens_' EnumArrays (Maybe [E'ArrayEnum])
    enumArraysArrayEnumL Maybe [E'ArrayEnum] -> f (Maybe [E'ArrayEnum])
    f EnumArrays{Maybe [E'ArrayEnum]
    Maybe E'JustSymbol
    enumArraysJustSymbol :: EnumArrays -> Maybe E'JustSymbol
    enumArraysArrayEnum :: EnumArrays -> Maybe [E'ArrayEnum]
    enumArraysJustSymbol :: Maybe E'JustSymbol
    enumArraysArrayEnum :: Maybe [E'ArrayEnum]
    ..} = (\Maybe [E'ArrayEnum]
    enumArraysArrayEnum -> EnumArrays { Maybe [E'ArrayEnum]
    enumArraysArrayEnum :: Maybe [E'ArrayEnum]
    enumArraysArrayEnum :: Maybe [E'ArrayEnum]
    enumArraysArrayEnum, Maybe E'JustSymbol
    enumArraysJustSymbol :: Maybe E'JustSymbol
    enumArraysJustSymbol :: Maybe E'JustSymbol
    ..} ) (Maybe [E'ArrayEnum] -> EnumArrays)
    -> f (Maybe [E'ArrayEnum]) -> f EnumArrays
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [E'ArrayEnum] -> f (Maybe [E'ArrayEnum])
    f Maybe [E'ArrayEnum]
    enumArraysArrayEnum
    {-# INLINE enumArraysArrayEnumL #-}

    -- * EnumClass

    -- * EnumTest

    -- | 'enumTestEnumString' Lens
    enumTestEnumStringL :: Lens_' EnumTest (Maybe E'EnumString)
    enumTestEnumStringL :: Lens_' EnumTest (Maybe E'EnumString)
    enumTestEnumStringL Maybe E'EnumString -> f (Maybe E'EnumString)
    f EnumTest{Maybe OuterEnum
    Maybe E'EnumString
    Maybe E'EnumNumber
    Maybe E'EnumInteger
    E'EnumString
    enumTestEnumString :: EnumTest -> Maybe E'EnumString
    enumTestEnumString :: Maybe E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestEnumNumber :: Maybe E'EnumNumber
    enumTestOuterEnum :: Maybe OuterEnum
    enumTestEnumStringRequired :: EnumTest -> E'EnumString
    enumTestEnumInteger :: EnumTest -> Maybe E'EnumInteger
    enumTestEnumNumber :: EnumTest -> Maybe E'EnumNumber
    enumTestOuterEnum :: EnumTest -> Maybe OuterEnum
    ..} = (\Maybe E'EnumString
    enumTestEnumString -> EnumTest { Maybe E'EnumString
    enumTestEnumString :: Maybe E'EnumString
    enumTestEnumString :: Maybe E'EnumString
    enumTestEnumString, Maybe OuterEnum
    Maybe E'EnumNumber
    Maybe E'EnumInteger
    E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestEnumNumber :: Maybe E'EnumNumber
    enumTestOuterEnum :: Maybe OuterEnum
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestEnumNumber :: Maybe E'EnumNumber
    enumTestOuterEnum :: Maybe OuterEnum
    ..} ) (Maybe E'EnumString -> EnumTest)
    -> f (Maybe E'EnumString) -> f EnumTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe E'EnumString -> f (Maybe E'EnumString)
    f Maybe E'EnumString
    enumTestEnumString
    {-# INLINE enumTestEnumStringL #-}

    -- | 'enumTestEnumStringRequired' Lens
    enumTestEnumStringRequiredL :: Lens_' EnumTest (E'EnumString)
    enumTestEnumStringRequiredL :: Lens_' EnumTest E'EnumString
    enumTestEnumStringRequiredL E'EnumString -> f E'EnumString
    f EnumTest{Maybe OuterEnum
    Maybe E'EnumString
    Maybe E'EnumNumber
    Maybe E'EnumInteger
    E'EnumString
    enumTestEnumString :: EnumTest -> Maybe E'EnumString
    enumTestEnumStringRequired :: EnumTest -> E'EnumString
    enumTestEnumInteger :: EnumTest -> Maybe E'EnumInteger
    enumTestEnumNumber :: EnumTest -> Maybe E'EnumNumber
    enumTestOuterEnum :: EnumTest -> Maybe OuterEnum
    enumTestEnumString :: Maybe E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestEnumNumber :: Maybe E'EnumNumber
    enumTestOuterEnum :: Maybe OuterEnum
    ..} = (\E'EnumString
    enumTestEnumStringRequired -> EnumTest { E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumStringRequired, Maybe OuterEnum
    Maybe E'EnumString
    Maybe E'EnumNumber
    Maybe E'EnumInteger
    enumTestEnumString :: Maybe E'EnumString
    enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestEnumNumber :: Maybe E'EnumNumber
    enumTestOuterEnum :: Maybe OuterEnum
    enumTestEnumString :: Maybe E'EnumString
    enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestEnumNumber :: Maybe E'EnumNumber
    enumTestOuterEnum :: Maybe OuterEnum
    ..} ) (E'EnumString -> EnumTest) -> f E'EnumString -> f EnumTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> E'EnumString -> f E'EnumString
    f E'EnumString
    enumTestEnumStringRequired
    {-# INLINE enumTestEnumStringRequiredL #-}

    -- | 'enumTestEnumInteger' Lens
    enumTestEnumIntegerL :: Lens_' EnumTest (Maybe E'EnumInteger)
    enumTestEnumIntegerL :: Lens_' EnumTest (Maybe E'EnumInteger)
    enumTestEnumIntegerL Maybe E'EnumInteger -> f (Maybe E'EnumInteger)
    f EnumTest{Maybe OuterEnum
    Maybe E'EnumString
    Maybe E'EnumNumber
    Maybe E'EnumInteger
    E'EnumString
    enumTestEnumString :: EnumTest -> Maybe E'EnumString
    enumTestEnumStringRequired :: EnumTest -> E'EnumString
    enumTestEnumInteger :: EnumTest -> Maybe E'EnumInteger
    enumTestEnumNumber :: EnumTest -> Maybe E'EnumNumber
    enumTestOuterEnum :: EnumTest -> Maybe OuterEnum
    enumTestEnumString :: Maybe E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestEnumNumber :: Maybe E'EnumNumber
    enumTestOuterEnum :: Maybe OuterEnum
    ..} = (\Maybe E'EnumInteger
    enumTestEnumInteger -> EnumTest { Maybe E'EnumInteger
    enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestEnumInteger, Maybe OuterEnum
    Maybe E'EnumString
    Maybe E'EnumNumber
    E'EnumString
    enumTestEnumString :: Maybe E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumNumber :: Maybe E'EnumNumber
    enumTestOuterEnum :: Maybe OuterEnum
    enumTestEnumString :: Maybe E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumNumber :: Maybe E'EnumNumber
    enumTestOuterEnum :: Maybe OuterEnum
    ..} ) (Maybe E'EnumInteger -> EnumTest)
    -> f (Maybe E'EnumInteger) -> f EnumTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe E'EnumInteger -> f (Maybe E'EnumInteger)
    f Maybe E'EnumInteger
    enumTestEnumInteger
    {-# INLINE enumTestEnumIntegerL #-}

    -- | 'enumTestEnumNumber' Lens
    enumTestEnumNumberL :: Lens_' EnumTest (Maybe E'EnumNumber)
    enumTestEnumNumberL :: Lens_' EnumTest (Maybe E'EnumNumber)
    enumTestEnumNumberL Maybe E'EnumNumber -> f (Maybe E'EnumNumber)
    f EnumTest{Maybe OuterEnum
    Maybe E'EnumString
    Maybe E'EnumNumber
    Maybe E'EnumInteger
    E'EnumString
    enumTestEnumString :: EnumTest -> Maybe E'EnumString
    enumTestEnumStringRequired :: EnumTest -> E'EnumString
    enumTestEnumInteger :: EnumTest -> Maybe E'EnumInteger
    enumTestEnumNumber :: EnumTest -> Maybe E'EnumNumber
    enumTestOuterEnum :: EnumTest -> Maybe OuterEnum
    enumTestEnumString :: Maybe E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestEnumNumber :: Maybe E'EnumNumber
    enumTestOuterEnum :: Maybe OuterEnum
    ..} = (\Maybe E'EnumNumber
    enumTestEnumNumber -> EnumTest { Maybe E'EnumNumber
    enumTestEnumNumber :: Maybe E'EnumNumber
    enumTestEnumNumber :: Maybe E'EnumNumber
    enumTestEnumNumber, Maybe OuterEnum
    Maybe E'EnumString
    Maybe E'EnumInteger
    E'EnumString
    enumTestEnumString :: Maybe E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestOuterEnum :: Maybe OuterEnum
    enumTestEnumString :: Maybe E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestOuterEnum :: Maybe OuterEnum
    ..} ) (Maybe E'EnumNumber -> EnumTest)
    -> f (Maybe E'EnumNumber) -> f EnumTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe E'EnumNumber -> f (Maybe E'EnumNumber)
    f Maybe E'EnumNumber
    enumTestEnumNumber
    {-# INLINE enumTestEnumNumberL #-}

    -- | 'enumTestOuterEnum' Lens
    enumTestOuterEnumL :: Lens_' EnumTest (Maybe OuterEnum)
    enumTestOuterEnumL :: Lens_' EnumTest (Maybe OuterEnum)
    enumTestOuterEnumL Maybe OuterEnum -> f (Maybe OuterEnum)
    f EnumTest{Maybe OuterEnum
    Maybe E'EnumString
    Maybe E'EnumNumber
    Maybe E'EnumInteger
    E'EnumString
    enumTestEnumString :: EnumTest -> Maybe E'EnumString
    enumTestEnumStringRequired :: EnumTest -> E'EnumString
    enumTestEnumInteger :: EnumTest -> Maybe E'EnumInteger
    enumTestEnumNumber :: EnumTest -> Maybe E'EnumNumber
    enumTestOuterEnum :: EnumTest -> Maybe OuterEnum
    enumTestEnumString :: Maybe E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestEnumNumber :: Maybe E'EnumNumber
    enumTestOuterEnum :: Maybe OuterEnum
    ..} = (\Maybe OuterEnum
    enumTestOuterEnum -> EnumTest { Maybe OuterEnum
    enumTestOuterEnum :: Maybe OuterEnum
    enumTestOuterEnum :: Maybe OuterEnum
    enumTestOuterEnum, Maybe E'EnumString
    Maybe E'EnumNumber
    Maybe E'EnumInteger
    E'EnumString
    enumTestEnumString :: Maybe E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestEnumNumber :: Maybe E'EnumNumber
    enumTestEnumString :: Maybe E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestEnumNumber :: Maybe E'EnumNumber
    ..} ) (Maybe OuterEnum -> EnumTest) -> f (Maybe OuterEnum) -> f EnumTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe OuterEnum -> f (Maybe OuterEnum)
    f Maybe OuterEnum
    enumTestOuterEnum
    {-# INLINE enumTestOuterEnumL #-}

    -- * File

    -- | 'fileSourceUri' Lens
    fileSourceUriL :: Lens_' File (Maybe Text)
    fileSourceUriL :: Lens_' File (Maybe Text)
    fileSourceUriL Maybe Text -> f (Maybe Text)
    f File{Maybe Text
    fileSourceUri :: File -> Maybe Text
    fileSourceUri :: Maybe Text
    ..} = (\Maybe Text
    fileSourceUri -> File { Maybe Text
    fileSourceUri :: Maybe Text
    fileSourceUri :: Maybe Text
    fileSourceUri, ..} ) (Maybe Text -> File) -> f (Maybe Text) -> f File
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    fileSourceUri
    {-# INLINE fileSourceUriL #-}

    -- * FileSchemaTestClass

    -- | 'fileSchemaTestClassFile' Lens
    fileSchemaTestClassFileL :: Lens_' FileSchemaTestClass (Maybe File)
    fileSchemaTestClassFileL :: Lens_' FileSchemaTestClass (Maybe File)
    fileSchemaTestClassFileL Maybe File -> f (Maybe File)
    f FileSchemaTestClass{Maybe [File]
    Maybe File
    fileSchemaTestClassFile :: FileSchemaTestClass -> Maybe File
    fileSchemaTestClassFile :: Maybe File
    fileSchemaTestClassFiles :: Maybe [File]
    fileSchemaTestClassFiles :: FileSchemaTestClass -> Maybe [File]
    ..} = (\Maybe File
    fileSchemaTestClassFile -> FileSchemaTestClass { Maybe File
    fileSchemaTestClassFile :: Maybe File
    fileSchemaTestClassFile :: Maybe File
    fileSchemaTestClassFile, Maybe [File]
    fileSchemaTestClassFiles :: Maybe [File]
    fileSchemaTestClassFiles :: Maybe [File]
    ..} ) (Maybe File -> FileSchemaTestClass)
    -> f (Maybe File) -> f FileSchemaTestClass
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe File -> f (Maybe File)
    f Maybe File
    fileSchemaTestClassFile
    {-# INLINE fileSchemaTestClassFileL #-}

    -- | 'fileSchemaTestClassFiles' Lens
    fileSchemaTestClassFilesL :: Lens_' FileSchemaTestClass (Maybe [File])
    fileSchemaTestClassFilesL :: Lens_' FileSchemaTestClass (Maybe [File])
    fileSchemaTestClassFilesL Maybe [File] -> f (Maybe [File])
    f FileSchemaTestClass{Maybe [File]
    Maybe File
    fileSchemaTestClassFile :: FileSchemaTestClass -> Maybe File
    fileSchemaTestClassFiles :: FileSchemaTestClass -> Maybe [File]
    fileSchemaTestClassFile :: Maybe File
    fileSchemaTestClassFiles :: Maybe [File]
    ..} = (\Maybe [File]
    fileSchemaTestClassFiles -> FileSchemaTestClass { Maybe [File]
    fileSchemaTestClassFiles :: Maybe [File]
    fileSchemaTestClassFiles :: Maybe [File]
    fileSchemaTestClassFiles, Maybe File
    fileSchemaTestClassFile :: Maybe File
    fileSchemaTestClassFile :: Maybe File
    ..} ) (Maybe [File] -> FileSchemaTestClass)
    -> f (Maybe [File]) -> f FileSchemaTestClass
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [File] -> f (Maybe [File])
    f Maybe [File]
    fileSchemaTestClassFiles
    {-# INLINE fileSchemaTestClassFilesL #-}

    -- * FormatTest

    -- | 'formatTestInteger' Lens
    formatTestIntegerL :: Lens_' FormatTest (Maybe Int)
    formatTestIntegerL :: Lens_' FormatTest (Maybe Int)
    formatTestIntegerL Maybe Int -> f (Maybe Int)
    f FormatTest{Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: FormatTest -> Maybe Int
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    formatTestInt32 :: FormatTest -> Maybe Int
    formatTestInt64 :: FormatTest -> Maybe Integer
    formatTestNumber :: FormatTest -> Double
    formatTestFloat :: FormatTest -> Maybe Float
    formatTestDouble :: FormatTest -> Maybe Double
    formatTestString :: FormatTest -> Maybe Text
    formatTestByte :: FormatTest -> ByteArray
    formatTestBinary :: FormatTest -> Maybe String
    formatTestDate :: FormatTest -> Date
    formatTestDateTime :: FormatTest -> Maybe DateTime
    formatTestUuid :: FormatTest -> Maybe Text
    formatTestPassword :: FormatTest -> Text
    formatTestBigDecimal :: FormatTest -> Maybe Double
    ..} = (\Maybe Int
    formatTestInteger -> FormatTest { Maybe Int
    formatTestInteger :: Maybe Int
    formatTestInteger :: Maybe Int
    formatTestInteger, Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} ) (Maybe Int -> FormatTest) -> f (Maybe Int) -> f FormatTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Int -> f (Maybe Int)
    f Maybe Int
    formatTestInteger
    {-# INLINE formatTestIntegerL #-}

    -- | 'formatTestInt32' Lens
    formatTestInt32L :: Lens_' FormatTest (Maybe Int)
    formatTestInt32L :: Lens_' FormatTest (Maybe Int)
    formatTestInt32L Maybe Int -> f (Maybe Int)
    f FormatTest{Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: FormatTest -> Maybe Int
    formatTestInt32 :: FormatTest -> Maybe Int
    formatTestInt64 :: FormatTest -> Maybe Integer
    formatTestNumber :: FormatTest -> Double
    formatTestFloat :: FormatTest -> Maybe Float
    formatTestDouble :: FormatTest -> Maybe Double
    formatTestString :: FormatTest -> Maybe Text
    formatTestByte :: FormatTest -> ByteArray
    formatTestBinary :: FormatTest -> Maybe String
    formatTestDate :: FormatTest -> Date
    formatTestDateTime :: FormatTest -> Maybe DateTime
    formatTestUuid :: FormatTest -> Maybe Text
    formatTestPassword :: FormatTest -> Text
    formatTestBigDecimal :: FormatTest -> Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} = (\Maybe Int
    formatTestInt32 -> FormatTest { Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt32, Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} ) (Maybe Int -> FormatTest) -> f (Maybe Int) -> f FormatTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Int -> f (Maybe Int)
    f Maybe Int
    formatTestInt32
    {-# INLINE formatTestInt32L #-}

    -- | 'formatTestInt64' Lens
    formatTestInt64L :: Lens_' FormatTest (Maybe Integer)
    formatTestInt64L :: Lens_' FormatTest (Maybe Integer)
    formatTestInt64L Maybe Integer -> f (Maybe Integer)
    f FormatTest{Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: FormatTest -> Maybe Int
    formatTestInt32 :: FormatTest -> Maybe Int
    formatTestInt64 :: FormatTest -> Maybe Integer
    formatTestNumber :: FormatTest -> Double
    formatTestFloat :: FormatTest -> Maybe Float
    formatTestDouble :: FormatTest -> Maybe Double
    formatTestString :: FormatTest -> Maybe Text
    formatTestByte :: FormatTest -> ByteArray
    formatTestBinary :: FormatTest -> Maybe String
    formatTestDate :: FormatTest -> Date
    formatTestDateTime :: FormatTest -> Maybe DateTime
    formatTestUuid :: FormatTest -> Maybe Text
    formatTestPassword :: FormatTest -> Text
    formatTestBigDecimal :: FormatTest -> Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} = (\Maybe Integer
    formatTestInt64 -> FormatTest { Maybe Integer
    formatTestInt64 :: Maybe Integer
    formatTestInt64 :: Maybe Integer
    formatTestInt64, Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} ) (Maybe Integer -> FormatTest) -> f (Maybe Integer) -> f FormatTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Integer -> f (Maybe Integer)
    f Maybe Integer
    formatTestInt64
    {-# INLINE formatTestInt64L #-}

    -- | 'formatTestNumber' Lens
    formatTestNumberL :: Lens_' FormatTest (Double)
    formatTestNumberL :: Lens_' FormatTest Double
    formatTestNumberL Double -> f Double
    f FormatTest{Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: FormatTest -> Maybe Int
    formatTestInt32 :: FormatTest -> Maybe Int
    formatTestInt64 :: FormatTest -> Maybe Integer
    formatTestNumber :: FormatTest -> Double
    formatTestFloat :: FormatTest -> Maybe Float
    formatTestDouble :: FormatTest -> Maybe Double
    formatTestString :: FormatTest -> Maybe Text
    formatTestByte :: FormatTest -> ByteArray
    formatTestBinary :: FormatTest -> Maybe String
    formatTestDate :: FormatTest -> Date
    formatTestDateTime :: FormatTest -> Maybe DateTime
    formatTestUuid :: FormatTest -> Maybe Text
    formatTestPassword :: FormatTest -> Text
    formatTestBigDecimal :: FormatTest -> Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} = (\Double
    formatTestNumber -> FormatTest { Double
    formatTestNumber :: Double
    formatTestNumber :: Double
    formatTestNumber, Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} ) (Double -> FormatTest) -> f Double -> f FormatTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Double -> f Double
    f Double
    formatTestNumber
    {-# INLINE formatTestNumberL #-}

    -- | 'formatTestFloat' Lens
    formatTestFloatL :: Lens_' FormatTest (Maybe Float)
    formatTestFloatL :: Lens_' FormatTest (Maybe Float)
    formatTestFloatL Maybe Float -> f (Maybe Float)
    f FormatTest{Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: FormatTest -> Maybe Int
    formatTestInt32 :: FormatTest -> Maybe Int
    formatTestInt64 :: FormatTest -> Maybe Integer
    formatTestNumber :: FormatTest -> Double
    formatTestFloat :: FormatTest -> Maybe Float
    formatTestDouble :: FormatTest -> Maybe Double
    formatTestString :: FormatTest -> Maybe Text
    formatTestByte :: FormatTest -> ByteArray
    formatTestBinary :: FormatTest -> Maybe String
    formatTestDate :: FormatTest -> Date
    formatTestDateTime :: FormatTest -> Maybe DateTime
    formatTestUuid :: FormatTest -> Maybe Text
    formatTestPassword :: FormatTest -> Text
    formatTestBigDecimal :: FormatTest -> Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} = (\Maybe Float
    formatTestFloat -> FormatTest { Maybe Float
    formatTestFloat :: Maybe Float
    formatTestFloat :: Maybe Float
    formatTestFloat, Double
    Maybe Double
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} ) (Maybe Float -> FormatTest) -> f (Maybe Float) -> f FormatTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Float -> f (Maybe Float)
    f Maybe Float
    formatTestFloat
    {-# INLINE formatTestFloatL #-}

    -- | 'formatTestDouble' Lens
    formatTestDoubleL :: Lens_' FormatTest (Maybe Double)
    formatTestDoubleL :: Lens_' FormatTest (Maybe Double)
    formatTestDoubleL Maybe Double -> f (Maybe Double)
    f FormatTest{Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: FormatTest -> Maybe Int
    formatTestInt32 :: FormatTest -> Maybe Int
    formatTestInt64 :: FormatTest -> Maybe Integer
    formatTestNumber :: FormatTest -> Double
    formatTestFloat :: FormatTest -> Maybe Float
    formatTestDouble :: FormatTest -> Maybe Double
    formatTestString :: FormatTest -> Maybe Text
    formatTestByte :: FormatTest -> ByteArray
    formatTestBinary :: FormatTest -> Maybe String
    formatTestDate :: FormatTest -> Date
    formatTestDateTime :: FormatTest -> Maybe DateTime
    formatTestUuid :: FormatTest -> Maybe Text
    formatTestPassword :: FormatTest -> Text
    formatTestBigDecimal :: FormatTest -> Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} = (\Maybe Double
    formatTestDouble -> FormatTest { Maybe Double
    formatTestDouble :: Maybe Double
    formatTestDouble :: Maybe Double
    formatTestDouble, Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} ) (Maybe Double -> FormatTest) -> f (Maybe Double) -> f FormatTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Double -> f (Maybe Double)
    f Maybe Double
    formatTestDouble
    {-# INLINE formatTestDoubleL #-}

    -- | 'formatTestString' Lens
    formatTestStringL :: Lens_' FormatTest (Maybe Text)
    formatTestStringL :: Lens_' FormatTest (Maybe Text)
    formatTestStringL Maybe Text -> f (Maybe Text)
    f FormatTest{Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: FormatTest -> Maybe Int
    formatTestInt32 :: FormatTest -> Maybe Int
    formatTestInt64 :: FormatTest -> Maybe Integer
    formatTestNumber :: FormatTest -> Double
    formatTestFloat :: FormatTest -> Maybe Float
    formatTestDouble :: FormatTest -> Maybe Double
    formatTestString :: FormatTest -> Maybe Text
    formatTestByte :: FormatTest -> ByteArray
    formatTestBinary :: FormatTest -> Maybe String
    formatTestDate :: FormatTest -> Date
    formatTestDateTime :: FormatTest -> Maybe DateTime
    formatTestUuid :: FormatTest -> Maybe Text
    formatTestPassword :: FormatTest -> Text
    formatTestBigDecimal :: FormatTest -> Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} = (\Maybe Text
    formatTestString -> FormatTest { Maybe Text
    formatTestString :: Maybe Text
    formatTestString :: Maybe Text
    formatTestString, Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} ) (Maybe Text -> FormatTest) -> f (Maybe Text) -> f FormatTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    formatTestString
    {-# INLINE formatTestStringL #-}

    -- | 'formatTestByte' Lens
    formatTestByteL :: Lens_' FormatTest (ByteArray)
    formatTestByteL :: Lens_' FormatTest ByteArray
    formatTestByteL ByteArray -> f ByteArray
    f FormatTest{Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: FormatTest -> Maybe Int
    formatTestInt32 :: FormatTest -> Maybe Int
    formatTestInt64 :: FormatTest -> Maybe Integer
    formatTestNumber :: FormatTest -> Double
    formatTestFloat :: FormatTest -> Maybe Float
    formatTestDouble :: FormatTest -> Maybe Double
    formatTestString :: FormatTest -> Maybe Text
    formatTestByte :: FormatTest -> ByteArray
    formatTestBinary :: FormatTest -> Maybe String
    formatTestDate :: FormatTest -> Date
    formatTestDateTime :: FormatTest -> Maybe DateTime
    formatTestUuid :: FormatTest -> Maybe Text
    formatTestPassword :: FormatTest -> Text
    formatTestBigDecimal :: FormatTest -> Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} = (\ByteArray
    formatTestByte -> FormatTest { ByteArray
    formatTestByte :: ByteArray
    formatTestByte :: ByteArray
    formatTestByte, Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    Date
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} ) (ByteArray -> FormatTest) -> f ByteArray -> f FormatTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ByteArray -> f ByteArray
    f ByteArray
    formatTestByte
    {-# INLINE formatTestByteL #-}

    -- | 'formatTestBinary' Lens
    formatTestBinaryL :: Lens_' FormatTest (Maybe FilePath)
    formatTestBinaryL :: Lens_' FormatTest (Maybe String)
    formatTestBinaryL Maybe String -> f (Maybe String)
    f FormatTest{Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: FormatTest -> Maybe Int
    formatTestInt32 :: FormatTest -> Maybe Int
    formatTestInt64 :: FormatTest -> Maybe Integer
    formatTestNumber :: FormatTest -> Double
    formatTestFloat :: FormatTest -> Maybe Float
    formatTestDouble :: FormatTest -> Maybe Double
    formatTestString :: FormatTest -> Maybe Text
    formatTestByte :: FormatTest -> ByteArray
    formatTestBinary :: FormatTest -> Maybe String
    formatTestDate :: FormatTest -> Date
    formatTestDateTime :: FormatTest -> Maybe DateTime
    formatTestUuid :: FormatTest -> Maybe Text
    formatTestPassword :: FormatTest -> Text
    formatTestBigDecimal :: FormatTest -> Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} = (\Maybe String
    formatTestBinary -> FormatTest { Maybe String
    formatTestBinary :: Maybe String
    formatTestBinary :: Maybe String
    formatTestBinary, Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} ) (Maybe String -> FormatTest) -> f (Maybe String) -> f FormatTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe String -> f (Maybe String)
    f Maybe String
    formatTestBinary
    {-# INLINE formatTestBinaryL #-}

    -- | 'formatTestDate' Lens
    formatTestDateL :: Lens_' FormatTest (Date)
    formatTestDateL :: Lens_' FormatTest Date
    formatTestDateL Date -> f Date
    f FormatTest{Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: FormatTest -> Maybe Int
    formatTestInt32 :: FormatTest -> Maybe Int
    formatTestInt64 :: FormatTest -> Maybe Integer
    formatTestNumber :: FormatTest -> Double
    formatTestFloat :: FormatTest -> Maybe Float
    formatTestDouble :: FormatTest -> Maybe Double
    formatTestString :: FormatTest -> Maybe Text
    formatTestByte :: FormatTest -> ByteArray
    formatTestBinary :: FormatTest -> Maybe String
    formatTestDate :: FormatTest -> Date
    formatTestDateTime :: FormatTest -> Maybe DateTime
    formatTestUuid :: FormatTest -> Maybe Text
    formatTestPassword :: FormatTest -> Text
    formatTestBigDecimal :: FormatTest -> Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} = (\Date
    formatTestDate -> FormatTest { Date
    formatTestDate :: Date
    formatTestDate :: Date
    formatTestDate, Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} ) (Date -> FormatTest) -> f Date -> f FormatTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Date -> f Date
    f Date
    formatTestDate
    {-# INLINE formatTestDateL #-}

    -- | 'formatTestDateTime' Lens
    formatTestDateTimeL :: Lens_' FormatTest (Maybe DateTime)
    formatTestDateTimeL :: Lens_' FormatTest (Maybe DateTime)
    formatTestDateTimeL Maybe DateTime -> f (Maybe DateTime)
    f FormatTest{Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: FormatTest -> Maybe Int
    formatTestInt32 :: FormatTest -> Maybe Int
    formatTestInt64 :: FormatTest -> Maybe Integer
    formatTestNumber :: FormatTest -> Double
    formatTestFloat :: FormatTest -> Maybe Float
    formatTestDouble :: FormatTest -> Maybe Double
    formatTestString :: FormatTest -> Maybe Text
    formatTestByte :: FormatTest -> ByteArray
    formatTestBinary :: FormatTest -> Maybe String
    formatTestDate :: FormatTest -> Date
    formatTestDateTime :: FormatTest -> Maybe DateTime
    formatTestUuid :: FormatTest -> Maybe Text
    formatTestPassword :: FormatTest -> Text
    formatTestBigDecimal :: FormatTest -> Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} = (\Maybe DateTime
    formatTestDateTime -> FormatTest { Maybe DateTime
    formatTestDateTime :: Maybe DateTime
    formatTestDateTime :: Maybe DateTime
    formatTestDateTime, Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Text
    ByteArray
    Date
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} ) (Maybe DateTime -> FormatTest)
    -> f (Maybe DateTime) -> f FormatTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe DateTime -> f (Maybe DateTime)
    f Maybe DateTime
    formatTestDateTime
    {-# INLINE formatTestDateTimeL #-}

    -- | 'formatTestUuid' Lens
    formatTestUuidL :: Lens_' FormatTest (Maybe Text)
    formatTestUuidL :: Lens_' FormatTest (Maybe Text)
    formatTestUuidL Maybe Text -> f (Maybe Text)
    f FormatTest{Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: FormatTest -> Maybe Int
    formatTestInt32 :: FormatTest -> Maybe Int
    formatTestInt64 :: FormatTest -> Maybe Integer
    formatTestNumber :: FormatTest -> Double
    formatTestFloat :: FormatTest -> Maybe Float
    formatTestDouble :: FormatTest -> Maybe Double
    formatTestString :: FormatTest -> Maybe Text
    formatTestByte :: FormatTest -> ByteArray
    formatTestBinary :: FormatTest -> Maybe String
    formatTestDate :: FormatTest -> Date
    formatTestDateTime :: FormatTest -> Maybe DateTime
    formatTestUuid :: FormatTest -> Maybe Text
    formatTestPassword :: FormatTest -> Text
    formatTestBigDecimal :: FormatTest -> Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} = (\Maybe Text
    formatTestUuid -> FormatTest { Maybe Text
    formatTestUuid :: Maybe Text
    formatTestUuid :: Maybe Text
    formatTestUuid, Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} ) (Maybe Text -> FormatTest) -> f (Maybe Text) -> f FormatTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    formatTestUuid
    {-# INLINE formatTestUuidL #-}

    -- | 'formatTestPassword' Lens
    formatTestPasswordL :: Lens_' FormatTest (Text)
    formatTestPasswordL :: Lens_' FormatTest Text
    formatTestPasswordL Text -> f Text
    f FormatTest{Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: FormatTest -> Maybe Int
    formatTestInt32 :: FormatTest -> Maybe Int
    formatTestInt64 :: FormatTest -> Maybe Integer
    formatTestNumber :: FormatTest -> Double
    formatTestFloat :: FormatTest -> Maybe Float
    formatTestDouble :: FormatTest -> Maybe Double
    formatTestString :: FormatTest -> Maybe Text
    formatTestByte :: FormatTest -> ByteArray
    formatTestBinary :: FormatTest -> Maybe String
    formatTestDate :: FormatTest -> Date
    formatTestDateTime :: FormatTest -> Maybe DateTime
    formatTestUuid :: FormatTest -> Maybe Text
    formatTestPassword :: FormatTest -> Text
    formatTestBigDecimal :: FormatTest -> Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} = (\Text
    formatTestPassword -> FormatTest { Text
    formatTestPassword :: Text
    formatTestPassword :: Text
    formatTestPassword, Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    ByteArray
    Date
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestBigDecimal :: Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestBigDecimal :: Maybe Double
    ..} ) (Text -> FormatTest) -> f Text -> f FormatTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text -> f Text
    f Text
    formatTestPassword
    {-# INLINE formatTestPasswordL #-}

    -- | 'formatTestBigDecimal' Lens
    formatTestBigDecimalL :: Lens_' FormatTest (Maybe Double)
    formatTestBigDecimalL :: Lens_' FormatTest (Maybe Double)
    formatTestBigDecimalL Maybe Double -> f (Maybe Double)
    f FormatTest{Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: FormatTest -> Maybe Int
    formatTestInt32 :: FormatTest -> Maybe Int
    formatTestInt64 :: FormatTest -> Maybe Integer
    formatTestNumber :: FormatTest -> Double
    formatTestFloat :: FormatTest -> Maybe Float
    formatTestDouble :: FormatTest -> Maybe Double
    formatTestString :: FormatTest -> Maybe Text
    formatTestByte :: FormatTest -> ByteArray
    formatTestBinary :: FormatTest -> Maybe String
    formatTestDate :: FormatTest -> Date
    formatTestDateTime :: FormatTest -> Maybe DateTime
    formatTestUuid :: FormatTest -> Maybe Text
    formatTestPassword :: FormatTest -> Text
    formatTestBigDecimal :: FormatTest -> Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} = (\Maybe Double
    formatTestBigDecimal -> FormatTest { Maybe Double
    formatTestBigDecimal :: Maybe Double
    formatTestBigDecimal :: Maybe Double
    formatTestBigDecimal, Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe String
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe String
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    ..} ) (Maybe Double -> FormatTest) -> f (Maybe Double) -> f FormatTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Double -> f (Maybe Double)
    f Maybe Double
    formatTestBigDecimal
    {-# INLINE formatTestBigDecimalL #-}

    -- * HasOnlyReadOnly

    -- | 'hasOnlyReadOnlyBar' Lens
    hasOnlyReadOnlyBarL :: Lens_' HasOnlyReadOnly (Maybe Text)
    hasOnlyReadOnlyBarL :: Lens_' HasOnlyReadOnly (Maybe Text)
    hasOnlyReadOnlyBarL Maybe Text -> f (Maybe Text)
    f HasOnlyReadOnly{Maybe Text
    hasOnlyReadOnlyBar :: HasOnlyReadOnly -> Maybe Text
    hasOnlyReadOnlyBar :: Maybe Text
    hasOnlyReadOnlyFoo :: Maybe Text
    hasOnlyReadOnlyFoo :: HasOnlyReadOnly -> Maybe Text
    ..} = (\Maybe Text
    hasOnlyReadOnlyBar -> HasOnlyReadOnly { Maybe Text
    hasOnlyReadOnlyBar :: Maybe Text
    hasOnlyReadOnlyBar :: Maybe Text
    hasOnlyReadOnlyBar, Maybe Text
    hasOnlyReadOnlyFoo :: Maybe Text
    hasOnlyReadOnlyFoo :: Maybe Text
    ..} ) (Maybe Text -> HasOnlyReadOnly)
    -> f (Maybe Text) -> f HasOnlyReadOnly
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    hasOnlyReadOnlyBar
    {-# INLINE hasOnlyReadOnlyBarL #-}

    -- | 'hasOnlyReadOnlyFoo' Lens
    hasOnlyReadOnlyFooL :: Lens_' HasOnlyReadOnly (Maybe Text)
    hasOnlyReadOnlyFooL :: Lens_' HasOnlyReadOnly (Maybe Text)
    hasOnlyReadOnlyFooL Maybe Text -> f (Maybe Text)
    f HasOnlyReadOnly{Maybe Text
    hasOnlyReadOnlyBar :: HasOnlyReadOnly -> Maybe Text
    hasOnlyReadOnlyFoo :: HasOnlyReadOnly -> Maybe Text
    hasOnlyReadOnlyBar :: Maybe Text
    hasOnlyReadOnlyFoo :: Maybe Text
    ..} = (\Maybe Text
    hasOnlyReadOnlyFoo -> HasOnlyReadOnly { Maybe Text
    hasOnlyReadOnlyFoo :: Maybe Text
    hasOnlyReadOnlyFoo :: Maybe Text
    hasOnlyReadOnlyFoo, Maybe Text
    hasOnlyReadOnlyBar :: Maybe Text
    hasOnlyReadOnlyBar :: Maybe Text
    ..} ) (Maybe Text -> HasOnlyReadOnly)
    -> f (Maybe Text) -> f HasOnlyReadOnly
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    hasOnlyReadOnlyFoo
    {-# INLINE hasOnlyReadOnlyFooL #-}

    -- * MapTest

    -- | 'mapTestMapMapOfString' Lens
    mapTestMapMapOfStringL :: Lens_' MapTest (Maybe (Map.Map String (Map.Map String Text)))
    mapTestMapMapOfStringL :: Lens_' MapTest (Maybe (Map String (Map String Text)))
    mapTestMapMapOfStringL Maybe (Map String (Map String Text))
    -> f (Maybe (Map String (Map String Text)))
    f MapTest{Maybe (Map String Bool)
    Maybe (Map String (Map String Text))
    Maybe (Map String E'Inner)
    mapTestMapMapOfString :: MapTest -> Maybe (Map String (Map String Text))
    mapTestMapMapOfString :: Maybe (Map String (Map String Text))
    mapTestMapOfEnumString :: Maybe (Map String E'Inner)
    mapTestDirectMap :: Maybe (Map String Bool)
    mapTestIndirectMap :: Maybe (Map String Bool)
    mapTestMapOfEnumString :: MapTest -> Maybe (Map String E'Inner)
    mapTestDirectMap :: MapTest -> Maybe (Map String Bool)
    mapTestIndirectMap :: MapTest -> Maybe (Map String Bool)
    ..} = (\Maybe (Map String (Map String Text))
    mapTestMapMapOfString -> MapTest { Maybe (Map String (Map String Text))
    mapTestMapMapOfString :: Maybe (Map String (Map String Text))
    mapTestMapMapOfString :: Maybe (Map String (Map String Text))
    mapTestMapMapOfString, Maybe (Map String Bool)
    Maybe (Map String E'Inner)
    mapTestMapOfEnumString :: Maybe (Map String E'Inner)
    mapTestDirectMap :: Maybe (Map String Bool)
    mapTestIndirectMap :: Maybe (Map String Bool)
    mapTestMapOfEnumString :: Maybe (Map String E'Inner)
    mapTestDirectMap :: Maybe (Map String Bool)
    mapTestIndirectMap :: Maybe (Map String Bool)
    ..} ) (Maybe (Map String (Map String Text)) -> MapTest)
    -> f (Maybe (Map String (Map String Text))) -> f MapTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (Map String (Map String Text))
    -> f (Maybe (Map String (Map String Text)))
    f Maybe (Map String (Map String Text))
    mapTestMapMapOfString
    {-# INLINE mapTestMapMapOfStringL #-}

    -- | 'mapTestMapOfEnumString' Lens
    mapTestMapOfEnumStringL :: Lens_' MapTest (Maybe (Map.Map String E'Inner))
    mapTestMapOfEnumStringL :: Lens_' MapTest (Maybe (Map String E'Inner))
    mapTestMapOfEnumStringL Maybe (Map String E'Inner) -> f (Maybe (Map String E'Inner))
    f MapTest{Maybe (Map String Bool)
    Maybe (Map String (Map String Text))
    Maybe (Map String E'Inner)
    mapTestMapMapOfString :: MapTest -> Maybe (Map String (Map String Text))
    mapTestMapOfEnumString :: MapTest -> Maybe (Map String E'Inner)
    mapTestDirectMap :: MapTest -> Maybe (Map String Bool)
    mapTestIndirectMap :: MapTest -> Maybe (Map String Bool)
    mapTestMapMapOfString :: Maybe (Map String (Map String Text))
    mapTestMapOfEnumString :: Maybe (Map String E'Inner)
    mapTestDirectMap :: Maybe (Map String Bool)
    mapTestIndirectMap :: Maybe (Map String Bool)
    ..} = (\Maybe (Map String E'Inner)
    mapTestMapOfEnumString -> MapTest { Maybe (Map String E'Inner)
    mapTestMapOfEnumString :: Maybe (Map String E'Inner)
    mapTestMapOfEnumString :: Maybe (Map String E'Inner)
    mapTestMapOfEnumString, Maybe (Map String Bool)
    Maybe (Map String (Map String Text))
    mapTestMapMapOfString :: Maybe (Map String (Map String Text))
    mapTestDirectMap :: Maybe (Map String Bool)
    mapTestIndirectMap :: Maybe (Map String Bool)
    mapTestMapMapOfString :: Maybe (Map String (Map String Text))
    mapTestDirectMap :: Maybe (Map String Bool)
    mapTestIndirectMap :: Maybe (Map String Bool)
    ..} ) (Maybe (Map String E'Inner) -> MapTest)
    -> f (Maybe (Map String E'Inner)) -> f MapTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (Map String E'Inner) -> f (Maybe (Map String E'Inner))
    f Maybe (Map String E'Inner)
    mapTestMapOfEnumString
    {-# INLINE mapTestMapOfEnumStringL #-}

    -- | 'mapTestDirectMap' Lens
    mapTestDirectMapL :: Lens_' MapTest (Maybe (Map.Map String Bool))
    mapTestDirectMapL :: Lens_' MapTest (Maybe (Map String Bool))
    mapTestDirectMapL Maybe (Map String Bool) -> f (Maybe (Map String Bool))
    f MapTest{Maybe (Map String Bool)
    Maybe (Map String (Map String Text))
    Maybe (Map String E'Inner)
    mapTestMapMapOfString :: MapTest -> Maybe (Map String (Map String Text))
    mapTestMapOfEnumString :: MapTest -> Maybe (Map String E'Inner)
    mapTestDirectMap :: MapTest -> Maybe (Map String Bool)
    mapTestIndirectMap :: MapTest -> Maybe (Map String Bool)
    mapTestMapMapOfString :: Maybe (Map String (Map String Text))
    mapTestMapOfEnumString :: Maybe (Map String E'Inner)
    mapTestDirectMap :: Maybe (Map String Bool)
    mapTestIndirectMap :: Maybe (Map String Bool)
    ..} = (\Maybe (Map String Bool)
    mapTestDirectMap -> MapTest { Maybe (Map String Bool)
    mapTestDirectMap :: Maybe (Map String Bool)
    mapTestDirectMap :: Maybe (Map String Bool)
    mapTestDirectMap, Maybe (Map String Bool)
    Maybe (Map String (Map String Text))
    Maybe (Map String E'Inner)
    mapTestMapMapOfString :: Maybe (Map String (Map String Text))
    mapTestMapOfEnumString :: Maybe (Map String E'Inner)
    mapTestIndirectMap :: Maybe (Map String Bool)
    mapTestMapMapOfString :: Maybe (Map String (Map String Text))
    mapTestMapOfEnumString :: Maybe (Map String E'Inner)
    mapTestIndirectMap :: Maybe (Map String Bool)
    ..} ) (Maybe (Map String Bool) -> MapTest)
    -> f (Maybe (Map String Bool)) -> f MapTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (Map String Bool) -> f (Maybe (Map String Bool))
    f Maybe (Map String Bool)
    mapTestDirectMap
    {-# INLINE mapTestDirectMapL #-}

    -- | 'mapTestIndirectMap' Lens
    mapTestIndirectMapL :: Lens_' MapTest (Maybe (Map.Map String Bool))
    mapTestIndirectMapL :: Lens_' MapTest (Maybe (Map String Bool))
    mapTestIndirectMapL Maybe (Map String Bool) -> f (Maybe (Map String Bool))
    f MapTest{Maybe (Map String Bool)
    Maybe (Map String (Map String Text))
    Maybe (Map String E'Inner)
    mapTestMapMapOfString :: MapTest -> Maybe (Map String (Map String Text))
    mapTestMapOfEnumString :: MapTest -> Maybe (Map String E'Inner)
    mapTestDirectMap :: MapTest -> Maybe (Map String Bool)
    mapTestIndirectMap :: MapTest -> Maybe (Map String Bool)
    mapTestMapMapOfString :: Maybe (Map String (Map String Text))
    mapTestMapOfEnumString :: Maybe (Map String E'Inner)
    mapTestDirectMap :: Maybe (Map String Bool)
    mapTestIndirectMap :: Maybe (Map String Bool)
    ..} = (\Maybe (Map String Bool)
    mapTestIndirectMap -> MapTest { Maybe (Map String Bool)
    mapTestIndirectMap :: Maybe (Map String Bool)
    mapTestIndirectMap :: Maybe (Map String Bool)
    mapTestIndirectMap, Maybe (Map String Bool)
    Maybe (Map String (Map String Text))
    Maybe (Map String E'Inner)
    mapTestMapMapOfString :: Maybe (Map String (Map String Text))
    mapTestMapOfEnumString :: Maybe (Map String E'Inner)
    mapTestDirectMap :: Maybe (Map String Bool)
    mapTestMapMapOfString :: Maybe (Map String (Map String Text))
    mapTestMapOfEnumString :: Maybe (Map String E'Inner)
    mapTestDirectMap :: Maybe (Map String Bool)
    ..} ) (Maybe (Map String Bool) -> MapTest)
    -> f (Maybe (Map String Bool)) -> f MapTest
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (Map String Bool) -> f (Maybe (Map String Bool))
    f Maybe (Map String Bool)
    mapTestIndirectMap
    {-# INLINE mapTestIndirectMapL #-}

    -- * MixedPropertiesAndAdditionalPropertiesClass

    -- | 'mixedPropertiesAndAdditionalPropertiesClassUuid' Lens
    mixedPropertiesAndAdditionalPropertiesClassUuidL :: Lens_' MixedPropertiesAndAdditionalPropertiesClass (Maybe Text)
    mixedPropertiesAndAdditionalPropertiesClassUuidL :: Lens_' MixedPropertiesAndAdditionalPropertiesClass (Maybe Text)
    mixedPropertiesAndAdditionalPropertiesClassUuidL Maybe Text -> f (Maybe Text)
    f MixedPropertiesAndAdditionalPropertiesClass{Maybe (Map String Animal)
    Maybe Text
    Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassUuid :: MixedPropertiesAndAdditionalPropertiesClass -> Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassUuid :: Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassDateTime :: Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassMap :: Maybe (Map String Animal)
    mixedPropertiesAndAdditionalPropertiesClassDateTime :: MixedPropertiesAndAdditionalPropertiesClass -> Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassMap :: MixedPropertiesAndAdditionalPropertiesClass
    -> Maybe (Map String Animal)
    ..} = (\Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassUuid -> MixedPropertiesAndAdditionalPropertiesClass { Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassUuid :: Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassUuid :: Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassUuid, Maybe (Map String Animal)
    Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassDateTime :: Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassMap :: Maybe (Map String Animal)
    mixedPropertiesAndAdditionalPropertiesClassDateTime :: Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassMap :: Maybe (Map String Animal)
    ..} ) (Maybe Text -> MixedPropertiesAndAdditionalPropertiesClass)
    -> f (Maybe Text) -> f MixedPropertiesAndAdditionalPropertiesClass
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassUuid
    {-# INLINE mixedPropertiesAndAdditionalPropertiesClassUuidL #-}

    -- | 'mixedPropertiesAndAdditionalPropertiesClassDateTime' Lens
    mixedPropertiesAndAdditionalPropertiesClassDateTimeL :: Lens_' MixedPropertiesAndAdditionalPropertiesClass (Maybe DateTime)
    mixedPropertiesAndAdditionalPropertiesClassDateTimeL :: Lens_' MixedPropertiesAndAdditionalPropertiesClass (Maybe DateTime)
    mixedPropertiesAndAdditionalPropertiesClassDateTimeL Maybe DateTime -> f (Maybe DateTime)
    f MixedPropertiesAndAdditionalPropertiesClass{Maybe (Map String Animal)
    Maybe Text
    Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassUuid :: MixedPropertiesAndAdditionalPropertiesClass -> Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassDateTime :: MixedPropertiesAndAdditionalPropertiesClass -> Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassMap :: MixedPropertiesAndAdditionalPropertiesClass
    -> Maybe (Map String Animal)
    mixedPropertiesAndAdditionalPropertiesClassUuid :: Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassDateTime :: Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassMap :: Maybe (Map String Animal)
    ..} = (\Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassDateTime -> MixedPropertiesAndAdditionalPropertiesClass { Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassDateTime :: Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassDateTime :: Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassDateTime, Maybe (Map String Animal)
    Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassUuid :: Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassMap :: Maybe (Map String Animal)
    mixedPropertiesAndAdditionalPropertiesClassUuid :: Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassMap :: Maybe (Map String Animal)
    ..} ) (Maybe DateTime -> MixedPropertiesAndAdditionalPropertiesClass)
    -> f (Maybe DateTime)
    -> f MixedPropertiesAndAdditionalPropertiesClass
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe DateTime -> f (Maybe DateTime)
    f Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassDateTime
    {-# INLINE mixedPropertiesAndAdditionalPropertiesClassDateTimeL #-}

    -- | 'mixedPropertiesAndAdditionalPropertiesClassMap' Lens
    mixedPropertiesAndAdditionalPropertiesClassMapL :: Lens_' MixedPropertiesAndAdditionalPropertiesClass (Maybe (Map.Map String Animal))
    mixedPropertiesAndAdditionalPropertiesClassMapL :: Lens_'
      MixedPropertiesAndAdditionalPropertiesClass
      (Maybe (Map String Animal))
    mixedPropertiesAndAdditionalPropertiesClassMapL Maybe (Map String Animal) -> f (Maybe (Map String Animal))
    f MixedPropertiesAndAdditionalPropertiesClass{Maybe (Map String Animal)
    Maybe Text
    Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassUuid :: MixedPropertiesAndAdditionalPropertiesClass -> Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassDateTime :: MixedPropertiesAndAdditionalPropertiesClass -> Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassMap :: MixedPropertiesAndAdditionalPropertiesClass
    -> Maybe (Map String Animal)
    mixedPropertiesAndAdditionalPropertiesClassUuid :: Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassDateTime :: Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassMap :: Maybe (Map String Animal)
    ..} = (\Maybe (Map String Animal)
    mixedPropertiesAndAdditionalPropertiesClassMap -> MixedPropertiesAndAdditionalPropertiesClass { Maybe (Map String Animal)
    mixedPropertiesAndAdditionalPropertiesClassMap :: Maybe (Map String Animal)
    mixedPropertiesAndAdditionalPropertiesClassMap :: Maybe (Map String Animal)
    mixedPropertiesAndAdditionalPropertiesClassMap, Maybe Text
    Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassUuid :: Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassDateTime :: Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassUuid :: Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassDateTime :: Maybe DateTime
    ..} ) (Maybe (Map String Animal)
     -> MixedPropertiesAndAdditionalPropertiesClass)
    -> f (Maybe (Map String Animal))
    -> f MixedPropertiesAndAdditionalPropertiesClass
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (Map String Animal) -> f (Maybe (Map String Animal))
    f Maybe (Map String Animal)
    mixedPropertiesAndAdditionalPropertiesClassMap
    {-# INLINE mixedPropertiesAndAdditionalPropertiesClassMapL #-}

    -- * Model200Response

    -- | 'model200ResponseName' Lens
    model200ResponseNameL :: Lens_' Model200Response (Maybe Int)
    model200ResponseNameL :: Lens_' Model200Response (Maybe Int)
    model200ResponseNameL Maybe Int -> f (Maybe Int)
    f Model200Response{Maybe Int
    Maybe Text
    model200ResponseName :: Model200Response -> Maybe Int
    model200ResponseName :: Maybe Int
    model200ResponseClass :: Maybe Text
    model200ResponseClass :: Model200Response -> Maybe Text
    ..} = (\Maybe Int
    model200ResponseName -> Model200Response { Maybe Int
    model200ResponseName :: Maybe Int
    model200ResponseName :: Maybe Int
    model200ResponseName, Maybe Text
    model200ResponseClass :: Maybe Text
    model200ResponseClass :: Maybe Text
    ..} ) (Maybe Int -> Model200Response)
    -> f (Maybe Int) -> f Model200Response
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Int -> f (Maybe Int)
    f Maybe Int
    model200ResponseName
    {-# INLINE model200ResponseNameL #-}

    -- | 'model200ResponseClass' Lens
    model200ResponseClassL :: Lens_' Model200Response (Maybe Text)
    model200ResponseClassL :: Lens_' Model200Response (Maybe Text)
    model200ResponseClassL Maybe Text -> f (Maybe Text)
    f Model200Response{Maybe Int
    Maybe Text
    model200ResponseName :: Model200Response -> Maybe Int
    model200ResponseClass :: Model200Response -> Maybe Text
    model200ResponseName :: Maybe Int
    model200ResponseClass :: Maybe Text
    ..} = (\Maybe Text
    model200ResponseClass -> Model200Response { Maybe Text
    model200ResponseClass :: Maybe Text
    model200ResponseClass :: Maybe Text
    model200ResponseClass, Maybe Int
    model200ResponseName :: Maybe Int
    model200ResponseName :: Maybe Int
    ..} ) (Maybe Text -> Model200Response)
    -> f (Maybe Text) -> f Model200Response
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    model200ResponseClass
    {-# INLINE model200ResponseClassL #-}

    -- * ModelList

    -- | 'modelList123list' Lens
    modelList123listL :: Lens_' ModelList (Maybe Text)
    modelList123listL :: Lens_' ModelList (Maybe Text)
    modelList123listL Maybe Text -> f (Maybe Text)
    f ModelList{Maybe Text
    modelList123list :: ModelList -> Maybe Text
    modelList123list :: Maybe Text
    ..} = (\Maybe Text
    modelList123list -> ModelList { Maybe Text
    modelList123list :: Maybe Text
    modelList123list :: Maybe Text
    modelList123list, ..} ) (Maybe Text -> ModelList) -> f (Maybe Text) -> f ModelList
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    modelList123list
    {-# INLINE modelList123listL #-}

    -- * ModelReturn

    -- | 'modelReturnReturn' Lens
    modelReturnReturnL :: Lens_' ModelReturn (Maybe Int)
    modelReturnReturnL :: Lens_' ModelReturn (Maybe Int)
    modelReturnReturnL Maybe Int -> f (Maybe Int)
    f ModelReturn{Maybe Int
    modelReturnReturn :: ModelReturn -> Maybe Int
    modelReturnReturn :: Maybe Int
    ..} = (\Maybe Int
    modelReturnReturn -> ModelReturn { Maybe Int
    modelReturnReturn :: Maybe Int
    modelReturnReturn :: Maybe Int
    modelReturnReturn, ..} ) (Maybe Int -> ModelReturn) -> f (Maybe Int) -> f ModelReturn
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Int -> f (Maybe Int)
    f Maybe Int
    modelReturnReturn
    {-# INLINE modelReturnReturnL #-}

    -- * Name

    -- | 'nameName' Lens
    nameNameL :: Lens_' Name (Int)
    nameNameL :: Lens_' Name Int
    nameNameL Int -> f Int
    f Name{Int
    Maybe Int
    Maybe Text
    nameName :: Name -> Int
    nameName :: Int
    nameSnakeCase :: Maybe Int
    nameProperty :: Maybe Text
    name123number :: Maybe Int
    nameSnakeCase :: Name -> Maybe Int
    nameProperty :: Name -> Maybe Text
    name123number :: Name -> Maybe Int
    ..} = (\Int
    nameName -> Name { Int
    nameName :: Int
    nameName :: Int
    nameName, Maybe Int
    Maybe Text
    nameSnakeCase :: Maybe Int
    nameProperty :: Maybe Text
    name123number :: Maybe Int
    nameSnakeCase :: Maybe Int
    nameProperty :: Maybe Text
    name123number :: Maybe Int
    ..} ) (Int -> Name) -> f Int -> f Name
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> f Int
    f Int
    nameName
    {-# INLINE nameNameL #-}

    -- | 'nameSnakeCase' Lens
    nameSnakeCaseL :: Lens_' Name (Maybe Int)
    nameSnakeCaseL :: Lens_' Name (Maybe Int)
    nameSnakeCaseL Maybe Int -> f (Maybe Int)
    f Name{Int
    Maybe Int
    Maybe Text
    nameName :: Name -> Int
    nameSnakeCase :: Name -> Maybe Int
    nameProperty :: Name -> Maybe Text
    name123number :: Name -> Maybe Int
    nameName :: Int
    nameSnakeCase :: Maybe Int
    nameProperty :: Maybe Text
    name123number :: Maybe Int
    ..} = (\Maybe Int
    nameSnakeCase -> Name { Maybe Int
    nameSnakeCase :: Maybe Int
    nameSnakeCase :: Maybe Int
    nameSnakeCase, Int
    Maybe Int
    Maybe Text
    nameName :: Int
    nameProperty :: Maybe Text
    name123number :: Maybe Int
    nameName :: Int
    nameProperty :: Maybe Text
    name123number :: Maybe Int
    ..} ) (Maybe Int -> Name) -> f (Maybe Int) -> f Name
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Int -> f (Maybe Int)
    f Maybe Int
    nameSnakeCase
    {-# INLINE nameSnakeCaseL #-}

    -- | 'nameProperty' Lens
    namePropertyL :: Lens_' Name (Maybe Text)
    namePropertyL :: Lens_' Name (Maybe Text)
    namePropertyL Maybe Text -> f (Maybe Text)
    f Name{Int
    Maybe Int
    Maybe Text
    nameName :: Name -> Int
    nameSnakeCase :: Name -> Maybe Int
    nameProperty :: Name -> Maybe Text
    name123number :: Name -> Maybe Int
    nameName :: Int
    nameSnakeCase :: Maybe Int
    nameProperty :: Maybe Text
    name123number :: Maybe Int
    ..} = (\Maybe Text
    nameProperty -> Name { Maybe Text
    nameProperty :: Maybe Text
    nameProperty :: Maybe Text
    nameProperty, Int
    Maybe Int
    nameName :: Int
    nameSnakeCase :: Maybe Int
    name123number :: Maybe Int
    nameName :: Int
    nameSnakeCase :: Maybe Int
    name123number :: Maybe Int
    ..} ) (Maybe Text -> Name) -> f (Maybe Text) -> f Name
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    nameProperty
    {-# INLINE namePropertyL #-}

    -- | 'name123number' Lens
    name123numberL :: Lens_' Name (Maybe Int)
    name123numberL :: Lens_' Name (Maybe Int)
    name123numberL Maybe Int -> f (Maybe Int)
    f Name{Int
    Maybe Int
    Maybe Text
    nameName :: Name -> Int
    nameSnakeCase :: Name -> Maybe Int
    nameProperty :: Name -> Maybe Text
    name123number :: Name -> Maybe Int
    nameName :: Int
    nameSnakeCase :: Maybe Int
    nameProperty :: Maybe Text
    name123number :: Maybe Int
    ..} = (\Maybe Int
    name123number -> Name { Maybe Int
    name123number :: Maybe Int
    name123number :: Maybe Int
    name123number, Int
    Maybe Int
    Maybe Text
    nameName :: Int
    nameSnakeCase :: Maybe Int
    nameProperty :: Maybe Text
    nameName :: Int
    nameSnakeCase :: Maybe Int
    nameProperty :: Maybe Text
    ..} ) (Maybe Int -> Name) -> f (Maybe Int) -> f Name
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Int -> f (Maybe Int)
    f Maybe Int
    name123number
    {-# INLINE name123numberL #-}

    -- * NumberOnly

    -- | 'numberOnlyJustNumber' Lens
    numberOnlyJustNumberL :: Lens_' NumberOnly (Maybe Double)
    numberOnlyJustNumberL :: Lens_' NumberOnly (Maybe Double)
    numberOnlyJustNumberL Maybe Double -> f (Maybe Double)
    f NumberOnly{Maybe Double
    numberOnlyJustNumber :: NumberOnly -> Maybe Double
    numberOnlyJustNumber :: Maybe Double
    ..} = (\Maybe Double
    numberOnlyJustNumber -> NumberOnly { Maybe Double
    numberOnlyJustNumber :: Maybe Double
    numberOnlyJustNumber :: Maybe Double
    numberOnlyJustNumber, ..} ) (Maybe Double -> NumberOnly) -> f (Maybe Double) -> f NumberOnly
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Double -> f (Maybe Double)
    f Maybe Double
    numberOnlyJustNumber
    {-# INLINE numberOnlyJustNumberL #-}

    -- * Order

    -- | 'orderId' Lens
    orderIdL :: Lens_' Order (Maybe Integer)
    orderIdL :: Lens_' Order (Maybe Integer)
    orderIdL Maybe Integer -> f (Maybe Integer)
    f Order{Maybe Bool
    Maybe Int
    Maybe Integer
    Maybe DateTime
    Maybe E'Status
    orderId :: Order -> Maybe Integer
    orderId :: Maybe Integer
    orderPetId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderShipDate :: Maybe DateTime
    orderStatus :: Maybe E'Status
    orderComplete :: Maybe Bool
    orderPetId :: Order -> Maybe Integer
    orderQuantity :: Order -> Maybe Int
    orderShipDate :: Order -> Maybe DateTime
    orderStatus :: Order -> Maybe E'Status
    orderComplete :: Order -> Maybe Bool
    ..} = (\Maybe Integer
    orderId -> Order { Maybe Integer
    orderId :: Maybe Integer
    orderId :: Maybe Integer
    orderId, Maybe Bool
    Maybe Int
    Maybe Integer
    Maybe DateTime
    Maybe E'Status
    orderPetId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderShipDate :: Maybe DateTime
    orderStatus :: Maybe E'Status
    orderComplete :: Maybe Bool
    orderPetId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderShipDate :: Maybe DateTime
    orderStatus :: Maybe E'Status
    orderComplete :: Maybe Bool
    ..} ) (Maybe Integer -> Order) -> f (Maybe Integer) -> f Order
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Integer -> f (Maybe Integer)
    f Maybe Integer
    orderId
    {-# INLINE orderIdL #-}

    -- | 'orderPetId' Lens
    orderPetIdL :: Lens_' Order (Maybe Integer)
    orderPetIdL :: Lens_' Order (Maybe Integer)
    orderPetIdL Maybe Integer -> f (Maybe Integer)
    f Order{Maybe Bool
    Maybe Int
    Maybe Integer
    Maybe DateTime
    Maybe E'Status
    orderId :: Order -> Maybe Integer
    orderPetId :: Order -> Maybe Integer
    orderQuantity :: Order -> Maybe Int
    orderShipDate :: Order -> Maybe DateTime
    orderStatus :: Order -> Maybe E'Status
    orderComplete :: Order -> Maybe Bool
    orderId :: Maybe Integer
    orderPetId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderShipDate :: Maybe DateTime
    orderStatus :: Maybe E'Status
    orderComplete :: Maybe Bool
    ..} = (\Maybe Integer
    orderPetId -> Order { Maybe Integer
    orderPetId :: Maybe Integer
    orderPetId :: Maybe Integer
    orderPetId, Maybe Bool
    Maybe Int
    Maybe Integer
    Maybe DateTime
    Maybe E'Status
    orderId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderShipDate :: Maybe DateTime
    orderStatus :: Maybe E'Status
    orderComplete :: Maybe Bool
    orderId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderShipDate :: Maybe DateTime
    orderStatus :: Maybe E'Status
    orderComplete :: Maybe Bool
    ..} ) (Maybe Integer -> Order) -> f (Maybe Integer) -> f Order
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Integer -> f (Maybe Integer)
    f Maybe Integer
    orderPetId
    {-# INLINE orderPetIdL #-}

    -- | 'orderQuantity' Lens
    orderQuantityL :: Lens_' Order (Maybe Int)
    orderQuantityL :: Lens_' Order (Maybe Int)
    orderQuantityL Maybe Int -> f (Maybe Int)
    f Order{Maybe Bool
    Maybe Int
    Maybe Integer
    Maybe DateTime
    Maybe E'Status
    orderId :: Order -> Maybe Integer
    orderPetId :: Order -> Maybe Integer
    orderQuantity :: Order -> Maybe Int
    orderShipDate :: Order -> Maybe DateTime
    orderStatus :: Order -> Maybe E'Status
    orderComplete :: Order -> Maybe Bool
    orderId :: Maybe Integer
    orderPetId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderShipDate :: Maybe DateTime
    orderStatus :: Maybe E'Status
    orderComplete :: Maybe Bool
    ..} = (\Maybe Int
    orderQuantity -> Order { Maybe Int
    orderQuantity :: Maybe Int
    orderQuantity :: Maybe Int
    orderQuantity, Maybe Bool
    Maybe Integer
    Maybe DateTime
    Maybe E'Status
    orderId :: Maybe Integer
    orderPetId :: Maybe Integer
    orderShipDate :: Maybe DateTime
    orderStatus :: Maybe E'Status
    orderComplete :: Maybe Bool
    orderId :: Maybe Integer
    orderPetId :: Maybe Integer
    orderShipDate :: Maybe DateTime
    orderStatus :: Maybe E'Status
    orderComplete :: Maybe Bool
    ..} ) (Maybe Int -> Order) -> f (Maybe Int) -> f Order
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Int -> f (Maybe Int)
    f Maybe Int
    orderQuantity
    {-# INLINE orderQuantityL #-}

    -- | 'orderShipDate' Lens
    orderShipDateL :: Lens_' Order (Maybe DateTime)
    orderShipDateL :: Lens_' Order (Maybe DateTime)
    orderShipDateL Maybe DateTime -> f (Maybe DateTime)
    f Order{Maybe Bool
    Maybe Int
    Maybe Integer
    Maybe DateTime
    Maybe E'Status
    orderId :: Order -> Maybe Integer
    orderPetId :: Order -> Maybe Integer
    orderQuantity :: Order -> Maybe Int
    orderShipDate :: Order -> Maybe DateTime
    orderStatus :: Order -> Maybe E'Status
    orderComplete :: Order -> Maybe Bool
    orderId :: Maybe Integer
    orderPetId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderShipDate :: Maybe DateTime
    orderStatus :: Maybe E'Status
    orderComplete :: Maybe Bool
    ..} = (\Maybe DateTime
    orderShipDate -> Order { Maybe DateTime
    orderShipDate :: Maybe DateTime
    orderShipDate :: Maybe DateTime
    orderShipDate, Maybe Bool
    Maybe Int
    Maybe Integer
    Maybe E'Status
    orderId :: Maybe Integer
    orderPetId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderStatus :: Maybe E'Status
    orderComplete :: Maybe Bool
    orderId :: Maybe Integer
    orderPetId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderStatus :: Maybe E'Status
    orderComplete :: Maybe Bool
    ..} ) (Maybe DateTime -> Order) -> f (Maybe DateTime) -> f Order
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe DateTime -> f (Maybe DateTime)
    f Maybe DateTime
    orderShipDate
    {-# INLINE orderShipDateL #-}

    -- | 'orderStatus' Lens
    orderStatusL :: Lens_' Order (Maybe E'Status)
    orderStatusL :: Lens_' Order (Maybe E'Status)
    orderStatusL Maybe E'Status -> f (Maybe E'Status)
    f Order{Maybe Bool
    Maybe Int
    Maybe Integer
    Maybe DateTime
    Maybe E'Status
    orderId :: Order -> Maybe Integer
    orderPetId :: Order -> Maybe Integer
    orderQuantity :: Order -> Maybe Int
    orderShipDate :: Order -> Maybe DateTime
    orderStatus :: Order -> Maybe E'Status
    orderComplete :: Order -> Maybe Bool
    orderId :: Maybe Integer
    orderPetId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderShipDate :: Maybe DateTime
    orderStatus :: Maybe E'Status
    orderComplete :: Maybe Bool
    ..} = (\Maybe E'Status
    orderStatus -> Order { Maybe E'Status
    orderStatus :: Maybe E'Status
    orderStatus :: Maybe E'Status
    orderStatus, Maybe Bool
    Maybe Int
    Maybe Integer
    Maybe DateTime
    orderId :: Maybe Integer
    orderPetId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderShipDate :: Maybe DateTime
    orderComplete :: Maybe Bool
    orderId :: Maybe Integer
    orderPetId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderShipDate :: Maybe DateTime
    orderComplete :: Maybe Bool
    ..} ) (Maybe E'Status -> Order) -> f (Maybe E'Status) -> f Order
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe E'Status -> f (Maybe E'Status)
    f Maybe E'Status
    orderStatus
    {-# INLINE orderStatusL #-}

    -- | 'orderComplete' Lens
    orderCompleteL :: Lens_' Order (Maybe Bool)
    orderCompleteL :: Lens_' Order (Maybe Bool)
    orderCompleteL Maybe Bool -> f (Maybe Bool)
    f Order{Maybe Bool
    Maybe Int
    Maybe Integer
    Maybe DateTime
    Maybe E'Status
    orderId :: Order -> Maybe Integer
    orderPetId :: Order -> Maybe Integer
    orderQuantity :: Order -> Maybe Int
    orderShipDate :: Order -> Maybe DateTime
    orderStatus :: Order -> Maybe E'Status
    orderComplete :: Order -> Maybe Bool
    orderId :: Maybe Integer
    orderPetId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderShipDate :: Maybe DateTime
    orderStatus :: Maybe E'Status
    orderComplete :: Maybe Bool
    ..} = (\Maybe Bool
    orderComplete -> Order { Maybe Bool
    orderComplete :: Maybe Bool
    orderComplete :: Maybe Bool
    orderComplete, Maybe Int
    Maybe Integer
    Maybe DateTime
    Maybe E'Status
    orderId :: Maybe Integer
    orderPetId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderShipDate :: Maybe DateTime
    orderStatus :: Maybe E'Status
    orderId :: Maybe Integer
    orderPetId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderShipDate :: Maybe DateTime
    orderStatus :: Maybe E'Status
    ..} ) (Maybe Bool -> Order) -> f (Maybe Bool) -> f Order
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Bool -> f (Maybe Bool)
    f Maybe Bool
    orderComplete
    {-# INLINE orderCompleteL #-}

    -- * OuterComposite

    -- | 'outerCompositeMyNumber' Lens
    outerCompositeMyNumberL :: Lens_' OuterComposite (Maybe Double)
    outerCompositeMyNumberL :: Lens_' OuterComposite (Maybe Double)
    outerCompositeMyNumberL Maybe Double -> f (Maybe Double)
    f OuterComposite{Maybe Bool
    Maybe Double
    Maybe Text
    outerCompositeMyNumber :: OuterComposite -> Maybe Double
    outerCompositeMyNumber :: Maybe Double
    outerCompositeMyString :: Maybe Text
    outerCompositeMyBoolean :: Maybe Bool
    outerCompositeMyString :: OuterComposite -> Maybe Text
    outerCompositeMyBoolean :: OuterComposite -> Maybe Bool
    ..} = (\Maybe Double
    outerCompositeMyNumber -> OuterComposite { Maybe Double
    outerCompositeMyNumber :: Maybe Double
    outerCompositeMyNumber :: Maybe Double
    outerCompositeMyNumber, Maybe Bool
    Maybe Text
    outerCompositeMyString :: Maybe Text
    outerCompositeMyBoolean :: Maybe Bool
    outerCompositeMyString :: Maybe Text
    outerCompositeMyBoolean :: Maybe Bool
    ..} ) (Maybe Double -> OuterComposite)
    -> f (Maybe Double) -> f OuterComposite
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Double -> f (Maybe Double)
    f Maybe Double
    outerCompositeMyNumber
    {-# INLINE outerCompositeMyNumberL #-}

    -- | 'outerCompositeMyString' Lens
    outerCompositeMyStringL :: Lens_' OuterComposite (Maybe Text)
    outerCompositeMyStringL :: Lens_' OuterComposite (Maybe Text)
    outerCompositeMyStringL Maybe Text -> f (Maybe Text)
    f OuterComposite{Maybe Bool
    Maybe Double
    Maybe Text
    outerCompositeMyNumber :: OuterComposite -> Maybe Double
    outerCompositeMyString :: OuterComposite -> Maybe Text
    outerCompositeMyBoolean :: OuterComposite -> Maybe Bool
    outerCompositeMyNumber :: Maybe Double
    outerCompositeMyString :: Maybe Text
    outerCompositeMyBoolean :: Maybe Bool
    ..} = (\Maybe Text
    outerCompositeMyString -> OuterComposite { Maybe Text
    outerCompositeMyString :: Maybe Text
    outerCompositeMyString :: Maybe Text
    outerCompositeMyString, Maybe Bool
    Maybe Double
    outerCompositeMyNumber :: Maybe Double
    outerCompositeMyBoolean :: Maybe Bool
    outerCompositeMyNumber :: Maybe Double
    outerCompositeMyBoolean :: Maybe Bool
    ..} ) (Maybe Text -> OuterComposite)
    -> f (Maybe Text) -> f OuterComposite
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    outerCompositeMyString
    {-# INLINE outerCompositeMyStringL #-}

    -- | 'outerCompositeMyBoolean' Lens
    outerCompositeMyBooleanL :: Lens_' OuterComposite (Maybe Bool)
    outerCompositeMyBooleanL :: Lens_' OuterComposite (Maybe Bool)
    outerCompositeMyBooleanL Maybe Bool -> f (Maybe Bool)
    f OuterComposite{Maybe Bool
    Maybe Double
    Maybe Text
    outerCompositeMyNumber :: OuterComposite -> Maybe Double
    outerCompositeMyString :: OuterComposite -> Maybe Text
    outerCompositeMyBoolean :: OuterComposite -> Maybe Bool
    outerCompositeMyNumber :: Maybe Double
    outerCompositeMyString :: Maybe Text
    outerCompositeMyBoolean :: Maybe Bool
    ..} = (\Maybe Bool
    outerCompositeMyBoolean -> OuterComposite { Maybe Bool
    outerCompositeMyBoolean :: Maybe Bool
    outerCompositeMyBoolean :: Maybe Bool
    outerCompositeMyBoolean, Maybe Double
    Maybe Text
    outerCompositeMyNumber :: Maybe Double
    outerCompositeMyString :: Maybe Text
    outerCompositeMyNumber :: Maybe Double
    outerCompositeMyString :: Maybe Text
    ..} ) (Maybe Bool -> OuterComposite)
    -> f (Maybe Bool) -> f OuterComposite
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Bool -> f (Maybe Bool)
    f Maybe Bool
    outerCompositeMyBoolean
    {-# INLINE outerCompositeMyBooleanL #-}

    -- * OuterEnum

    -- * Pet

    -- | 'petId' Lens
    petIdL :: Lens_' Pet (Maybe Integer)
    petIdL :: Lens_' Pet (Maybe Integer)
    petIdL Maybe Integer -> f (Maybe Integer)
    f Pet{[Text]
    Maybe Integer
    Maybe [Tag]
    Maybe E'Status2
    Maybe Category
    Text
    petId :: Pet -> Maybe Integer
    petId :: Maybe Integer
    petCategory :: Maybe Category
    petName :: Text
    petPhotoUrls :: [Text]
    petTags :: Maybe [Tag]
    petStatus :: Maybe E'Status2
    petCategory :: Pet -> Maybe Category
    petName :: Pet -> Text
    petPhotoUrls :: Pet -> [Text]
    petTags :: Pet -> Maybe [Tag]
    petStatus :: Pet -> Maybe E'Status2
    ..} = (\Maybe Integer
    petId -> Pet { Maybe Integer
    petId :: Maybe Integer
    petId :: Maybe Integer
    petId, [Text]
    Maybe [Tag]
    Maybe E'Status2
    Maybe Category
    Text
    petCategory :: Maybe Category
    petName :: Text
    petPhotoUrls :: [Text]
    petTags :: Maybe [Tag]
    petStatus :: Maybe E'Status2
    petCategory :: Maybe Category
    petName :: Text
    petPhotoUrls :: [Text]
    petTags :: Maybe [Tag]
    petStatus :: Maybe E'Status2
    ..} ) (Maybe Integer -> Pet) -> f (Maybe Integer) -> f Pet
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Integer -> f (Maybe Integer)
    f Maybe Integer
    petId
    {-# INLINE petIdL #-}

    -- | 'petCategory' Lens
    petCategoryL :: Lens_' Pet (Maybe Category)
    petCategoryL :: Lens_' Pet (Maybe Category)
    petCategoryL Maybe Category -> f (Maybe Category)
    f Pet{[Text]
    Maybe Integer
    Maybe [Tag]
    Maybe E'Status2
    Maybe Category
    Text
    petId :: Pet -> Maybe Integer
    petCategory :: Pet -> Maybe Category
    petName :: Pet -> Text
    petPhotoUrls :: Pet -> [Text]
    petTags :: Pet -> Maybe [Tag]
    petStatus :: Pet -> Maybe E'Status2
    petId :: Maybe Integer
    petCategory :: Maybe Category
    petName :: Text
    petPhotoUrls :: [Text]
    petTags :: Maybe [Tag]
    petStatus :: Maybe E'Status2
    ..} = (\Maybe Category
    petCategory -> Pet { Maybe Category
    petCategory :: Maybe Category
    petCategory :: Maybe Category
    petCategory, [Text]
    Maybe Integer
    Maybe [Tag]
    Maybe E'Status2
    Text
    petId :: Maybe Integer
    petName :: Text
    petPhotoUrls :: [Text]
    petTags :: Maybe [Tag]
    petStatus :: Maybe E'Status2
    petId :: Maybe Integer
    petName :: Text
    petPhotoUrls :: [Text]
    petTags :: Maybe [Tag]
    petStatus :: Maybe E'Status2
    ..} ) (Maybe Category -> Pet) -> f (Maybe Category) -> f Pet
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Category -> f (Maybe Category)
    f Maybe Category
    petCategory
    {-# INLINE petCategoryL #-}

    -- | 'petName' Lens
    petNameL :: Lens_' Pet (Text)
    petNameL :: Lens_' Pet Text
    petNameL Text -> f Text
    f Pet{[Text]
    Maybe Integer
    Maybe [Tag]
    Maybe E'Status2
    Maybe Category
    Text
    petId :: Pet -> Maybe Integer
    petCategory :: Pet -> Maybe Category
    petName :: Pet -> Text
    petPhotoUrls :: Pet -> [Text]
    petTags :: Pet -> Maybe [Tag]
    petStatus :: Pet -> Maybe E'Status2
    petId :: Maybe Integer
    petCategory :: Maybe Category
    petName :: Text
    petPhotoUrls :: [Text]
    petTags :: Maybe [Tag]
    petStatus :: Maybe E'Status2
    ..} = (\Text
    petName -> Pet { Text
    petName :: Text
    petName :: Text
    petName, [Text]
    Maybe Integer
    Maybe [Tag]
    Maybe E'Status2
    Maybe Category
    petId :: Maybe Integer
    petCategory :: Maybe Category
    petPhotoUrls :: [Text]
    petTags :: Maybe [Tag]
    petStatus :: Maybe E'Status2
    petId :: Maybe Integer
    petCategory :: Maybe Category
    petPhotoUrls :: [Text]
    petTags :: Maybe [Tag]
    petStatus :: Maybe E'Status2
    ..} ) (Text -> Pet) -> f Text -> f Pet
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text -> f Text
    f Text
    petName
    {-# INLINE petNameL #-}

    -- | 'petPhotoUrls' Lens
    petPhotoUrlsL :: Lens_' Pet ([Text])
    petPhotoUrlsL :: Lens_' Pet [Text]
    petPhotoUrlsL [Text] -> f [Text]
    f Pet{[Text]
    Maybe Integer
    Maybe [Tag]
    Maybe E'Status2
    Maybe Category
    Text
    petId :: Pet -> Maybe Integer
    petCategory :: Pet -> Maybe Category
    petName :: Pet -> Text
    petPhotoUrls :: Pet -> [Text]
    petTags :: Pet -> Maybe [Tag]
    petStatus :: Pet -> Maybe E'Status2
    petId :: Maybe Integer
    petCategory :: Maybe Category
    petName :: Text
    petPhotoUrls :: [Text]
    petTags :: Maybe [Tag]
    petStatus :: Maybe E'Status2
    ..} = (\[Text]
    petPhotoUrls -> Pet { [Text]
    petPhotoUrls :: [Text]
    petPhotoUrls :: [Text]
    petPhotoUrls, Maybe Integer
    Maybe [Tag]
    Maybe E'Status2
    Maybe Category
    Text
    petId :: Maybe Integer
    petCategory :: Maybe Category
    petName :: Text
    petTags :: Maybe [Tag]
    petStatus :: Maybe E'Status2
    petId :: Maybe Integer
    petCategory :: Maybe Category
    petName :: Text
    petTags :: Maybe [Tag]
    petStatus :: Maybe E'Status2
    ..} ) ([Text] -> Pet) -> f [Text] -> f Pet
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [Text] -> f [Text]
    f [Text]
    petPhotoUrls
    {-# INLINE petPhotoUrlsL #-}

    -- | 'petTags' Lens
    petTagsL :: Lens_' Pet (Maybe [Tag])
    petTagsL :: Lens_' Pet (Maybe [Tag])
    petTagsL Maybe [Tag] -> f (Maybe [Tag])
    f Pet{[Text]
    Maybe Integer
    Maybe [Tag]
    Maybe E'Status2
    Maybe Category
    Text
    petId :: Pet -> Maybe Integer
    petCategory :: Pet -> Maybe Category
    petName :: Pet -> Text
    petPhotoUrls :: Pet -> [Text]
    petTags :: Pet -> Maybe [Tag]
    petStatus :: Pet -> Maybe E'Status2
    petId :: Maybe Integer
    petCategory :: Maybe Category
    petName :: Text
    petPhotoUrls :: [Text]
    petTags :: Maybe [Tag]
    petStatus :: Maybe E'Status2
    ..} = (\Maybe [Tag]
    petTags -> Pet { Maybe [Tag]
    petTags :: Maybe [Tag]
    petTags :: Maybe [Tag]
    petTags, [Text]
    Maybe Integer
    Maybe E'Status2
    Maybe Category
    Text
    petId :: Maybe Integer
    petCategory :: Maybe Category
    petName :: Text
    petPhotoUrls :: [Text]
    petStatus :: Maybe E'Status2
    petId :: Maybe Integer
    petCategory :: Maybe Category
    petName :: Text
    petPhotoUrls :: [Text]
    petStatus :: Maybe E'Status2
    ..} ) (Maybe [Tag] -> Pet) -> f (Maybe [Tag]) -> f Pet
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [Tag] -> f (Maybe [Tag])
    f Maybe [Tag]
    petTags
    {-# INLINE petTagsL #-}

    -- | 'petStatus' Lens
    petStatusL :: Lens_' Pet (Maybe E'Status2)
    petStatusL :: Lens_' Pet (Maybe E'Status2)
    petStatusL Maybe E'Status2 -> f (Maybe E'Status2)
    f Pet{[Text]
    Maybe Integer
    Maybe [Tag]
    Maybe E'Status2
    Maybe Category
    Text
    petId :: Pet -> Maybe Integer
    petCategory :: Pet -> Maybe Category
    petName :: Pet -> Text
    petPhotoUrls :: Pet -> [Text]
    petTags :: Pet -> Maybe [Tag]
    petStatus :: Pet -> Maybe E'Status2
    petId :: Maybe Integer
    petCategory :: Maybe Category
    petName :: Text
    petPhotoUrls :: [Text]
    petTags :: Maybe [Tag]
    petStatus :: Maybe E'Status2
    ..} = (\Maybe E'Status2
    petStatus -> Pet { Maybe E'Status2
    petStatus :: Maybe E'Status2
    petStatus :: Maybe E'Status2
    petStatus, [Text]
    Maybe Integer
    Maybe [Tag]
    Maybe Category
    Text
    petId :: Maybe Integer
    petCategory :: Maybe Category
    petName :: Text
    petPhotoUrls :: [Text]
    petTags :: Maybe [Tag]
    petId :: Maybe Integer
    petCategory :: Maybe Category
    petName :: Text
    petPhotoUrls :: [Text]
    petTags :: Maybe [Tag]
    ..} ) (Maybe E'Status2 -> Pet) -> f (Maybe E'Status2) -> f Pet
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe E'Status2 -> f (Maybe E'Status2)
    f Maybe E'Status2
    petStatus
    {-# INLINE petStatusL #-}

    -- * ReadOnlyFirst

    -- | 'readOnlyFirstBar' Lens
    readOnlyFirstBarL :: Lens_' ReadOnlyFirst (Maybe Text)
    readOnlyFirstBarL :: Lens_' ReadOnlyFirst (Maybe Text)
    readOnlyFirstBarL Maybe Text -> f (Maybe Text)
    f ReadOnlyFirst{Maybe Text
    readOnlyFirstBar :: ReadOnlyFirst -> Maybe Text
    readOnlyFirstBar :: Maybe Text
    readOnlyFirstBaz :: Maybe Text
    readOnlyFirstBaz :: ReadOnlyFirst -> Maybe Text
    ..} = (\Maybe Text
    readOnlyFirstBar -> ReadOnlyFirst { Maybe Text
    readOnlyFirstBar :: Maybe Text
    readOnlyFirstBar :: Maybe Text
    readOnlyFirstBar, Maybe Text
    readOnlyFirstBaz :: Maybe Text
    readOnlyFirstBaz :: Maybe Text
    ..} ) (Maybe Text -> ReadOnlyFirst) -> f (Maybe Text) -> f ReadOnlyFirst
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    readOnlyFirstBar
    {-# INLINE readOnlyFirstBarL #-}

    -- | 'readOnlyFirstBaz' Lens
    readOnlyFirstBazL :: Lens_' ReadOnlyFirst (Maybe Text)
    readOnlyFirstBazL :: Lens_' ReadOnlyFirst (Maybe Text)
    readOnlyFirstBazL Maybe Text -> f (Maybe Text)
    f ReadOnlyFirst{Maybe Text
    readOnlyFirstBar :: ReadOnlyFirst -> Maybe Text
    readOnlyFirstBaz :: ReadOnlyFirst -> Maybe Text
    readOnlyFirstBar :: Maybe Text
    readOnlyFirstBaz :: Maybe Text
    ..} = (\Maybe Text
    readOnlyFirstBaz -> ReadOnlyFirst { Maybe Text
    readOnlyFirstBaz :: Maybe Text
    readOnlyFirstBaz :: Maybe Text
    readOnlyFirstBaz, Maybe Text
    readOnlyFirstBar :: Maybe Text
    readOnlyFirstBar :: Maybe Text
    ..} ) (Maybe Text -> ReadOnlyFirst) -> f (Maybe Text) -> f ReadOnlyFirst
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    readOnlyFirstBaz
    {-# INLINE readOnlyFirstBazL #-}

    -- * SpecialModelName

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

    -- * Tag

    -- | 'tagId' Lens
    tagIdL :: Lens_' Tag (Maybe Integer)
    tagIdL :: Lens_' Tag (Maybe Integer)
    tagIdL Maybe Integer -> f (Maybe Integer)
    f Tag{Maybe Integer
    Maybe Text
    tagId :: Tag -> Maybe Integer
    tagId :: Maybe Integer
    tagName :: Maybe Text
    tagName :: Tag -> Maybe Text
    ..} = (\Maybe Integer
    tagId -> Tag { Maybe Integer
    tagId :: Maybe Integer
    tagId :: Maybe Integer
    tagId, Maybe Text
    tagName :: Maybe Text
    tagName :: Maybe Text
    ..} ) (Maybe Integer -> Tag) -> f (Maybe Integer) -> f Tag
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Integer -> f (Maybe Integer)
    f Maybe Integer
    tagId
    {-# INLINE tagIdL #-}

    -- | 'tagName' Lens
    tagNameL :: Lens_' Tag (Maybe Text)
    tagNameL :: Lens_' Tag (Maybe Text)
    tagNameL Maybe Text -> f (Maybe Text)
    f Tag{Maybe Integer
    Maybe Text
    tagId :: Tag -> Maybe Integer
    tagName :: Tag -> Maybe Text
    tagId :: Maybe Integer
    tagName :: Maybe Text
    ..} = (\Maybe Text
    tagName -> Tag { Maybe Text
    tagName :: Maybe Text
    tagName :: Maybe Text
    tagName, Maybe Integer
    tagId :: Maybe Integer
    tagId :: Maybe Integer
    ..} ) (Maybe Text -> Tag) -> f (Maybe Text) -> f Tag
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    tagName
    {-# INLINE tagNameL #-}

    -- * TypeHolderDefault

    -- | 'typeHolderDefaultStringItem' Lens
    typeHolderDefaultStringItemL :: Lens_' TypeHolderDefault (Text)
    typeHolderDefaultStringItemL :: Lens_' TypeHolderDefault Text
    typeHolderDefaultStringItemL Text -> f Text
    f TypeHolderDefault{Bool
    Double
    Int
    [Int]
    Text
    typeHolderDefaultStringItem :: TypeHolderDefault -> Text
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultArrayItem :: [Int]
    typeHolderDefaultNumberItem :: TypeHolderDefault -> Double
    typeHolderDefaultIntegerItem :: TypeHolderDefault -> Int
    typeHolderDefaultBoolItem :: TypeHolderDefault -> Bool
    typeHolderDefaultArrayItem :: TypeHolderDefault -> [Int]
    ..} = (\Text
    typeHolderDefaultStringItem -> TypeHolderDefault { Text
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultStringItem, Bool
    Double
    Int
    [Int]
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultArrayItem :: [Int]
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultArrayItem :: [Int]
    ..} ) (Text -> TypeHolderDefault) -> f Text -> f TypeHolderDefault
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text -> f Text
    f Text
    typeHolderDefaultStringItem
    {-# INLINE typeHolderDefaultStringItemL #-}

    -- | 'typeHolderDefaultNumberItem' Lens
    typeHolderDefaultNumberItemL :: Lens_' TypeHolderDefault (Double)
    typeHolderDefaultNumberItemL :: Lens_' TypeHolderDefault Double
    typeHolderDefaultNumberItemL Double -> f Double
    f TypeHolderDefault{Bool
    Double
    Int
    [Int]
    Text
    typeHolderDefaultStringItem :: TypeHolderDefault -> Text
    typeHolderDefaultNumberItem :: TypeHolderDefault -> Double
    typeHolderDefaultIntegerItem :: TypeHolderDefault -> Int
    typeHolderDefaultBoolItem :: TypeHolderDefault -> Bool
    typeHolderDefaultArrayItem :: TypeHolderDefault -> [Int]
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultArrayItem :: [Int]
    ..} = (\Double
    typeHolderDefaultNumberItem -> TypeHolderDefault { Double
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultNumberItem, Bool
    Int
    [Int]
    Text
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultArrayItem :: [Int]
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultArrayItem :: [Int]
    ..} ) (Double -> TypeHolderDefault) -> f Double -> f TypeHolderDefault
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Double -> f Double
    f Double
    typeHolderDefaultNumberItem
    {-# INLINE typeHolderDefaultNumberItemL #-}

    -- | 'typeHolderDefaultIntegerItem' Lens
    typeHolderDefaultIntegerItemL :: Lens_' TypeHolderDefault (Int)
    typeHolderDefaultIntegerItemL :: Lens_' TypeHolderDefault Int
    typeHolderDefaultIntegerItemL Int -> f Int
    f TypeHolderDefault{Bool
    Double
    Int
    [Int]
    Text
    typeHolderDefaultStringItem :: TypeHolderDefault -> Text
    typeHolderDefaultNumberItem :: TypeHolderDefault -> Double
    typeHolderDefaultIntegerItem :: TypeHolderDefault -> Int
    typeHolderDefaultBoolItem :: TypeHolderDefault -> Bool
    typeHolderDefaultArrayItem :: TypeHolderDefault -> [Int]
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultArrayItem :: [Int]
    ..} = (\Int
    typeHolderDefaultIntegerItem -> TypeHolderDefault { Int
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultIntegerItem, Bool
    Double
    [Int]
    Text
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultArrayItem :: [Int]
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultArrayItem :: [Int]
    ..} ) (Int -> TypeHolderDefault) -> f Int -> f TypeHolderDefault
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> f Int
    f Int
    typeHolderDefaultIntegerItem
    {-# INLINE typeHolderDefaultIntegerItemL #-}

    -- | 'typeHolderDefaultBoolItem' Lens
    typeHolderDefaultBoolItemL :: Lens_' TypeHolderDefault (Bool)
    typeHolderDefaultBoolItemL :: Lens_' TypeHolderDefault Bool
    typeHolderDefaultBoolItemL Bool -> f Bool
    f TypeHolderDefault{Bool
    Double
    Int
    [Int]
    Text
    typeHolderDefaultStringItem :: TypeHolderDefault -> Text
    typeHolderDefaultNumberItem :: TypeHolderDefault -> Double
    typeHolderDefaultIntegerItem :: TypeHolderDefault -> Int
    typeHolderDefaultBoolItem :: TypeHolderDefault -> Bool
    typeHolderDefaultArrayItem :: TypeHolderDefault -> [Int]
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultArrayItem :: [Int]
    ..} = (\Bool
    typeHolderDefaultBoolItem -> TypeHolderDefault { Bool
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultBoolItem, Double
    Int
    [Int]
    Text
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultArrayItem :: [Int]
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultArrayItem :: [Int]
    ..} ) (Bool -> TypeHolderDefault) -> f Bool -> f TypeHolderDefault
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Bool -> f Bool
    f Bool
    typeHolderDefaultBoolItem
    {-# INLINE typeHolderDefaultBoolItemL #-}

    -- | 'typeHolderDefaultArrayItem' Lens
    typeHolderDefaultArrayItemL :: Lens_' TypeHolderDefault ([Int])
    typeHolderDefaultArrayItemL :: Lens_' TypeHolderDefault [Int]
    typeHolderDefaultArrayItemL [Int] -> f [Int]
    f TypeHolderDefault{Bool
    Double
    Int
    [Int]
    Text
    typeHolderDefaultStringItem :: TypeHolderDefault -> Text
    typeHolderDefaultNumberItem :: TypeHolderDefault -> Double
    typeHolderDefaultIntegerItem :: TypeHolderDefault -> Int
    typeHolderDefaultBoolItem :: TypeHolderDefault -> Bool
    typeHolderDefaultArrayItem :: TypeHolderDefault -> [Int]
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultArrayItem :: [Int]
    ..} = (\[Int]
    typeHolderDefaultArrayItem -> TypeHolderDefault { [Int]
    typeHolderDefaultArrayItem :: [Int]
    typeHolderDefaultArrayItem :: [Int]
    typeHolderDefaultArrayItem, Bool
    Double
    Int
    Text
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultBoolItem :: Bool
    ..} ) ([Int] -> TypeHolderDefault) -> f [Int] -> f TypeHolderDefault
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [Int] -> f [Int]
    f [Int]
    typeHolderDefaultArrayItem
    {-# INLINE typeHolderDefaultArrayItemL #-}

    -- * TypeHolderExample

    -- | 'typeHolderExampleStringItem' Lens
    typeHolderExampleStringItemL :: Lens_' TypeHolderExample (Text)
    typeHolderExampleStringItemL :: Lens_' TypeHolderExample Text
    typeHolderExampleStringItemL Text -> f Text
    f TypeHolderExample{Bool
    Double
    Float
    Int
    [Int]
    Text
    typeHolderExampleStringItem :: TypeHolderExample -> Text
    typeHolderExampleStringItem :: Text
    typeHolderExampleNumberItem :: Double
    typeHolderExampleFloatItem :: Float
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleArrayItem :: [Int]
    typeHolderExampleNumberItem :: TypeHolderExample -> Double
    typeHolderExampleFloatItem :: TypeHolderExample -> Float
    typeHolderExampleIntegerItem :: TypeHolderExample -> Int
    typeHolderExampleBoolItem :: TypeHolderExample -> Bool
    typeHolderExampleArrayItem :: TypeHolderExample -> [Int]
    ..} = (\Text
    typeHolderExampleStringItem -> TypeHolderExample { Text
    typeHolderExampleStringItem :: Text
    typeHolderExampleStringItem :: Text
    typeHolderExampleStringItem, Bool
    Double
    Float
    Int
    [Int]
    typeHolderExampleNumberItem :: Double
    typeHolderExampleFloatItem :: Float
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleArrayItem :: [Int]
    typeHolderExampleNumberItem :: Double
    typeHolderExampleFloatItem :: Float
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleArrayItem :: [Int]
    ..} ) (Text -> TypeHolderExample) -> f Text -> f TypeHolderExample
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text -> f Text
    f Text
    typeHolderExampleStringItem
    {-# INLINE typeHolderExampleStringItemL #-}

    -- | 'typeHolderExampleNumberItem' Lens
    typeHolderExampleNumberItemL :: Lens_' TypeHolderExample (Double)
    typeHolderExampleNumberItemL :: Lens_' TypeHolderExample Double
    typeHolderExampleNumberItemL Double -> f Double
    f TypeHolderExample{Bool
    Double
    Float
    Int
    [Int]
    Text
    typeHolderExampleStringItem :: TypeHolderExample -> Text
    typeHolderExampleNumberItem :: TypeHolderExample -> Double
    typeHolderExampleFloatItem :: TypeHolderExample -> Float
    typeHolderExampleIntegerItem :: TypeHolderExample -> Int
    typeHolderExampleBoolItem :: TypeHolderExample -> Bool
    typeHolderExampleArrayItem :: TypeHolderExample -> [Int]
    typeHolderExampleStringItem :: Text
    typeHolderExampleNumberItem :: Double
    typeHolderExampleFloatItem :: Float
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleArrayItem :: [Int]
    ..} = (\Double
    typeHolderExampleNumberItem -> TypeHolderExample { Double
    typeHolderExampleNumberItem :: Double
    typeHolderExampleNumberItem :: Double
    typeHolderExampleNumberItem, Bool
    Float
    Int
    [Int]
    Text
    typeHolderExampleStringItem :: Text
    typeHolderExampleFloatItem :: Float
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleArrayItem :: [Int]
    typeHolderExampleStringItem :: Text
    typeHolderExampleFloatItem :: Float
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleArrayItem :: [Int]
    ..} ) (Double -> TypeHolderExample) -> f Double -> f TypeHolderExample
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Double -> f Double
    f Double
    typeHolderExampleNumberItem
    {-# INLINE typeHolderExampleNumberItemL #-}

    -- | 'typeHolderExampleFloatItem' Lens
    typeHolderExampleFloatItemL :: Lens_' TypeHolderExample (Float)
    typeHolderExampleFloatItemL :: Lens_' TypeHolderExample Float
    typeHolderExampleFloatItemL Float -> f Float
    f TypeHolderExample{Bool
    Double
    Float
    Int
    [Int]
    Text
    typeHolderExampleStringItem :: TypeHolderExample -> Text
    typeHolderExampleNumberItem :: TypeHolderExample -> Double
    typeHolderExampleFloatItem :: TypeHolderExample -> Float
    typeHolderExampleIntegerItem :: TypeHolderExample -> Int
    typeHolderExampleBoolItem :: TypeHolderExample -> Bool
    typeHolderExampleArrayItem :: TypeHolderExample -> [Int]
    typeHolderExampleStringItem :: Text
    typeHolderExampleNumberItem :: Double
    typeHolderExampleFloatItem :: Float
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleArrayItem :: [Int]
    ..} = (\Float
    typeHolderExampleFloatItem -> TypeHolderExample { Float
    typeHolderExampleFloatItem :: Float
    typeHolderExampleFloatItem :: Float
    typeHolderExampleFloatItem, Bool
    Double
    Int
    [Int]
    Text
    typeHolderExampleStringItem :: Text
    typeHolderExampleNumberItem :: Double
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleArrayItem :: [Int]
    typeHolderExampleStringItem :: Text
    typeHolderExampleNumberItem :: Double
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleArrayItem :: [Int]
    ..} ) (Float -> TypeHolderExample) -> f Float -> f TypeHolderExample
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Float -> f Float
    f Float
    typeHolderExampleFloatItem
    {-# INLINE typeHolderExampleFloatItemL #-}

    -- | 'typeHolderExampleIntegerItem' Lens
    typeHolderExampleIntegerItemL :: Lens_' TypeHolderExample (Int)
    typeHolderExampleIntegerItemL :: Lens_' TypeHolderExample Int
    typeHolderExampleIntegerItemL Int -> f Int
    f TypeHolderExample{Bool
    Double
    Float
    Int
    [Int]
    Text
    typeHolderExampleStringItem :: TypeHolderExample -> Text
    typeHolderExampleNumberItem :: TypeHolderExample -> Double
    typeHolderExampleFloatItem :: TypeHolderExample -> Float
    typeHolderExampleIntegerItem :: TypeHolderExample -> Int
    typeHolderExampleBoolItem :: TypeHolderExample -> Bool
    typeHolderExampleArrayItem :: TypeHolderExample -> [Int]
    typeHolderExampleStringItem :: Text
    typeHolderExampleNumberItem :: Double
    typeHolderExampleFloatItem :: Float
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleArrayItem :: [Int]
    ..} = (\Int
    typeHolderExampleIntegerItem -> TypeHolderExample { Int
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleIntegerItem, Bool
    Double
    Float
    [Int]
    Text
    typeHolderExampleStringItem :: Text
    typeHolderExampleNumberItem :: Double
    typeHolderExampleFloatItem :: Float
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleArrayItem :: [Int]
    typeHolderExampleStringItem :: Text
    typeHolderExampleNumberItem :: Double
    typeHolderExampleFloatItem :: Float
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleArrayItem :: [Int]
    ..} ) (Int -> TypeHolderExample) -> f Int -> f TypeHolderExample
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> f Int
    f Int
    typeHolderExampleIntegerItem
    {-# INLINE typeHolderExampleIntegerItemL #-}

    -- | 'typeHolderExampleBoolItem' Lens
    typeHolderExampleBoolItemL :: Lens_' TypeHolderExample (Bool)
    typeHolderExampleBoolItemL :: Lens_' TypeHolderExample Bool
    typeHolderExampleBoolItemL Bool -> f Bool
    f TypeHolderExample{Bool
    Double
    Float
    Int
    [Int]
    Text
    typeHolderExampleStringItem :: TypeHolderExample -> Text
    typeHolderExampleNumberItem :: TypeHolderExample -> Double
    typeHolderExampleFloatItem :: TypeHolderExample -> Float
    typeHolderExampleIntegerItem :: TypeHolderExample -> Int
    typeHolderExampleBoolItem :: TypeHolderExample -> Bool
    typeHolderExampleArrayItem :: TypeHolderExample -> [Int]
    typeHolderExampleStringItem :: Text
    typeHolderExampleNumberItem :: Double
    typeHolderExampleFloatItem :: Float
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleArrayItem :: [Int]
    ..} = (\Bool
    typeHolderExampleBoolItem -> TypeHolderExample { Bool
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleBoolItem, Double
    Float
    Int
    [Int]
    Text
    typeHolderExampleStringItem :: Text
    typeHolderExampleNumberItem :: Double
    typeHolderExampleFloatItem :: Float
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleArrayItem :: [Int]
    typeHolderExampleStringItem :: Text
    typeHolderExampleNumberItem :: Double
    typeHolderExampleFloatItem :: Float
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleArrayItem :: [Int]
    ..} ) (Bool -> TypeHolderExample) -> f Bool -> f TypeHolderExample
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Bool -> f Bool
    f Bool
    typeHolderExampleBoolItem
    {-# INLINE typeHolderExampleBoolItemL #-}

    -- | 'typeHolderExampleArrayItem' Lens
    typeHolderExampleArrayItemL :: Lens_' TypeHolderExample ([Int])
    typeHolderExampleArrayItemL :: Lens_' TypeHolderExample [Int]
    typeHolderExampleArrayItemL [Int] -> f [Int]
    f TypeHolderExample{Bool
    Double
    Float
    Int
    [Int]
    Text
    typeHolderExampleStringItem :: TypeHolderExample -> Text
    typeHolderExampleNumberItem :: TypeHolderExample -> Double
    typeHolderExampleFloatItem :: TypeHolderExample -> Float
    typeHolderExampleIntegerItem :: TypeHolderExample -> Int
    typeHolderExampleBoolItem :: TypeHolderExample -> Bool
    typeHolderExampleArrayItem :: TypeHolderExample -> [Int]
    typeHolderExampleStringItem :: Text
    typeHolderExampleNumberItem :: Double
    typeHolderExampleFloatItem :: Float
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleArrayItem :: [Int]
    ..} = (\[Int]
    typeHolderExampleArrayItem -> TypeHolderExample { [Int]
    typeHolderExampleArrayItem :: [Int]
    typeHolderExampleArrayItem :: [Int]
    typeHolderExampleArrayItem, Bool
    Double
    Float
    Int
    Text
    typeHolderExampleStringItem :: Text
    typeHolderExampleNumberItem :: Double
    typeHolderExampleFloatItem :: Float
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleStringItem :: Text
    typeHolderExampleNumberItem :: Double
    typeHolderExampleFloatItem :: Float
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleBoolItem :: Bool
    ..} ) ([Int] -> TypeHolderExample) -> f [Int] -> f TypeHolderExample
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [Int] -> f [Int]
    f [Int]
    typeHolderExampleArrayItem
    {-# INLINE typeHolderExampleArrayItemL #-}

    -- * User

    -- | 'userId' Lens
    userIdL :: Lens_' User (Maybe Integer)
    userIdL :: Lens_' User (Maybe Integer)
    userIdL Maybe Integer -> f (Maybe Integer)
    f User{Maybe Int
    Maybe Integer
    Maybe Text
    userId :: User -> Maybe Integer
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    userUsername :: User -> Maybe Text
    userFirstName :: User -> Maybe Text
    userLastName :: User -> Maybe Text
    userEmail :: User -> Maybe Text
    userPassword :: User -> Maybe Text
    userPhone :: User -> Maybe Text
    userUserStatus :: User -> Maybe Int
    ..} = (\Maybe Integer
    userId -> User { Maybe Integer
    userId :: Maybe Integer
    userId :: Maybe Integer
    userId, Maybe Int
    Maybe Text
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    ..} ) (Maybe Integer -> User) -> f (Maybe Integer) -> f User
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Integer -> f (Maybe Integer)
    f Maybe Integer
    userId
    {-# INLINE userIdL #-}

    -- | 'userUsername' Lens
    userUsernameL :: Lens_' User (Maybe Text)
    userUsernameL :: Lens_' User (Maybe Text)
    userUsernameL Maybe Text -> f (Maybe Text)
    f User{Maybe Int
    Maybe Integer
    Maybe Text
    userId :: User -> Maybe Integer
    userUsername :: User -> Maybe Text
    userFirstName :: User -> Maybe Text
    userLastName :: User -> Maybe Text
    userEmail :: User -> Maybe Text
    userPassword :: User -> Maybe Text
    userPhone :: User -> Maybe Text
    userUserStatus :: User -> Maybe Int
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    ..} = (\Maybe Text
    userUsername -> User { Maybe Text
    userUsername :: Maybe Text
    userUsername :: Maybe Text
    userUsername, Maybe Int
    Maybe Integer
    Maybe Text
    userId :: Maybe Integer
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    userId :: Maybe Integer
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    ..} ) (Maybe Text -> User) -> f (Maybe Text) -> f User
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    userUsername
    {-# INLINE userUsernameL #-}

    -- | 'userFirstName' Lens
    userFirstNameL :: Lens_' User (Maybe Text)
    userFirstNameL :: Lens_' User (Maybe Text)
    userFirstNameL Maybe Text -> f (Maybe Text)
    f User{Maybe Int
    Maybe Integer
    Maybe Text
    userId :: User -> Maybe Integer
    userUsername :: User -> Maybe Text
    userFirstName :: User -> Maybe Text
    userLastName :: User -> Maybe Text
    userEmail :: User -> Maybe Text
    userPassword :: User -> Maybe Text
    userPhone :: User -> Maybe Text
    userUserStatus :: User -> Maybe Int
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    ..} = (\Maybe Text
    userFirstName -> User { Maybe Text
    userFirstName :: Maybe Text
    userFirstName :: Maybe Text
    userFirstName, Maybe Int
    Maybe Integer
    Maybe Text
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    ..} ) (Maybe Text -> User) -> f (Maybe Text) -> f User
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    userFirstName
    {-# INLINE userFirstNameL #-}

    -- | 'userLastName' Lens
    userLastNameL :: Lens_' User (Maybe Text)
    userLastNameL :: Lens_' User (Maybe Text)
    userLastNameL Maybe Text -> f (Maybe Text)
    f User{Maybe Int
    Maybe Integer
    Maybe Text
    userId :: User -> Maybe Integer
    userUsername :: User -> Maybe Text
    userFirstName :: User -> Maybe Text
    userLastName :: User -> Maybe Text
    userEmail :: User -> Maybe Text
    userPassword :: User -> Maybe Text
    userPhone :: User -> Maybe Text
    userUserStatus :: User -> Maybe Int
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    ..} = (\Maybe Text
    userLastName -> User { Maybe Text
    userLastName :: Maybe Text
    userLastName :: Maybe Text
    userLastName, Maybe Int
    Maybe Integer
    Maybe Text
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    ..} ) (Maybe Text -> User) -> f (Maybe Text) -> f User
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    userLastName
    {-# INLINE userLastNameL #-}

    -- | 'userEmail' Lens
    userEmailL :: Lens_' User (Maybe Text)
    userEmailL :: Lens_' User (Maybe Text)
    userEmailL Maybe Text -> f (Maybe Text)
    f User{Maybe Int
    Maybe Integer
    Maybe Text
    userId :: User -> Maybe Integer
    userUsername :: User -> Maybe Text
    userFirstName :: User -> Maybe Text
    userLastName :: User -> Maybe Text
    userEmail :: User -> Maybe Text
    userPassword :: User -> Maybe Text
    userPhone :: User -> Maybe Text
    userUserStatus :: User -> Maybe Int
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    ..} = (\Maybe Text
    userEmail -> User { Maybe Text
    userEmail :: Maybe Text
    userEmail :: Maybe Text
    userEmail, Maybe Int
    Maybe Integer
    Maybe Text
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    ..} ) (Maybe Text -> User) -> f (Maybe Text) -> f User
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    userEmail
    {-# INLINE userEmailL #-}

    -- | 'userPassword' Lens
    userPasswordL :: Lens_' User (Maybe Text)
    userPasswordL :: Lens_' User (Maybe Text)
    userPasswordL Maybe Text -> f (Maybe Text)
    f User{Maybe Int
    Maybe Integer
    Maybe Text
    userId :: User -> Maybe Integer
    userUsername :: User -> Maybe Text
    userFirstName :: User -> Maybe Text
    userLastName :: User -> Maybe Text
    userEmail :: User -> Maybe Text
    userPassword :: User -> Maybe Text
    userPhone :: User -> Maybe Text
    userUserStatus :: User -> Maybe Int
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    ..} = (\Maybe Text
    userPassword -> User { Maybe Text
    userPassword :: Maybe Text
    userPassword :: Maybe Text
    userPassword, Maybe Int
    Maybe Integer
    Maybe Text
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    ..} ) (Maybe Text -> User) -> f (Maybe Text) -> f User
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    userPassword
    {-# INLINE userPasswordL #-}

    -- | 'userPhone' Lens
    userPhoneL :: Lens_' User (Maybe Text)
    userPhoneL :: Lens_' User (Maybe Text)
    userPhoneL Maybe Text -> f (Maybe Text)
    f User{Maybe Int
    Maybe Integer
    Maybe Text
    userId :: User -> Maybe Integer
    userUsername :: User -> Maybe Text
    userFirstName :: User -> Maybe Text
    userLastName :: User -> Maybe Text
    userEmail :: User -> Maybe Text
    userPassword :: User -> Maybe Text
    userPhone :: User -> Maybe Text
    userUserStatus :: User -> Maybe Int
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    ..} = (\Maybe Text
    userPhone -> User { Maybe Text
    userPhone :: Maybe Text
    userPhone :: Maybe Text
    userPhone, Maybe Int
    Maybe Integer
    Maybe Text
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userUserStatus :: Maybe Int
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userUserStatus :: Maybe Int
    ..} ) (Maybe Text -> User) -> f (Maybe Text) -> f User
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    userPhone
    {-# INLINE userPhoneL #-}

    -- | 'userUserStatus' Lens
    userUserStatusL :: Lens_' User (Maybe Int)
    userUserStatusL :: Lens_' User (Maybe Int)
    userUserStatusL Maybe Int -> f (Maybe Int)
    f User{Maybe Int
    Maybe Integer
    Maybe Text
    userId :: User -> Maybe Integer
    userUsername :: User -> Maybe Text
    userFirstName :: User -> Maybe Text
    userLastName :: User -> Maybe Text
    userEmail :: User -> Maybe Text
    userPassword :: User -> Maybe Text
    userPhone :: User -> Maybe Text
    userUserStatus :: User -> Maybe Int
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    ..} = (\Maybe Int
    userUserStatus -> User { Maybe Int
    userUserStatus :: Maybe Int
    userUserStatus :: Maybe Int
    userUserStatus, Maybe Integer
    Maybe Text
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    ..} ) (Maybe Int -> User) -> f (Maybe Int) -> f User
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Int -> f (Maybe Int)
    f Maybe Int
    userUserStatus
    {-# INLINE userUserStatusL #-}

    -- * XmlItem

    -- | 'xmlItemAttributeString' Lens
    xmlItemAttributeStringL :: Lens_' XmlItem (Maybe Text)
    xmlItemAttributeStringL :: Lens_' XmlItem (Maybe Text)
    xmlItemAttributeStringL Maybe Text -> f (Maybe Text)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    ..} = (\Maybe Text
    xmlItemAttributeString -> XmlItem { Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeString, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Text -> XmlItem) -> f (Maybe Text) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    xmlItemAttributeString
    {-# INLINE xmlItemAttributeStringL #-}

    -- | 'xmlItemAttributeNumber' Lens
    xmlItemAttributeNumberL :: Lens_' XmlItem (Maybe Double)
    xmlItemAttributeNumberL :: Lens_' XmlItem (Maybe Double)
    xmlItemAttributeNumberL Maybe Double -> f (Maybe Double)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Double
    xmlItemAttributeNumber -> XmlItem { Maybe Double
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeNumber, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Double -> XmlItem) -> f (Maybe Double) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Double -> f (Maybe Double)
    f Maybe Double
    xmlItemAttributeNumber
    {-# INLINE xmlItemAttributeNumberL #-}

    -- | 'xmlItemAttributeInteger' Lens
    xmlItemAttributeIntegerL :: Lens_' XmlItem (Maybe Int)
    xmlItemAttributeIntegerL :: Lens_' XmlItem (Maybe Int)
    xmlItemAttributeIntegerL Maybe Int -> f (Maybe Int)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Int
    xmlItemAttributeInteger -> XmlItem { Maybe Int
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeInteger, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Int -> XmlItem) -> f (Maybe Int) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Int -> f (Maybe Int)
    f Maybe Int
    xmlItemAttributeInteger
    {-# INLINE xmlItemAttributeIntegerL #-}

    -- | 'xmlItemAttributeBoolean' Lens
    xmlItemAttributeBooleanL :: Lens_' XmlItem (Maybe Bool)
    xmlItemAttributeBooleanL :: Lens_' XmlItem (Maybe Bool)
    xmlItemAttributeBooleanL Maybe Bool -> f (Maybe Bool)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Bool
    xmlItemAttributeBoolean -> XmlItem { Maybe Bool
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemAttributeBoolean, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Bool -> XmlItem) -> f (Maybe Bool) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Bool -> f (Maybe Bool)
    f Maybe Bool
    xmlItemAttributeBoolean
    {-# INLINE xmlItemAttributeBooleanL #-}

    -- | 'xmlItemWrappedArray' Lens
    xmlItemWrappedArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemWrappedArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemWrappedArrayL Maybe [Int] -> f (Maybe [Int])
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe [Int]
    xmlItemWrappedArray -> XmlItem { Maybe [Int]
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemWrappedArray, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe [Int] -> XmlItem) -> f (Maybe [Int]) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [Int] -> f (Maybe [Int])
    f Maybe [Int]
    xmlItemWrappedArray
    {-# INLINE xmlItemWrappedArrayL #-}

    -- | 'xmlItemNameString' Lens
    xmlItemNameStringL :: Lens_' XmlItem (Maybe Text)
    xmlItemNameStringL :: Lens_' XmlItem (Maybe Text)
    xmlItemNameStringL Maybe Text -> f (Maybe Text)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Text
    xmlItemNameString -> XmlItem { Maybe Text
    xmlItemNameString :: Maybe Text
    xmlItemNameString :: Maybe Text
    xmlItemNameString, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Text -> XmlItem) -> f (Maybe Text) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    xmlItemNameString
    {-# INLINE xmlItemNameStringL #-}

    -- | 'xmlItemNameNumber' Lens
    xmlItemNameNumberL :: Lens_' XmlItem (Maybe Double)
    xmlItemNameNumberL :: Lens_' XmlItem (Maybe Double)
    xmlItemNameNumberL Maybe Double -> f (Maybe Double)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Double
    xmlItemNameNumber -> XmlItem { Maybe Double
    xmlItemNameNumber :: Maybe Double
    xmlItemNameNumber :: Maybe Double
    xmlItemNameNumber, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Double -> XmlItem) -> f (Maybe Double) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Double -> f (Maybe Double)
    f Maybe Double
    xmlItemNameNumber
    {-# INLINE xmlItemNameNumberL #-}

    -- | 'xmlItemNameInteger' Lens
    xmlItemNameIntegerL :: Lens_' XmlItem (Maybe Int)
    xmlItemNameIntegerL :: Lens_' XmlItem (Maybe Int)
    xmlItemNameIntegerL Maybe Int -> f (Maybe Int)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Int
    xmlItemNameInteger -> XmlItem { Maybe Int
    xmlItemNameInteger :: Maybe Int
    xmlItemNameInteger :: Maybe Int
    xmlItemNameInteger, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Int -> XmlItem) -> f (Maybe Int) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Int -> f (Maybe Int)
    f Maybe Int
    xmlItemNameInteger
    {-# INLINE xmlItemNameIntegerL #-}

    -- | 'xmlItemNameBoolean' Lens
    xmlItemNameBooleanL :: Lens_' XmlItem (Maybe Bool)
    xmlItemNameBooleanL :: Lens_' XmlItem (Maybe Bool)
    xmlItemNameBooleanL Maybe Bool -> f (Maybe Bool)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Bool
    xmlItemNameBoolean -> XmlItem { Maybe Bool
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameBoolean, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Bool -> XmlItem) -> f (Maybe Bool) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Bool -> f (Maybe Bool)
    f Maybe Bool
    xmlItemNameBoolean
    {-# INLINE xmlItemNameBooleanL #-}

    -- | 'xmlItemNameArray' Lens
    xmlItemNameArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemNameArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemNameArrayL Maybe [Int] -> f (Maybe [Int])
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe [Int]
    xmlItemNameArray -> XmlItem { Maybe [Int]
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameArray, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe [Int] -> XmlItem) -> f (Maybe [Int]) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [Int] -> f (Maybe [Int])
    f Maybe [Int]
    xmlItemNameArray
    {-# INLINE xmlItemNameArrayL #-}

    -- | 'xmlItemNameWrappedArray' Lens
    xmlItemNameWrappedArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemNameWrappedArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemNameWrappedArrayL Maybe [Int] -> f (Maybe [Int])
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe [Int]
    xmlItemNameWrappedArray -> XmlItem { Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemNameWrappedArray, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe [Int] -> XmlItem) -> f (Maybe [Int]) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [Int] -> f (Maybe [Int])
    f Maybe [Int]
    xmlItemNameWrappedArray
    {-# INLINE xmlItemNameWrappedArrayL #-}

    -- | 'xmlItemPrefixString' Lens
    xmlItemPrefixStringL :: Lens_' XmlItem (Maybe Text)
    xmlItemPrefixStringL :: Lens_' XmlItem (Maybe Text)
    xmlItemPrefixStringL Maybe Text -> f (Maybe Text)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Text
    xmlItemPrefixString -> XmlItem { Maybe Text
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixString, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Text -> XmlItem) -> f (Maybe Text) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    xmlItemPrefixString
    {-# INLINE xmlItemPrefixStringL #-}

    -- | 'xmlItemPrefixNumber' Lens
    xmlItemPrefixNumberL :: Lens_' XmlItem (Maybe Double)
    xmlItemPrefixNumberL :: Lens_' XmlItem (Maybe Double)
    xmlItemPrefixNumberL Maybe Double -> f (Maybe Double)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Double
    xmlItemPrefixNumber -> XmlItem { Maybe Double
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixNumber, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Double -> XmlItem) -> f (Maybe Double) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Double -> f (Maybe Double)
    f Maybe Double
    xmlItemPrefixNumber
    {-# INLINE xmlItemPrefixNumberL #-}

    -- | 'xmlItemPrefixInteger' Lens
    xmlItemPrefixIntegerL :: Lens_' XmlItem (Maybe Int)
    xmlItemPrefixIntegerL :: Lens_' XmlItem (Maybe Int)
    xmlItemPrefixIntegerL Maybe Int -> f (Maybe Int)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Int
    xmlItemPrefixInteger -> XmlItem { Maybe Int
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixInteger, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Int -> XmlItem) -> f (Maybe Int) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Int -> f (Maybe Int)
    f Maybe Int
    xmlItemPrefixInteger
    {-# INLINE xmlItemPrefixIntegerL #-}

    -- | 'xmlItemPrefixBoolean' Lens
    xmlItemPrefixBooleanL :: Lens_' XmlItem (Maybe Bool)
    xmlItemPrefixBooleanL :: Lens_' XmlItem (Maybe Bool)
    xmlItemPrefixBooleanL Maybe Bool -> f (Maybe Bool)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Bool
    xmlItemPrefixBoolean -> XmlItem { Maybe Bool
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixBoolean, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Bool -> XmlItem) -> f (Maybe Bool) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Bool -> f (Maybe Bool)
    f Maybe Bool
    xmlItemPrefixBoolean
    {-# INLINE xmlItemPrefixBooleanL #-}

    -- | 'xmlItemPrefixArray' Lens
    xmlItemPrefixArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemPrefixArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemPrefixArrayL Maybe [Int] -> f (Maybe [Int])
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe [Int]
    xmlItemPrefixArray -> XmlItem { Maybe [Int]
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixArray, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe [Int] -> XmlItem) -> f (Maybe [Int]) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [Int] -> f (Maybe [Int])
    f Maybe [Int]
    xmlItemPrefixArray
    {-# INLINE xmlItemPrefixArrayL #-}

    -- | 'xmlItemPrefixWrappedArray' Lens
    xmlItemPrefixWrappedArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemPrefixWrappedArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemPrefixWrappedArrayL Maybe [Int] -> f (Maybe [Int])
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe [Int]
    xmlItemPrefixWrappedArray -> XmlItem { Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemPrefixWrappedArray, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe [Int] -> XmlItem) -> f (Maybe [Int]) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [Int] -> f (Maybe [Int])
    f Maybe [Int]
    xmlItemPrefixWrappedArray
    {-# INLINE xmlItemPrefixWrappedArrayL #-}

    -- | 'xmlItemNamespaceString' Lens
    xmlItemNamespaceStringL :: Lens_' XmlItem (Maybe Text)
    xmlItemNamespaceStringL :: Lens_' XmlItem (Maybe Text)
    xmlItemNamespaceStringL Maybe Text -> f (Maybe Text)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Text
    xmlItemNamespaceString -> XmlItem { Maybe Text
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceString, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Text -> XmlItem) -> f (Maybe Text) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    xmlItemNamespaceString
    {-# INLINE xmlItemNamespaceStringL #-}

    -- | 'xmlItemNamespaceNumber' Lens
    xmlItemNamespaceNumberL :: Lens_' XmlItem (Maybe Double)
    xmlItemNamespaceNumberL :: Lens_' XmlItem (Maybe Double)
    xmlItemNamespaceNumberL Maybe Double -> f (Maybe Double)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Double
    xmlItemNamespaceNumber -> XmlItem { Maybe Double
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceNumber, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Double -> XmlItem) -> f (Maybe Double) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Double -> f (Maybe Double)
    f Maybe Double
    xmlItemNamespaceNumber
    {-# INLINE xmlItemNamespaceNumberL #-}

    -- | 'xmlItemNamespaceInteger' Lens
    xmlItemNamespaceIntegerL :: Lens_' XmlItem (Maybe Int)
    xmlItemNamespaceIntegerL :: Lens_' XmlItem (Maybe Int)
    xmlItemNamespaceIntegerL Maybe Int -> f (Maybe Int)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Int
    xmlItemNamespaceInteger -> XmlItem { Maybe Int
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceInteger, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Int -> XmlItem) -> f (Maybe Int) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Int -> f (Maybe Int)
    f Maybe Int
    xmlItemNamespaceInteger
    {-# INLINE xmlItemNamespaceIntegerL #-}

    -- | 'xmlItemNamespaceBoolean' Lens
    xmlItemNamespaceBooleanL :: Lens_' XmlItem (Maybe Bool)
    xmlItemNamespaceBooleanL :: Lens_' XmlItem (Maybe Bool)
    xmlItemNamespaceBooleanL Maybe Bool -> f (Maybe Bool)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Bool
    xmlItemNamespaceBoolean -> XmlItem { Maybe Bool
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceBoolean, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Bool -> XmlItem) -> f (Maybe Bool) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Bool -> f (Maybe Bool)
    f Maybe Bool
    xmlItemNamespaceBoolean
    {-# INLINE xmlItemNamespaceBooleanL #-}

    -- | 'xmlItemNamespaceArray' Lens
    xmlItemNamespaceArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemNamespaceArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemNamespaceArrayL Maybe [Int] -> f (Maybe [Int])
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe [Int]
    xmlItemNamespaceArray -> XmlItem { Maybe [Int]
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceArray, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe [Int] -> XmlItem) -> f (Maybe [Int]) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [Int] -> f (Maybe [Int])
    f Maybe [Int]
    xmlItemNamespaceArray
    {-# INLINE xmlItemNamespaceArrayL #-}

    -- | 'xmlItemNamespaceWrappedArray' Lens
    xmlItemNamespaceWrappedArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemNamespaceWrappedArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemNamespaceWrappedArrayL Maybe [Int] -> f (Maybe [Int])
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe [Int]
    xmlItemNamespaceWrappedArray -> XmlItem { Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe [Int] -> XmlItem) -> f (Maybe [Int]) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [Int] -> f (Maybe [Int])
    f Maybe [Int]
    xmlItemNamespaceWrappedArray
    {-# INLINE xmlItemNamespaceWrappedArrayL #-}

    -- | 'xmlItemPrefixNsString' Lens
    xmlItemPrefixNsStringL :: Lens_' XmlItem (Maybe Text)
    xmlItemPrefixNsStringL :: Lens_' XmlItem (Maybe Text)
    xmlItemPrefixNsStringL Maybe Text -> f (Maybe Text)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Text
    xmlItemPrefixNsString -> XmlItem { Maybe Text
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsString, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Text -> XmlItem) -> f (Maybe Text) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text -> f (Maybe Text)
    f Maybe Text
    xmlItemPrefixNsString
    {-# INLINE xmlItemPrefixNsStringL #-}

    -- | 'xmlItemPrefixNsNumber' Lens
    xmlItemPrefixNsNumberL :: Lens_' XmlItem (Maybe Double)
    xmlItemPrefixNsNumberL :: Lens_' XmlItem (Maybe Double)
    xmlItemPrefixNsNumberL Maybe Double -> f (Maybe Double)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Double
    xmlItemPrefixNsNumber -> XmlItem { Maybe Double
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsNumber, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Double -> XmlItem) -> f (Maybe Double) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Double -> f (Maybe Double)
    f Maybe Double
    xmlItemPrefixNsNumber
    {-# INLINE xmlItemPrefixNsNumberL #-}

    -- | 'xmlItemPrefixNsInteger' Lens
    xmlItemPrefixNsIntegerL :: Lens_' XmlItem (Maybe Int)
    xmlItemPrefixNsIntegerL :: Lens_' XmlItem (Maybe Int)
    xmlItemPrefixNsIntegerL Maybe Int -> f (Maybe Int)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Int
    xmlItemPrefixNsInteger -> XmlItem { Maybe Int
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsInteger, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Int -> XmlItem) -> f (Maybe Int) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Int -> f (Maybe Int)
    f Maybe Int
    xmlItemPrefixNsInteger
    {-# INLINE xmlItemPrefixNsIntegerL #-}

    -- | 'xmlItemPrefixNsBoolean' Lens
    xmlItemPrefixNsBooleanL :: Lens_' XmlItem (Maybe Bool)
    xmlItemPrefixNsBooleanL :: Lens_' XmlItem (Maybe Bool)
    xmlItemPrefixNsBooleanL Maybe Bool -> f (Maybe Bool)
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe Bool
    xmlItemPrefixNsBoolean -> XmlItem { Maybe Bool
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsBoolean, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe Bool -> XmlItem) -> f (Maybe Bool) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Bool -> f (Maybe Bool)
    f Maybe Bool
    xmlItemPrefixNsBoolean
    {-# INLINE xmlItemPrefixNsBooleanL #-}

    -- | 'xmlItemPrefixNsArray' Lens
    xmlItemPrefixNsArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemPrefixNsArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemPrefixNsArrayL Maybe [Int] -> f (Maybe [Int])
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe [Int]
    xmlItemPrefixNsArray -> XmlItem { Maybe [Int]
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsArray, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} ) (Maybe [Int] -> XmlItem) -> f (Maybe [Int]) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [Int] -> f (Maybe [Int])
    f Maybe [Int]
    xmlItemPrefixNsArray
    {-# INLINE xmlItemPrefixNsArrayL #-}

    -- | 'xmlItemPrefixNsWrappedArray' Lens
    xmlItemPrefixNsWrappedArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemPrefixNsWrappedArrayL :: Lens_' XmlItem (Maybe [Int])
    xmlItemPrefixNsWrappedArrayL Maybe [Int] -> f (Maybe [Int])
    f XmlItem{Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} = (\Maybe [Int]
    xmlItemPrefixNsWrappedArray -> XmlItem { Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray, Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    ..} ) (Maybe [Int] -> XmlItem) -> f (Maybe [Int]) -> f XmlItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [Int] -> f (Maybe [Int])
    f Maybe [Int]
    xmlItemPrefixNsWrappedArray
    {-# INLINE xmlItemPrefixNsWrappedArrayL #-}