content: {-# LANGUAGE CPP #-}
  {-# OPTIONS_GHC -fno-warn-unused-imports -fno-warn-unused-matches #-}
  
  module Instances where
  
  import OpenAPIPetstore.Model
  import OpenAPIPetstore.Core
  
  import qualified Data.Aeson as A
  import qualified Data.ByteString.Lazy as BL
  import qualified Data.HashMap.Strict as HM
  import qualified Data.Set as Set
  import qualified Data.Text as T
  import qualified Data.Time as TI
  import qualified Data.Vector as V
  import Data.String (fromString)
  
  import Control.Monad
  import Data.Char (isSpace)
  import Data.List (sort)
  import Test.QuickCheck
  
  import ApproxEq
  
  instance Arbitrary T.Text where
    arbitrary = T.pack <$> arbitrary
  
  instance Arbitrary TI.Day where
    arbitrary = TI.ModifiedJulianDay . (2000 +) <$> arbitrary
    shrink = (TI.ModifiedJulianDay <$>) . shrink . TI.toModifiedJulianDay
  
  instance Arbitrary TI.UTCTime where
    arbitrary =
      TI.UTCTime <$> arbitrary <*> (TI.secondsToDiffTime <$> choose (0, 86401))
  
  instance Arbitrary BL.ByteString where
      arbitrary = BL.pack <$> arbitrary
      shrink xs = BL.pack <$> shrink (BL.unpack xs)
  
  instance Arbitrary ByteArray where
      arbitrary = ByteArray <$> arbitrary
      shrink (ByteArray xs) = ByteArray <$> shrink xs
  
  instance Arbitrary Binary where
      arbitrary = Binary <$> arbitrary
      shrink (Binary xs) = Binary <$> shrink xs
  
  instance Arbitrary DateTime where
      arbitrary = DateTime <$> arbitrary
      shrink (DateTime xs) = DateTime <$> shrink xs
  
  instance Arbitrary Date where
      arbitrary = Date <$> arbitrary
      shrink (Date xs) = Date <$> shrink xs
  
  #if MIN_VERSION_aeson(2,0,0)
  #else
  -- | A naive Arbitrary instance for A.Value:
  instance Arbitrary A.Value where
    arbitrary = arbitraryValue
  #endif
  
  arbitraryValue :: Gen A.Value
  arbitraryValue =
    frequency [(3, simpleTypes), (1, arrayTypes), (1, objectTypes)]
      where
        simpleTypes :: Gen A.Value
        simpleTypes =
          frequency
            [ (1, return A.Null)
            , (2, liftM A.Bool (arbitrary :: Gen Bool))
            , (2, liftM (A.Number . fromIntegral) (arbitrary :: Gen Int))
            , (2, liftM (A.String . T.pack) (arbitrary :: Gen String))
            ]
        mapF (k, v) = (fromString k, v)
        simpleAndArrays = frequency [(1, sized sizedArray), (4, simpleTypes)]
        arrayTypes = sized sizedArray
        objectTypes = sized sizedObject
        sizedArray n = liftM (A.Array . V.fromList) $ replicateM n simpleTypes
        sizedObject n =
          liftM (A.object . map mapF) $
          replicateM n $ (,) <$> (arbitrary :: Gen String) <*> simpleAndArrays
  
  -- | Checks if a given list has no duplicates in _O(n log n)_.
  hasNoDups
    :: (Ord a)
    => [a] -> Bool
  hasNoDups = go Set.empty
    where
      go _ [] = True
      go s (x:xs)
        | s' <- Set.insert x s
        , Set.size s' > Set.size s = go s' xs
        | otherwise = False
  
  instance ApproxEq TI.Day where
    (=~) = (==)
  
  arbitraryReduced :: Arbitrary a => Int -> Gen a
  arbitraryReduced n = resize (n `div` 2) arbitrary
  
  arbitraryReducedMaybe :: Arbitrary a => Int -> Gen (Maybe a)
  arbitraryReducedMaybe 0 = elements [Nothing]
  arbitraryReducedMaybe n = arbitraryReduced n
  
  arbitraryReducedMaybeValue :: Int -> Gen (Maybe A.Value)
  arbitraryReducedMaybeValue 0 = elements [Nothing]
  arbitraryReducedMaybeValue n = do
    generated <- arbitraryReduced n
    if generated == Just A.Null
      then return Nothing
      else return generated
  
  -- * Models
  
  instance Arbitrary AdditionalPropertiesAnyType where
    arbitrary = sized genAdditionalPropertiesAnyType
  
  genAdditionalPropertiesAnyType :: Int -> Gen AdditionalPropertiesAnyType
  genAdditionalPropertiesAnyType n =
    AdditionalPropertiesAnyType
      <$> arbitraryReducedMaybe n -- additionalPropertiesAnyTypeName :: Maybe Text
    
  instance Arbitrary AdditionalPropertiesArray where
    arbitrary = sized genAdditionalPropertiesArray
  
  genAdditionalPropertiesArray :: Int -> Gen AdditionalPropertiesArray
  genAdditionalPropertiesArray n =
    AdditionalPropertiesArray
      <$> arbitraryReducedMaybe n -- additionalPropertiesArrayName :: Maybe Text
    
  instance Arbitrary AdditionalPropertiesBoolean where
    arbitrary = sized genAdditionalPropertiesBoolean
  
  genAdditionalPropertiesBoolean :: Int -> Gen AdditionalPropertiesBoolean
  genAdditionalPropertiesBoolean n =
    AdditionalPropertiesBoolean
      <$> arbitraryReducedMaybe n -- additionalPropertiesBooleanName :: Maybe Text
    
  instance Arbitrary AdditionalPropertiesClass where
    arbitrary = sized genAdditionalPropertiesClass
  
  genAdditionalPropertiesClass :: Int -> Gen AdditionalPropertiesClass
  genAdditionalPropertiesClass n =
    AdditionalPropertiesClass
      <$> arbitraryReducedMaybe n -- additionalPropertiesClassMapString :: Maybe (Map.Map String Text)
      <*> arbitraryReducedMaybe n -- additionalPropertiesClassMapNumber :: Maybe (Map.Map String Double)
      <*> arbitraryReducedMaybe n -- additionalPropertiesClassMapInteger :: Maybe (Map.Map String Int)
      <*> arbitraryReducedMaybe n -- additionalPropertiesClassMapBoolean :: Maybe (Map.Map String Bool)
      <*> arbitraryReducedMaybe n -- additionalPropertiesClassMapArrayInteger :: Maybe (Map.Map String [Int])
      <*> arbitraryReducedMaybe n -- additionalPropertiesClassMapArrayAnytype :: Maybe (Map.Map String [A.Value])
      <*> arbitraryReducedMaybe n -- additionalPropertiesClassMapMapString :: Maybe (Map.Map String (Map.Map String Text))
      <*> arbitraryReducedMaybe n -- additionalPropertiesClassMapMapAnytype :: Maybe (Map.Map String (Map.Map String A.Value))
      <*> arbitraryReducedMaybeValue n -- additionalPropertiesClassAnytype1 :: Maybe A.Value
      <*> arbitraryReducedMaybeValue n -- additionalPropertiesClassAnytype2 :: Maybe A.Value
      <*> arbitraryReducedMaybeValue n -- additionalPropertiesClassAnytype3 :: Maybe A.Value
    
  instance Arbitrary AdditionalPropertiesInteger where
    arbitrary = sized genAdditionalPropertiesInteger
  
  genAdditionalPropertiesInteger :: Int -> Gen AdditionalPropertiesInteger
  genAdditionalPropertiesInteger n =
    AdditionalPropertiesInteger
      <$> arbitraryReducedMaybe n -- additionalPropertiesIntegerName :: Maybe Text
    
  instance Arbitrary AdditionalPropertiesNumber where
    arbitrary = sized genAdditionalPropertiesNumber
  
  genAdditionalPropertiesNumber :: Int -> Gen AdditionalPropertiesNumber
  genAdditionalPropertiesNumber n =
    AdditionalPropertiesNumber
      <$> arbitraryReducedMaybe n -- additionalPropertiesNumberName :: Maybe Text
    
  instance Arbitrary AdditionalPropertiesObject where
    arbitrary = sized genAdditionalPropertiesObject
  
  genAdditionalPropertiesObject :: Int -> Gen AdditionalPropertiesObject
  genAdditionalPropertiesObject n =
    AdditionalPropertiesObject
      <$> arbitraryReducedMaybe n -- additionalPropertiesObjectName :: Maybe Text
    
  instance Arbitrary AdditionalPropertiesString where
    arbitrary = sized genAdditionalPropertiesString
  
  genAdditionalPropertiesString :: Int -> Gen AdditionalPropertiesString
  genAdditionalPropertiesString n =
    AdditionalPropertiesString
      <$> arbitraryReducedMaybe n -- additionalPropertiesStringName :: Maybe Text
    
  instance Arbitrary Animal where
    arbitrary = sized genAnimal
  
  genAnimal :: Int -> Gen Animal
  genAnimal n =
    Animal
      <$> arbitrary -- animalClassName :: Text
      <*> arbitraryReducedMaybe n -- animalColor :: Maybe Text
    
  instance Arbitrary ApiResponse where
    arbitrary = sized genApiResponse
  
  genApiResponse :: Int -> Gen ApiResponse
  genApiResponse n =
    ApiResponse
      <$> arbitraryReducedMaybe n -- apiResponseCode :: Maybe Int
      <*> arbitraryReducedMaybe n -- apiResponseType :: Maybe Text
      <*> arbitraryReducedMaybe n -- apiResponseMessage :: Maybe Text
    
  instance Arbitrary ArrayOfArrayOfNumberOnly where
    arbitrary = sized genArrayOfArrayOfNumberOnly
  
  genArrayOfArrayOfNumberOnly :: Int -> Gen ArrayOfArrayOfNumberOnly
  genArrayOfArrayOfNumberOnly n =
    ArrayOfArrayOfNumberOnly
      <$> arbitraryReducedMaybe n -- arrayOfArrayOfNumberOnlyArrayArrayNumber :: Maybe [[Double]]
    
  instance Arbitrary ArrayOfNumberOnly where
    arbitrary = sized genArrayOfNumberOnly
  
  genArrayOfNumberOnly :: Int -> Gen ArrayOfNumberOnly
  genArrayOfNumberOnly n =
    ArrayOfNumberOnly
      <$> arbitraryReducedMaybe n -- arrayOfNumberOnlyArrayNumber :: Maybe [Double]
    
  instance Arbitrary ArrayTest where
    arbitrary = sized genArrayTest
  
  genArrayTest :: Int -> Gen ArrayTest
  genArrayTest n =
    ArrayTest
      <$> arbitraryReducedMaybe n -- arrayTestArrayOfString :: Maybe [Text]
      <*> arbitraryReducedMaybe n -- arrayTestArrayArrayOfInteger :: Maybe [[Integer]]
      <*> arbitraryReducedMaybe n -- arrayTestArrayArrayOfModel :: Maybe [[ReadOnlyFirst]]
    
  instance Arbitrary BigCat where
    arbitrary = sized genBigCat
  
  genBigCat :: Int -> Gen BigCat
  genBigCat n =
    BigCat
      <$> arbitrary -- bigCatClassName :: Text
      <*> arbitraryReducedMaybe n -- bigCatColor :: Maybe Text
      <*> arbitraryReducedMaybe n -- bigCatDeclawed :: Maybe Bool
      <*> arbitraryReducedMaybe n -- bigCatKind :: Maybe E'Kind
    
  instance Arbitrary Capitalization where
    arbitrary = sized genCapitalization
  
  genCapitalization :: Int -> Gen Capitalization
  genCapitalization n =
    Capitalization
      <$> arbitraryReducedMaybe n -- capitalizationSmallCamel :: Maybe Text
      <*> arbitraryReducedMaybe n -- capitalizationCapitalCamel :: Maybe Text
      <*> arbitraryReducedMaybe n -- capitalizationSmallSnake :: Maybe Text
      <*> arbitraryReducedMaybe n -- capitalizationCapitalSnake :: Maybe Text
      <*> arbitraryReducedMaybe n -- capitalizationScaEthFlowPoints :: Maybe Text
      <*> arbitraryReducedMaybe n -- capitalizationAttName :: Maybe Text
    
  instance Arbitrary Cat where
    arbitrary = sized genCat
  
  genCat :: Int -> Gen Cat
  genCat n =
    Cat
      <$> arbitrary -- catClassName :: Text
      <*> arbitraryReducedMaybe n -- catColor :: Maybe Text
      <*> arbitraryReducedMaybe n -- catDeclawed :: Maybe Bool
    
  instance Arbitrary Category where
    arbitrary = sized genCategory
  
  genCategory :: Int -> Gen Category
  genCategory n =
    Category
      <$> arbitraryReducedMaybe n -- categoryId :: Maybe Integer
      <*> arbitrary -- categoryName :: Text
    
  instance Arbitrary ClassModel where
    arbitrary = sized genClassModel
  
  genClassModel :: Int -> Gen ClassModel
  genClassModel n =
    ClassModel
      <$> arbitraryReducedMaybe n -- classModelClass :: Maybe Text
    
  instance Arbitrary Client where
    arbitrary = sized genClient
  
  genClient :: Int -> Gen Client
  genClient n =
    Client
      <$> arbitraryReducedMaybe n -- clientClient :: Maybe Text
    
  instance Arbitrary Dog where
    arbitrary = sized genDog
  
  genDog :: Int -> Gen Dog
  genDog n =
    Dog
      <$> arbitrary -- dogClassName :: Text
      <*> arbitraryReducedMaybe n -- dogColor :: Maybe Text
      <*> arbitraryReducedMaybe n -- dogBreed :: Maybe Text
    
  instance Arbitrary EnumArrays where
    arbitrary = sized genEnumArrays
  
  genEnumArrays :: Int -> Gen EnumArrays
  genEnumArrays n =
    EnumArrays
      <$> arbitraryReducedMaybe n -- enumArraysJustSymbol :: Maybe E'JustSymbol
      <*> arbitraryReducedMaybe n -- enumArraysArrayEnum :: Maybe [E'ArrayEnum]
    
  instance Arbitrary EnumTest where
    arbitrary = sized genEnumTest
  
  genEnumTest :: Int -> Gen EnumTest
  genEnumTest n =
    EnumTest
      <$> arbitraryReducedMaybe n -- enumTestEnumString :: Maybe E'EnumString
      <*> arbitrary -- enumTestEnumStringRequired :: E'EnumString
      <*> arbitraryReducedMaybe n -- enumTestEnumInteger :: Maybe E'EnumInteger
      <*> arbitraryReducedMaybe n -- enumTestEnumNumber :: Maybe E'EnumNumber
      <*> arbitraryReducedMaybe n -- enumTestOuterEnum :: Maybe OuterEnum
    
  instance Arbitrary File where
    arbitrary = sized genFile
  
  genFile :: Int -> Gen File
  genFile n =
    File
      <$> arbitraryReducedMaybe n -- fileSourceUri :: Maybe Text
    
  instance Arbitrary FileSchemaTestClass where
    arbitrary = sized genFileSchemaTestClass
  
  genFileSchemaTestClass :: Int -> Gen FileSchemaTestClass
  genFileSchemaTestClass n =
    FileSchemaTestClass
      <$> arbitraryReducedMaybe n -- fileSchemaTestClassFile :: Maybe File
      <*> arbitraryReducedMaybe n -- fileSchemaTestClassFiles :: Maybe [File]
    
  instance Arbitrary FormatTest where
    arbitrary = sized genFormatTest
  
  genFormatTest :: Int -> Gen FormatTest
  genFormatTest n =
    FormatTest
      <$> arbitraryReducedMaybe n -- formatTestInteger :: Maybe Int
      <*> arbitraryReducedMaybe n -- formatTestInt32 :: Maybe Int
      <*> arbitraryReducedMaybe n -- formatTestInt64 :: Maybe Integer
      <*> arbitrary -- formatTestNumber :: Double
      <*> arbitraryReducedMaybe n -- formatTestFloat :: Maybe Float
      <*> arbitraryReducedMaybe n -- formatTestDouble :: Maybe Double
      <*> arbitraryReducedMaybe n -- formatTestString :: Maybe Text
      <*> arbitraryReduced n -- formatTestByte :: ByteArray
      <*> arbitraryReducedMaybe n -- formatTestBinary :: Maybe FilePath
      <*> arbitraryReduced n -- formatTestDate :: Date
      <*> arbitraryReducedMaybe n -- formatTestDateTime :: Maybe DateTime
      <*> arbitraryReducedMaybe n -- formatTestUuid :: Maybe Text
      <*> arbitrary -- formatTestPassword :: Text
      <*> arbitraryReducedMaybe n -- formatTestBigDecimal :: Maybe Double
    
  instance Arbitrary HasOnlyReadOnly where
    arbitrary = sized genHasOnlyReadOnly
  
  genHasOnlyReadOnly :: Int -> Gen HasOnlyReadOnly
  genHasOnlyReadOnly n =
    HasOnlyReadOnly
      <$> arbitraryReducedMaybe n -- hasOnlyReadOnlyBar :: Maybe Text
      <*> arbitraryReducedMaybe n -- hasOnlyReadOnlyFoo :: Maybe Text
    
  instance Arbitrary MapTest where
    arbitrary = sized genMapTest
  
  genMapTest :: Int -> Gen MapTest
  genMapTest n =
    MapTest
      <$> arbitraryReducedMaybe n -- mapTestMapMapOfString :: Maybe (Map.Map String (Map.Map String Text))
      <*> arbitraryReducedMaybe n -- mapTestMapOfEnumString :: Maybe (Map.Map String E'Inner)
      <*> arbitraryReducedMaybe n -- mapTestDirectMap :: Maybe (Map.Map String Bool)
      <*> arbitraryReducedMaybe n -- mapTestIndirectMap :: Maybe (Map.Map String Bool)
    
  instance Arbitrary MixedPropertiesAndAdditionalPropertiesClass where
    arbitrary = sized genMixedPropertiesAndAdditionalPropertiesClass
  
  genMixedPropertiesAndAdditionalPropertiesClass :: Int -> Gen MixedPropertiesAndAdditionalPropertiesClass
  genMixedPropertiesAndAdditionalPropertiesClass n =
    MixedPropertiesAndAdditionalPropertiesClass
      <$> arbitraryReducedMaybe n -- mixedPropertiesAndAdditionalPropertiesClassUuid :: Maybe Text
      <*> arbitraryReducedMaybe n -- mixedPropertiesAndAdditionalPropertiesClassDateTime :: Maybe DateTime
      <*> arbitraryReducedMaybe n -- mixedPropertiesAndAdditionalPropertiesClassMap :: Maybe (Map.Map String Animal)
    
  instance Arbitrary Model200Response where
    arbitrary = sized genModel200Response
  
  genModel200Response :: Int -> Gen Model200Response
  genModel200Response n =
    Model200Response
      <$> arbitraryReducedMaybe n -- model200ResponseName :: Maybe Int
      <*> arbitraryReducedMaybe n -- model200ResponseClass :: Maybe Text
    
  instance Arbitrary ModelList where
    arbitrary = sized genModelList
  
  genModelList :: Int -> Gen ModelList
  genModelList n =
    ModelList
      <$> arbitraryReducedMaybe n -- modelList123list :: Maybe Text
    
  instance Arbitrary ModelReturn where
    arbitrary = sized genModelReturn
  
  genModelReturn :: Int -> Gen ModelReturn
  genModelReturn n =
    ModelReturn
      <$> arbitraryReducedMaybe n -- modelReturnReturn :: Maybe Int
    
  instance Arbitrary Name where
    arbitrary = sized genName
  
  genName :: Int -> Gen Name
  genName n =
    Name
      <$> arbitrary -- nameName :: Int
      <*> arbitraryReducedMaybe n -- nameSnakeCase :: Maybe Int
      <*> arbitraryReducedMaybe n -- nameProperty :: Maybe Text
      <*> arbitraryReducedMaybe n -- name123number :: Maybe Int
    
  instance Arbitrary NumberOnly where
    arbitrary = sized genNumberOnly
  
  genNumberOnly :: Int -> Gen NumberOnly
  genNumberOnly n =
    NumberOnly
      <$> arbitraryReducedMaybe n -- numberOnlyJustNumber :: Maybe Double
    
  instance Arbitrary Order where
    arbitrary = sized genOrder
  
  genOrder :: Int -> Gen Order
  genOrder n =
    Order
      <$> arbitraryReducedMaybe n -- orderId :: Maybe Integer
      <*> arbitraryReducedMaybe n -- orderPetId :: Maybe Integer
      <*> arbitraryReducedMaybe n -- orderQuantity :: Maybe Int
      <*> arbitraryReducedMaybe n -- orderShipDate :: Maybe DateTime
      <*> arbitraryReducedMaybe n -- orderStatus :: Maybe E'Status
      <*> arbitraryReducedMaybe n -- orderComplete :: Maybe Bool
    
  instance Arbitrary OuterComposite where
    arbitrary = sized genOuterComposite
  
  genOuterComposite :: Int -> Gen OuterComposite
  genOuterComposite n =
    OuterComposite
      <$> arbitraryReducedMaybe n -- outerCompositeMyNumber :: Maybe Double
      <*> arbitraryReducedMaybe n -- outerCompositeMyString :: Maybe Text
      <*> arbitraryReducedMaybe n -- outerCompositeMyBoolean :: Maybe Bool
    
  instance Arbitrary Pet where
    arbitrary = sized genPet
  
  genPet :: Int -> Gen Pet
  genPet n =
    Pet
      <$> arbitraryReducedMaybe n -- petId :: Maybe Integer
      <*> arbitraryReducedMaybe n -- petCategory :: Maybe Category
      <*> arbitrary -- petName :: Text
      <*> arbitrary -- petPhotoUrls :: [Text]
      <*> arbitraryReducedMaybe n -- petTags :: Maybe [Tag]
      <*> arbitraryReducedMaybe n -- petStatus :: Maybe E'Status2
    
  instance Arbitrary PetFilter where
    arbitrary = sized genPetFilter
  
  genPetFilter :: Int -> Gen PetFilter
  genPetFilter n =
    PetFilter
      <$> arbitraryReducedMaybe n -- petFilterTags :: Maybe [Text]
      <*> arbitraryReducedMaybe n -- petFilterStatus :: Maybe [Text]
    
  instance Arbitrary PetOrder where
    arbitrary = sized genPetOrder
  
  genPetOrder :: Int -> Gen PetOrder
  genPetOrder n =
    PetOrder
      <$> arbitraryReducedMaybe n -- petOrderName :: Maybe E'Name
    
  instance Arbitrary ReadOnlyFirst where
    arbitrary = sized genReadOnlyFirst
  
  genReadOnlyFirst :: Int -> Gen ReadOnlyFirst
  genReadOnlyFirst n =
    ReadOnlyFirst
      <$> arbitraryReducedMaybe n -- readOnlyFirstBar :: Maybe Text
      <*> arbitraryReducedMaybe n -- readOnlyFirstBaz :: Maybe Text
    
  instance Arbitrary Tag where
    arbitrary = sized genTag
  
  genTag :: Int -> Gen Tag
  genTag n =
    Tag
      <$> arbitraryReducedMaybe n -- tagId :: Maybe Integer
      <*> arbitraryReducedMaybe n -- tagName :: Maybe Text
    
  instance Arbitrary TypeHolderDefault where
    arbitrary = sized genTypeHolderDefault
  
  genTypeHolderDefault :: Int -> Gen TypeHolderDefault
  genTypeHolderDefault n =
    TypeHolderDefault
      <$> arbitrary -- typeHolderDefaultStringItem :: Text
      <*> arbitrary -- typeHolderDefaultNumberItem :: Double
      <*> arbitrary -- typeHolderDefaultIntegerItem :: Int
      <*> arbitrary -- typeHolderDefaultBoolItem :: Bool
      <*> arbitrary -- typeHolderDefaultArrayItem :: [Int]
    
  instance Arbitrary TypeHolderExample where
    arbitrary = sized genTypeHolderExample
  
  genTypeHolderExample :: Int -> Gen TypeHolderExample
  genTypeHolderExample n =
    TypeHolderExample
      <$> arbitrary -- typeHolderExampleStringItem :: Text
      <*> arbitrary -- typeHolderExampleNumberItem :: Double
      <*> arbitrary -- typeHolderExampleFloatItem :: Float
      <*> arbitrary -- typeHolderExampleIntegerItem :: Int
      <*> arbitrary -- typeHolderExampleBoolItem :: Bool
      <*> arbitrary -- typeHolderExampleArrayItem :: [Int]
    
  instance Arbitrary User where
    arbitrary = sized genUser
  
  genUser :: Int -> Gen User
  genUser n =
    User
      <$> arbitraryReducedMaybe n -- userId :: Maybe Integer
      <*> arbitraryReducedMaybe n -- userUsername :: Maybe Text
      <*> arbitraryReducedMaybe n -- userFirstName :: Maybe Text
      <*> arbitraryReducedMaybe n -- userLastName :: Maybe Text
      <*> arbitraryReducedMaybe n -- userEmail :: Maybe Text
      <*> arbitraryReducedMaybe n -- userPassword :: Maybe Text
      <*> arbitraryReducedMaybe n -- userPhone :: Maybe Text
      <*> arbitraryReducedMaybe n -- userUserStatus :: Maybe Int
    
  instance Arbitrary XmlItem where
    arbitrary = sized genXmlItem
  
  genXmlItem :: Int -> Gen XmlItem
  genXmlItem n =
    XmlItem
      <$> arbitraryReducedMaybe n -- xmlItemAttributeString :: Maybe Text
      <*> arbitraryReducedMaybe n -- xmlItemAttributeNumber :: Maybe Double
      <*> arbitraryReducedMaybe n -- xmlItemAttributeInteger :: Maybe Int
      <*> arbitraryReducedMaybe n -- xmlItemAttributeBoolean :: Maybe Bool
      <*> arbitraryReducedMaybe n -- xmlItemWrappedArray :: Maybe [Int]
      <*> arbitraryReducedMaybe n -- xmlItemNameString :: Maybe Text
      <*> arbitraryReducedMaybe n -- xmlItemNameNumber :: Maybe Double
      <*> arbitraryReducedMaybe n -- xmlItemNameInteger :: Maybe Int
      <*> arbitraryReducedMaybe n -- xmlItemNameBoolean :: Maybe Bool
      <*> arbitraryReducedMaybe n -- xmlItemNameArray :: Maybe [Int]
      <*> arbitraryReducedMaybe n -- xmlItemNameWrappedArray :: Maybe [Int]
      <*> arbitraryReducedMaybe n -- xmlItemPrefixString :: Maybe Text
      <*> arbitraryReducedMaybe n -- xmlItemPrefixNumber :: Maybe Double
      <*> arbitraryReducedMaybe n -- xmlItemPrefixInteger :: Maybe Int
      <*> arbitraryReducedMaybe n -- xmlItemPrefixBoolean :: Maybe Bool
      <*> arbitraryReducedMaybe n -- xmlItemPrefixArray :: Maybe [Int]
      <*> arbitraryReducedMaybe n -- xmlItemPrefixWrappedArray :: Maybe [Int]
      <*> arbitraryReducedMaybe n -- xmlItemNamespaceString :: Maybe Text
      <*> arbitraryReducedMaybe n -- xmlItemNamespaceNumber :: Maybe Double
      <*> arbitraryReducedMaybe n -- xmlItemNamespaceInteger :: Maybe Int
      <*> arbitraryReducedMaybe n -- xmlItemNamespaceBoolean :: Maybe Bool
      <*> arbitraryReducedMaybe n -- xmlItemNamespaceArray :: Maybe [Int]
      <*> arbitraryReducedMaybe n -- xmlItemNamespaceWrappedArray :: Maybe [Int]
      <*> arbitraryReducedMaybe n -- xmlItemPrefixNsString :: Maybe Text
      <*> arbitraryReducedMaybe n -- xmlItemPrefixNsNumber :: Maybe Double
      <*> arbitraryReducedMaybe n -- xmlItemPrefixNsInteger :: Maybe Int
      <*> arbitraryReducedMaybe n -- xmlItemPrefixNsBoolean :: Maybe Bool
      <*> arbitraryReducedMaybe n -- xmlItemPrefixNsArray :: Maybe [Int]
      <*> arbitraryReducedMaybe n -- xmlItemPrefixNsWrappedArray :: Maybe [Int]
    
  
  
  
  instance Arbitrary E'ArrayEnum where
    arbitrary = arbitraryBoundedEnum
  
  instance Arbitrary E'EnumFormString where
    arbitrary = arbitraryBoundedEnum
  
  instance Arbitrary E'EnumFormStringArray where
    arbitrary = arbitraryBoundedEnum
  
  instance Arbitrary E'EnumInteger where
    arbitrary = arbitraryBoundedEnum
  
  instance Arbitrary E'EnumNumber where
    arbitrary = arbitraryBoundedEnum
  
  instance Arbitrary E'EnumQueryInteger where
    arbitrary = arbitraryBoundedEnum
  
  instance Arbitrary E'EnumString where
    arbitrary = arbitraryBoundedEnum
  
  instance Arbitrary E'Inner where
    arbitrary = arbitraryBoundedEnum
  
  instance Arbitrary E'JustSymbol where
    arbitrary = arbitraryBoundedEnum
  
  instance Arbitrary E'Kind where
    arbitrary = arbitraryBoundedEnum
  
  instance Arbitrary E'Name where
    arbitrary = arbitraryBoundedEnum
  
  instance Arbitrary E'Status where
    arbitrary = arbitraryBoundedEnum
  
  instance Arbitrary E'Status2 where
    arbitrary = arbitraryBoundedEnum
  
  instance Arbitrary EnumClass where
    arbitrary = arbitraryBoundedEnum
  
  instance Arbitrary OuterEnum where
    arbitrary = arbitraryBoundedEnum
  
  