-- | A model for Avro schemas. Based on the Avro 1.11.1 specification:
-- |   https://avro.apache.org/docs/1.11.1/specification

module Hydra.Langs.Avro.Schema where

import qualified Hydra.Core as Core
import qualified Hydra.Json as Json
import Data.Int
import Data.List as L
import Data.Map as M
import Data.Set as S

data Array = 
  Array {
    Array -> Schema
arrayItems :: Schema}
  deriving (Array -> Array -> Bool
(Array -> Array -> Bool) -> (Array -> Array -> Bool) -> Eq Array
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Array -> Array -> Bool
== :: Array -> Array -> Bool
$c/= :: Array -> Array -> Bool
/= :: Array -> Array -> Bool
Eq, Eq Array
Eq Array =>
(Array -> Array -> Ordering)
-> (Array -> Array -> Bool)
-> (Array -> Array -> Bool)
-> (Array -> Array -> Bool)
-> (Array -> Array -> Bool)
-> (Array -> Array -> Array)
-> (Array -> Array -> Array)
-> Ord Array
Array -> Array -> Bool
Array -> Array -> Ordering
Array -> Array -> Array
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
$ccompare :: Array -> Array -> Ordering
compare :: Array -> Array -> Ordering
$c< :: Array -> Array -> Bool
< :: Array -> Array -> Bool
$c<= :: Array -> Array -> Bool
<= :: Array -> Array -> Bool
$c> :: Array -> Array -> Bool
> :: Array -> Array -> Bool
$c>= :: Array -> Array -> Bool
>= :: Array -> Array -> Bool
$cmax :: Array -> Array -> Array
max :: Array -> Array -> Array
$cmin :: Array -> Array -> Array
min :: Array -> Array -> Array
Ord, ReadPrec [Array]
ReadPrec Array
Int -> ReadS Array
ReadS [Array]
(Int -> ReadS Array)
-> ReadS [Array]
-> ReadPrec Array
-> ReadPrec [Array]
-> Read Array
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Array
readsPrec :: Int -> ReadS Array
$creadList :: ReadS [Array]
readList :: ReadS [Array]
$creadPrec :: ReadPrec Array
readPrec :: ReadPrec Array
$creadListPrec :: ReadPrec [Array]
readListPrec :: ReadPrec [Array]
Read, Int -> Array -> ShowS
[Array] -> ShowS
Array -> String
(Int -> Array -> ShowS)
-> (Array -> String) -> ([Array] -> ShowS) -> Show Array
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Array -> ShowS
showsPrec :: Int -> Array -> ShowS
$cshow :: Array -> String
show :: Array -> String
$cshowList :: [Array] -> ShowS
showList :: [Array] -> ShowS
Show)

_Array :: Name
_Array = (String -> Name
Core.Name String
"hydra/langs/avro/schema.Array")

_Array_items :: Name
_Array_items = (String -> Name
Core.Name String
"items")

