-- | A partial XML Schema model, focusing on datatypes. All simple datatypes (i.e. xsd:anySimpleType and below) are included.
-- | See: https://www.w3.org/TR/xmlschema-2
-- | Note: for most of the XML Schema datatype definitions included here, the associated Hydra type is simply
-- |       the string type. Exceptions are made for xsd:boolean and most of the numeric types, where there is a clearly
-- |       corresponding Hydra literal type.

module Hydra.Ext.Xml.Schema where

import qualified Hydra.Core as Core
import Data.List
import Data.Map
import Data.Set

newtype AnySimpleType = 
  AnySimpleType {
    AnySimpleType -> String
unAnySimpleType :: String}
  deriving (AnySimpleType -> AnySimpleType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnySimpleType -> AnySimpleType -> Bool
$c/= :: AnySimpleType -> AnySimpleType -> Bool
== :: AnySimpleType -> AnySimpleType -> Bool
$c== :: AnySimpleType -> AnySimpleType -> Bool
Eq, Eq AnySimpleType
AnySimpleType -> AnySimpleType -> Bool
AnySimpleType -> AnySimpleType -> Ordering
AnySimpleType -> AnySimpleType -> AnySimpleType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: AnySimpleType -> AnySimpleType -> AnySimpleType
$cmin :: AnySimpleType -> AnySimpleType -> AnySimpleType
max :: AnySimpleType -> AnySimpleType -> AnySimpleType
$cmax :: AnySimpleType -> AnySimpleType -> AnySimpleType
>= :: AnySimpleType -> AnySimpleType -> Bool
$c>= :: AnySimpleType -> AnySimpleType -> Bool
> :: AnySimpleType -> AnySimpleType -> Bool
$c> :: AnySimpleType -> AnySimpleType -> Bool
<= :: AnySimpleType -> AnySimpleType -> Bool
$c<= :: AnySimpleType -> AnySimpleType -> Bool
< :: AnySimpleType -> AnySimpleType -> Bool
$c< :: AnySimpleType -> AnySimpleType -> Bool
compare :: AnySimpleType -> AnySimpleType -> Ordering
$ccompare :: AnySimpleType -> AnySimpleType -> Ordering
Ord, ReadPrec [AnySimpleType]
ReadPrec AnySimpleType
Int -> ReadS AnySimpleType
ReadS [AnySimpleType]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AnySimpleType]
$creadListPrec :: ReadPrec [AnySimpleType]
readPrec :: ReadPrec AnySimpleType
$creadPrec :: ReadPrec AnySimpleType
readList :: ReadS [AnySimpleType]
$creadList :: ReadS [AnySimpleType]
readsPrec :: Int -> ReadS AnySimpleType
$creadsPrec :: Int -> ReadS AnySimpleType
Read, Int -> AnySimpleType -> String -> String
[AnySimpleType] -> String -> String
AnySimpleType -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [AnySimpleType] -> String -> String
$cshowList :: [AnySimpleType] -> String -> String
show :: AnySimpleType -> String
$cshow :: AnySimpleType -> String
showsPrec :: Int -> AnySimpleType -> String -> String
$cshowsPrec :: Int -> AnySimpleType -> String -> String
Show)

_AnySimpleType :: Name
_AnySimpleType = (String -> Name
Core.Name String
"hydra/ext/xml/schema.AnySimpleType")

newtype AnyType = 
  AnyType {
    AnyType -> String
unAnyType :: String}
  deriving (AnyType -> AnyType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnyType -> AnyType -> Bool
$c/= :: AnyType -> AnyType -> Bool
== :: AnyType -> AnyType -> Bool
$c== :: AnyType -> AnyType -> Bool
Eq, Eq AnyType
AnyType -> AnyType -> Bool
AnyType -> AnyType -> Ordering
AnyType -> AnyType -> AnyType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: AnyType -> AnyType -> AnyType
$cmin :: AnyType -> AnyType -> AnyType
max :: AnyType -> AnyType -> AnyType
$cmax :: AnyType -> AnyType -> AnyType
>= :: AnyType -> AnyType -> Bool
$c>= :: AnyType -> AnyType -> Bool
> :: AnyType -> AnyType -> Bool
$c> :: AnyType -> AnyType -> Bool
<= :: AnyType -> AnyType -> Bool
$c<= :: AnyType -> AnyType -> Bool
< :: AnyType -> AnyType -> Bool
$c< :: AnyType -> AnyType -> Bool
compare :: AnyType -> AnyType -> Ordering
$ccompare :: AnyType -> AnyType -> Ordering
Ord, ReadPrec [AnyType]
ReadPrec AnyType
Int -> ReadS AnyType
ReadS [AnyType]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AnyType]
$creadListPrec :: ReadPrec [AnyType]
readPrec :: ReadPrec AnyType
$creadPrec :: ReadPrec AnyType
readList :: ReadS [AnyType]
$creadList :: ReadS [AnyType]
readsPrec :: Int -> ReadS AnyType
$creadsPrec :: Int -> ReadS AnyType
Read, Int -> AnyType -> String -> String
[AnyType] -> String -> String
AnyType -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [AnyType] -> String -> String
$cshowList :: [AnyType] -> String -> String
show :: AnyType -> String
$cshow :: AnyType -> String
showsPrec :: Int -> AnyType -> String -> String
$cshowsPrec :: Int -> AnyType -> String -> String
Show)

_AnyType :: Name
_AnyType = (String -> Name
Core.Name String
"hydra/ext/xml/schema.AnyType")

newtype AnyURI = 
  AnyURI {
    AnyURI -> String
unAnyURI :: String}
  deriving (AnyURI -> AnyURI -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnyURI -> AnyURI -> Bool
$c/= :: AnyURI -> AnyURI -> Bool
== :: AnyURI -> AnyURI -> Bool
$c== :: AnyURI -> AnyURI -> Bool
Eq, Eq AnyURI
AnyURI -> AnyURI -> Bool
AnyURI -> AnyURI -> Ordering
AnyURI -> AnyURI -> AnyURI
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: AnyURI -> AnyURI -> AnyURI
$cmin :: AnyURI -> AnyURI -> AnyURI
max :: AnyURI -> AnyURI -> AnyURI
$cmax :: AnyURI -> AnyURI -> AnyURI
>= :: AnyURI -> AnyURI -> Bool
$c>= :: AnyURI -> AnyURI -> Bool
> :: AnyURI -> AnyURI -> Bool
$c> :: AnyURI -> AnyURI -> Bool
<= :: AnyURI -> AnyURI -> Bool
$c<= :: AnyURI -> AnyURI -> Bool
< :: AnyURI -> AnyURI -> Bool
$c< :: AnyURI -> AnyURI -> Bool
compare :: AnyURI -> AnyURI -> Ordering
$ccompare :: AnyURI -> AnyURI -> Ordering
Ord, ReadPrec [AnyURI]
ReadPrec AnyURI
Int -> ReadS AnyURI
ReadS [AnyURI]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AnyURI]
$creadListPrec :: ReadPrec [AnyURI]
readPrec :: ReadPrec AnyURI
$creadPrec :: ReadPrec AnyURI
readList :: ReadS [AnyURI]
$creadList :: ReadS [AnyURI]
readsPrec :: Int -> ReadS AnyURI
$creadsPrec :: Int -> ReadS AnyURI
Read, Int -> AnyURI -> String -> String
[AnyURI] -> String -> String
AnyURI -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [AnyURI] -> String -> String
$cshowList :: [AnyURI] -> String -> String
show :: AnyURI -> String
$cshow :: AnyURI -> String
showsPrec :: Int -> AnyURI -> String -> String
$cshowsPrec :: Int -> AnyURI -> String -> String
Show)

_AnyURI :: Name
_AnyURI = (String -> Name
Core.Name String
"hydra/ext/xml/schema.AnyURI")

newtype Base64Binary = 
  Base64Binary {
    Base64Binary -> String
unBase64Binary :: String}
  deriving (Base64Binary -> Base64Binary -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Base64Binary -> Base64Binary -> Bool
$c/= :: Base64Binary -> Base64Binary -> Bool
== :: Base64Binary -> Base64Binary -> Bool
$c== :: Base64Binary -> Base64Binary -> Bool
Eq, Eq Base64Binary
Base64Binary -> Base64Binary -> Bool
Base64Binary -> Base64Binary -> Ordering
Base64Binary -> Base64Binary -> Base64Binary
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Base64Binary -> Base64Binary -> Base64Binary
$cmin :: Base64Binary -> Base64Binary -> Base64Binary
max :: Base64Binary -> Base64Binary -> Base64Binary
$cmax :: Base64Binary -> Base64Binary -> Base64Binary
>= :: Base64Binary -> Base64Binary -> Bool
$c>= :: Base64Binary -> Base64Binary -> Bool
> :: Base64Binary -> Base64Binary -> Bool
$c> :: Base64Binary -> Base64Binary -> Bool
<= :: Base64Binary -> Base64Binary -> Bool
$c<= :: Base64Binary -> Base64Binary -> Bool
< :: Base64Binary -> Base64Binary -> Bool
$c< :: Base64Binary -> Base64Binary -> Bool
compare :: Base64Binary -> Base64Binary -> Ordering
$ccompare :: Base64Binary -> Base64Binary -> Ordering
Ord, ReadPrec [Base64Binary]
ReadPrec Base64Binary
Int -> ReadS Base64Binary
ReadS [Base64Binary]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Base64Binary]
$creadListPrec :: ReadPrec [Base64Binary]
readPrec :: ReadPrec Base64Binary
$creadPrec :: ReadPrec Base64Binary
readList :: ReadS [Base64Binary]
$creadList :: ReadS [Base64Binary]
readsPrec :: Int -> ReadS Base64Binary
$creadsPrec :: Int -> ReadS Base64Binary
Read, Int -> Base64Binary -> String -> String
[Base64Binary] -> String -> String
Base64Binary -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Base64Binary] -> String -> String
$cshowList :: [Base64Binary] -> String -> String
show :: Base64Binary -> String
$cshow :: Base64Binary -> String
showsPrec :: Int -> Base64Binary -> String -> String
$cshowsPrec :: Int -> Base64Binary -> String -> String
Show)

_Base64Binary :: Name
_Base64Binary = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Base64Binary")

newtype Boolean = 
  Boolean {
    Boolean -> Bool
unBoolean :: Bool}
  deriving (Boolean -> Boolean -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Boolean -> Boolean -> Bool
$c/= :: Boolean -> Boolean -> Bool
== :: Boolean -> Boolean -> Bool
$c== :: Boolean -> Boolean -> Bool
Eq, Eq Boolean
Boolean -> Boolean -> Bool
Boolean -> Boolean -> Ordering
Boolean -> Boolean -> Boolean
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Boolean -> Boolean -> Boolean
$cmin :: Boolean -> Boolean -> Boolean
max :: Boolean -> Boolean -> Boolean
$cmax :: Boolean -> Boolean -> Boolean
>= :: Boolean -> Boolean -> Bool
$c>= :: Boolean -> Boolean -> Bool
> :: Boolean -> Boolean -> Bool
$c> :: Boolean -> Boolean -> Bool
<= :: Boolean -> Boolean -> Bool
$c<= :: Boolean -> Boolean -> Bool
< :: Boolean -> Boolean -> Bool
$c< :: Boolean -> Boolean -> Bool
compare :: Boolean -> Boolean -> Ordering
$ccompare :: Boolean -> Boolean -> Ordering
Ord, ReadPrec [Boolean]
ReadPrec Boolean
Int -> ReadS Boolean
ReadS [Boolean]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Boolean]
$creadListPrec :: ReadPrec [Boolean]
readPrec :: ReadPrec Boolean
$creadPrec :: ReadPrec Boolean
readList :: ReadS [Boolean]
$creadList :: ReadS [Boolean]
readsPrec :: Int -> ReadS Boolean
$creadsPrec :: Int -> ReadS Boolean
Read, Int -> Boolean -> String -> String
[Boolean] -> String -> String
Boolean -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Boolean] -> String -> String
$cshowList :: [Boolean] -> String -> String
show :: Boolean -> String
$cshow :: Boolean -> String
showsPrec :: Int -> Boolean -> String -> String
$cshowsPrec :: Int -> Boolean -> String -> String
Show)

_Boolean :: Name
_Boolean = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Boolean")

newtype Byte = 
  Byte {
    Byte -> Int
unByte :: Int}
  deriving (Byte -> Byte -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Byte -> Byte -> Bool
$c/= :: Byte -> Byte -> Bool
== :: Byte -> Byte -> Bool
$c== :: Byte -> Byte -> Bool
Eq, Eq Byte
Byte -> Byte -> Bool
Byte -> Byte -> Ordering
Byte -> Byte -> Byte
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Byte -> Byte -> Byte
$cmin :: Byte -> Byte -> Byte
max :: Byte -> Byte -> Byte
$cmax :: Byte -> Byte -> Byte
>= :: Byte -> Byte -> Bool
$c>= :: Byte -> Byte -> Bool
> :: Byte -> Byte -> Bool
$c> :: Byte -> Byte -> Bool
<= :: Byte -> Byte -> Bool
$c<= :: Byte -> Byte -> Bool
< :: Byte -> Byte -> Bool
$c< :: Byte -> Byte -> Bool
compare :: Byte -> Byte -> Ordering
$ccompare :: Byte -> Byte -> Ordering
Ord, ReadPrec [Byte]
ReadPrec Byte
Int -> ReadS Byte
ReadS [Byte]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Byte]
$creadListPrec :: ReadPrec [Byte]
readPrec :: ReadPrec Byte
$creadPrec :: ReadPrec Byte
readList :: ReadS [Byte]
$creadList :: ReadS [Byte]
readsPrec :: Int -> ReadS Byte
$creadsPrec :: Int -> ReadS Byte
Read, Int -> Byte -> String -> String
[Byte] -> String -> String
Byte -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Byte] -> String -> String
$cshowList :: [Byte] -> String -> String
show :: Byte -> String
$cshow :: Byte -> String
showsPrec :: Int -> Byte -> String -> String
$cshowsPrec :: Int -> Byte -> String -> String
Show)

