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