data Enum_ = 
  Enum_ {
    -- | a JSON array, listing symbols, as JSON strings. All symbols in an enum must be unique; duplicates are prohibited. Every symbol must match the regular expression [A-Za-z_][A-Za-z0-9_]* (the same requirement as for names)
    Enum_ -> [String]
enumSymbols :: [String],
    -- | A default value for this enumeration, used during resolution when the reader encounters a symbol from the writer that isn’t defined in the reader’s schema. The value provided here must be a JSON string that’s a member of the symbols array
    Enum_ -> Maybe String
enumDefault :: (Maybe String)}
  deriving (Enum_ -> Enum_ -> Bool
(Enum_ -> Enum_ -> Bool) -> (Enum_ -> Enum_ -> Bool) -> Eq Enum_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Enum_ -> Enum_ -> Bool
== :: Enum_ -> Enum_ -> Bool
$c/= :: Enum_ -> Enum_ -> Bool
/= :: Enum_ -> Enum_ -> Bool
Eq, Eq Enum_
Eq Enum_ =>
(Enum_ -> Enum_ -> Ordering)
-> (Enum_ -> Enum_ -> Bool)
-> (Enum_ -> Enum_ -> Bool)
-> (Enum_ -> Enum_ -> Bool)
-> (Enum_ -> Enum_ -> Bool)
-> (Enum_ -> Enum_ -> Enum_)
-> (Enum_ -> Enum_ -> Enum_)
-> Ord Enum_
Enum_ -> Enum_ -> Bool
Enum_ -> Enum_ -> Ordering
Enum_ -> Enum_ -> Enum_
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
$ccompare :: Enum_ -> Enum_ -> Ordering
compare :: Enum_ -> Enum_ -> Ordering
$c< :: Enum_ -> Enum_ -> Bool
< :: Enum_ -> Enum_ -> Bool
$c<= :: Enum_ -> Enum_ -> Bool
<= :: Enum_ -> Enum_ -> Bool
$c> :: Enum_ -> Enum_ -> Bool
> :: Enum_ -> Enum_ -> Bool
$c>= :: Enum_ -> Enum_ -> Bool
>= :: Enum_ -> Enum_ -> Bool
$cmax :: Enum_ -> Enum_ -> Enum_
max :: Enum_ -> Enum_ -> Enum_
$cmin :: Enum_ -> Enum_ -> Enum_
min :: Enum_ -> Enum_ -> Enum_
Ord, ReadPrec [Enum_]
ReadPrec Enum_
Int -> ReadS Enum_
ReadS [Enum_]
(Int -> ReadS Enum_)
-> ReadS [Enum_]
-> ReadPrec Enum_
-> ReadPrec [Enum_]
-> Read Enum_
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Enum_
readsPrec :: Int -> ReadS Enum_
$creadList :: ReadS [Enum_]
readList :: ReadS [Enum_]
$creadPrec :: ReadPrec Enum_
readPrec :: ReadPrec Enum_
$creadListPrec :: ReadPrec [Enum_]
readListPrec :: ReadPrec [Enum_]
Read, Int -> Enum_ -> ShowS
[Enum_] -> ShowS
Enum_ -> String
(Int -> Enum_ -> ShowS)
-> (Enum_ -> String) -> ([Enum_] -> ShowS) -> Show Enum_
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Enum_ -> ShowS
showsPrec :: Int -> Enum_ -> ShowS
$cshow :: Enum_ -> String
show :: Enum_ -> String
$cshowList :: [Enum_] -> ShowS
showList :: [Enum_] -> ShowS
Show)

_Enum :: Name
_Enum = (String -> Name
Core.Name String
"hydra/langs/avro/schema.Enum")

_Enum_symbols :: Name
_Enum_symbols = (String -> Name
Core.Name String
"symbols")

_Enum_default :: Name
_Enum_default = (String -> Name
Core.Name String
"default")

data Field = 
  Field {
    -- | a JSON string providing the name of the field
    Field -> String
fieldName :: String,
    -- | a JSON string describing this field for users
    Field -> Maybe String
fieldDoc :: (Maybe String),
    -- | a schema
    Field -> Schema
fieldType :: Schema,
    -- | default value for this field, only used when reading instances that lack the field for schema evolution purposes
    Field -> Maybe Value
fieldDefault :: (Maybe Json.Value),
    -- | specifies how this field impacts sort ordering of this record
    Field -> Maybe Order
fieldOrder :: (Maybe Order),
    -- | a JSON array of strings, providing alternate names for this field
    Field -> Maybe [String]
fieldAliases :: (Maybe [String]),
    -- | Any additional key/value pairs attached to the field
    Field -> Map String Value
fieldAnnotations :: (Map String Json.Value)}
  deriving (Field -> Field -> Bool
(Field -> Field -> Bool) -> (Field -> Field -> Bool) -> Eq Field
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Field -> Field -> Bool
== :: Field -> Field -> Bool
$c/= :: Field -> Field -> Bool
/= :: Field -> Field -> Bool
Eq, Eq Field
Eq Field =>
(Field -> Field -> Ordering)
-> (Field -> Field -> Bool)
-> (Field -> Field -> Bool)
-> (Field -> Field -> Bool)
-> (Field -> Field -> Bool)
-> (Field -> Field -> Field)
-> (Field -> Field -> Field)
-> Ord Field
Field -> Field -> Bool
Field -> Field -> Ordering
Field -> Field -> Field
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
$ccompare :: Field -> Field -> Ordering
compare :: Field -> Field -> Ordering
$c< :: Field -> Field -> Bool
< :: Field -> Field -> Bool
$c<= :: Field -> Field -> Bool
<= :: Field -> Field -> Bool
$c> :: Field -> Field -> Bool
> :: Field -> Field -> Bool
$c>= :: Field -> Field -> Bool
>= :: Field -> Field -> Bool
$cmax :: Field -> Field -> Field
max :: Field -> Field -> Field
$cmin :: Field -> Field -> Field
min :: Field -> Field -> Field
Ord, ReadPrec [Field]
ReadPrec Field
Int -> ReadS Field
ReadS [Field]
(Int -> ReadS Field)
-> ReadS [Field]
-> ReadPrec Field
-> ReadPrec [Field]
-> Read Field
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Field
readsPrec :: Int -> ReadS Field
$creadList :: ReadS [Field]
readList :: ReadS [Field]
$creadPrec :: ReadPrec Field
readPrec :: ReadPrec Field
$creadListPrec :: ReadPrec [Field]
readListPrec :: ReadPrec [Field]
Read, Int -> Field -> ShowS
[Field] -> ShowS
Field -> String
(Int -> Field -> ShowS)
-> (Field -> String) -> ([Field] -> ShowS) -> Show Field
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Field -> ShowS
showsPrec :: Int -> Field -> ShowS
$cshow :: Field -> String
show :: Field -> String
$cshowList :: [Field] -> ShowS
showList :: [Field] -> ShowS
Show)