_Byte :: Name
_Byte = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Byte")

newtype Date = 
  Date {
    Date -> String
unDate :: String}
  deriving (Date -> Date -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Date -> Date -> Bool
$c/= :: Date -> Date -> Bool
== :: Date -> Date -> Bool
$c== :: Date -> Date -> Bool
Eq, Eq Date
Date -> Date -> Bool
Date -> Date -> Ordering
Date -> Date -> Date
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Date -> Date -> Date
$cmin :: Date -> Date -> Date
max :: Date -> Date -> Date
$cmax :: Date -> Date -> Date
>= :: Date -> Date -> Bool
$c>= :: Date -> Date -> Bool
> :: Date -> Date -> Bool
$c> :: Date -> Date -> Bool
<= :: Date -> Date -> Bool
$c<= :: Date -> Date -> Bool
< :: Date -> Date -> Bool
$c< :: Date -> Date -> Bool
compare :: Date -> Date -> Ordering
$ccompare :: Date -> Date -> Ordering
Ord, ReadPrec [Date]
ReadPrec Date
Int -> ReadS Date
ReadS [Date]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Date]
$creadListPrec :: ReadPrec [Date]
readPrec :: ReadPrec Date
$creadPrec :: ReadPrec Date
readList :: ReadS [Date]
$creadList :: ReadS [Date]
readsPrec :: Int -> ReadS Date
$creadsPrec :: Int -> ReadS Date
Read, Int -> Date -> String -> String
[Date] -> String -> String
Date -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Date] -> String -> String
$cshowList :: [Date] -> String -> String
show :: Date -> String
$cshow :: Date -> String
showsPrec :: Int -> Date -> String -> String
$cshowsPrec :: Int -> Date -> String -> String
Show)

_Date :: Name
_Date = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Date")

newtype DateTime = 
  DateTime {
    DateTime -> String
unDateTime :: String}
  deriving (DateTime -> DateTime -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DateTime -> DateTime -> Bool
$c/= :: DateTime -> DateTime -> Bool
== :: DateTime -> DateTime -> Bool
$c== :: DateTime -> DateTime -> Bool
Eq, Eq DateTime
DateTime -> DateTime -> Bool
DateTime -> DateTime -> Ordering
DateTime -> DateTime -> DateTime
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DateTime -> DateTime -> DateTime
$cmin :: DateTime -> DateTime -> DateTime
max :: DateTime -> DateTime -> DateTime
$cmax :: DateTime -> DateTime -> DateTime
>= :: DateTime -> DateTime -> Bool
$c>= :: DateTime -> DateTime -> Bool
> :: DateTime -> DateTime -> Bool
$c> :: DateTime -> DateTime -> Bool
<= :: DateTime -> DateTime -> Bool
$c<= :: DateTime -> DateTime -> Bool
< :: DateTime -> DateTime -> Bool
$c< :: DateTime -> DateTime -> Bool
compare :: DateTime -> DateTime -> Ordering
$ccompare :: DateTime -> DateTime -> Ordering
Ord, ReadPrec [DateTime]
ReadPrec DateTime
Int -> ReadS DateTime
ReadS [DateTime]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DateTime]
$creadListPrec :: ReadPrec [DateTime]
readPrec :: ReadPrec DateTime
$creadPrec :: ReadPrec DateTime
readList :: ReadS [DateTime]
$creadList :: ReadS [DateTime]
readsPrec :: Int -> ReadS DateTime
$creadsPrec :: Int -> ReadS DateTime
Read, Int -> DateTime -> String -> String
[DateTime] -> String -> String
DateTime -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [DateTime] -> String -> String
$cshowList :: [DateTime] -> String -> String
show :: DateTime -> String
$cshow :: DateTime -> String
showsPrec :: Int -> DateTime -> String -> String
$cshowsPrec :: Int -> DateTime -> String -> String
Show)

_DateTime :: Name
_DateTime = (String -> Name
Core.Name String
"hydra/ext/xml/schema.DateTime")

newtype Decimal = 
  Decimal {
    Decimal -> String
unDecimal :: String}
  deriving (Decimal -> Decimal -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Decimal -> Decimal -> Bool
$c/= :: Decimal -> Decimal -> Bool
== :: Decimal -> Decimal -> Bool
$c== :: Decimal -> Decimal -> Bool
Eq, Eq Decimal
Decimal -> Decimal -> Bool
Decimal -> Decimal -> Ordering
Decimal -> Decimal -> Decimal
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Decimal -> Decimal -> Decimal
$cmin :: Decimal -> Decimal -> Decimal
max :: Decimal -> Decimal -> Decimal
$cmax :: Decimal -> Decimal -> Decimal
>= :: Decimal -> Decimal -> Bool
$c>= :: Decimal -> Decimal -> Bool
> :: Decimal -> Decimal -> Bool
$c> :: Decimal -> Decimal -> Bool
<= :: Decimal -> Decimal -> Bool
$c<= :: Decimal -> Decimal -> Bool
< :: Decimal -> Decimal -> Bool
$c< :: Decimal -> Decimal -> Bool
compare :: Decimal -> Decimal -> Ordering
$ccompare :: Decimal -> Decimal -> Ordering
Ord, ReadPrec [Decimal]
ReadPrec Decimal
Int -> ReadS Decimal
ReadS [Decimal]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Decimal]
$creadListPrec :: ReadPrec [Decimal]
readPrec :: ReadPrec Decimal
$creadPrec :: ReadPrec Decimal
readList :: ReadS [Decimal]
$creadList :: ReadS [Decimal]
readsPrec :: Int -> ReadS Decimal
$creadsPrec :: Int -> ReadS Decimal
Read, Int -> Decimal -> String -> String
[Decimal] -> String -> String
Decimal -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Decimal] -> String -> String
$cshowList :: [Decimal] -> String -> String
show :: Decimal -> String
$cshow :: Decimal -> String
showsPrec :: Int -> Decimal -> String -> String
$cshowsPrec :: Int -> Decimal -> String -> String
Show)

_Decimal :: Name
_Decimal = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Decimal")

newtype Double_ = 
  Double_ {
    Double_ -> Double
unDouble :: Double}
  deriving (Double_ -> Double_ -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Double_ -> Double_ -> Bool
$c/= :: Double_ -> Double_ -> Bool
== :: Double_ -> Double_ -> Bool
$c== :: Double_ -> Double_ -> Bool
Eq, Eq Double_
Double_ -> Double_ -> Bool
Double_ -> Double_ -> Ordering
Double_ -> Double_ -> Double_
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Double_ -> Double_ -> Double_
$cmin :: Double_ -> Double_ -> Double_
max :: Double_ -> Double_ -> Double_
$cmax :: Double_ -> Double_ -> Double_
>= :: Double_ -> Double_ -> Bool
$c>= :: Double_ -> Double_ -> Bool
> :: Double_ -> Double_ -> Bool
$c> :: Double_ -> Double_ -> Bool
<= :: Double_ -> Double_ -> Bool
$c<= :: Double_ -> Double_ -> Bool
< :: Double_ -> Double_ -> Bool
$c< :: Double_ -> Double_ -> Bool
compare :: Double_ -> Double_ -> Ordering
$ccompare :: Double_ -> Double_ -> Ordering
Ord, ReadPrec [Double_]
ReadPrec Double_
Int -> ReadS Double_
ReadS [Double_]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Double_]
$creadListPrec :: ReadPrec [Double_]
readPrec :: ReadPrec Double_
$creadPrec :: ReadPrec Double_
readList :: ReadS [Double_]
$creadList :: ReadS [Double_]
readsPrec :: Int -> ReadS Double_
$creadsPrec :: Int -> ReadS Double_
Read, Int -> Double_ -> String -> String
[Double_] -> String -> String
Double_ -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Double_] -> String -> String
$cshowList :: [Double_] -> String -> String
show :: Double_ -> String
$cshow :: Double_ -> String
showsPrec :: Int -> Double_ -> String -> String
$cshowsPrec :: Int -> Double_ -> String -> String
Show)

_Double :: Name
_Double = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Double")

newtype Duration = 
  Duration {
    Duration -> String
unDuration :: String}
  deriving (Duration -> Duration -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Duration -> Duration -> Bool
$c/= :: Duration -> Duration -> Bool
== :: Duration -> Duration -> Bool
$c== :: Duration -> Duration -> Bool
Eq, Eq Duration
Duration -> Duration -> Bool
Duration -> Duration -> Ordering
Duration -> Duration -> Duration
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Duration -> Duration -> Duration
$cmin :: Duration -> Duration -> Duration
max :: Duration -> Duration -> Duration
$cmax :: Duration -> Duration -> Duration
>= :: Duration -> Duration -> Bool
$c>= :: Duration -> Duration -> Bool
> :: Duration -> Duration -> Bool
$c> :: Duration -> Duration -> Bool
<= :: Duration -> Duration -> Bool
$c<= :: Duration -> Duration -> Bool
< :: Duration -> Duration -> Bool
$c< :: Duration -> Duration -> Bool
compare :: Duration -> Duration -> Ordering
$ccompare :: Duration -> Duration -> Ordering
Ord, ReadPrec [Duration]
ReadPrec Duration
Int -> ReadS Duration
ReadS [Duration]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Duration]
$creadListPrec :: ReadPrec [Duration]
readPrec :: ReadPrec Duration
$creadPrec :: ReadPrec Duration
readList :: ReadS [Duration]
$creadList :: ReadS [Duration]
readsPrec :: Int -> ReadS Duration
$creadsPrec :: Int -> ReadS Duration
Read, Int -> Duration -> String -> String
[Duration] -> String -> String
Duration -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Duration] -> String -> String
$cshowList :: [Duration] -> String -> String
show :: Duration -> String
$cshow :: Duration -> String
showsPrec :: Int -> Duration -> String -> String
$cshowsPrec :: Int -> Duration -> String -> String
Show)

_Duration :: Name
_Duration = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Duration")

newtype ENTITIES = 
  ENTITIES {
    ENTITIES -> String
unENTITIES :: String}
  deriving (ENTITIES -> ENTITIES -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ENTITIES -> ENTITIES -> Bool
$c/= :: ENTITIES -> ENTITIES -> Bool
== :: ENTITIES -> ENTITIES -> Bool
$c== :: ENTITIES -> ENTITIES -> Bool
Eq, Eq ENTITIES
ENTITIES -> ENTITIES -> Bool
ENTITIES -> ENTITIES -> Ordering
ENTITIES -> ENTITIES -> ENTITIES
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ENTITIES -> ENTITIES -> ENTITIES
$cmin :: ENTITIES -> ENTITIES -> ENTITIES
max :: ENTITIES -> ENTITIES -> ENTITIES
$cmax :: ENTITIES -> ENTITIES -> ENTITIES
>= :: ENTITIES -> ENTITIES -> Bool
$c>= :: ENTITIES -> ENTITIES -> Bool
> :: ENTITIES -> ENTITIES -> Bool
$c> :: ENTITIES -> ENTITIES -> Bool
<= :: ENTITIES -> ENTITIES -> Bool
$c<= :: ENTITIES -> ENTITIES -> Bool
< :: ENTITIES -> ENTITIES -> Bool
$c< :: ENTITIES -> ENTITIES -> Bool
compare :: ENTITIES -> ENTITIES -> Ordering
$ccompare :: ENTITIES -> ENTITIES -> Ordering
Ord, ReadPrec [ENTITIES]
ReadPrec ENTITIES
Int -> ReadS ENTITIES
ReadS [ENTITIES]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ENTITIES]
$creadListPrec :: ReadPrec [ENTITIES]
readPrec :: ReadPrec ENTITIES
$creadPrec :: ReadPrec ENTITIES
readList :: ReadS [ENTITIES]
$creadList :: ReadS [ENTITIES]
readsPrec :: Int -> ReadS ENTITIES
$creadsPrec :: Int -> ReadS ENTITIES
Read, Int -> ENTITIES -> String -> String
[ENTITIES] -> String -> String
ENTITIES -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [ENTITIES] -> String -> String
$cshowList :: [ENTITIES] -> String -> String
show :: ENTITIES -> String
$cshow :: ENTITIES -> String
showsPrec :: Int -> ENTITIES -> String -> String
$cshowsPrec :: Int -> ENTITIES -> String -> String
Show)

_ENTITIES :: Name
_ENTITIES = (String -> Name
Core.Name String
"hydra/ext/xml/schema.ENTITIES")

newtype ENTITY = 
  ENTITY {
    ENTITY -> String
unENTITY :: String}
  deriving (ENTITY -> ENTITY -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ENTITY -> ENTITY -> Bool
$c/= :: ENTITY -> ENTITY -> Bool
== :: ENTITY -> ENTITY -> Bool
$c== :: ENTITY -> ENTITY -> Bool
Eq, Eq ENTITY
ENTITY -> ENTITY -> Bool
ENTITY -> ENTITY -> Ordering
ENTITY -> ENTITY -> ENTITY
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ENTITY -> ENTITY -> ENTITY
$cmin :: ENTITY -> ENTITY -> ENTITY
max :: ENTITY -> ENTITY -> ENTITY
$cmax :: ENTITY -> ENTITY -> ENTITY
>= :: ENTITY -> ENTITY -> Bool
$c>= :: ENTITY -> ENTITY -> Bool
> :: ENTITY -> ENTITY -> Bool
$c> :: ENTITY -> ENTITY -> Bool
<= :: ENTITY -> ENTITY -> Bool
$c<= :: ENTITY -> ENTITY -> Bool
< :: ENTITY -> ENTITY -> Bool
$c< :: ENTITY -> ENTITY -> Bool
compare :: ENTITY -> ENTITY -> Ordering
$ccompare :: ENTITY -> ENTITY -> Ordering
Ord, ReadPrec [ENTITY]
ReadPrec ENTITY
Int -> ReadS ENTITY
ReadS [ENTITY]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ENTITY]
$creadListPrec :: ReadPrec [ENTITY]
readPrec :: ReadPrec ENTITY
$creadPrec :: ReadPrec ENTITY
readList :: ReadS [ENTITY]
$creadList :: ReadS [ENTITY]
readsPrec :: Int -> ReadS ENTITY
$creadsPrec :: Int -> ReadS ENTITY
Read, Int -> ENTITY -> String -> String
[ENTITY] -> String -> String
ENTITY -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [ENTITY] -> String -> String
$cshowList :: [ENTITY] -> String -> String
show :: ENTITY -> String
$cshow :: ENTITY -> String
showsPrec :: Int -> ENTITY -> String -> String
$cshowsPrec :: Int -> ENTITY -> String -> String
Show)

