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