_Field :: Name
_Field = (String -> Name
Core.Name String
"hydra/langs/avro/schema.Field")

_Field_name :: Name
_Field_name = (String -> Name
Core.Name String
"name")

_Field_doc :: Name
_Field_doc = (String -> Name
Core.Name String
"doc")

_Field_type :: Name
_Field_type = (String -> Name
Core.Name String
"type")

_Field_default :: Name
_Field_default = (String -> Name
Core.Name String
"default")

_Field_order :: Name
_Field_order = (String -> Name
Core.Name String
"order")

_Field_aliases :: Name
_Field_aliases = (String -> Name
Core.Name String
"aliases")

_Field_annotations :: Name
_Field_annotations = (String -> Name
Core.Name String
"annotations")

data Fixed = 
  Fixed {
    -- | an integer, specifying the number of bytes per value
    Fixed -> Int
fixedSize :: Int}
  deriving (Fixed -> Fixed -> Bool
(Fixed -> Fixed -> Bool) -> (Fixed -> Fixed -> Bool) -> Eq Fixed
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Fixed -> Fixed -> Bool
== :: Fixed -> Fixed -> Bool
$c/= :: Fixed -> Fixed -> Bool
/= :: Fixed -> Fixed -> Bool
Eq, Eq Fixed
Eq Fixed =>
(Fixed -> Fixed -> Ordering)
-> (Fixed -> Fixed -> Bool)
-> (Fixed -> Fixed -> Bool)
-> (Fixed -> Fixed -> Bool)
-> (Fixed -> Fixed -> Bool)
-> (Fixed -> Fixed -> Fixed)
-> (Fixed -> Fixed -> Fixed)
-> Ord Fixed
Fixed -> Fixed -> Bool
Fixed -> Fixed -> Ordering
Fixed -> Fixed -> Fixed
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
$ccompare :: Fixed -> Fixed -> Ordering
compare :: Fixed -> Fixed -> Ordering
$c< :: Fixed -> Fixed -> Bool
< :: Fixed -> Fixed -> Bool
$c<= :: Fixed -> Fixed -> Bool
<= :: Fixed -> Fixed -> Bool
$c> :: Fixed -> Fixed -> Bool
> :: Fixed -> Fixed -> Bool
$c>= :: Fixed -> Fixed -> Bool
>= :: Fixed -> Fixed -> Bool
$cmax :: Fixed -> Fixed -> Fixed
max :: Fixed -> Fixed -> Fixed
$cmin :: Fixed -> Fixed -> Fixed
min :: Fixed -> Fixed -> Fixed
Ord, ReadPrec [Fixed]
ReadPrec Fixed
Int -> ReadS Fixed
ReadS [Fixed]
(Int -> ReadS Fixed)
-> ReadS [Fixed]
-> ReadPrec Fixed
-> ReadPrec [Fixed]
-> Read Fixed
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Fixed
readsPrec :: Int -> ReadS Fixed
$creadList :: ReadS [Fixed]
readList :: ReadS [Fixed]
$creadPrec :: ReadPrec Fixed
readPrec :: ReadPrec Fixed
$creadListPrec :: ReadPrec [Fixed]
readListPrec :: ReadPrec [Fixed]
Read, Int -> Fixed -> ShowS
[Fixed] -> ShowS
Fixed -> String
(Int -> Fixed -> ShowS)
-> (Fixed -> String) -> ([Fixed] -> ShowS) -> Show Fixed
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Fixed -> ShowS
showsPrec :: Int -> Fixed -> ShowS
$cshow :: Fixed -> String
show :: Fixed -> String
$cshowList :: [Fixed] -> ShowS
showList :: [Fixed] -> ShowS
Show)

_Fixed :: Name
_Fixed = (String -> Name
Core.Name String
"hydra/langs/avro/schema.Fixed")

_Fixed_size :: Name
_Fixed_size = (String -> Name
Core.Name String
"size")