_ENTITY :: Name
_ENTITY = (String -> Name
Core.Name String
"hydra/ext/xml/schema.ENTITY")

newtype Float_ = 
  Float_ {
    Float_ -> Float
unFloat :: Float}
  deriving (Float_ -> Float_ -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Float_ -> Float_ -> Bool
$c/= :: Float_ -> Float_ -> Bool
== :: Float_ -> Float_ -> Bool
$c== :: Float_ -> Float_ -> Bool
Eq, Eq Float_
Float_ -> Float_ -> Bool
Float_ -> Float_ -> Ordering
Float_ -> Float_ -> Float_
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Float_ -> Float_ -> Float_
$cmin :: Float_ -> Float_ -> Float_
max :: Float_ -> Float_ -> Float_
$cmax :: Float_ -> Float_ -> Float_
>= :: Float_ -> Float_ -> Bool
$c>= :: Float_ -> Float_ -> Bool
> :: Float_ -> Float_ -> Bool
$c> :: Float_ -> Float_ -> Bool
<= :: Float_ -> Float_ -> Bool
$c<= :: Float_ -> Float_ -> Bool
< :: Float_ -> Float_ -> Bool
$c< :: Float_ -> Float_ -> Bool
compare :: Float_ -> Float_ -> Ordering
$ccompare :: Float_ -> Float_ -> Ordering
Ord, ReadPrec [Float_]
ReadPrec Float_
Int -> ReadS Float_
ReadS [Float_]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Float_]
$creadListPrec :: ReadPrec [Float_]
readPrec :: ReadPrec Float_
$creadPrec :: ReadPrec Float_
readList :: ReadS [Float_]
$creadList :: ReadS [Float_]
readsPrec :: Int -> ReadS Float_
$creadsPrec :: Int -> ReadS Float_
Read, Int -> Float_ -> String -> String
[Float_] -> String -> String
Float_ -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Float_] -> String -> String
$cshowList :: [Float_] -> String -> String
show :: Float_ -> String
$cshow :: Float_ -> String
showsPrec :: Int -> Float_ -> String -> String
$cshowsPrec :: Int -> Float_ -> String -> String
Show)

_Float :: Name
_Float = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Float")

newtype GDay = 
  GDay {
    GDay -> String
unGDay :: String}
  deriving (GDay -> GDay -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GDay -> GDay -> Bool
$c/= :: GDay -> GDay -> Bool
== :: GDay -> GDay -> Bool
$c== :: GDay -> GDay -> Bool
Eq, Eq GDay
GDay -> GDay -> Bool
GDay -> GDay -> Ordering
GDay -> GDay -> GDay
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GDay -> GDay -> GDay
$cmin :: GDay -> GDay -> GDay
max :: GDay -> GDay -> GDay
$cmax :: GDay -> GDay -> GDay
>= :: GDay -> GDay -> Bool
$c>= :: GDay -> GDay -> Bool
> :: GDay -> GDay -> Bool
$c> :: GDay -> GDay -> Bool
<= :: GDay -> GDay -> Bool
$c<= :: GDay -> GDay -> Bool
< :: GDay -> GDay -> Bool
$c< :: GDay -> GDay -> Bool
compare :: GDay -> GDay -> Ordering
$ccompare :: GDay -> GDay -> Ordering
Ord, ReadPrec [GDay]
ReadPrec GDay
Int -> ReadS GDay
ReadS [GDay]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GDay]
$creadListPrec :: ReadPrec [GDay]
readPrec :: ReadPrec GDay
$creadPrec :: ReadPrec GDay
readList :: ReadS [GDay]
$creadList :: ReadS [GDay]
readsPrec :: Int -> ReadS GDay
$creadsPrec :: Int -> ReadS GDay
Read, Int -> GDay -> String -> String
[GDay] -> String -> String
GDay -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [GDay] -> String -> String
$cshowList :: [GDay] -> String -> String
show :: GDay -> String
$cshow :: GDay -> String
showsPrec :: Int -> GDay -> String -> String
$cshowsPrec :: Int -> GDay -> String -> String
Show)

_GDay :: Name
_GDay = (String -> Name
Core.Name String
"hydra/ext/xml/schema.GDay")

newtype GMonth = 
  GMonth {
    GMonth -> String
unGMonth :: String}
  deriving (GMonth -> GMonth -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GMonth -> GMonth -> Bool
$c/= :: GMonth -> GMonth -> Bool
== :: GMonth -> GMonth -> Bool
$c== :: GMonth -> GMonth -> Bool
Eq, Eq GMonth
GMonth -> GMonth -> Bool
GMonth -> GMonth -> Ordering
GMonth -> GMonth -> GMonth
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GMonth -> GMonth -> GMonth
$cmin :: GMonth -> GMonth -> GMonth
max :: GMonth -> GMonth -> GMonth
$cmax :: GMonth -> GMonth -> GMonth
>= :: GMonth -> GMonth -> Bool
$c>= :: GMonth -> GMonth -> Bool
> :: GMonth -> GMonth -> Bool
$c> :: GMonth -> GMonth -> Bool
<= :: GMonth -> GMonth -> Bool
$c<= :: GMonth -> GMonth -> Bool
< :: GMonth -> GMonth -> Bool
$c< :: GMonth -> GMonth -> Bool
compare :: GMonth -> GMonth -> Ordering
$ccompare :: GMonth -> GMonth -> Ordering
Ord, ReadPrec [GMonth]
ReadPrec GMonth
Int -> ReadS GMonth
ReadS [GMonth]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GMonth]
$creadListPrec :: ReadPrec [GMonth]
readPrec :: ReadPrec GMonth
$creadPrec :: ReadPrec GMonth
readList :: ReadS [GMonth]
$creadList :: ReadS [GMonth]
readsPrec :: Int -> ReadS GMonth
$creadsPrec :: Int -> ReadS GMonth
Read, Int -> GMonth -> String -> String
[GMonth] -> String -> String
GMonth -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [GMonth] -> String -> String
$cshowList :: [GMonth] -> String -> String
show :: GMonth -> String
$cshow :: GMonth -> String
showsPrec :: Int -> GMonth -> String -> String
$cshowsPrec :: Int -> GMonth -> String -> String
Show)

_GMonth :: Name
_GMonth = (String -> Name
Core.Name String
"hydra/ext/xml/schema.GMonth")

newtype GMonthDay = 
  GMonthDay {
    GMonthDay -> String
unGMonthDay :: String}
  deriving (GMonthDay -> GMonthDay -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GMonthDay -> GMonthDay -> Bool
$c/= :: GMonthDay -> GMonthDay -> Bool
== :: GMonthDay -> GMonthDay -> Bool
$c== :: GMonthDay -> GMonthDay -> Bool
Eq, Eq GMonthDay
GMonthDay -> GMonthDay -> Bool
GMonthDay -> GMonthDay -> Ordering
GMonthDay -> GMonthDay -> GMonthDay
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GMonthDay -> GMonthDay -> GMonthDay
$cmin :: GMonthDay -> GMonthDay -> GMonthDay
max :: GMonthDay -> GMonthDay -> GMonthDay
$cmax :: GMonthDay -> GMonthDay -> GMonthDay
>= :: GMonthDay -> GMonthDay -> Bool
$c>= :: GMonthDay -> GMonthDay -> Bool
> :: GMonthDay -> GMonthDay -> Bool
$c> :: GMonthDay -> GMonthDay -> Bool
<= :: GMonthDay -> GMonthDay -> Bool
$c<= :: GMonthDay -> GMonthDay -> Bool
< :: GMonthDay -> GMonthDay -> Bool
$c< :: GMonthDay -> GMonthDay -> Bool
compare :: GMonthDay -> GMonthDay -> Ordering
$ccompare :: GMonthDay -> GMonthDay -> Ordering
Ord, ReadPrec [GMonthDay]
ReadPrec GMonthDay
Int -> ReadS GMonthDay
ReadS [GMonthDay]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GMonthDay]
$creadListPrec :: ReadPrec [GMonthDay]
readPrec :: ReadPrec GMonthDay
$creadPrec :: ReadPrec GMonthDay
readList :: ReadS [GMonthDay]
$creadList :: ReadS [GMonthDay]
readsPrec :: Int -> ReadS GMonthDay
$creadsPrec :: Int -> ReadS GMonthDay
Read, Int -> GMonthDay -> String -> String
[GMonthDay] -> String -> String
GMonthDay -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [GMonthDay] -> String -> String
$cshowList :: [GMonthDay] -> String -> String
show :: GMonthDay -> String
$cshow :: GMonthDay -> String
showsPrec :: Int -> GMonthDay -> String -> String
$cshowsPrec :: Int -> GMonthDay -> String -> String
Show)

_GMonthDay :: Name
_GMonthDay = (String -> Name
Core.Name String
"hydra/ext/xml/schema.GMonthDay")

newtype GYear = 
  GYear {
    GYear -> String
unGYear :: String}
  deriving (GYear -> GYear -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GYear -> GYear -> Bool
$c/= :: GYear -> GYear -> Bool
== :: GYear -> GYear -> Bool
$c== :: GYear -> GYear -> Bool
Eq, Eq GYear
GYear -> GYear -> Bool
GYear -> GYear -> Ordering
GYear -> GYear -> GYear
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GYear -> GYear -> GYear
$cmin :: GYear -> GYear -> GYear
max :: GYear -> GYear -> GYear
$cmax :: GYear -> GYear -> GYear
>= :: GYear -> GYear -> Bool
$c>= :: GYear -> GYear -> Bool
> :: GYear -> GYear -> Bool
$c> :: GYear -> GYear -> Bool
<= :: GYear -> GYear -> Bool
$c<= :: GYear -> GYear -> Bool
< :: GYear -> GYear -> Bool
$c< :: GYear -> GYear -> Bool
compare :: GYear -> GYear -> Ordering
$ccompare :: GYear -> GYear -> Ordering
Ord, ReadPrec [GYear]
ReadPrec GYear
Int -> ReadS GYear
ReadS [GYear]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GYear]
$creadListPrec :: ReadPrec [GYear]
readPrec :: ReadPrec GYear
$creadPrec :: ReadPrec GYear
readList :: ReadS [GYear]
$creadList :: ReadS [GYear]
readsPrec :: Int -> ReadS GYear
$creadsPrec :: Int -> ReadS GYear
Read, Int -> GYear -> String -> String
[GYear] -> String -> String
GYear -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [GYear] -> String -> String
$cshowList :: [GYear] -> String -> String
show :: GYear -> String
$cshow :: GYear -> String
showsPrec :: Int -> GYear -> String -> String
$cshowsPrec :: Int -> GYear -> String -> String
Show)

_GYear :: Name
_GYear = (String -> Name
Core.Name String
"hydra/ext/xml/schema.GYear")

newtype GYearMonth = 
  GYearMonth {
    GYearMonth -> String
unGYearMonth :: String}
  deriving (GYearMonth -> GYearMonth -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GYearMonth -> GYearMonth -> Bool
$c/= :: GYearMonth -> GYearMonth -> Bool
== :: GYearMonth -> GYearMonth -> Bool
$c== :: GYearMonth -> GYearMonth -> Bool
Eq, Eq GYearMonth
GYearMonth -> GYearMonth -> Bool
GYearMonth -> GYearMonth -> Ordering
GYearMonth -> GYearMonth -> GYearMonth
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GYearMonth -> GYearMonth -> GYearMonth
$cmin :: GYearMonth -> GYearMonth -> GYearMonth
max :: GYearMonth -> GYearMonth -> GYearMonth
$cmax :: GYearMonth -> GYearMonth -> GYearMonth
>= :: GYearMonth -> GYearMonth -> Bool
$c>= :: GYearMonth -> GYearMonth -> Bool
> :: GYearMonth -> GYearMonth -> Bool
$c> :: GYearMonth -> GYearMonth -> Bool
<= :: GYearMonth -> GYearMonth -> Bool
$c<= :: GYearMonth -> GYearMonth -> Bool
< :: GYearMonth -> GYearMonth -> Bool
$c< :: GYearMonth -> GYearMonth -> Bool
compare :: GYearMonth -> GYearMonth -> Ordering
$ccompare :: GYearMonth -> GYearMonth -> Ordering
Ord, ReadPrec [GYearMonth]
ReadPrec GYearMonth
Int -> ReadS GYearMonth
ReadS [GYearMonth]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GYearMonth]
$creadListPrec :: ReadPrec [GYearMonth]
readPrec :: ReadPrec GYearMonth
$creadPrec :: ReadPrec GYearMonth
readList :: ReadS [GYearMonth]
$creadList :: ReadS [GYearMonth]
readsPrec :: Int -> ReadS GYearMonth
$creadsPrec :: Int -> ReadS GYearMonth
Read, Int -> GYearMonth -> String -> String
[GYearMonth] -> String -> String
GYearMonth -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [GYearMonth] -> String -> String
$cshowList :: [GYearMonth] -> String -> String
show :: GYearMonth -> String
$cshow :: GYearMonth -> String
showsPrec :: Int -> GYearMonth -> String -> String
$cshowsPrec :: Int -> GYearMonth -> String -> String
Show)