data Map_ = 
  Map_ {
    Map_ -> Schema
mapValues :: Schema}
  deriving (Map_ -> Map_ -> Bool
(Map_ -> Map_ -> Bool) -> (Map_ -> Map_ -> Bool) -> Eq Map_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Map_ -> Map_ -> Bool
== :: Map_ -> Map_ -> Bool
$c/= :: Map_ -> Map_ -> Bool
/= :: Map_ -> Map_ -> Bool
Eq, Eq Map_
Eq Map_ =>
(Map_ -> Map_ -> Ordering)
-> (Map_ -> Map_ -> Bool)
-> (Map_ -> Map_ -> Bool)
-> (Map_ -> Map_ -> Bool)
-> (Map_ -> Map_ -> Bool)
-> (Map_ -> Map_ -> Map_)
-> (Map_ -> Map_ -> Map_)
-> Ord Map_
Map_ -> Map_ -> Bool
Map_ -> Map_ -> Ordering
Map_ -> Map_ -> Map_
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
$ccompare :: Map_ -> Map_ -> Ordering
compare :: Map_ -> Map_ -> Ordering
$c< :: Map_ -> Map_ -> Bool
< :: Map_ -> Map_ -> Bool
$c<= :: Map_ -> Map_ -> Bool
<= :: Map_ -> Map_ -> Bool
$c> :: Map_ -> Map_ -> Bool
> :: Map_ -> Map_ -> Bool
$c>= :: Map_ -> Map_ -> Bool
>= :: Map_ -> Map_ -> Bool
$cmax :: Map_ -> Map_ -> Map_
max :: Map_ -> Map_ -> Map_
$cmin :: Map_ -> Map_ -> Map_
min :: Map_ -> Map_ -> Map_
Ord, ReadPrec [Map_]
ReadPrec Map_
Int -> ReadS Map_
ReadS [Map_]
(Int -> ReadS Map_)
-> ReadS [Map_] -> ReadPrec Map_ -> ReadPrec [Map_] -> Read Map_
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Map_
readsPrec :: Int -> ReadS Map_
$creadList :: ReadS [Map_]
readList :: ReadS [Map_]
$creadPrec :: ReadPrec Map_
readPrec :: ReadPrec Map_
$creadListPrec :: ReadPrec [Map_]
readListPrec :: ReadPrec [Map_]
Read, Int -> Map_ -> ShowS
[Map_] -> ShowS
Map_ -> String
(Int -> Map_ -> ShowS)
-> (Map_ -> String) -> ([Map_] -> ShowS) -> Show Map_
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Map_ -> ShowS
showsPrec :: Int -> Map_ -> ShowS
$cshow :: Map_ -> String
show :: Map_ -> String
$cshowList :: [Map_] -> ShowS
showList :: [Map_] -> ShowS
Show)

_Map :: Name
_Map = (String -> Name
Core.Name String
"hydra/langs/avro/schema.Map")

_Map_values :: Name
_Map_values = (String -> Name
Core.Name String
"values")

data Named = 
  Named {
    -- | a string naming this schema
    Named -> String
namedName :: String,
    -- | a string that qualifies the name
    Named -> Maybe String
namedNamespace :: (Maybe String),
    -- | a JSON array of strings, providing alternate names for this schema
    Named -> Maybe [String]
namedAliases :: (Maybe [String]),
    -- | a JSON string providing documentation to the user of this schema
    Named -> Maybe String
namedDoc :: (Maybe String),
    Named -> NamedType
namedType :: NamedType,
    -- | Any additional key/value pairs attached to the type
    Named -> Map String Value
namedAnnotations :: (Map String Json.Value)}
  deriving (Named -> Named -> Bool
(Named -> Named -> Bool) -> (Named -> Named -> Bool) -> Eq Named
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Named -> Named -> Bool
== :: Named -> Named -> Bool
$c/= :: Named -> Named -> Bool
/= :: Named -> Named -> Bool
Eq, Eq Named
Eq Named =>
(Named -> Named -> Ordering)
-> (Named -> Named -> Bool)
-> (Named -> Named -> Bool)
-> (Named -> Named -> Bool)
-> (Named -> Named -> Bool)
-> (Named -> Named -> Named)
-> (Named -> Named -> Named)
-> Ord Named
Named -> Named -> Bool
Named -> Named -> Ordering
Named -> Named -> Named
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
$ccompare :: Named -> Named -> Ordering
compare :: Named -> Named -> Ordering
$c< :: Named -> Named -> Bool
< :: Named -> Named -> Bool
$c<= :: Named -> Named -> Bool
<= :: Named -> Named -> Bool
$c> :: Named -> Named -> Bool
> :: Named -> Named -> Bool
$c>= :: Named -> Named -> Bool
>= :: Named -> Named -> Bool
$cmax :: Named -> Named -> Named
max :: Named -> Named -> Named
$cmin :: Named -> Named -> Named
min :: Named -> Named -> Named
Ord, ReadPrec [Named]
ReadPrec Named
Int -> ReadS Named
ReadS [Named]
(Int -> ReadS Named)
-> ReadS [Named]
-> ReadPrec Named
-> ReadPrec [Named]
-> Read Named
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Named
readsPrec :: Int -> ReadS Named
$creadList :: ReadS [Named]
readList :: ReadS [Named]
$creadPrec :: ReadPrec Named
readPrec :: ReadPrec Named
$creadListPrec :: ReadPrec [Named]
readListPrec :: ReadPrec [Named]
Read, Int -> Named -> ShowS
[Named] -> ShowS
Named -> String
(Int -> Named -> ShowS)
-> (Named -> String) -> ([Named] -> ShowS) -> Show Named
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Named -> ShowS
showsPrec :: Int -> Named -> ShowS
$cshow :: Named -> String
show :: Named -> String
$cshowList :: [Named] -> ShowS
showList :: [Named] -> ShowS
Show)

_Named :: Name
_Named = (String -> Name
Core.Name String
"hydra/langs/avro/schema.Named")

_Named_name :: Name
_Named_name = (String -> Name
Core.Name String
"name")

_Named_namespace :: Name
_Named_namespace = (String -> Name
Core.Name String
"namespace")

_Named_aliases :: Name
_Named_aliases = (String -> Name
Core.Name String
"aliases")

_Named_doc :: Name
_Named_doc = (String -> Name
Core.Name String
"doc")

_Named_type :: Name
_Named_type = (String -> Name
Core.Name String
"type")

_Named_annotations :: Name
_Named_annotations = (String -> Name
Core.Name String
"annotations")

data NamedType = 
  NamedTypeEnum Enum_ |
  NamedTypeFixed Fixed |
  NamedTypeRecord Record
  deriving (NamedType -> NamedType -> Bool
(NamedType -> NamedType -> Bool)
-> (NamedType -> NamedType -> Bool) -> Eq NamedType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamedType -> NamedType -> Bool
== :: NamedType -> NamedType -> Bool
$c/= :: NamedType -> NamedType -> Bool
/= :: NamedType -> NamedType -> Bool
Eq, Eq NamedType
Eq NamedType =>
(NamedType -> NamedType -> Ordering)
-> (NamedType -> NamedType -> Bool)
-> (NamedType -> NamedType -> Bool)
-> (NamedType -> NamedType -> Bool)
-> (NamedType -> NamedType -> Bool)
-> (NamedType -> NamedType -> NamedType)
-> (NamedType -> NamedType -> NamedType)
-> Ord NamedType
NamedType -> NamedType -> Bool
NamedType -> NamedType -> Ordering
NamedType -> NamedType -> NamedType
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
$ccompare :: NamedType -> NamedType -> Ordering
compare :: NamedType -> NamedType -> Ordering
$c< :: NamedType -> NamedType -> Bool
< :: NamedType -> NamedType -> Bool
$c<= :: NamedType -> NamedType -> Bool
<= :: NamedType -> NamedType -> Bool
$c> :: NamedType -> NamedType -> Bool
> :: NamedType -> NamedType -> Bool
$c>= :: NamedType -> NamedType -> Bool
>= :: NamedType -> NamedType -> Bool
$cmax :: NamedType -> NamedType -> NamedType
max :: NamedType -> NamedType -> NamedType
$cmin :: NamedType -> NamedType -> NamedType
min :: NamedType -> NamedType -> NamedType
Ord, ReadPrec [NamedType]
ReadPrec NamedType
Int -> ReadS NamedType
ReadS [NamedType]
(Int -> ReadS NamedType)
-> ReadS [NamedType]
-> ReadPrec NamedType
-> ReadPrec [NamedType]
-> Read NamedType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NamedType
readsPrec :: Int -> ReadS NamedType
$creadList :: ReadS [NamedType]
readList :: ReadS [NamedType]
$creadPrec :: ReadPrec NamedType
readPrec :: ReadPrec NamedType
$creadListPrec :: ReadPrec [NamedType]
readListPrec :: ReadPrec [NamedType]
Read, Int -> NamedType -> ShowS
[NamedType] -> ShowS
NamedType -> String
(Int -> NamedType -> ShowS)
-> (NamedType -> String)
-> ([NamedType] -> ShowS)
-> Show NamedType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NamedType -> ShowS
showsPrec :: Int -> NamedType -> ShowS
$cshow :: NamedType -> String
show :: NamedType -> String
$cshowList :: [NamedType] -> ShowS
showList :: [NamedType] -> ShowS
Show)