_GYearMonth :: Name
_GYearMonth = (String -> Name
Core.Name String
"hydra/ext/xml/schema.GYearMonth")

newtype HexBinary = 
  HexBinary {
    HexBinary -> String
unHexBinary :: String}
  deriving (HexBinary -> HexBinary -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HexBinary -> HexBinary -> Bool
$c/= :: HexBinary -> HexBinary -> Bool
== :: HexBinary -> HexBinary -> Bool
$c== :: HexBinary -> HexBinary -> Bool
Eq, Eq HexBinary
HexBinary -> HexBinary -> Bool
HexBinary -> HexBinary -> Ordering
HexBinary -> HexBinary -> HexBinary
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: HexBinary -> HexBinary -> HexBinary
$cmin :: HexBinary -> HexBinary -> HexBinary
max :: HexBinary -> HexBinary -> HexBinary
$cmax :: HexBinary -> HexBinary -> HexBinary
>= :: HexBinary -> HexBinary -> Bool
$c>= :: HexBinary -> HexBinary -> Bool
> :: HexBinary -> HexBinary -> Bool
$c> :: HexBinary -> HexBinary -> Bool
<= :: HexBinary -> HexBinary -> Bool
$c<= :: HexBinary -> HexBinary -> Bool
< :: HexBinary -> HexBinary -> Bool
$c< :: HexBinary -> HexBinary -> Bool
compare :: HexBinary -> HexBinary -> Ordering
$ccompare :: HexBinary -> HexBinary -> Ordering
Ord, ReadPrec [HexBinary]
ReadPrec HexBinary
Int -> ReadS HexBinary
ReadS [HexBinary]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [HexBinary]
$creadListPrec :: ReadPrec [HexBinary]
readPrec :: ReadPrec HexBinary
$creadPrec :: ReadPrec HexBinary
readList :: ReadS [HexBinary]
$creadList :: ReadS [HexBinary]
readsPrec :: Int -> ReadS HexBinary
$creadsPrec :: Int -> ReadS HexBinary
Read, Int -> HexBinary -> String -> String
[HexBinary] -> String -> String
HexBinary -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [HexBinary] -> String -> String
$cshowList :: [HexBinary] -> String -> String
show :: HexBinary -> String
$cshow :: HexBinary -> String
showsPrec :: Int -> HexBinary -> String -> String
$cshowsPrec :: Int -> HexBinary -> String -> String
Show)

_HexBinary :: Name
_HexBinary = (String -> Name
Core.Name String
"hydra/ext/xml/schema.HexBinary")

newtype ID = 
  ID {
    ID -> String
unID :: String}
  deriving (ID -> ID -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ID -> ID -> Bool
$c/= :: ID -> ID -> Bool
== :: ID -> ID -> Bool
$c== :: ID -> ID -> Bool
Eq, Eq ID
ID -> ID -> Bool
ID -> ID -> Ordering
ID -> ID -> ID
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ID -> ID -> ID
$cmin :: ID -> ID -> ID
max :: ID -> ID -> ID
$cmax :: ID -> ID -> ID
>= :: ID -> ID -> Bool
$c>= :: ID -> ID -> Bool
> :: ID -> ID -> Bool
$c> :: ID -> ID -> Bool
<= :: ID -> ID -> Bool
$c<= :: ID -> ID -> Bool
< :: ID -> ID -> Bool
$c< :: ID -> ID -> Bool
compare :: ID -> ID -> Ordering
$ccompare :: ID -> ID -> Ordering
Ord, ReadPrec [ID]
ReadPrec ID
Int -> ReadS ID
ReadS [ID]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ID]
$creadListPrec :: ReadPrec [ID]
readPrec :: ReadPrec ID
$creadPrec :: ReadPrec ID
readList :: ReadS [ID]
$creadList :: ReadS [ID]
readsPrec :: Int -> ReadS ID
$creadsPrec :: Int -> ReadS ID
Read, Int -> ID -> String -> String
[ID] -> String -> String
ID -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [ID] -> String -> String
$cshowList :: [ID] -> String -> String
show :: ID -> String
$cshow :: ID -> String
showsPrec :: Int -> ID -> String -> String
$cshowsPrec :: Int -> ID -> String -> String
Show)

_ID :: Name
_ID = (String -> Name
Core.Name String
"hydra/ext/xml/schema.ID")

newtype IDREF = 
  IDREF {
    IDREF -> String
unIDREF :: String}
  deriving (IDREF -> IDREF -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IDREF -> IDREF -> Bool
$c/= :: IDREF -> IDREF -> Bool
== :: IDREF -> IDREF -> Bool
$c== :: IDREF -> IDREF -> Bool
Eq, Eq IDREF
IDREF -> IDREF -> Bool
IDREF -> IDREF -> Ordering
IDREF -> IDREF -> IDREF
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: IDREF -> IDREF -> IDREF
$cmin :: IDREF -> IDREF -> IDREF
max :: IDREF -> IDREF -> IDREF
$cmax :: IDREF -> IDREF -> IDREF
>= :: IDREF -> IDREF -> Bool
$c>= :: IDREF -> IDREF -> Bool
> :: IDREF -> IDREF -> Bool
$c> :: IDREF -> IDREF -> Bool
<= :: IDREF -> IDREF -> Bool
$c<= :: IDREF -> IDREF -> Bool
< :: IDREF -> IDREF -> Bool
$c< :: IDREF -> IDREF -> Bool
compare :: IDREF -> IDREF -> Ordering
$ccompare :: IDREF -> IDREF -> Ordering
Ord, ReadPrec [IDREF]
ReadPrec IDREF
Int -> ReadS IDREF
ReadS [IDREF]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IDREF]
$creadListPrec :: ReadPrec [IDREF]
readPrec :: ReadPrec IDREF
$creadPrec :: ReadPrec IDREF
readList :: ReadS [IDREF]
$creadList :: ReadS [IDREF]
readsPrec :: Int -> ReadS IDREF
$creadsPrec :: Int -> ReadS IDREF
Read, Int -> IDREF -> String -> String
[IDREF] -> String -> String
IDREF -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [IDREF] -> String -> String
$cshowList :: [IDREF] -> String -> String
show :: IDREF -> String
$cshow :: IDREF -> String
showsPrec :: Int -> IDREF -> String -> String
$cshowsPrec :: Int -> IDREF -> String -> String
Show)

_IDREF :: Name
_IDREF = (String -> Name
Core.Name String
"hydra/ext/xml/schema.IDREF")

newtype IDREFS = 
  IDREFS {
    IDREFS -> String
unIDREFS :: String}
  deriving (IDREFS -> IDREFS -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IDREFS -> IDREFS -> Bool
$c/= :: IDREFS -> IDREFS -> Bool
== :: IDREFS -> IDREFS -> Bool
$c== :: IDREFS -> IDREFS -> Bool
Eq, Eq IDREFS
IDREFS -> IDREFS -> Bool
IDREFS -> IDREFS -> Ordering
IDREFS -> IDREFS -> IDREFS
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: IDREFS -> IDREFS -> IDREFS
$cmin :: IDREFS -> IDREFS -> IDREFS
max :: IDREFS -> IDREFS -> IDREFS
$cmax :: IDREFS -> IDREFS -> IDREFS
>= :: IDREFS -> IDREFS -> Bool
$c>= :: IDREFS -> IDREFS -> Bool
> :: IDREFS -> IDREFS -> Bool
$c> :: IDREFS -> IDREFS -> Bool
<= :: IDREFS -> IDREFS -> Bool
$c<= :: IDREFS -> IDREFS -> Bool
< :: IDREFS -> IDREFS -> Bool
$c< :: IDREFS -> IDREFS -> Bool
compare :: IDREFS -> IDREFS -> Ordering
$ccompare :: IDREFS -> IDREFS -> Ordering
Ord, ReadPrec [IDREFS]
ReadPrec IDREFS
Int -> ReadS IDREFS
ReadS [IDREFS]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IDREFS]
$creadListPrec :: ReadPrec [IDREFS]
readPrec :: ReadPrec IDREFS
$creadPrec :: ReadPrec IDREFS
readList :: ReadS [IDREFS]
$creadList :: ReadS [IDREFS]
readsPrec :: Int -> ReadS IDREFS
$creadsPrec :: Int -> ReadS IDREFS
Read, Int -> IDREFS -> String -> String
[IDREFS] -> String -> String
IDREFS -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [IDREFS] -> String -> String
$cshowList :: [IDREFS] -> String -> String
show :: IDREFS -> String
$cshow :: IDREFS -> String
showsPrec :: Int -> IDREFS -> String -> String
$cshowsPrec :: Int -> IDREFS -> String -> String
Show)

_IDREFS :: Name
_IDREFS = (String -> Name
Core.Name String
"hydra/ext/xml/schema.IDREFS")

newtype Int_ = 
  Int_ {
    Int_ -> Int
unInt :: Int}
  deriving (Int_ -> Int_ -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Int_ -> Int_ -> Bool
$c/= :: Int_ -> Int_ -> Bool
== :: Int_ -> Int_ -> Bool
$c== :: Int_ -> Int_ -> Bool
Eq, Eq Int_
Int_ -> Int_ -> Bool
Int_ -> Int_ -> Ordering
Int_ -> Int_ -> Int_
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Int_ -> Int_ -> Int_
$cmin :: Int_ -> Int_ -> Int_
max :: Int_ -> Int_ -> Int_
$cmax :: Int_ -> Int_ -> Int_
>= :: Int_ -> Int_ -> Bool
$c>= :: Int_ -> Int_ -> Bool
> :: Int_ -> Int_ -> Bool
$c> :: Int_ -> Int_ -> Bool
<= :: Int_ -> Int_ -> Bool
$c<= :: Int_ -> Int_ -> Bool
< :: Int_ -> Int_ -> Bool
$c< :: Int_ -> Int_ -> Bool
compare :: Int_ -> Int_ -> Ordering
$ccompare :: Int_ -> Int_ -> Ordering
Ord, ReadPrec [Int_]
ReadPrec Int_
Int -> ReadS Int_
ReadS [Int_]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Int_]
$creadListPrec :: ReadPrec [Int_]
readPrec :: ReadPrec Int_
$creadPrec :: ReadPrec Int_
readList :: ReadS [Int_]
$creadList :: ReadS [Int_]
readsPrec :: Int -> ReadS Int_
$creadsPrec :: Int -> ReadS Int_
Read, Int -> Int_ -> String -> String
[Int_] -> String -> String
Int_ -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Int_] -> String -> String
$cshowList :: [Int_] -> String -> String
show :: Int_ -> String
$cshow :: Int_ -> String
showsPrec :: Int -> Int_ -> String -> String
$cshowsPrec :: Int -> Int_ -> String -> String
Show)

_Int :: Name
_Int = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Int")

newtype Integer_ = 
  Integer_ {
    Integer_ -> Integer
unInteger :: Integer}
  deriving (Integer_ -> Integer_ -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Integer_ -> Integer_ -> Bool
$c/= :: Integer_ -> Integer_ -> Bool
== :: Integer_ -> Integer_ -> Bool
$c== :: Integer_ -> Integer_ -> Bool
Eq, Eq Integer_
Integer_ -> Integer_ -> Bool
Integer_ -> Integer_ -> Ordering
Integer_ -> Integer_ -> Integer_
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Integer_ -> Integer_ -> Integer_
$cmin :: Integer_ -> Integer_ -> Integer_
max :: Integer_ -> Integer_ -> Integer_
$cmax :: Integer_ -> Integer_ -> Integer_
>= :: Integer_ -> Integer_ -> Bool
$c>= :: Integer_ -> Integer_ -> Bool
> :: Integer_ -> Integer_ -> Bool
$c> :: Integer_ -> Integer_ -> Bool
<= :: Integer_ -> Integer_ -> Bool
$c<= :: Integer_ -> Integer_ -> Bool
< :: Integer_ -> Integer_ -> Bool
$c< :: Integer_ -> Integer_ -> Bool
compare :: Integer_ -> Integer_ -> Ordering
$ccompare :: Integer_ -> Integer_ -> Ordering
Ord, ReadPrec [Integer_]
ReadPrec Integer_
Int -> ReadS Integer_
ReadS [Integer_]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Integer_]
$creadListPrec :: ReadPrec [Integer_]
readPrec :: ReadPrec Integer_
$creadPrec :: ReadPrec Integer_
readList :: ReadS [Integer_]
$creadList :: ReadS [Integer_]
readsPrec :: Int -> ReadS Integer_
$creadsPrec :: Int -> ReadS Integer_
Read, Int -> Integer_ -> String -> String
[Integer_] -> String -> String
Integer_ -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Integer_] -> String -> String
$cshowList :: [Integer_] -> String -> String
show :: Integer_ -> String
$cshow :: Integer_ -> String
showsPrec :: Int -> Integer_ -> String -> String
$cshowsPrec :: Int -> Integer_ -> String -> String
Show)

_Integer :: Name
_Integer = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Integer")