_NamedType :: Name
_NamedType = (String -> Name
Core.Name String
"hydra/langs/avro/schema.NamedType")

_NamedType_enum :: Name
_NamedType_enum = (String -> Name
Core.Name String
"enum")

_NamedType_fixed :: Name
_NamedType_fixed = (String -> Name
Core.Name String
"fixed")

_NamedType_record :: Name
_NamedType_record = (String -> Name
Core.Name String
"record")

data Order = 
  OrderAscending  |
  OrderDescending  |
  OrderIgnore 
  deriving (Order -> Order -> Bool
(Order -> Order -> Bool) -> (Order -> Order -> Bool) -> Eq Order
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Order -> Order -> Bool
== :: Order -> Order -> Bool
$c/= :: Order -> Order -> Bool
/= :: Order -> Order -> Bool
Eq, Eq Order
Eq Order =>
(Order -> Order -> Ordering)
-> (Order -> Order -> Bool)
-> (Order -> Order -> Bool)
-> (Order -> Order -> Bool)
-> (Order -> Order -> Bool)
-> (Order -> Order -> Order)
-> (Order -> Order -> Order)
-> Ord Order
Order -> Order -> Bool
Order -> Order -> Ordering
Order -> Order -> Order
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
$ccompare :: Order -> Order -> Ordering
compare :: Order -> Order -> Ordering
$c< :: Order -> Order -> Bool
< :: Order -> Order -> Bool
$c<= :: Order -> Order -> Bool
<= :: Order -> Order -> Bool
$c> :: Order -> Order -> Bool
> :: Order -> Order -> Bool
$c>= :: Order -> Order -> Bool
>= :: Order -> Order -> Bool
$cmax :: Order -> Order -> Order
max :: Order -> Order -> Order
$cmin :: Order -> Order -> Order
min :: Order -> Order -> Order
Ord, ReadPrec [Order]
ReadPrec Order
Int -> ReadS Order
ReadS [Order]
(Int -> ReadS Order)
-> ReadS [Order]
-> ReadPrec Order
-> ReadPrec [Order]
-> Read Order
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Order
readsPrec :: Int -> ReadS Order
$creadList :: ReadS [Order]
readList :: ReadS [Order]
$creadPrec :: ReadPrec Order
readPrec :: ReadPrec Order
$creadListPrec :: ReadPrec [Order]
readListPrec :: ReadPrec [Order]
Read, Int -> Order -> ShowS
[Order] -> ShowS
Order -> String
(Int -> Order -> ShowS)
-> (Order -> String) -> ([Order] -> ShowS) -> Show Order
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Order -> ShowS
showsPrec :: Int -> Order -> ShowS
$cshow :: Order -> String
show :: Order -> String
$cshowList :: [Order] -> ShowS
showList :: [Order] -> ShowS
Show)

_Order :: Name
_Order = (String -> Name
Core.Name String
"hydra/langs/avro/schema.Order")

_Order_ascending :: Name
_Order_ascending = (String -> Name
Core.Name String
"ascending")

_Order_descending :: Name
_Order_descending = (String -> Name
Core.Name String
"descending")

_Order_ignore :: Name
_Order_ignore = (String -> Name
Core.Name String
"ignore")

data Primitive = 
  -- | no value
  PrimitiveNull  |
  -- | A binary value
  PrimitiveBoolean  |
  -- | 32-bit signed integer
  PrimitiveInt  |
  -- | 64-bit signed integer
  PrimitiveLong  |
  -- | single precision (32-bit) IEEE 754 floating-point number
  PrimitiveFloat  |
  -- | double precision (64-bit) IEEE 754 floating-point number
  PrimitiveDouble  |
  -- | sequence of 8-bit unsigned bytes
  PrimitiveBytes  |
  -- | unicode character sequence
  PrimitiveString 
  deriving (Primitive -> Primitive -> Bool
(Primitive -> Primitive -> Bool)
-> (Primitive -> Primitive -> Bool) -> Eq Primitive
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Primitive -> Primitive -> Bool
== :: Primitive -> Primitive -> Bool
$c/= :: Primitive -> Primitive -> Bool
/= :: Primitive -> Primitive -> Bool
Eq, Eq Primitive
Eq Primitive =>
(Primitive -> Primitive -> Ordering)
-> (Primitive -> Primitive -> Bool)
-> (Primitive -> Primitive -> Bool)
-> (Primitive -> Primitive -> Bool)
-> (Primitive -> Primitive -> Bool)
-> (Primitive -> Primitive -> Primitive)
-> (Primitive -> Primitive -> Primitive)
-> Ord Primitive
Primitive -> Primitive -> Bool
Primitive -> Primitive -> Ordering
Primitive -> Primitive -> Primitive
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
$ccompare :: Primitive -> Primitive -> Ordering
compare :: Primitive -> Primitive -> Ordering
$c< :: Primitive -> Primitive -> Bool
< :: Primitive -> Primitive -> Bool
$c<= :: Primitive -> Primitive -> Bool
<= :: Primitive -> Primitive -> Bool
$c> :: Primitive -> Primitive -> Bool
> :: Primitive -> Primitive -> Bool
$c>= :: Primitive -> Primitive -> Bool
>= :: Primitive -> Primitive -> Bool
$cmax :: Primitive -> Primitive -> Primitive
max :: Primitive -> Primitive -> Primitive
$cmin :: Primitive -> Primitive -> Primitive
min :: Primitive -> Primitive -> Primitive
Ord, ReadPrec [Primitive]
ReadPrec Primitive
Int -> ReadS Primitive
ReadS [Primitive]
(Int -> ReadS Primitive)
-> ReadS [Primitive]
-> ReadPrec Primitive
-> ReadPrec [Primitive]
-> Read Primitive
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Primitive
readsPrec :: Int -> ReadS Primitive
$creadList :: ReadS [Primitive]
readList :: ReadS [Primitive]
$creadPrec :: ReadPrec Primitive
readPrec :: ReadPrec Primitive
$creadListPrec :: ReadPrec [Primitive]
readListPrec :: ReadPrec [Primitive]
Read, Int -> Primitive -> ShowS
[Primitive] -> ShowS
Primitive -> String
(Int -> Primitive -> ShowS)
-> (Primitive -> String)
-> ([Primitive] -> ShowS)
-> Show Primitive
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Primitive -> ShowS
showsPrec :: Int -> Primitive -> ShowS
$cshow :: Primitive -> String
show :: Primitive -> String
$cshowList :: [Primitive] -> ShowS
showList :: [Primitive] -> ShowS
Show)

_Primitive :: Name
_Primitive = (String -> Name
Core.Name String
"hydra/langs/avro/schema.Primitive")

_Primitive_null :: Name
_Primitive_null = (String -> Name
Core.Name String
"null")

_Primitive_boolean :: Name
_Primitive_boolean = (String -> Name
Core.Name String
"boolean")

_Primitive_int :: Name
_Primitive_int = (String -> Name
Core.Name String
"int")

_Primitive_long :: Name
_Primitive_long = (String -> Name
Core.Name String
"long")

_Primitive_float :: Name
_Primitive_float = (String -> Name
Core.Name String
"float")

_Primitive_double :: Name
_Primitive_double = (String -> Name
Core.Name String
"double")

_Primitive_bytes :: Name
_Primitive_bytes = (String -> Name
Core.Name String
"bytes")

_Primitive_string :: Name
_Primitive_string = (String -> Name
Core.Name String
"string")

data Record = 
  Record {
    -- | a JSON array, listing fields
    Record -> [Field]
recordFields :: [Field]}
  deriving (Record -> Record -> Bool
(Record -> Record -> Bool)
-> (Record -> Record -> Bool) -> Eq Record
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Record -> Record -> Bool
== :: Record -> Record -> Bool
$c/= :: Record -> Record -> Bool
/= :: Record -> Record -> Bool
Eq, Eq Record
Eq Record =>
(Record -> Record -> Ordering)
-> (Record -> Record -> Bool)
-> (Record -> Record -> Bool)
-> (Record -> Record -> Bool)
-> (Record -> Record -> Bool)
-> (Record -> Record -> Record)
-> (Record -> Record -> Record)
-> Ord Record
Record -> Record -> Bool
Record -> Record -> Ordering
Record -> Record -> Record
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
$ccompare :: Record -> Record -> Ordering
compare :: Record -> Record -> Ordering
$c< :: Record -> Record -> Bool
< :: Record -> Record -> Bool
$c<= :: Record -> Record -> Bool
<= :: Record -> Record -> Bool
$c> :: Record -> Record -> Bool
> :: Record -> Record -> Bool
$c>= :: Record -> Record -> Bool
>= :: Record -> Record -> Bool
$cmax :: Record -> Record -> Record
max :: Record -> Record -> Record
$cmin :: Record -> Record -> Record
min :: Record -> Record -> Record
Ord, ReadPrec [Record]
ReadPrec Record
Int -> ReadS Record
ReadS [Record]
(Int -> ReadS Record)
-> ReadS [Record]
-> ReadPrec Record
-> ReadPrec [Record]
-> Read Record
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Record
readsPrec :: Int -> ReadS Record
$creadList :: ReadS [Record]
readList :: ReadS [Record]
$creadPrec :: ReadPrec Record
readPrec :: ReadPrec Record
$creadListPrec :: ReadPrec [Record]
readListPrec :: ReadPrec [Record]
Read, Int -> Record -> ShowS
[Record] -> ShowS
Record -> String
(Int -> Record -> ShowS)
-> (Record -> String) -> ([Record] -> ShowS) -> Show Record
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Record -> ShowS
showsPrec :: Int -> Record -> ShowS
$cshow :: Record -> String
show :: Record -> String
$cshowList :: [Record] -> ShowS
showList :: [Record] -> ShowS
Show)