newtype Language = 
  Language {
    Language -> String
unLanguage :: String}
  deriving (Language -> Language -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Language -> Language -> Bool
$c/= :: Language -> Language -> Bool
== :: Language -> Language -> Bool
$c== :: Language -> Language -> Bool
Eq, Eq Language
Language -> Language -> Bool
Language -> Language -> Ordering
Language -> Language -> Language
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Language -> Language -> Language
$cmin :: Language -> Language -> Language
max :: Language -> Language -> Language
$cmax :: Language -> Language -> Language
>= :: Language -> Language -> Bool
$c>= :: Language -> Language -> Bool
> :: Language -> Language -> Bool
$c> :: Language -> Language -> Bool
<= :: Language -> Language -> Bool
$c<= :: Language -> Language -> Bool
< :: Language -> Language -> Bool
$c< :: Language -> Language -> Bool
compare :: Language -> Language -> Ordering
$ccompare :: Language -> Language -> Ordering
Ord, ReadPrec [Language]
ReadPrec Language
Int -> ReadS Language
ReadS [Language]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Language]
$creadListPrec :: ReadPrec [Language]
readPrec :: ReadPrec Language
$creadPrec :: ReadPrec Language
readList :: ReadS [Language]
$creadList :: ReadS [Language]
readsPrec :: Int -> ReadS Language
$creadsPrec :: Int -> ReadS Language
Read, Int -> Language -> String -> String
[Language] -> String -> String
Language -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Language] -> String -> String
$cshowList :: [Language] -> String -> String
show :: Language -> String
$cshow :: Language -> String
showsPrec :: Int -> Language -> String -> String
$cshowsPrec :: Int -> Language -> String -> String
Show)

_Language :: Name
_Language = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Language")

newtype Long = 
  Long {
    Long -> Integer
unLong :: Integer}
  deriving (Long -> Long -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Long -> Long -> Bool
$c/= :: Long -> Long -> Bool
== :: Long -> Long -> Bool
$c== :: Long -> Long -> Bool
Eq, Eq Long
Long -> Long -> Bool
Long -> Long -> Ordering
Long -> Long -> Long
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Long -> Long -> Long
$cmin :: Long -> Long -> Long
max :: Long -> Long -> Long
$cmax :: Long -> Long -> Long
>= :: Long -> Long -> Bool
$c>= :: Long -> Long -> Bool
> :: Long -> Long -> Bool
$c> :: Long -> Long -> Bool
<= :: Long -> Long -> Bool
$c<= :: Long -> Long -> Bool
< :: Long -> Long -> Bool
$c< :: Long -> Long -> Bool
compare :: Long -> Long -> Ordering
$ccompare :: Long -> Long -> Ordering
Ord, ReadPrec [Long]
ReadPrec Long
Int -> ReadS Long
ReadS [Long]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Long]
$creadListPrec :: ReadPrec [Long]
readPrec :: ReadPrec Long
$creadPrec :: ReadPrec Long
readList :: ReadS [Long]
$creadList :: ReadS [Long]
readsPrec :: Int -> ReadS Long
$creadsPrec :: Int -> ReadS Long
Read, Int -> Long -> String -> String
[Long] -> String -> String
Long -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Long] -> String -> String
$cshowList :: [Long] -> String -> String
show :: Long -> String
$cshow :: Long -> String
showsPrec :: Int -> Long -> String -> String
$cshowsPrec :: Int -> Long -> String -> String
Show)

_Long :: Name
_Long = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Long")

newtype NMTOKEN = 
  NMTOKEN {
    NMTOKEN -> String
unNMTOKEN :: String}
  deriving (NMTOKEN -> NMTOKEN -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NMTOKEN -> NMTOKEN -> Bool
$c/= :: NMTOKEN -> NMTOKEN -> Bool
== :: NMTOKEN -> NMTOKEN -> Bool
$c== :: NMTOKEN -> NMTOKEN -> Bool
Eq, Eq NMTOKEN
NMTOKEN -> NMTOKEN -> Bool
NMTOKEN -> NMTOKEN -> Ordering
NMTOKEN -> NMTOKEN -> NMTOKEN
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: NMTOKEN -> NMTOKEN -> NMTOKEN
$cmin :: NMTOKEN -> NMTOKEN -> NMTOKEN
max :: NMTOKEN -> NMTOKEN -> NMTOKEN
$cmax :: NMTOKEN -> NMTOKEN -> NMTOKEN
>= :: NMTOKEN -> NMTOKEN -> Bool
$c>= :: NMTOKEN -> NMTOKEN -> Bool
> :: NMTOKEN -> NMTOKEN -> Bool
$c> :: NMTOKEN -> NMTOKEN -> Bool
<= :: NMTOKEN -> NMTOKEN -> Bool
$c<= :: NMTOKEN -> NMTOKEN -> Bool
< :: NMTOKEN -> NMTOKEN -> Bool
$c< :: NMTOKEN -> NMTOKEN -> Bool
compare :: NMTOKEN -> NMTOKEN -> Ordering
$ccompare :: NMTOKEN -> NMTOKEN -> Ordering
Ord, ReadPrec [NMTOKEN]
ReadPrec NMTOKEN
Int -> ReadS NMTOKEN
ReadS [NMTOKEN]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NMTOKEN]
$creadListPrec :: ReadPrec [NMTOKEN]
readPrec :: ReadPrec NMTOKEN
$creadPrec :: ReadPrec NMTOKEN
readList :: ReadS [NMTOKEN]
$creadList :: ReadS [NMTOKEN]
readsPrec :: Int -> ReadS NMTOKEN
$creadsPrec :: Int -> ReadS NMTOKEN
Read, Int -> NMTOKEN -> String -> String
[NMTOKEN] -> String -> String
NMTOKEN -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [NMTOKEN] -> String -> String
$cshowList :: [NMTOKEN] -> String -> String
show :: NMTOKEN -> String
$cshow :: NMTOKEN -> String
showsPrec :: Int -> NMTOKEN -> String -> String
$cshowsPrec :: Int -> NMTOKEN -> String -> String
Show)

_NMTOKEN :: Name
_NMTOKEN = (String -> Name
Core.Name String
"hydra/ext/xml/schema.NMTOKEN")

newtype NOTATION = 
  NOTATION {
    NOTATION -> String
unNOTATION :: String}
  deriving (NOTATION -> NOTATION -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NOTATION -> NOTATION -> Bool
$c/= :: NOTATION -> NOTATION -> Bool
== :: NOTATION -> NOTATION -> Bool
$c== :: NOTATION -> NOTATION -> Bool
Eq, Eq NOTATION
NOTATION -> NOTATION -> Bool
NOTATION -> NOTATION -> Ordering
NOTATION -> NOTATION -> NOTATION
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: NOTATION -> NOTATION -> NOTATION
$cmin :: NOTATION -> NOTATION -> NOTATION
max :: NOTATION -> NOTATION -> NOTATION
$cmax :: NOTATION -> NOTATION -> NOTATION
>= :: NOTATION -> NOTATION -> Bool
$c>= :: NOTATION -> NOTATION -> Bool
> :: NOTATION -> NOTATION -> Bool
$c> :: NOTATION -> NOTATION -> Bool
<= :: NOTATION -> NOTATION -> Bool
$c<= :: NOTATION -> NOTATION -> Bool
< :: NOTATION -> NOTATION -> Bool
$c< :: NOTATION -> NOTATION -> Bool
compare :: NOTATION -> NOTATION -> Ordering
$ccompare :: NOTATION -> NOTATION -> Ordering
Ord, ReadPrec [NOTATION]
ReadPrec NOTATION
Int -> ReadS NOTATION
ReadS [NOTATION]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NOTATION]
$creadListPrec :: ReadPrec [NOTATION]
readPrec :: ReadPrec NOTATION
$creadPrec :: ReadPrec NOTATION
readList :: ReadS [NOTATION]
$creadList :: ReadS [NOTATION]
readsPrec :: Int -> ReadS NOTATION
$creadsPrec :: Int -> ReadS NOTATION
Read, Int -> NOTATION -> String -> String
[NOTATION] -> String -> String
NOTATION -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [NOTATION] -> String -> String
$cshowList :: [NOTATION] -> String -> String
show :: NOTATION -> String
$cshow :: NOTATION -> String
showsPrec :: Int -> NOTATION -> String -> String
$cshowsPrec :: Int -> NOTATION -> String -> String
Show)

_NOTATION :: Name
_NOTATION = (String -> Name
Core.Name String
"hydra/ext/xml/schema.NOTATION")

newtype Name = 
  Name {
    Name -> String
unName :: String}
  deriving (Name -> Name -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c== :: Name -> Name -> Bool
Eq, Eq Name
Name -> Name -> Bool
Name -> Name -> Ordering
Name -> Name -> Name
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Name -> Name -> Name
$cmin :: Name -> Name -> Name
max :: Name -> Name -> Name
$cmax :: Name -> Name -> Name
>= :: Name -> Name -> Bool
$c>= :: Name -> Name -> Bool
> :: Name -> Name -> Bool
$c> :: Name -> Name -> Bool
<= :: Name -> Name -> Bool
$c<= :: Name -> Name -> Bool
< :: Name -> Name -> Bool
$c< :: Name -> Name -> Bool
compare :: Name -> Name -> Ordering
$ccompare :: Name -> Name -> Ordering
Ord, ReadPrec [Name]
ReadPrec Name
Int -> ReadS Name
ReadS [Name]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Name]
$creadListPrec :: ReadPrec [Name]
readPrec :: ReadPrec Name
$creadPrec :: ReadPrec Name
readList :: ReadS [Name]
$creadList :: ReadS [Name]
readsPrec :: Int -> ReadS Name
$creadsPrec :: Int -> ReadS Name
Read, Int -> Name -> String -> String
[Name] -> String -> String
Name -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Name] -> String -> String
$cshowList :: [Name] -> String -> String
show :: Name -> String
$cshow :: Name -> String
showsPrec :: Int -> Name -> String -> String
$cshowsPrec :: Int -> Name -> String -> String
Show)

_Name :: Name
_Name = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Name")

newtype NegativeInteger = 
  NegativeInteger {
    NegativeInteger -> Integer
unNegativeInteger :: Integer}
  deriving (NegativeInteger -> NegativeInteger -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NegativeInteger -> NegativeInteger -> Bool
$c/= :: NegativeInteger -> NegativeInteger -> Bool
== :: NegativeInteger -> NegativeInteger -> Bool
$c== :: NegativeInteger -> NegativeInteger -> Bool
Eq, Eq NegativeInteger
NegativeInteger -> NegativeInteger -> Bool
NegativeInteger -> NegativeInteger -> Ordering
NegativeInteger -> NegativeInteger -> NegativeInteger
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: NegativeInteger -> NegativeInteger -> NegativeInteger
$cmin :: NegativeInteger -> NegativeInteger -> NegativeInteger
max :: NegativeInteger -> NegativeInteger -> NegativeInteger
$cmax :: NegativeInteger -> NegativeInteger -> NegativeInteger
>= :: NegativeInteger -> NegativeInteger -> Bool
$c>= :: NegativeInteger -> NegativeInteger -> Bool
> :: NegativeInteger -> NegativeInteger -> Bool
$c> :: NegativeInteger -> NegativeInteger -> Bool
<= :: NegativeInteger -> NegativeInteger -> Bool
$c<= :: NegativeInteger -> NegativeInteger -> Bool
< :: NegativeInteger -> NegativeInteger -> Bool
$c< :: NegativeInteger -> NegativeInteger -> Bool
compare :: NegativeInteger -> NegativeInteger -> Ordering
$ccompare :: NegativeInteger -> NegativeInteger -> Ordering
Ord, ReadPrec [NegativeInteger]
ReadPrec NegativeInteger
Int -> ReadS NegativeInteger
ReadS [NegativeInteger]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NegativeInteger]
$creadListPrec :: ReadPrec [NegativeInteger]
readPrec :: ReadPrec NegativeInteger
$creadPrec :: ReadPrec NegativeInteger
readList :: ReadS [NegativeInteger]
$creadList :: ReadS [NegativeInteger]
readsPrec :: Int -> ReadS NegativeInteger
$creadsPrec :: Int -> ReadS NegativeInteger
Read, Int -> NegativeInteger -> String -> String
[NegativeInteger] -> String -> String
NegativeInteger -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [NegativeInteger] -> String -> String
$cshowList :: [NegativeInteger] -> String -> String
show :: NegativeInteger -> String
$cshow :: NegativeInteger -> String
showsPrec :: Int -> NegativeInteger -> String -> String
$cshowsPrec :: Int -> NegativeInteger -> String -> String
Show)

_NegativeInteger :: Name
_NegativeInteger = (String -> Name
Core.Name String
"hydra/ext/xml/schema.NegativeInteger")

newtype NonNegativeInteger = 
  NonNegativeInteger {
    NonNegativeInteger -> Integer
unNonNegativeInteger :: Integer}
  deriving (NonNegativeInteger -> NonNegativeInteger -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NonNegativeInteger -> NonNegativeInteger -> Bool
$c/= :: NonNegativeInteger -> NonNegativeInteger -> Bool
== :: NonNegativeInteger -> NonNegativeInteger -> Bool
$c== :: NonNegativeInteger -> NonNegativeInteger -> Bool
Eq, Eq NonNegativeInteger
NonNegativeInteger -> NonNegativeInteger -> Bool
NonNegativeInteger -> NonNegativeInteger -> Ordering
NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger
$cmin :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger
max :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger
$cmax :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger
>= :: NonNegativeInteger -> NonNegativeInteger -> Bool
$c>= :: NonNegativeInteger -> NonNegativeInteger -> Bool
> :: NonNegativeInteger -> NonNegativeInteger -> Bool
$c> :: NonNegativeInteger -> NonNegativeInteger -> Bool
<= :: NonNegativeInteger -> NonNegativeInteger -> Bool
$c<= :: NonNegativeInteger -> NonNegativeInteger -> Bool
< :: NonNegativeInteger -> NonNegativeInteger -> Bool
$c< :: NonNegativeInteger -> NonNegativeInteger -> Bool
compare :: NonNegativeInteger -> NonNegativeInteger -> Ordering
$ccompare :: NonNegativeInteger -> NonNegativeInteger -> Ordering
Ord, ReadPrec [NonNegativeInteger]
ReadPrec NonNegativeInteger
Int -> ReadS NonNegativeInteger
ReadS [NonNegativeInteger]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NonNegativeInteger]
$creadListPrec :: ReadPrec [NonNegativeInteger]
readPrec :: ReadPrec NonNegativeInteger
$creadPrec :: ReadPrec NonNegativeInteger
readList :: ReadS [NonNegativeInteger]
$creadList :: ReadS [NonNegativeInteger]
readsPrec :: Int -> ReadS NonNegativeInteger
$creadsPrec :: Int -> ReadS NonNegativeInteger
Read, Int -> NonNegativeInteger -> String -> String
[NonNegativeInteger] -> String -> String
NonNegativeInteger -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [NonNegativeInteger] -> String -> String
$cshowList :: [NonNegativeInteger] -> String -> String
show :: NonNegativeInteger -> String
$cshow :: NonNegativeInteger -> String
showsPrec :: Int -> NonNegativeInteger -> String -> String
$cshowsPrec :: Int -> NonNegativeInteger -> String -> String
Show)