_Record :: Name
_Record = (String -> Name
Core.Name String
"hydra/langs/avro/schema.Record")

_Record_fields :: Name
_Record_fields = (String -> Name
Core.Name String
"fields")

data Schema = 
  SchemaArray Array |
  SchemaMap Map_ |
  SchemaNamed Named |
  SchemaPrimitive Primitive |
  -- | A reference by name to a previously defined type
  SchemaReference String |
  SchemaUnion Union
  deriving (Schema -> Schema -> Bool
(Schema -> Schema -> Bool)
-> (Schema -> Schema -> Bool) -> Eq Schema
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Schema -> Schema -> Bool
== :: Schema -> Schema -> Bool
$c/= :: Schema -> Schema -> Bool
/= :: Schema -> Schema -> Bool
Eq, Eq Schema
Eq Schema =>
(Schema -> Schema -> Ordering)
-> (Schema -> Schema -> Bool)
-> (Schema -> Schema -> Bool)
-> (Schema -> Schema -> Bool)
-> (Schema -> Schema -> Bool)
-> (Schema -> Schema -> Schema)
-> (Schema -> Schema -> Schema)
-> Ord Schema
Schema -> Schema -> Bool
Schema -> Schema -> Ordering
Schema -> Schema -> Schema
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
$ccompare :: Schema -> Schema -> Ordering
compare :: Schema -> Schema -> Ordering
$c< :: Schema -> Schema -> Bool
< :: Schema -> Schema -> Bool
$c<= :: Schema -> Schema -> Bool
<= :: Schema -> Schema -> Bool
$c> :: Schema -> Schema -> Bool
> :: Schema -> Schema -> Bool
$c>= :: Schema -> Schema -> Bool
>= :: Schema -> Schema -> Bool
$cmax :: Schema -> Schema -> Schema
max :: Schema -> Schema -> Schema
$cmin :: Schema -> Schema -> Schema
min :: Schema -> Schema -> Schema
Ord, ReadPrec [Schema]
ReadPrec Schema
Int -> ReadS Schema
ReadS [Schema]
(Int -> ReadS Schema)
-> ReadS [Schema]
-> ReadPrec Schema
-> ReadPrec [Schema]
-> Read Schema
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Schema
readsPrec :: Int -> ReadS Schema
$creadList :: ReadS [Schema]
readList :: ReadS [Schema]
$creadPrec :: ReadPrec Schema
readPrec :: ReadPrec Schema
$creadListPrec :: ReadPrec [Schema]
readListPrec :: ReadPrec [Schema]
Read, Int -> Schema -> ShowS
[Schema] -> ShowS
Schema -> String
(Int -> Schema -> ShowS)
-> (Schema -> String) -> ([Schema] -> ShowS) -> Show Schema
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Schema -> ShowS
showsPrec :: Int -> Schema -> ShowS
$cshow :: Schema -> String
show :: Schema -> String
$cshowList :: [Schema] -> ShowS
showList :: [Schema] -> ShowS
Show)

_Schema :: Name
_Schema = (String -> Name
Core.Name String
"hydra/langs/avro/schema.Schema")

_Schema_array :: Name
_Schema_array = (String -> Name
Core.Name String
"array")

_Schema_map :: Name
_Schema_map = (String -> Name
Core.Name String
"map")

_Schema_named :: Name
_Schema_named = (String -> Name
Core.Name String
"named")

_Schema_primitive :: Name
_Schema_primitive = (String -> Name
Core.Name String
"primitive")

_Schema_reference :: Name
_Schema_reference = (String -> Name
Core.Name String
"reference")

_Schema_union :: Name
_Schema_union = (String -> Name
Core.Name String
"union")

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

_Union :: Name
_Union = (String -> Name
Core.Name String
"hydra/langs/avro/schema.Union")