_NonNegativeInteger :: Name
_NonNegativeInteger = (String -> Name
Core.Name String
"hydra/ext/xml/schema.NonNegativeInteger")

newtype NonPositiveInteger = 
  NonPositiveInteger {
    NonPositiveInteger -> Integer
unNonPositiveInteger :: Integer}
  deriving (NonPositiveInteger -> NonPositiveInteger -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NonPositiveInteger -> NonPositiveInteger -> Bool
$c/= :: NonPositiveInteger -> NonPositiveInteger -> Bool
== :: NonPositiveInteger -> NonPositiveInteger -> Bool
$c== :: NonPositiveInteger -> NonPositiveInteger -> Bool
Eq, Eq NonPositiveInteger
NonPositiveInteger -> NonPositiveInteger -> Bool
NonPositiveInteger -> NonPositiveInteger -> Ordering
NonPositiveInteger -> NonPositiveInteger -> NonPositiveInteger
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: NonPositiveInteger -> NonPositiveInteger -> NonPositiveInteger
$cmin :: NonPositiveInteger -> NonPositiveInteger -> NonPositiveInteger
max :: NonPositiveInteger -> NonPositiveInteger -> NonPositiveInteger
$cmax :: NonPositiveInteger -> NonPositiveInteger -> NonPositiveInteger
>= :: NonPositiveInteger -> NonPositiveInteger -> Bool
$c>= :: NonPositiveInteger -> NonPositiveInteger -> Bool
> :: NonPositiveInteger -> NonPositiveInteger -> Bool
$c> :: NonPositiveInteger -> NonPositiveInteger -> Bool
<= :: NonPositiveInteger -> NonPositiveInteger -> Bool
$c<= :: NonPositiveInteger -> NonPositiveInteger -> Bool
< :: NonPositiveInteger -> NonPositiveInteger -> Bool
$c< :: NonPositiveInteger -> NonPositiveInteger -> Bool
compare :: NonPositiveInteger -> NonPositiveInteger -> Ordering
$ccompare :: NonPositiveInteger -> NonPositiveInteger -> Ordering
Ord, ReadPrec [NonPositiveInteger]
ReadPrec NonPositiveInteger
Int -> ReadS NonPositiveInteger
ReadS [NonPositiveInteger]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NonPositiveInteger]
$creadListPrec :: ReadPrec [NonPositiveInteger]
readPrec :: ReadPrec NonPositiveInteger
$creadPrec :: ReadPrec NonPositiveInteger
readList :: ReadS [NonPositiveInteger]
$creadList :: ReadS [NonPositiveInteger]
readsPrec :: Int -> ReadS NonPositiveInteger
$creadsPrec :: Int -> ReadS NonPositiveInteger
Read, Int -> NonPositiveInteger -> String -> String
[NonPositiveInteger] -> String -> String
NonPositiveInteger -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [NonPositiveInteger] -> String -> String
$cshowList :: [NonPositiveInteger] -> String -> String
show :: NonPositiveInteger -> String
$cshow :: NonPositiveInteger -> String
showsPrec :: Int -> NonPositiveInteger -> String -> String
$cshowsPrec :: Int -> NonPositiveInteger -> String -> String
Show)

_NonPositiveInteger :: Name
_NonPositiveInteger = (String -> Name
Core.Name String
"hydra/ext/xml/schema.NonPositiveInteger")

newtype NormalizedString = 
  NormalizedString {
    NormalizedString -> String
unNormalizedString :: String}
  deriving (NormalizedString -> NormalizedString -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NormalizedString -> NormalizedString -> Bool
$c/= :: NormalizedString -> NormalizedString -> Bool
== :: NormalizedString -> NormalizedString -> Bool
$c== :: NormalizedString -> NormalizedString -> Bool
Eq, Eq NormalizedString
NormalizedString -> NormalizedString -> Bool
NormalizedString -> NormalizedString -> Ordering
NormalizedString -> NormalizedString -> NormalizedString
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: NormalizedString -> NormalizedString -> NormalizedString
$cmin :: NormalizedString -> NormalizedString -> NormalizedString
max :: NormalizedString -> NormalizedString -> NormalizedString
$cmax :: NormalizedString -> NormalizedString -> NormalizedString
>= :: NormalizedString -> NormalizedString -> Bool
$c>= :: NormalizedString -> NormalizedString -> Bool
> :: NormalizedString -> NormalizedString -> Bool
$c> :: NormalizedString -> NormalizedString -> Bool
<= :: NormalizedString -> NormalizedString -> Bool
$c<= :: NormalizedString -> NormalizedString -> Bool
< :: NormalizedString -> NormalizedString -> Bool
$c< :: NormalizedString -> NormalizedString -> Bool
compare :: NormalizedString -> NormalizedString -> Ordering
$ccompare :: NormalizedString -> NormalizedString -> Ordering
Ord, ReadPrec [NormalizedString]
ReadPrec NormalizedString
Int -> ReadS NormalizedString
ReadS [NormalizedString]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NormalizedString]
$creadListPrec :: ReadPrec [NormalizedString]
readPrec :: ReadPrec NormalizedString
$creadPrec :: ReadPrec NormalizedString
readList :: ReadS [NormalizedString]
$creadList :: ReadS [NormalizedString]
readsPrec :: Int -> ReadS NormalizedString
$creadsPrec :: Int -> ReadS NormalizedString
Read, Int -> NormalizedString -> String -> String
[NormalizedString] -> String -> String
NormalizedString -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [NormalizedString] -> String -> String
$cshowList :: [NormalizedString] -> String -> String
show :: NormalizedString -> String
$cshow :: NormalizedString -> String
showsPrec :: Int -> NormalizedString -> String -> String
$cshowsPrec :: Int -> NormalizedString -> String -> String
Show)

_NormalizedString :: Name
_NormalizedString = (String -> Name
Core.Name String
"hydra/ext/xml/schema.NormalizedString")

newtype PositiveInteger = 
  PositiveInteger {
    PositiveInteger -> Integer
unPositiveInteger :: Integer}
  deriving (PositiveInteger -> PositiveInteger -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PositiveInteger -> PositiveInteger -> Bool
$c/= :: PositiveInteger -> PositiveInteger -> Bool
== :: PositiveInteger -> PositiveInteger -> Bool
$c== :: PositiveInteger -> PositiveInteger -> Bool
Eq, Eq PositiveInteger
PositiveInteger -> PositiveInteger -> Bool
PositiveInteger -> PositiveInteger -> Ordering
PositiveInteger -> PositiveInteger -> PositiveInteger
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PositiveInteger -> PositiveInteger -> PositiveInteger
$cmin :: PositiveInteger -> PositiveInteger -> PositiveInteger
max :: PositiveInteger -> PositiveInteger -> PositiveInteger
$cmax :: PositiveInteger -> PositiveInteger -> PositiveInteger
>= :: PositiveInteger -> PositiveInteger -> Bool
$c>= :: PositiveInteger -> PositiveInteger -> Bool
> :: PositiveInteger -> PositiveInteger -> Bool
$c> :: PositiveInteger -> PositiveInteger -> Bool
<= :: PositiveInteger -> PositiveInteger -> Bool
$c<= :: PositiveInteger -> PositiveInteger -> Bool
< :: PositiveInteger -> PositiveInteger -> Bool
$c< :: PositiveInteger -> PositiveInteger -> Bool
compare :: PositiveInteger -> PositiveInteger -> Ordering
$ccompare :: PositiveInteger -> PositiveInteger -> Ordering
Ord, ReadPrec [PositiveInteger]
ReadPrec PositiveInteger
Int -> ReadS PositiveInteger
ReadS [PositiveInteger]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PositiveInteger]
$creadListPrec :: ReadPrec [PositiveInteger]
readPrec :: ReadPrec PositiveInteger
$creadPrec :: ReadPrec PositiveInteger
readList :: ReadS [PositiveInteger]
$creadList :: ReadS [PositiveInteger]
readsPrec :: Int -> ReadS PositiveInteger
$creadsPrec :: Int -> ReadS PositiveInteger
Read, Int -> PositiveInteger -> String -> String
[PositiveInteger] -> String -> String
PositiveInteger -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [PositiveInteger] -> String -> String
$cshowList :: [PositiveInteger] -> String -> String
show :: PositiveInteger -> String
$cshow :: PositiveInteger -> String
showsPrec :: Int -> PositiveInteger -> String -> String
$cshowsPrec :: Int -> PositiveInteger -> String -> String
Show)

_PositiveInteger :: Name
_PositiveInteger = (String -> Name
Core.Name String
"hydra/ext/xml/schema.PositiveInteger")

newtype QName = 
  QName {
    QName -> String
unQName :: String}
  deriving (QName -> QName -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: QName -> QName -> Bool
$c/= :: QName -> QName -> Bool
== :: QName -> QName -> Bool
$c== :: QName -> QName -> Bool
Eq, Eq QName
QName -> QName -> Bool
QName -> QName -> Ordering
QName -> QName -> QName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: QName -> QName -> QName
$cmin :: QName -> QName -> QName
max :: QName -> QName -> QName
$cmax :: QName -> QName -> QName
>= :: QName -> QName -> Bool
$c>= :: QName -> QName -> Bool
> :: QName -> QName -> Bool
$c> :: QName -> QName -> Bool
<= :: QName -> QName -> Bool
$c<= :: QName -> QName -> Bool
< :: QName -> QName -> Bool
$c< :: QName -> QName -> Bool
compare :: QName -> QName -> Ordering
$ccompare :: QName -> QName -> Ordering
Ord, ReadPrec [QName]
ReadPrec QName
Int -> ReadS QName
ReadS [QName]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [QName]
$creadListPrec :: ReadPrec [QName]
readPrec :: ReadPrec QName
$creadPrec :: ReadPrec QName
readList :: ReadS [QName]
$creadList :: ReadS [QName]
readsPrec :: Int -> ReadS QName
$creadsPrec :: Int -> ReadS QName
Read, Int -> QName -> String -> String
[QName] -> String -> String
QName -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [QName] -> String -> String
$cshowList :: [QName] -> String -> String
show :: QName -> String
$cshow :: QName -> String
showsPrec :: Int -> QName -> String -> String
$cshowsPrec :: Int -> QName -> String -> String
Show)

_QName :: Name
_QName = (String -> Name
Core.Name String
"hydra/ext/xml/schema.QName")

newtype Short = 
  Short {
    Short -> Int
unShort :: Int}
  deriving (Short -> Short -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Short -> Short -> Bool
$c/= :: Short -> Short -> Bool
== :: Short -> Short -> Bool
$c== :: Short -> Short -> Bool
Eq, Eq Short
Short -> Short -> Bool
Short -> Short -> Ordering
Short -> Short -> Short
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Short -> Short -> Short
$cmin :: Short -> Short -> Short
max :: Short -> Short -> Short
$cmax :: Short -> Short -> Short
>= :: Short -> Short -> Bool
$c>= :: Short -> Short -> Bool
> :: Short -> Short -> Bool
$c> :: Short -> Short -> Bool
<= :: Short -> Short -> Bool
$c<= :: Short -> Short -> Bool
< :: Short -> Short -> Bool
$c< :: Short -> Short -> Bool
compare :: Short -> Short -> Ordering
$ccompare :: Short -> Short -> Ordering
Ord, ReadPrec [Short]
ReadPrec Short
Int -> ReadS Short
ReadS [Short]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Short]
$creadListPrec :: ReadPrec [Short]
readPrec :: ReadPrec Short
$creadPrec :: ReadPrec Short
readList :: ReadS [Short]
$creadList :: ReadS [Short]
readsPrec :: Int -> ReadS Short
$creadsPrec :: Int -> ReadS Short
Read, Int -> Short -> String -> String
[Short] -> String -> String
Short -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Short] -> String -> String
$cshowList :: [Short] -> String -> String
show :: Short -> String
$cshow :: Short -> String
showsPrec :: Int -> Short -> String -> String
$cshowsPrec :: Int -> Short -> String -> String
Show)

_Short :: Name
_Short = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Short")

newtype String_ = 
  String_ {
    String_ -> String
unString :: String}
  deriving (String_ -> String_ -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: String_ -> String_ -> Bool
$c/= :: String_ -> String_ -> Bool
== :: String_ -> String_ -> Bool
$c== :: String_ -> String_ -> Bool
Eq, Eq String_
String_ -> String_ -> Bool
String_ -> String_ -> Ordering
String_ -> String_ -> String_
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: String_ -> String_ -> String_
$cmin :: String_ -> String_ -> String_
max :: String_ -> String_ -> String_
$cmax :: String_ -> String_ -> String_
>= :: String_ -> String_ -> Bool
$c>= :: String_ -> String_ -> Bool
> :: String_ -> String_ -> Bool
$c> :: String_ -> String_ -> Bool
<= :: String_ -> String_ -> Bool
$c<= :: String_ -> String_ -> Bool
< :: String_ -> String_ -> Bool
$c< :: String_ -> String_ -> Bool
compare :: String_ -> String_ -> Ordering
$ccompare :: String_ -> String_ -> Ordering
Ord, ReadPrec [String_]
ReadPrec String_
Int -> ReadS String_
ReadS [String_]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [String_]
$creadListPrec :: ReadPrec [String_]
readPrec :: ReadPrec String_
$creadPrec :: ReadPrec String_
readList :: ReadS [String_]
$creadList :: ReadS [String_]
readsPrec :: Int -> ReadS String_
$creadsPrec :: Int -> ReadS String_
Read, Int -> String_ -> String -> String
[String_] -> String -> String
String_ -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [String_] -> String -> String
$cshowList :: [String_] -> String -> String
show :: String_ -> String
$cshow :: String_ -> String
showsPrec :: Int -> String_ -> String -> String
$cshowsPrec :: Int -> String_ -> String -> String
Show)

_String :: Name
_String = (String -> Name
Core.Name String
"hydra/ext/xml/schema.String")

newtype Time = 
  Time {
    Time -> String
unTime :: String}
  deriving (Time -> Time -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Time -> Time -> Bool
$c/= :: Time -> Time -> Bool
== :: Time -> Time -> Bool
$c== :: Time -> Time -> Bool
Eq, Eq Time
Time -> Time -> Bool
Time -> Time -> Ordering
Time -> Time -> Time
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Time -> Time -> Time
$cmin :: Time -> Time -> Time
max :: Time -> Time -> Time
$cmax :: Time -> Time -> Time
>= :: Time -> Time -> Bool
$c>= :: Time -> Time -> Bool
> :: Time -> Time -> Bool
$c> :: Time -> Time -> Bool
<= :: Time -> Time -> Bool
$c<= :: Time -> Time -> Bool
< :: Time -> Time -> Bool
$c< :: Time -> Time -> Bool
compare :: Time -> Time -> Ordering
$ccompare :: Time -> Time -> Ordering
Ord, ReadPrec [Time]
ReadPrec Time
Int -> ReadS Time
ReadS [Time]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Time]
$creadListPrec :: ReadPrec [Time]
readPrec :: ReadPrec Time
$creadPrec :: ReadPrec Time
readList :: ReadS [Time]
$creadList :: ReadS [Time]
readsPrec :: Int -> ReadS Time
$creadsPrec :: Int -> ReadS Time
Read, Int -> Time -> String -> String
[Time] -> String -> String
Time -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Time] -> String -> String
$cshowList :: [Time] -> String -> String
show :: Time -> String
$cshow :: Time -> String
showsPrec :: Int -> Time -> String -> String
$cshowsPrec :: Int -> Time -> String -> String
Show)

_Time :: Name
_Time = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Time")

newtype Token = 
  Token {
    Token -> String
unToken :: String}
  deriving (Token -> Token -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Token -> Token -> Bool
$c/= :: Token -> Token -> Bool
== :: Token -> Token -> Bool
$c== :: Token -> Token -> Bool
Eq, Eq Token
Token -> Token -> Bool
Token -> Token -> Ordering
Token -> Token -> Token
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Token -> Token -> Token
$cmin :: Token -> Token -> Token
max :: Token -> Token -> Token
$cmax :: Token -> Token -> Token
>= :: Token -> Token -> Bool
$c>= :: Token -> Token -> Bool
> :: Token -> Token -> Bool
$c> :: Token -> Token -> Bool
<= :: Token -> Token -> Bool
$c<= :: Token -> Token -> Bool
< :: Token -> Token -> Bool
$c< :: Token -> Token -> Bool
compare :: Token -> Token -> Ordering
$ccompare :: Token -> Token -> Ordering
Ord, ReadPrec [Token]
ReadPrec Token
Int -> ReadS Token
ReadS [Token]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Token]
$creadListPrec :: ReadPrec [Token]
readPrec :: ReadPrec Token
$creadPrec :: ReadPrec Token
readList :: ReadS [Token]
$creadList :: ReadS [Token]
readsPrec :: Int -> ReadS Token
$creadsPrec :: Int -> ReadS Token
Read, Int -> Token -> String -> String
[Token] -> String -> String
Token -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Token] -> String -> String
$cshowList :: [Token] -> String -> String
show :: Token -> String
$cshow :: Token -> String
showsPrec :: Int -> Token -> String -> String
$cshowsPrec :: Int -> Token -> String -> String
Show)

_Token :: Name
_Token = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Token")

newtype UnsignedByte = 
  UnsignedByte {
    UnsignedByte -> Int
unUnsignedByte :: Int}
  deriving (UnsignedByte -> UnsignedByte -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnsignedByte -> UnsignedByte -> Bool
$c/= :: UnsignedByte -> UnsignedByte -> Bool
== :: UnsignedByte -> UnsignedByte -> Bool
$c== :: UnsignedByte -> UnsignedByte -> Bool
Eq, Eq UnsignedByte
UnsignedByte -> UnsignedByte -> Bool
UnsignedByte -> UnsignedByte -> Ordering
UnsignedByte -> UnsignedByte -> UnsignedByte
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: UnsignedByte -> UnsignedByte -> UnsignedByte
$cmin :: UnsignedByte -> UnsignedByte -> UnsignedByte
max :: UnsignedByte -> UnsignedByte -> UnsignedByte
$cmax :: UnsignedByte -> UnsignedByte -> UnsignedByte
>= :: UnsignedByte -> UnsignedByte -> Bool
$c>= :: UnsignedByte -> UnsignedByte -> Bool
> :: UnsignedByte -> UnsignedByte -> Bool
$c> :: UnsignedByte -> UnsignedByte -> Bool
<= :: UnsignedByte -> UnsignedByte -> Bool
$c<= :: UnsignedByte -> UnsignedByte -> Bool
< :: UnsignedByte -> UnsignedByte -> Bool
$c< :: UnsignedByte -> UnsignedByte -> Bool
compare :: UnsignedByte -> UnsignedByte -> Ordering
$ccompare :: UnsignedByte -> UnsignedByte -> Ordering
Ord, ReadPrec [UnsignedByte]
ReadPrec UnsignedByte
Int -> ReadS UnsignedByte
ReadS [UnsignedByte]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UnsignedByte]
$creadListPrec :: ReadPrec [UnsignedByte]
readPrec :: ReadPrec UnsignedByte
$creadPrec :: ReadPrec UnsignedByte
readList :: ReadS [UnsignedByte]
$creadList :: ReadS [UnsignedByte]
readsPrec :: Int -> ReadS UnsignedByte
$creadsPrec :: Int -> ReadS UnsignedByte
Read, Int -> UnsignedByte -> String -> String
[UnsignedByte] -> String -> String
UnsignedByte -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [UnsignedByte] -> String -> String
$cshowList :: [UnsignedByte] -> String -> String
show :: UnsignedByte -> String
$cshow :: UnsignedByte -> String
showsPrec :: Int -> UnsignedByte -> String -> String
$cshowsPrec :: Int -> UnsignedByte -> String -> String
Show)

_UnsignedByte :: Name
_UnsignedByte = (String -> Name
Core.Name String
"hydra/ext/xml/schema.UnsignedByte")

newtype UnsignedInt = 
  UnsignedInt {
    UnsignedInt -> Integer
unUnsignedInt :: Integer}
  deriving (UnsignedInt -> UnsignedInt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnsignedInt -> UnsignedInt -> Bool
$c/= :: UnsignedInt -> UnsignedInt -> Bool
== :: UnsignedInt -> UnsignedInt -> Bool
$c== :: UnsignedInt -> UnsignedInt -> Bool
Eq, Eq UnsignedInt
UnsignedInt -> UnsignedInt -> Bool
UnsignedInt -> UnsignedInt -> Ordering
UnsignedInt -> UnsignedInt -> UnsignedInt
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: UnsignedInt -> UnsignedInt -> UnsignedInt
$cmin :: UnsignedInt -> UnsignedInt -> UnsignedInt
max :: UnsignedInt -> UnsignedInt -> UnsignedInt
$cmax :: UnsignedInt -> UnsignedInt -> UnsignedInt
>= :: UnsignedInt -> UnsignedInt -> Bool
$c>= :: UnsignedInt -> UnsignedInt -> Bool
> :: UnsignedInt -> UnsignedInt -> Bool
$c> :: UnsignedInt -> UnsignedInt -> Bool
<= :: UnsignedInt -> UnsignedInt -> Bool
$c<= :: UnsignedInt -> UnsignedInt -> Bool
< :: UnsignedInt -> UnsignedInt -> Bool
$c< :: UnsignedInt -> UnsignedInt -> Bool
compare :: UnsignedInt -> UnsignedInt -> Ordering
$ccompare :: UnsignedInt -> UnsignedInt -> Ordering
Ord, ReadPrec [UnsignedInt]
ReadPrec UnsignedInt
Int -> ReadS UnsignedInt
ReadS [UnsignedInt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UnsignedInt]
$creadListPrec :: ReadPrec [UnsignedInt]
readPrec :: ReadPrec UnsignedInt
$creadPrec :: ReadPrec UnsignedInt
readList :: ReadS [UnsignedInt]
$creadList :: ReadS [UnsignedInt]
readsPrec :: Int -> ReadS UnsignedInt
$creadsPrec :: Int -> ReadS UnsignedInt
Read, Int -> UnsignedInt -> String -> String
[UnsignedInt] -> String -> String
UnsignedInt -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [UnsignedInt] -> String -> String
$cshowList :: [UnsignedInt] -> String -> String
show :: UnsignedInt -> String
$cshow :: UnsignedInt -> String
showsPrec :: Int -> UnsignedInt -> String -> String
$cshowsPrec :: Int -> UnsignedInt -> String -> String
Show)

_UnsignedInt :: Name
_UnsignedInt = (String -> Name
Core.Name String
"hydra/ext/xml/schema.UnsignedInt")

newtype UnsignedLong = 
  UnsignedLong {
    UnsignedLong -> Integer
unUnsignedLong :: Integer}
  deriving (UnsignedLong -> UnsignedLong -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnsignedLong -> UnsignedLong -> Bool
$c/= :: UnsignedLong -> UnsignedLong -> Bool
== :: UnsignedLong -> UnsignedLong -> Bool
$c== :: UnsignedLong -> UnsignedLong -> Bool
Eq, Eq UnsignedLong
UnsignedLong -> UnsignedLong -> Bool
UnsignedLong -> UnsignedLong -> Ordering
UnsignedLong -> UnsignedLong -> UnsignedLong
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: UnsignedLong -> UnsignedLong -> UnsignedLong
$cmin :: UnsignedLong -> UnsignedLong -> UnsignedLong
max :: UnsignedLong -> UnsignedLong -> UnsignedLong
$cmax :: UnsignedLong -> UnsignedLong -> UnsignedLong
>= :: UnsignedLong -> UnsignedLong -> Bool
$c>= :: UnsignedLong -> UnsignedLong -> Bool
> :: UnsignedLong -> UnsignedLong -> Bool
$c> :: UnsignedLong -> UnsignedLong -> Bool
<= :: UnsignedLong -> UnsignedLong -> Bool
$c<= :: UnsignedLong -> UnsignedLong -> Bool
< :: UnsignedLong -> UnsignedLong -> Bool
$c< :: UnsignedLong -> UnsignedLong -> Bool
compare :: UnsignedLong -> UnsignedLong -> Ordering
$ccompare :: UnsignedLong -> UnsignedLong -> Ordering
Ord, ReadPrec [UnsignedLong]
ReadPrec UnsignedLong
Int -> ReadS UnsignedLong
ReadS [UnsignedLong]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UnsignedLong]
$creadListPrec :: ReadPrec [UnsignedLong]
readPrec :: ReadPrec UnsignedLong
$creadPrec :: ReadPrec UnsignedLong
readList :: ReadS [UnsignedLong]
$creadList :: ReadS [UnsignedLong]
readsPrec :: Int -> ReadS UnsignedLong
$creadsPrec :: Int -> ReadS UnsignedLong
Read, Int -> UnsignedLong -> String -> String
[UnsignedLong] -> String -> String
UnsignedLong -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [UnsignedLong] -> String -> String
$cshowList :: [UnsignedLong] -> String -> String
show :: UnsignedLong -> String
$cshow :: UnsignedLong -> String
showsPrec :: Int -> UnsignedLong -> String -> String
$cshowsPrec :: Int -> UnsignedLong -> String -> String
Show)

_UnsignedLong :: Name
_UnsignedLong = (String -> Name
Core.Name String
"hydra/ext/xml/schema.UnsignedLong")

newtype UnsignedShort = 
  UnsignedShort {
    UnsignedShort -> Int
unUnsignedShort :: Int}
  deriving (UnsignedShort -> UnsignedShort -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnsignedShort -> UnsignedShort -> Bool
$c/= :: UnsignedShort -> UnsignedShort -> Bool
== :: UnsignedShort -> UnsignedShort -> Bool
$c== :: UnsignedShort -> UnsignedShort -> Bool
Eq, Eq UnsignedShort
UnsignedShort -> UnsignedShort -> Bool
UnsignedShort -> UnsignedShort -> Ordering
UnsignedShort -> UnsignedShort -> UnsignedShort
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: UnsignedShort -> UnsignedShort -> UnsignedShort
$cmin :: UnsignedShort -> UnsignedShort -> UnsignedShort
max :: UnsignedShort -> UnsignedShort -> UnsignedShort
$cmax :: UnsignedShort -> UnsignedShort -> UnsignedShort
>= :: UnsignedShort -> UnsignedShort -> Bool
$c>= :: UnsignedShort -> UnsignedShort -> Bool
> :: UnsignedShort -> UnsignedShort -> Bool
$c> :: UnsignedShort -> UnsignedShort -> Bool
<= :: UnsignedShort -> UnsignedShort -> Bool
$c<= :: UnsignedShort -> UnsignedShort -> Bool
< :: UnsignedShort -> UnsignedShort -> Bool
$c< :: UnsignedShort -> UnsignedShort -> Bool
compare :: UnsignedShort -> UnsignedShort -> Ordering
$ccompare :: UnsignedShort -> UnsignedShort -> Ordering
Ord, ReadPrec [UnsignedShort]
ReadPrec UnsignedShort
Int -> ReadS UnsignedShort
ReadS [UnsignedShort]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UnsignedShort]
$creadListPrec :: ReadPrec [UnsignedShort]
readPrec :: ReadPrec UnsignedShort
$creadPrec :: ReadPrec UnsignedShort
readList :: ReadS [UnsignedShort]
$creadList :: ReadS [UnsignedShort]
readsPrec :: Int -> ReadS UnsignedShort
$creadsPrec :: Int -> ReadS UnsignedShort
Read, Int -> UnsignedShort -> String -> String
[UnsignedShort] -> String -> String
UnsignedShort -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [UnsignedShort] -> String -> String
$cshowList :: [UnsignedShort] -> String -> String
show :: UnsignedShort -> String
$cshow :: UnsignedShort -> String
showsPrec :: Int -> UnsignedShort -> String -> String
$cshowsPrec :: Int -> UnsignedShort -> String -> String
Show)

_UnsignedShort :: Name
_UnsignedShort = (String -> Name
Core.Name String
"hydra/ext/xml/schema.UnsignedShort")

-- | See https://www.w3.org/TR/xmlschema-2/#non-fundamental
data ConstrainingFacet = 
  ConstrainingFacet {}
  deriving (ConstrainingFacet -> ConstrainingFacet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConstrainingFacet -> ConstrainingFacet -> Bool
$c/= :: ConstrainingFacet -> ConstrainingFacet -> Bool
== :: ConstrainingFacet -> ConstrainingFacet -> Bool
$c== :: ConstrainingFacet -> ConstrainingFacet -> Bool
Eq, Eq ConstrainingFacet
ConstrainingFacet -> ConstrainingFacet -> Bool
ConstrainingFacet -> ConstrainingFacet -> Ordering
ConstrainingFacet -> ConstrainingFacet -> ConstrainingFacet
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ConstrainingFacet -> ConstrainingFacet -> ConstrainingFacet
$cmin :: ConstrainingFacet -> ConstrainingFacet -> ConstrainingFacet
max :: ConstrainingFacet -> ConstrainingFacet -> ConstrainingFacet
$cmax :: ConstrainingFacet -> ConstrainingFacet -> ConstrainingFacet
>= :: ConstrainingFacet -> ConstrainingFacet -> Bool
$c>= :: ConstrainingFacet -> ConstrainingFacet -> Bool
> :: ConstrainingFacet -> ConstrainingFacet -> Bool
$c> :: ConstrainingFacet -> ConstrainingFacet -> Bool
<= :: ConstrainingFacet -> ConstrainingFacet -> Bool
$c<= :: ConstrainingFacet -> ConstrainingFacet -> Bool
< :: ConstrainingFacet -> ConstrainingFacet -> Bool
$c< :: ConstrainingFacet -> ConstrainingFacet -> Bool
compare :: ConstrainingFacet -> ConstrainingFacet -> Ordering
$ccompare :: ConstrainingFacet -> ConstrainingFacet -> Ordering
Ord, ReadPrec [ConstrainingFacet]
ReadPrec ConstrainingFacet
Int -> ReadS ConstrainingFacet
ReadS [ConstrainingFacet]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ConstrainingFacet]
$creadListPrec :: ReadPrec [ConstrainingFacet]
readPrec :: ReadPrec ConstrainingFacet
$creadPrec :: ReadPrec ConstrainingFacet
readList :: ReadS [ConstrainingFacet]
$creadList :: ReadS [ConstrainingFacet]
readsPrec :: Int -> ReadS ConstrainingFacet
$creadsPrec :: Int -> ReadS ConstrainingFacet
Read, Int -> ConstrainingFacet -> String -> String
[ConstrainingFacet] -> String -> String
ConstrainingFacet -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [ConstrainingFacet] -> String -> String
$cshowList :: [ConstrainingFacet] -> String -> String
show :: ConstrainingFacet -> String
$cshow :: ConstrainingFacet -> String
showsPrec :: Int -> ConstrainingFacet -> String -> String
$cshowsPrec :: Int -> ConstrainingFacet -> String -> String
Show)

_ConstrainingFacet :: Name
_ConstrainingFacet = (String -> Name
Core.Name String
"hydra/ext/xml/schema.ConstrainingFacet")

data Datatype = 
  DatatypeAnySimpleType  |
  DatatypeAnyType  |
  DatatypeAnyURI  |
  DatatypeBase64Binary  |
  DatatypeBoolean  |
  DatatypeByte  |
  DatatypeDate  |
  DatatypeDateTime  |
  DatatypeDecimal  |
  DatatypeDouble  |
  DatatypeDuration  |
  DatatypeENTITIES  |
  DatatypeENTITY  |
  DatatypeFloat  |
  DatatypeGDay  |
  DatatypeGMonth  |
  DatatypeGMonthDay  |
  DatatypeGYear  |
  DatatypeGYearMonth  |
  DatatypeHexBinary  |
  DatatypeID  |
  DatatypeIDREF  |
  DatatypeIDREFS  |
  DatatypeInt  |
  DatatypeInteger  |
  DatatypeLanguage  |
  DatatypeLong  |
  DatatypeNMTOKEN  |
  DatatypeNOTATION  |
  DatatypeName  |
  DatatypeNegativeInteger  |
  DatatypeNonNegativeInteger  |
  DatatypeNonPositiveInteger  |
  DatatypeNormalizedString  |
  DatatypePositiveInteger  |
  DatatypeQName  |
  DatatypeShort  |
  DatatypeString  |
  DatatypeTime  |
  DatatypeToken  |
  DatatypeUnsignedByte  |
  DatatypeUnsignedInt  |
  DatatypeUnsignedLong  |
  DatatypeUnsignedShort 
  deriving (Datatype -> Datatype -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Datatype -> Datatype -> Bool
$c/= :: Datatype -> Datatype -> Bool
== :: Datatype -> Datatype -> Bool
$c== :: Datatype -> Datatype -> Bool
Eq, Eq Datatype
Datatype -> Datatype -> Bool
Datatype -> Datatype -> Ordering
Datatype -> Datatype -> Datatype
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Datatype -> Datatype -> Datatype
$cmin :: Datatype -> Datatype -> Datatype
max :: Datatype -> Datatype -> Datatype
$cmax :: Datatype -> Datatype -> Datatype
>= :: Datatype -> Datatype -> Bool
$c>= :: Datatype -> Datatype -> Bool
> :: Datatype -> Datatype -> Bool
$c> :: Datatype -> Datatype -> Bool
<= :: Datatype -> Datatype -> Bool
$c<= :: Datatype -> Datatype -> Bool
< :: Datatype -> Datatype -> Bool
$c< :: Datatype -> Datatype -> Bool
compare :: Datatype -> Datatype -> Ordering
$ccompare :: Datatype -> Datatype -> Ordering
Ord, ReadPrec [Datatype]
ReadPrec Datatype
Int -> ReadS Datatype
ReadS [Datatype]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Datatype]
$creadListPrec :: ReadPrec [Datatype]
readPrec :: ReadPrec Datatype
$creadPrec :: ReadPrec Datatype
readList :: ReadS [Datatype]
$creadList :: ReadS [Datatype]
readsPrec :: Int -> ReadS Datatype
$creadsPrec :: Int -> ReadS Datatype
Read, Int -> Datatype -> String -> String
[Datatype] -> String -> String
Datatype -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Datatype] -> String -> String
$cshowList :: [Datatype] -> String -> String
show :: Datatype -> String
$cshow :: Datatype -> String
showsPrec :: Int -> Datatype -> String -> String
$cshowsPrec :: Int -> Datatype -> String -> String
Show)

_Datatype :: Name
_Datatype = (String -> Name
Core.Name String
"hydra/ext/xml/schema.Datatype")

_Datatype_anySimpleType :: FieldName
_Datatype_anySimpleType = (String -> FieldName
Core.FieldName String
"anySimpleType")

_Datatype_anyType :: FieldName
_Datatype_anyType = (String -> FieldName
Core.FieldName String
"anyType")

_Datatype_anyURI :: FieldName
_Datatype_anyURI = (String -> FieldName
Core.FieldName String
"anyURI")

_Datatype_base64Binary :: FieldName
_Datatype_base64Binary = (String -> FieldName
Core.FieldName String
"base64Binary")

_Datatype_boolean :: FieldName
_Datatype_boolean = (String -> FieldName
Core.FieldName String
"boolean")

_Datatype_byte :: FieldName
_Datatype_byte = (String -> FieldName
Core.FieldName String
"byte")

_Datatype_date :: FieldName
_Datatype_date = (String -> FieldName
Core.FieldName String
"date")

_Datatype_dateTime :: FieldName
_Datatype_dateTime = (String -> FieldName
Core.FieldName String
"dateTime")

_Datatype_decimal :: FieldName
_Datatype_decimal = (String -> FieldName
Core.FieldName String
"decimal")

_Datatype_double :: FieldName
_Datatype_double = (String -> FieldName
Core.FieldName String
"double")

_Datatype_duration :: FieldName
_Datatype_duration = (String -> FieldName
Core.FieldName String
"duration")

_Datatype_ENTITIES :: FieldName
_Datatype_ENTITIES = (String -> FieldName
Core.FieldName String
"ENTITIES")

_Datatype_ENTITY :: FieldName
_Datatype_ENTITY = (String -> FieldName
Core.FieldName String
"ENTITY")

_Datatype_float :: FieldName
_Datatype_float = (String -> FieldName
Core.FieldName String
"float")

_Datatype_gDay :: FieldName
_Datatype_gDay = (String -> FieldName
Core.FieldName String
"gDay")

_Datatype_gMonth :: FieldName
_Datatype_gMonth = (String -> FieldName
Core.FieldName String
"gMonth")

_Datatype_gMonthDay :: FieldName
_Datatype_gMonthDay = (String -> FieldName
Core.FieldName String
"gMonthDay")

_Datatype_gYear :: FieldName
_Datatype_gYear = (String -> FieldName
Core.FieldName String
"gYear")

_Datatype_gYearMonth :: FieldName
_Datatype_gYearMonth = (String -> FieldName
Core.FieldName String
"gYearMonth")

_Datatype_hexBinary :: FieldName
_Datatype_hexBinary = (String -> FieldName
Core.FieldName String
"hexBinary")

_Datatype_ID :: FieldName
_Datatype_ID = (String -> FieldName
Core.FieldName String
"ID")

_Datatype_IDREF :: FieldName
_Datatype_IDREF = (String -> FieldName
Core.FieldName String
"IDREF")

_Datatype_IDREFS :: FieldName
_Datatype_IDREFS = (String -> FieldName
Core.FieldName String
"IDREFS")

_Datatype_int :: FieldName
_Datatype_int = (String -> FieldName
Core.FieldName String
"int")

_Datatype_integer :: FieldName
_Datatype_integer = (String -> FieldName
Core.FieldName String
"integer")

_Datatype_language :: FieldName
_Datatype_language = (String -> FieldName
Core.FieldName String
"language")

_Datatype_long :: FieldName
_Datatype_long = (String -> FieldName
Core.FieldName String
"long")

_Datatype_NMTOKEN :: FieldName
_Datatype_NMTOKEN = (String -> FieldName
Core.FieldName String
"NMTOKEN")

_Datatype_NOTATION :: FieldName
_Datatype_NOTATION = (String -> FieldName
Core.FieldName String
"NOTATION")

_Datatype_name :: FieldName
_Datatype_name = (String -> FieldName
Core.FieldName String
"name")

_Datatype_negativeInteger :: FieldName
_Datatype_negativeInteger = (String -> FieldName
Core.FieldName String
"negativeInteger")

_Datatype_nonNegativeInteger :: FieldName
_Datatype_nonNegativeInteger = (String -> FieldName
Core.FieldName String
"nonNegativeInteger")

_Datatype_nonPositiveInteger :: FieldName
_Datatype_nonPositiveInteger = (String -> FieldName
Core.FieldName String
"nonPositiveInteger")

_Datatype_normalizedString :: FieldName
_Datatype_normalizedString = (String -> FieldName
Core.FieldName String
"normalizedString")

_Datatype_positiveInteger :: FieldName
_Datatype_positiveInteger = (String -> FieldName
Core.FieldName String
"positiveInteger")

_Datatype_qName :: FieldName
_Datatype_qName = (String -> FieldName
Core.FieldName String
"qName")

_Datatype_short :: FieldName
_Datatype_short = (String -> FieldName
Core.FieldName String
"short")

_Datatype_string :: FieldName
_Datatype_string = (String -> FieldName
Core.FieldName String
"string")

_Datatype_time :: FieldName
_Datatype_time = (String -> FieldName
Core.FieldName String
"time")

_Datatype_token :: FieldName
_Datatype_token = (String -> FieldName
Core.FieldName String
"token")

_Datatype_unsignedByte :: FieldName
_Datatype_unsignedByte = (String -> FieldName
Core.FieldName String
"unsignedByte")

_Datatype_unsignedInt :: FieldName
_Datatype_unsignedInt = (String -> FieldName
Core.FieldName String
"unsignedInt")

_Datatype_unsignedLong :: FieldName
_Datatype_unsignedLong = (String -> FieldName
Core.FieldName String
"unsignedLong")

_Datatype_unsignedShort :: FieldName
_Datatype_unsignedShort = (String -> FieldName
Core.FieldName String
"unsignedShort")